rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove all uses of the deprecated functions heap_formtuple, heap_modifytuple, 

and heap_deformtuple in favor of the newer functions heap_form_tuple et al
(which do the same things but use bool control flags instead of arbitrary
char values).  Eliminate the former duplicate coding of these functions,
reducing the deprecated functions to mere wrappers around the newer ones.
We can't get rid of them entirely because add-on modules probably still
contain many instances of the old coding style.

Kris Jurka
This commit is contained in:
Tom Lane 2008-11-02 01:45:28 +00:00
parent 492059daba
commit 902d1cb35f
46 changed files with 630 additions and 1013 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
contrib/hstore/hstore_op.c
View File

@ -610,7 +610,7 @@ each(PG_FUNCTION_ARGS)
HEntry *ptr = &(ARRPTR(st->hs)[st->i]); HEntry *ptr = &(ARRPTR(st->hs)[st->i]);
Datum res, Datum res,
dvalues[2]; dvalues[2];
char nulls[] = {' ', ' '}; bool nulls[2] = {false, false};
text *item; text *item;
HeapTuple tuple; HeapTuple tuple;
@ -620,7 +620,7 @@ each(PG_FUNCTION_ARGS)
if (ptr->valisnull) if (ptr->valisnull)
{ {
dvalues[1] = (Datum) 0; dvalues[1] = (Datum) 0;
nulls[1] = 'n'; nulls[1] = true;
} }
else else
{ {
@ -630,11 +630,11 @@ each(PG_FUNCTION_ARGS)
} }
st->i++; st->i++;
tuple = heap_formtuple(funcctx->attinmeta->tupdesc, dvalues, nulls); tuple = heap_form_tuple(funcctx->attinmeta->tupdesc, dvalues, nulls);
res = HeapTupleGetDatum(tuple); res = HeapTupleGetDatum(tuple);
pfree(DatumGetPointer(dvalues[0])); pfree(DatumGetPointer(dvalues[0]));
if (nulls[1] != 'n') if (!nulls[1])
pfree(DatumGetPointer(dvalues[1])); pfree(DatumGetPointer(dvalues[1]));
SRF_RETURN_NEXT(funcctx, PointerGetDatum(res)); SRF_RETURN_NEXT(funcctx, PointerGetDatum(res));

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

@ -4,13 +4,6 @@
* This file contains heap tuple accessor and mutator routines, as well * This file contains heap tuple accessor and mutator routines, as well
* as various tuple utilities. * as various tuple utilities.
* *
* NOTE: there is massive duplication of code in this module to
* support both the convention that a null is marked by a bool TRUE,
* and the convention that a null is marked by a char 'n'. The latter
* convention is deprecated but it'll probably be a long time before
* we can get rid of it entirely.
*
*
* Some notes about varlenas and this code: * Some notes about varlenas and this code:
* *
* Before Postgres 8.3 varlenas always had a 4-byte length header, and * Before Postgres 8.3 varlenas always had a 4-byte length header, and
@ -24,8 +17,8 @@
* be expanded back to the normal 4-byte-header format by pg_detoast_datum. * be expanded back to the normal 4-byte-header format by pg_detoast_datum.
* (In performance-critical code paths we can use pg_detoast_datum_packed * (In performance-critical code paths we can use pg_detoast_datum_packed
* and the appropriate access macros to avoid that overhead.) Note that this * and the appropriate access macros to avoid that overhead.) Note that this
* conversion is performed directly in heap_form_tuple (or heap_formtuple), * conversion is performed directly in heap_form_tuple, without invoking
* without explicitly invoking the toaster. * tuptoaster.c.
* *
* This change will break any code that assumes it needn't detoast values * This change will break any code that assumes it needn't detoast values
* that have been put into a tuple but never sent to disk. Hopefully there * that have been put into a tuple but never sent to disk. Hopefully there
@ -57,7 +50,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/access/common/heaptuple.c,v 1.122 2008/05/12 00:00:43 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/access/common/heaptuple.c,v 1.123 2008/11/02 01:45:26 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -128,54 +121,6 @@ heap_compute_data_size(TupleDesc tupleDesc,
return data_length; return data_length;
} }
/* ----------------
* ComputeDataSize
*
* Determine size of the data area of a tuple to be constructed
*
* OLD API with char 'n'/' ' convention for indicating nulls
* ----------------
*/
static Size
ComputeDataSize(TupleDesc tupleDesc,
Datum *values,
char *nulls)
{
Size data_length = 0;
int i;
int numberOfAttributes = tupleDesc->natts;
Form_pg_attribute *att = tupleDesc->attrs;
for (i = 0; i < numberOfAttributes; i++)
{
Datum val;
if (nulls[i] != ' ')
continue;
val = values[i];
if (ATT_IS_PACKABLE(att[i]) &&
VARATT_CAN_MAKE_SHORT(DatumGetPointer(val)))
{
/*
* we're anticipating converting to a short varlena header, so
* adjust length and don't count any alignment
*/
data_length += VARATT_CONVERTED_SHORT_SIZE(DatumGetPointer(val));
}
else
{
data_length = att_align_datum(data_length, att[i]->attalign,
att[i]->attlen, val);
data_length = att_addlength_datum(data_length, att[i]->attlen,
val);
}
}
return data_length;
}
/* /*
* heap_fill_tuple * heap_fill_tuple
* Load data portion of a tuple from values/isnull arrays * Load data portion of a tuple from values/isnull arrays
@ -310,138 +255,6 @@ heap_fill_tuple(TupleDesc tupleDesc,
Assert((data - start) == data_size); Assert((data - start) == data_size);
} }
/* ----------------
* DataFill
*
* Load data portion of a tuple from values/nulls arrays
*
* OLD API with char 'n'/' ' convention for indicating nulls
* ----------------
*/
static void
DataFill(TupleDesc tupleDesc,
Datum *values, char *nulls,
char *data, Size data_size,
uint16 *infomask, bits8 *bit)
{
bits8 *bitP;
int bitmask;
int i;
int numberOfAttributes = tupleDesc->natts;
Form_pg_attribute *att = tupleDesc->attrs;
#ifdef USE_ASSERT_CHECKING
char *start = data;
#endif
if (bit != NULL)
{
bitP = &bit[-1];
bitmask = HIGHBIT;
}
else
{
/* just to keep compiler quiet */
bitP = NULL;
bitmask = 0;
}
*infomask &= ~(HEAP_HASNULL | HEAP_HASVARWIDTH | HEAP_HASEXTERNAL);
for (i = 0; i < numberOfAttributes; i++)
{
Size data_length;
if (bit != NULL)
{
if (bitmask != HIGHBIT)
bitmask <<= 1;
else
{
bitP += 1;
*bitP = 0x0;
bitmask = 1;
}
if (nulls[i] == 'n')
{
*infomask |= HEAP_HASNULL;
continue;
}
*bitP |= bitmask;
}
/*
* XXX we use the att_align macros on the pointer value itself, not on
* an offset. This is a bit of a hack.
*/
if (att[i]->attbyval)
{
/* pass-by-value */
data = (char *) att_align_nominal((long) data, att[i]->attalign);
store_att_byval(data, values[i], att[i]->attlen);
data_length = att[i]->attlen;
}
else if (att[i]->attlen == -1)
{
/* varlena */
Pointer val = DatumGetPointer(values[i]);
*infomask |= HEAP_HASVARWIDTH;
if (VARATT_IS_EXTERNAL(val))
{
*infomask |= HEAP_HASEXTERNAL;
/* no alignment, since it's short by definition */
data_length = VARSIZE_EXTERNAL(val);
memcpy(data, val, data_length);
}
else if (VARATT_IS_SHORT(val))
{
/* no alignment for short varlenas */
data_length = VARSIZE_SHORT(val);
memcpy(data, val, data_length);
}
else if (VARLENA_ATT_IS_PACKABLE(att[i]) &&
VARATT_CAN_MAKE_SHORT(val))
{
/* convert to short varlena -- no alignment */
data_length = VARATT_CONVERTED_SHORT_SIZE(val);
SET_VARSIZE_SHORT(data, data_length);
memcpy(data + 1, VARDATA(val), data_length - 1);
}
else
{
/* full 4-byte header varlena */
data = (char *) att_align_nominal((long) data,
att[i]->attalign);
data_length = VARSIZE(val);
memcpy(data, val, data_length);
}
}
else if (att[i]->attlen == -2)
{
/* cstring ... never needs alignment */
*infomask |= HEAP_HASVARWIDTH;
Assert(att[i]->attalign == 'c');
data_length = strlen(DatumGetCString(values[i])) + 1;
memcpy(data, DatumGetPointer(values[i]), data_length);
}
else
{
/* fixed-length pass-by-reference */
data = (char *) att_align_nominal((long) data, att[i]->attalign);
Assert(att[i]->attlen > 0);
data_length = att[i]->attlen;
memcpy(data, DatumGetPointer(values[i]), data_length);
}
data += data_length;
}
Assert((data - start) == data_size);
}
/* ---------------------------------------------------------------- /* ----------------------------------------------------------------
* heap tuple interface * heap tuple interface
@ -952,7 +765,7 @@ heap_form_tuple(TupleDesc tupleDescriptor,
return tuple; return tuple;
} }
/* ---------------- /*
* heap_formtuple * heap_formtuple
* *
* construct a tuple from the given values[] and nulls[] arrays * construct a tuple from the given values[] and nulls[] arrays
@ -960,8 +773,9 @@ heap_form_tuple(TupleDesc tupleDescriptor,
* Null attributes are indicated by a 'n' in the appropriate byte * Null attributes are indicated by a 'n' in the appropriate byte
* of nulls[]. Non-null attributes are indicated by a ' ' (space). * of nulls[]. Non-null attributes are indicated by a ' ' (space).
* *
* OLD API with char 'n'/' ' convention for indicating nulls * OLD API with char 'n'/' ' convention for indicating nulls.
* ---------------- * This is deprecated and should not be used in new code, but we keep it
* around for use by old add-on modules.
*/ */
HeapTuple HeapTuple
heap_formtuple(TupleDesc tupleDescriptor, heap_formtuple(TupleDesc tupleDescriptor,
@ -969,96 +783,16 @@ heap_formtuple(TupleDesc tupleDescriptor,
char *nulls) char *nulls)
{ {
HeapTuple tuple; /* return tuple */ HeapTuple tuple; /* return tuple */
HeapTupleHeader td; /* tuple data */
Size len,
data_len;
int hoff;
bool hasnull = false;
Form_pg_attribute *att = tupleDescriptor->attrs;
int numberOfAttributes = tupleDescriptor->natts; int numberOfAttributes = tupleDescriptor->natts;
bool *boolNulls = (bool *) palloc(numberOfAttributes * sizeof(bool));
int i; int i;
if (numberOfAttributes > MaxTupleAttributeNumber)
ereport(ERROR,
(errcode(ERRCODE_TOO_MANY_COLUMNS),
errmsg("number of columns (%d) exceeds limit (%d)",
numberOfAttributes, MaxTupleAttributeNumber)));
/*
* Check for nulls and embedded tuples; expand any toasted attributes in
* embedded tuples. This preserves the invariant that toasting can only
* go one level deep.
*
* We can skip calling toast_flatten_tuple_attribute() if the attribute
* couldn't possibly be of composite type. All composite datums are
* varlena and have alignment 'd'; furthermore they aren't arrays. Also,
* if an attribute is already toasted, it must have been sent to disk
* already and so cannot contain toasted attributes.
*/
for (i = 0; i < numberOfAttributes; i++) for (i = 0; i < numberOfAttributes; i++)
{ boolNulls[i] = (nulls[i] == 'n');
if (nulls[i] != ' ')
hasnull = true;
else if (att[i]->attlen == -1 &&
att[i]->attalign == 'd' &&
att[i]->attndims == 0 &&
!VARATT_IS_EXTENDED(DatumGetPointer(values[i])))
{
values[i] = toast_flatten_tuple_attribute(values[i],
att[i]->atttypid,
att[i]->atttypmod);
}
}
/* tuple = heap_form_tuple(tupleDescriptor, values, boolNulls);
* Determine total space needed
*/
len = offsetof(HeapTupleHeaderData, t_bits);
if (hasnull) pfree(boolNulls);
len += BITMAPLEN(numberOfAttributes);
if (tupleDescriptor->tdhasoid)
len += sizeof(Oid);
hoff = len = MAXALIGN(len); /* align user data safely */
data_len = ComputeDataSize(tupleDescriptor, values, nulls);
len += data_len;
/*
* Allocate and zero the space needed. Note that the tuple body and
* HeapTupleData management structure are allocated in one chunk.
*/
tuple = (HeapTuple) palloc0(HEAPTUPLESIZE + len);
tuple->t_data = td = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
/*
* And fill in the information. Note we fill the Datum fields even though
* this tuple may never become a Datum.
*/
tuple->t_len = len;
ItemPointerSetInvalid(&(tuple->t_self));
tuple->t_tableOid = InvalidOid;
HeapTupleHeaderSetDatumLength(td, len);
HeapTupleHeaderSetTypeId(td, tupleDescriptor->tdtypeid);
HeapTupleHeaderSetTypMod(td, tupleDescriptor->tdtypmod);
HeapTupleHeaderSetNatts(td, numberOfAttributes);
td->t_hoff = hoff;
if (tupleDescriptor->tdhasoid) /* else leave infomask = 0 */
td->t_infomask = HEAP_HASOID;
DataFill(tupleDescriptor,
values,
nulls,
(char *) td + hoff,
data_len,
&td->t_infomask,
(hasnull ? td->t_bits : NULL));
return tuple; return tuple;
} }
@ -1134,7 +868,7 @@ heap_modify_tuple(HeapTuple tuple,
return newTuple; return newTuple;
} }
/* ---------------- /*
* heap_modifytuple * heap_modifytuple
* *
* forms a new tuple from an old tuple and a set of replacement values. * forms a new tuple from an old tuple and a set of replacement values.
@ -1142,7 +876,8 @@ heap_modify_tuple(HeapTuple tuple,
* *
* OLD API with char 'n'/' ' convention for indicating nulls, and * OLD API with char 'n'/' ' convention for indicating nulls, and
* char 'r'/' ' convention for indicating whether to replace columns. * char 'r'/' ' convention for indicating whether to replace columns.
* ---------------- * This is deprecated and should not be used in new code, but we keep it
* around for use by old add-on modules.
*/ */
HeapTuple HeapTuple
heap_modifytuple(HeapTuple tuple, heap_modifytuple(HeapTuple tuple,
@ -1151,59 +886,24 @@ heap_modifytuple(HeapTuple tuple,
char *replNulls, char *replNulls,
char *replActions) char *replActions)
{ {
HeapTuple result;
int numberOfAttributes = tupleDesc->natts; int numberOfAttributes = tupleDesc->natts;
int attoff; bool *boolNulls = (bool *) palloc(numberOfAttributes * sizeof(bool));
Datum *values; bool *boolActions = (bool *) palloc(numberOfAttributes * sizeof(bool));
char *nulls; int attnum;
HeapTuple newTuple;
/* for (attnum = 0; attnum < numberOfAttributes; attnum++)
* allocate and fill values and nulls arrays from either the tuple or the
* repl information, as appropriate.
*
* NOTE: it's debatable whether to use heap_deformtuple() here or just
* heap_getattr() only the non-replaced colums. The latter could win if
* there are many replaced columns and few non-replaced ones. However,
* heap_deformtuple costs only O(N) while the heap_getattr way would cost
* O(N^2) if there are many non-replaced columns, so it seems better to
* err on the side of linear cost.
*/
values = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
nulls = (char *) palloc(numberOfAttributes * sizeof(char));
heap_deformtuple(tuple, tupleDesc, values, nulls);
for (attoff = 0; attoff < numberOfAttributes; attoff++)
{ {
if (replActions[attoff] == 'r') boolNulls[attnum] = (replNulls[attnum] == 'n');
{ boolActions[attnum] = (replActions[attnum] == 'r');
values[attoff] = replValues[attoff];
nulls[attoff] = replNulls[attoff];
}
else if (replActions[attoff] != ' ')
elog(ERROR, "unrecognized replace flag: %d",
(int) replActions[attoff]);
} }
/* result = heap_modify_tuple(tuple, tupleDesc, replValues, boolNulls, boolActions);
* create a new tuple from the values and nulls arrays
*/
newTuple = heap_formtuple(tupleDesc, values, nulls);
pfree(values); pfree(boolNulls);
pfree(nulls); pfree(boolActions);
/* return result;
* copy the identification info of the old tuple: t_ctid, t_self, and OID
* (if any)
*/
newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
newTuple->t_self = tuple->t_self;
newTuple->t_tableOid = tuple->t_tableOid;
if (tupleDesc->tdhasoid)
HeapTupleSetOid(newTuple, HeapTupleGetOid(tuple));
return newTuple;
} }
/* /*
@ -1312,7 +1012,7 @@ heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc,
} }
} }
/* ---------------- /*
* heap_deformtuple * heap_deformtuple
* *
* Given a tuple, extract data into values/nulls arrays; this is * Given a tuple, extract data into values/nulls arrays; this is
@ -1329,8 +1029,9 @@ heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc,
* heap_getattr; the loop will become O(N^2) as soon as any * heap_getattr; the loop will become O(N^2) as soon as any
* noncacheable attribute offsets are involved. * noncacheable attribute offsets are involved.
* *
* OLD API with char 'n'/' ' convention for indicating nulls * OLD API with char 'n'/' ' convention for indicating nulls.
* ---------------- * This is deprecated and should not be used in new code, but we keep it
* around for use by old add-on modules.
*/ */
void void
heap_deformtuple(HeapTuple tuple, heap_deformtuple(HeapTuple tuple,
@ -1338,90 +1039,16 @@ heap_deformtuple(HeapTuple tuple,
Datum *values, Datum *values,
char *nulls) char *nulls)
{ {
HeapTupleHeader tup = tuple->t_data; int natts = tupleDesc->natts;
bool hasnulls = HeapTupleHasNulls(tuple); bool *boolNulls = (bool *) palloc(natts * sizeof(bool));
Form_pg_attribute *att = tupleDesc->attrs;
int tdesc_natts = tupleDesc->natts;
int natts; /* number of atts to extract */
int attnum; int attnum;
char *tp; /* ptr to tuple data */
long off; /* offset in tuple data */
bits8 *bp = tup->t_bits; /* ptr to null bitmap in tuple */
bool slow = false; /* can we use/set attcacheoff? */
natts = HeapTupleHeaderGetNatts(tup); heap_deform_tuple(tuple, tupleDesc, values, boolNulls);
/*
* In inheritance situations, it is possible that the given tuple actually
* has more fields than the caller is expecting. Don't run off the end of
* the caller's arrays.
*/
natts = Min(natts, tdesc_natts);
tp = (char *) tup + tup->t_hoff;
off = 0;
for (attnum = 0; attnum < natts; attnum++) for (attnum = 0; attnum < natts; attnum++)
{ nulls[attnum] = (boolNulls[attnum] ? 'n' : ' ');
Form_pg_attribute thisatt = att[attnum];
if (hasnulls && att_isnull(attnum, bp)) pfree(boolNulls);
{
values[attnum] = (Datum) 0;
nulls[attnum] = 'n';
slow = true; /* can't use attcacheoff anymore */
continue;
}
nulls[attnum] = ' ';
if (!slow && thisatt->attcacheoff >= 0)
off = thisatt->attcacheoff;
else if (thisatt->attlen == -1)
{
/*
* We can only cache the offset for a varlena attribute if the
* offset is already suitably aligned, so that there would be no
* pad bytes in any case: then the offset will be valid for either
* an aligned or unaligned value.
*/
if (!slow &&
off == att_align_nominal(off, thisatt->attalign))
thisatt->attcacheoff = off;
else
{
off = att_align_pointer(off, thisatt->attalign, -1,
tp + off);
slow = true;
}
}
else
{
/* not varlena, so safe to use att_align_nominal */
off = att_align_nominal(off, thisatt->attalign);
if (!slow)
thisatt->attcacheoff = off;
}
values[attnum] = fetchatt(thisatt, tp + off);
off = att_addlength_pointer(off, thisatt->attlen, tp + off);
if (thisatt->attlen <= 0)
slow = true; /* can't use attcacheoff anymore */
}
/*
* If tuple doesn't have all the atts indicated by tupleDesc, read the
* rest as null
*/
for (; attnum < tdesc_natts; attnum++)
{
values[attnum] = (Datum) 0;
nulls[attnum] = 'n';
}
} }
/* /*

6
src/backend/access/heap/tuptoaster.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/access/heap/tuptoaster.c,v 1.89 2008/06/19 00:46:03 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/access/heap/tuptoaster.c,v 1.90 2008/11/02 01:45:27 tgl Exp $
* *
* *
* INTERFACE ROUTINES * INTERFACE ROUTINES
@ -359,10 +359,10 @@ toast_delete(Relation rel, HeapTuple oldtup)
/* /*
* Get the tuple descriptor and break down the tuple into fields. * Get the tuple descriptor and break down the tuple into fields.
* *
* NOTE: it's debatable whether to use heap_deformtuple() here or just * NOTE: it's debatable whether to use heap_deform_tuple() here or just
* heap_getattr() only the varlena columns. The latter could win if there * heap_getattr() only the varlena columns. The latter could win if there
* are few varlena columns and many non-varlena ones. However, * are few varlena columns and many non-varlena ones. However,
* heap_deformtuple costs only O(N) while the heap_getattr way would cost * heap_deform_tuple costs only O(N) while the heap_getattr way would cost
* O(N^2) if there are many varlena columns, so it seems better to err on * O(N^2) if there are many varlena columns, so it seems better to err on
* the side of linear cost. (We won't even be here unless there's at * the side of linear cost. (We won't even be here unless there's at
* least one varlena column, by the way.) * least one varlena column, by the way.)

14
src/backend/bootstrap/bootstrap.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/bootstrap/bootstrap.c,v 1.246 2008/09/30 10:52:11 heikki Exp $ * $PostgreSQL: pgsql/src/backend/bootstrap/bootstrap.c,v 1.247 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -169,7 +169,7 @@ struct typmap
static struct typmap **Typ = NULL; static struct typmap **Typ = NULL;
static struct typmap *Ap = NULL; static struct typmap *Ap = NULL;
static char Blanks[MAXATTR]; static bool Nulls[MAXATTR];
Form_pg_attribute attrtypes[MAXATTR]; /* points to attribute info */ Form_pg_attribute attrtypes[MAXATTR]; /* points to attribute info */
static Datum values[MAXATTR]; /* corresponding attribute values */ static Datum values[MAXATTR]; /* corresponding attribute values */
@ -488,7 +488,7 @@ BootstrapModeMain(void)
for (i = 0; i < MAXATTR; i++) for (i = 0; i < MAXATTR; i++)
{ {
attrtypes[i] = NULL; attrtypes[i] = NULL;
Blanks[i] = ' '; Nulls[i] = false;
} }
for (i = 0; i < STRTABLESIZE; ++i) for (i = 0; i < STRTABLESIZE; ++i)
strtable[i] = NULL; strtable[i] = NULL;
@ -797,7 +797,7 @@ InsertOneTuple(Oid objectid)
tupDesc = CreateTupleDesc(numattr, tupDesc = CreateTupleDesc(numattr,
RelationGetForm(boot_reldesc)->relhasoids, RelationGetForm(boot_reldesc)->relhasoids,
attrtypes); attrtypes);
tuple = heap_formtuple(tupDesc, values, Blanks); tuple = heap_form_tuple(tupDesc, values, Nulls);
if (objectid != (Oid) 0) if (objectid != (Oid) 0)
HeapTupleSetOid(tuple, objectid); HeapTupleSetOid(tuple, objectid);
pfree(tupDesc); /* just free's tupDesc, not the attrtypes */ pfree(tupDesc); /* just free's tupDesc, not the attrtypes */
@ -807,10 +807,10 @@ InsertOneTuple(Oid objectid)
elog(DEBUG4, "row inserted"); elog(DEBUG4, "row inserted");
/* /*
* Reset blanks for next tuple * Reset null markers for next tuple
*/ */
for (i = 0; i < numattr; i++) for (i = 0; i < numattr; i++)
Blanks[i] = ' '; Nulls[i] = false;
} }
/* ---------------- /* ----------------
@ -857,7 +857,7 @@ InsertOneNull(int i)
elog(DEBUG4, "inserting column %d NULL", i); elog(DEBUG4, "inserting column %d NULL", i);
Assert(i >= 0 || i < MAXATTR); Assert(i >= 0 || i < MAXATTR);
values[i] = PointerGetDatum(NULL); values[i] = PointerGetDatum(NULL);
Blanks[i] = 'n'; Nulls[i] = true;
} }
/* ---------------- /* ----------------

84
src/backend/catalog/aclchk.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/aclchk.c,v 1.148 2008/09/08 00:47:40 tgl Exp $ * $PostgreSQL: pgsql/src/backend/catalog/aclchk.c,v 1.149 2008/11/02 01:45:27 tgl Exp $
* *
* NOTES * NOTES
* See acl.h. * See acl.h.
@ -554,8 +554,8 @@ ExecGrant_Relation(InternalGrant *istmt)
HeapTuple tuple; HeapTuple tuple;
HeapTuple newtuple; HeapTuple newtuple;
Datum values[Natts_pg_class]; Datum values[Natts_pg_class];
char nulls[Natts_pg_class]; bool nulls[Natts_pg_class];
char replaces[Natts_pg_class]; bool replaces[Natts_pg_class];
int noldmembers; int noldmembers;
int nnewmembers; int nnewmembers;
Oid *oldmembers; Oid *oldmembers;
@ -694,13 +694,13 @@ ExecGrant_Relation(InternalGrant *istmt)
/* finished building new ACL value, now insert it */ /* finished building new ACL value, now insert it */
MemSet(values, 0, sizeof(values)); MemSet(values, 0, sizeof(values));
MemSet(nulls, ' ', sizeof(nulls)); MemSet(nulls, false, sizeof(nulls));
MemSet(replaces, ' ', sizeof(replaces)); MemSet(replaces, false, sizeof(replaces));
replaces[Anum_pg_class_relacl - 1] = 'r'; replaces[Anum_pg_class_relacl - 1] = true;
values[Anum_pg_class_relacl - 1] = PointerGetDatum(new_acl); values[Anum_pg_class_relacl - 1] = PointerGetDatum(new_acl);
newtuple = heap_modifytuple(tuple, RelationGetDescr(relation), values, nulls, replaces); newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values, nulls, replaces);
simple_heap_update(relation, &newtuple->t_self, newtuple); simple_heap_update(relation, &newtuple->t_self, newtuple);
@ -749,8 +749,8 @@ ExecGrant_Database(InternalGrant *istmt)
Oid ownerId; Oid ownerId;
HeapTuple newtuple; HeapTuple newtuple;
Datum values[Natts_pg_database]; Datum values[Natts_pg_database];
char nulls[Natts_pg_database]; bool nulls[Natts_pg_database];
char replaces[Natts_pg_database]; bool replaces[Natts_pg_database];
int noldmembers; int noldmembers;
int nnewmembers; int nnewmembers;
Oid *oldmembers; Oid *oldmembers;
@ -809,14 +809,14 @@ ExecGrant_Database(InternalGrant *istmt)
/* finished building new ACL value, now insert it */ /* finished building new ACL value, now insert it */
MemSet(values, 0, sizeof(values)); MemSet(values, 0, sizeof(values));
MemSet(nulls, ' ', sizeof(nulls)); MemSet(nulls, false, sizeof(nulls));
MemSet(replaces, ' ', sizeof(replaces)); MemSet(replaces, false, sizeof(replaces));
replaces[Anum_pg_database_datacl - 1] = 'r'; replaces[Anum_pg_database_datacl - 1] = true;
values[Anum_pg_database_datacl - 1] = PointerGetDatum(new_acl); values[Anum_pg_database_datacl - 1] = PointerGetDatum(new_acl);
newtuple = heap_modifytuple(tuple, RelationGetDescr(relation), values, newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
nulls, replaces); nulls, replaces);
simple_heap_update(relation, &newtuple->t_self, newtuple); simple_heap_update(relation, &newtuple->t_self, newtuple);
@ -866,8 +866,8 @@ ExecGrant_Function(InternalGrant *istmt)
HeapTuple tuple; HeapTuple tuple;
HeapTuple newtuple; HeapTuple newtuple;
Datum values[Natts_pg_proc]; Datum values[Natts_pg_proc];
char nulls[Natts_pg_proc]; bool nulls[Natts_pg_proc];
char replaces[Natts_pg_proc]; bool replaces[Natts_pg_proc];
int noldmembers; int noldmembers;
int nnewmembers; int nnewmembers;
Oid *oldmembers; Oid *oldmembers;
@ -925,14 +925,14 @@ ExecGrant_Function(InternalGrant *istmt)
/* finished building new ACL value, now insert it */ /* finished building new ACL value, now insert it */
MemSet(values, 0, sizeof(values)); MemSet(values, 0, sizeof(values));
MemSet(nulls, ' ', sizeof(nulls)); MemSet(nulls, false, sizeof(nulls));
MemSet(replaces, ' ', sizeof(replaces)); MemSet(replaces, false, sizeof(replaces));
replaces[Anum_pg_proc_proacl - 1] = 'r'; replaces[Anum_pg_proc_proacl - 1] = true;
values[Anum_pg_proc_proacl - 1] = PointerGetDatum(new_acl); values[Anum_pg_proc_proacl - 1] = PointerGetDatum(new_acl);
newtuple = heap_modifytuple(tuple, RelationGetDescr(relation), values, newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
nulls, replaces); nulls, replaces);
simple_heap_update(relation, &newtuple->t_self, newtuple); simple_heap_update(relation, &newtuple->t_self, newtuple);
@ -982,8 +982,8 @@ ExecGrant_Language(InternalGrant *istmt)
HeapTuple tuple; HeapTuple tuple;
HeapTuple newtuple; HeapTuple newtuple;
Datum values[Natts_pg_language]; Datum values[Natts_pg_language];
char nulls[Natts_pg_language]; bool nulls[Natts_pg_language];
char replaces[Natts_pg_language]; bool replaces[Natts_pg_language];
int noldmembers; int noldmembers;
int nnewmembers; int nnewmembers;
Oid *oldmembers; Oid *oldmembers;
@ -1048,14 +1048,14 @@ ExecGrant_Language(InternalGrant *istmt)
/* finished building new ACL value, now insert it */ /* finished building new ACL value, now insert it */
MemSet(values, 0, sizeof(values)); MemSet(values, 0, sizeof(values));
MemSet(nulls, ' ', sizeof(nulls)); MemSet(nulls, false, sizeof(nulls));
MemSet(replaces, ' ', sizeof(replaces)); MemSet(replaces, false, sizeof(replaces));
replaces[Anum_pg_language_lanacl - 1] = 'r'; replaces[Anum_pg_language_lanacl - 1] = true;
values[Anum_pg_language_lanacl - 1] = PointerGetDatum(new_acl); values[Anum_pg_language_lanacl - 1] = PointerGetDatum(new_acl);
newtuple = heap_modifytuple(tuple, RelationGetDescr(relation), values, newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
nulls, replaces); nulls, replaces);
simple_heap_update(relation, &newtuple->t_self, newtuple); simple_heap_update(relation, &newtuple->t_self, newtuple);
@ -1105,8 +1105,8 @@ ExecGrant_Namespace(InternalGrant *istmt)
HeapTuple tuple; HeapTuple tuple;
HeapTuple newtuple; HeapTuple newtuple;
Datum values[Natts_pg_namespace]; Datum values[Natts_pg_namespace];
char nulls[Natts_pg_namespace]; bool nulls[Natts_pg_namespace];
char replaces[Natts_pg_namespace]; bool replaces[Natts_pg_namespace];
int noldmembers; int noldmembers;
int nnewmembers; int nnewmembers;
Oid *oldmembers; Oid *oldmembers;
@ -1165,14 +1165,14 @@ ExecGrant_Namespace(InternalGrant *istmt)
/* finished building new ACL value, now insert it */ /* finished building new ACL value, now insert it */
MemSet(values, 0, sizeof(values)); MemSet(values, 0, sizeof(values));
MemSet(nulls, ' ', sizeof(nulls)); MemSet(nulls, false, sizeof(nulls));
MemSet(replaces, ' ', sizeof(replaces)); MemSet(replaces, false, sizeof(replaces));
replaces[Anum_pg_namespace_nspacl - 1] = 'r'; replaces[Anum_pg_namespace_nspacl - 1] = true;
values[Anum_pg_namespace_nspacl - 1] = PointerGetDatum(new_acl); values[Anum_pg_namespace_nspacl - 1] = PointerGetDatum(new_acl);
newtuple = heap_modifytuple(tuple, RelationGetDescr(relation), values, newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
nulls, replaces); nulls, replaces);
simple_heap_update(relation, &newtuple->t_self, newtuple); simple_heap_update(relation, &newtuple->t_self, newtuple);
@ -1221,8 +1221,8 @@ ExecGrant_Tablespace(InternalGrant *istmt)
Oid ownerId; Oid ownerId;
HeapTuple newtuple; HeapTuple newtuple;
Datum values[Natts_pg_tablespace]; Datum values[Natts_pg_tablespace];
char nulls[Natts_pg_tablespace]; bool nulls[Natts_pg_tablespace];
char replaces[Natts_pg_tablespace]; bool replaces[Natts_pg_tablespace];
int noldmembers; int noldmembers;
int nnewmembers; int nnewmembers;
Oid *oldmembers; Oid *oldmembers;
@ -1288,14 +1288,14 @@ ExecGrant_Tablespace(InternalGrant *istmt)
/* finished building new ACL value, now insert it */ /* finished building new ACL value, now insert it */
MemSet(values, 0, sizeof(values)); MemSet(values, 0, sizeof(values));
MemSet(nulls, ' ', sizeof(nulls)); MemSet(nulls, false, sizeof(nulls));
MemSet(replaces, ' ', sizeof(replaces)); MemSet(replaces, false, sizeof(replaces));
replaces[Anum_pg_tablespace_spcacl - 1] = 'r'; replaces[Anum_pg_tablespace_spcacl - 1] = true;
values[Anum_pg_tablespace_spcacl - 1] = PointerGetDatum(new_acl); values[Anum_pg_tablespace_spcacl - 1] = PointerGetDatum(new_acl);
newtuple = heap_modifytuple(tuple, RelationGetDescr(relation), values, newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values,
nulls, replaces); nulls, replaces);
simple_heap_update(relation, &newtuple->t_self, newtuple); simple_heap_update(relation, &newtuple->t_self, newtuple);

16
src/backend/catalog/heap.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/heap.c,v 1.341 2008/10/14 23:27:40 tgl Exp $ * $PostgreSQL: pgsql/src/backend/catalog/heap.c,v 1.342 2008/11/02 01:45:27 tgl Exp $
* *
* *
* INTERFACE ROUTINES * INTERFACE ROUTINES
@ -618,12 +618,12 @@ InsertPgClassTuple(Relation pg_class_desc,
{ {
Form_pg_class rd_rel = new_rel_desc->rd_rel; Form_pg_class rd_rel = new_rel_desc->rd_rel;
Datum values[Natts_pg_class]; Datum values[Natts_pg_class];
char nulls[Natts_pg_class]; bool nulls[Natts_pg_class];
HeapTuple tup; HeapTuple tup;
/* This is a tad tedious, but way cleaner than what we used to do... */ /* This is a tad tedious, but way cleaner than what we used to do... */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
values[Anum_pg_class_relname - 1] = NameGetDatum(&rd_rel->relname); values[Anum_pg_class_relname - 1] = NameGetDatum(&rd_rel->relname);
values[Anum_pg_class_relnamespace - 1] = ObjectIdGetDatum(rd_rel->relnamespace); values[Anum_pg_class_relnamespace - 1] = ObjectIdGetDatum(rd_rel->relnamespace);
@ -651,13 +651,13 @@ InsertPgClassTuple(Relation pg_class_desc,
values[Anum_pg_class_relhassubclass - 1] = BoolGetDatum(rd_rel->relhassubclass); values[Anum_pg_class_relhassubclass - 1] = BoolGetDatum(rd_rel->relhassubclass);
values[Anum_pg_class_relfrozenxid - 1] = TransactionIdGetDatum(rd_rel->relfrozenxid); values[Anum_pg_class_relfrozenxid - 1] = TransactionIdGetDatum(rd_rel->relfrozenxid);
/* start out with empty permissions */ /* start out with empty permissions */
nulls[Anum_pg_class_relacl - 1] = 'n'; nulls[Anum_pg_class_relacl - 1] = true;
if (reloptions != (Datum) 0) if (reloptions != (Datum) 0)
values[Anum_pg_class_reloptions - 1] = reloptions; values[Anum_pg_class_reloptions - 1] = reloptions;
else else
nulls[Anum_pg_class_reloptions - 1] = 'n'; nulls[Anum_pg_class_reloptions - 1] = true;
tup = heap_formtuple(RelationGetDescr(pg_class_desc), values, nulls); tup = heap_form_tuple(RelationGetDescr(pg_class_desc), values, nulls);
/* /*
* The new tuple must have the oid already chosen for the rel. Sure would * The new tuple must have the oid already chosen for the rel. Sure would
@ -1464,7 +1464,7 @@ StoreAttrDefault(Relation rel, AttrNumber attnum, Node *expr)
Relation adrel; Relation adrel;
HeapTuple tuple; HeapTuple tuple;
Datum values[4]; Datum values[4];
static char nulls[4] = {' ', ' ', ' ', ' '}; static bool nulls[4] = {false, false, false, false};
Relation attrrel; Relation attrrel;
HeapTuple atttup; HeapTuple atttup;
Form_pg_attribute attStruct; Form_pg_attribute attStruct;
@ -1495,7 +1495,7 @@ StoreAttrDefault(Relation rel, AttrNumber attnum, Node *expr)
adrel = heap_open(AttrDefaultRelationId, RowExclusiveLock); adrel = heap_open(AttrDefaultRelationId, RowExclusiveLock);
tuple = heap_formtuple(adrel->rd_att, values, nulls); tuple = heap_form_tuple(adrel->rd_att, values, nulls);
attrdefOid = simple_heap_insert(adrel, tuple); attrdefOid = simple_heap_insert(adrel, tuple);
CatalogUpdateIndexes(adrel, tuple); CatalogUpdateIndexes(adrel, tuple);

12
src/backend/catalog/index.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/index.c,v 1.306 2008/10/14 21:47:39 tgl Exp $ * $PostgreSQL: pgsql/src/backend/catalog/index.c,v 1.307 2008/11/02 01:45:27 tgl Exp $
* *
* *
* INTERFACE ROUTINES * INTERFACE ROUTINES
@ -389,7 +389,7 @@ UpdateIndexRelation(Oid indexoid,
Datum exprsDatum; Datum exprsDatum;
Datum predDatum; Datum predDatum;
Datum values[Natts_pg_index]; Datum values[Natts_pg_index];
char nulls[Natts_pg_index]; bool nulls[Natts_pg_index];
Relation pg_index; Relation pg_index;
HeapTuple tuple; HeapTuple tuple;
int i; int i;
@ -441,7 +441,7 @@ UpdateIndexRelation(Oid indexoid,
/* /*
* Build a pg_index tuple * Build a pg_index tuple
*/ */
MemSet(nulls, ' ', sizeof(nulls)); MemSet(nulls, false, sizeof(nulls));
values[Anum_pg_index_indexrelid - 1] = ObjectIdGetDatum(indexoid); values[Anum_pg_index_indexrelid - 1] = ObjectIdGetDatum(indexoid);
values[Anum_pg_index_indrelid - 1] = ObjectIdGetDatum(heapoid); values[Anum_pg_index_indrelid - 1] = ObjectIdGetDatum(heapoid);
@ -458,12 +458,12 @@ UpdateIndexRelation(Oid indexoid,
values[Anum_pg_index_indoption - 1] = PointerGetDatum(indoption); values[Anum_pg_index_indoption - 1] = PointerGetDatum(indoption);
values[Anum_pg_index_indexprs - 1] = exprsDatum; values[Anum_pg_index_indexprs - 1] = exprsDatum;
if (exprsDatum == (Datum) 0) if (exprsDatum == (Datum) 0)
nulls[Anum_pg_index_indexprs - 1] = 'n'; nulls[Anum_pg_index_indexprs - 1] = true;
values[Anum_pg_index_indpred - 1] = predDatum; values[Anum_pg_index_indpred - 1] = predDatum;
if (predDatum == (Datum) 0) if (predDatum == (Datum) 0)
nulls[Anum_pg_index_indpred - 1] = 'n'; nulls[Anum_pg_index_indpred - 1] = true;
tuple = heap_formtuple(RelationGetDescr(pg_index), values, nulls); tuple = heap_form_tuple(RelationGetDescr(pg_index), values, nulls);
/* /*
* insert the tuple into the pg_index catalog * insert the tuple into the pg_index catalog

10
src/backend/catalog/pg_aggregate.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/pg_aggregate.c,v 1.95 2008/07/16 16:55:23 tgl Exp $ * $PostgreSQL: pgsql/src/backend/catalog/pg_aggregate.c,v 1.96 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -54,7 +54,7 @@ AggregateCreate(const char *aggName,
{ {
Relation aggdesc; Relation aggdesc;
HeapTuple tup; HeapTuple tup;
char nulls[Natts_pg_aggregate]; bool nulls[Natts_pg_aggregate];
Datum values[Natts_pg_aggregate]; Datum values[Natts_pg_aggregate];
Form_pg_proc proc; Form_pg_proc proc;
Oid transfn; Oid transfn;
@ -225,7 +225,7 @@ AggregateCreate(const char *aggName,
/* initialize nulls and values */ /* initialize nulls and values */
for (i = 0; i < Natts_pg_aggregate; i++) for (i = 0; i < Natts_pg_aggregate; i++)
{ {
nulls[i] = ' '; nulls[i] = false;
values[i] = (Datum) NULL; values[i] = (Datum) NULL;
} }
values[Anum_pg_aggregate_aggfnoid - 1] = ObjectIdGetDatum(procOid); values[Anum_pg_aggregate_aggfnoid - 1] = ObjectIdGetDatum(procOid);
@ -236,12 +236,12 @@ AggregateCreate(const char *aggName,
if (agginitval) if (agginitval)
values[Anum_pg_aggregate_agginitval - 1] = CStringGetTextDatum(agginitval); values[Anum_pg_aggregate_agginitval - 1] = CStringGetTextDatum(agginitval);
else else
nulls[Anum_pg_aggregate_agginitval - 1] = 'n'; nulls[Anum_pg_aggregate_agginitval - 1] = true;
aggdesc = heap_open(AggregateRelationId, RowExclusiveLock); aggdesc = heap_open(AggregateRelationId, RowExclusiveLock);
tupDesc = aggdesc->rd_att; tupDesc = aggdesc->rd_att;
tup = heap_formtuple(tupDesc, values, nulls); tup = heap_form_tuple(tupDesc, values, nulls);
simple_heap_insert(aggdesc, tup); simple_heap_insert(aggdesc, tup);
CatalogUpdateIndexes(aggdesc, tup); CatalogUpdateIndexes(aggdesc, tup);

22
src/backend/catalog/pg_constraint.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/pg_constraint.c,v 1.42 2008/06/19 00:46:04 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/catalog/pg_constraint.c,v 1.43 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -68,7 +68,7 @@ CreateConstraintEntry(const char *constraintName,
Relation conDesc; Relation conDesc;
Oid conOid; Oid conOid;
HeapTuple tup; HeapTuple tup;
char nulls[Natts_pg_constraint]; bool nulls[Natts_pg_constraint];
Datum values[Natts_pg_constraint]; Datum values[Natts_pg_constraint];
ArrayType *conkeyArray; ArrayType *conkeyArray;
ArrayType *confkeyArray; ArrayType *confkeyArray;
@ -133,7 +133,7 @@ CreateConstraintEntry(const char *constraintName,
/* initialize nulls and values */ /* initialize nulls and values */
for (i = 0; i < Natts_pg_constraint; i++) for (i = 0; i < Natts_pg_constraint; i++)
{ {
nulls[i] = ' '; nulls[i] = false;
values[i] = (Datum) NULL; values[i] = (Datum) NULL;
} }
@ -154,27 +154,27 @@ CreateConstraintEntry(const char *constraintName,
if (conkeyArray) if (conkeyArray)
values[Anum_pg_constraint_conkey - 1] = PointerGetDatum(conkeyArray); values[Anum_pg_constraint_conkey - 1] = PointerGetDatum(conkeyArray);
else else
nulls[Anum_pg_constraint_conkey - 1] = 'n'; nulls[Anum_pg_constraint_conkey - 1] = true;
if (confkeyArray) if (confkeyArray)
values[Anum_pg_constraint_confkey - 1] = PointerGetDatum(confkeyArray); values[Anum_pg_constraint_confkey - 1] = PointerGetDatum(confkeyArray);
else else
nulls[Anum_pg_constraint_confkey - 1] = 'n'; nulls[Anum_pg_constraint_confkey - 1] = true;
if (conpfeqopArray) if (conpfeqopArray)
values[Anum_pg_constraint_conpfeqop - 1] = PointerGetDatum(conpfeqopArray); values[Anum_pg_constraint_conpfeqop - 1] = PointerGetDatum(conpfeqopArray);
else else
nulls[Anum_pg_constraint_conpfeqop - 1] = 'n'; nulls[Anum_pg_constraint_conpfeqop - 1] = true;
if (conppeqopArray) if (conppeqopArray)
values[Anum_pg_constraint_conppeqop - 1] = PointerGetDatum(conppeqopArray); values[Anum_pg_constraint_conppeqop - 1] = PointerGetDatum(conppeqopArray);
else else
nulls[Anum_pg_constraint_conppeqop - 1] = 'n'; nulls[Anum_pg_constraint_conppeqop - 1] = true;
if (conffeqopArray) if (conffeqopArray)
values[Anum_pg_constraint_conffeqop - 1] = PointerGetDatum(conffeqopArray); values[Anum_pg_constraint_conffeqop - 1] = PointerGetDatum(conffeqopArray);
else else
nulls[Anum_pg_constraint_conffeqop - 1] = 'n'; nulls[Anum_pg_constraint_conffeqop - 1] = true;
/* /*
* initialize the binary form of the check constraint. * initialize the binary form of the check constraint.
@ -182,7 +182,7 @@ CreateConstraintEntry(const char *constraintName,
if (conBin) if (conBin)
values[Anum_pg_constraint_conbin - 1] = CStringGetTextDatum(conBin); values[Anum_pg_constraint_conbin - 1] = CStringGetTextDatum(conBin);
else else
nulls[Anum_pg_constraint_conbin - 1] = 'n'; nulls[Anum_pg_constraint_conbin - 1] = true;
/* /*
* initialize the text form of the check constraint * initialize the text form of the check constraint
@ -190,9 +190,9 @@ CreateConstraintEntry(const char *constraintName,
if (conSrc) if (conSrc)
values[Anum_pg_constraint_consrc - 1] = CStringGetTextDatum(conSrc); values[Anum_pg_constraint_consrc - 1] = CStringGetTextDatum(conSrc);
else else
nulls[Anum_pg_constraint_consrc - 1] = 'n'; nulls[Anum_pg_constraint_consrc - 1] = true;
tup = heap_formtuple(RelationGetDescr(conDesc), values, nulls); tup = heap_form_tuple(RelationGetDescr(conDesc), values, nulls);
conOid = simple_heap_insert(conDesc, tup); conOid = simple_heap_insert(conDesc, tup);

8
src/backend/catalog/pg_conversion.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/pg_conversion.c,v 1.45 2008/06/19 00:46:04 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/catalog/pg_conversion.c,v 1.46 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -46,7 +46,7 @@ ConversionCreate(const char *conname, Oid connamespace,
Relation rel; Relation rel;
TupleDesc tupDesc; TupleDesc tupDesc;
HeapTuple tup; HeapTuple tup;
char nulls[Natts_pg_conversion]; bool nulls[Natts_pg_conversion];
Datum values[Natts_pg_conversion]; Datum values[Natts_pg_conversion];
NameData cname; NameData cname;
Oid oid; Oid oid;
@ -89,7 +89,7 @@ ConversionCreate(const char *conname, Oid connamespace,
/* initialize nulls and values */ /* initialize nulls and values */
for (i = 0; i < Natts_pg_conversion; i++) for (i = 0; i < Natts_pg_conversion; i++)
{ {
nulls[i] = ' '; nulls[i] = false;
values[i] = (Datum) NULL; values[i] = (Datum) NULL;
} }
@ -103,7 +103,7 @@ ConversionCreate(const char *conname, Oid connamespace,
values[Anum_pg_conversion_conproc - 1] = ObjectIdGetDatum(conproc); values[Anum_pg_conversion_conproc - 1] = ObjectIdGetDatum(conproc);
values[Anum_pg_conversion_condefault - 1] = BoolGetDatum(def); values[Anum_pg_conversion_condefault - 1] = BoolGetDatum(def);
tup = heap_formtuple(tupDesc, values, nulls); tup = heap_form_tuple(tupDesc, values, nulls);
/* insert a new tuple */ /* insert a new tuple */
oid = simple_heap_insert(rel, tup); oid = simple_heap_insert(rel, tup);

8
src/backend/catalog/pg_depend.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/pg_depend.c,v 1.29 2008/06/19 00:46:04 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/catalog/pg_depend.c,v 1.30 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -59,7 +59,7 @@ recordMultipleDependencies(const ObjectAddress *depender,
CatalogIndexState indstate; CatalogIndexState indstate;
HeapTuple tup; HeapTuple tup;
int i; int i;
char nulls[Natts_pg_depend]; bool nulls[Natts_pg_depend];
Datum values[Natts_pg_depend]; Datum values[Natts_pg_depend];
if (nreferenced <= 0) if (nreferenced <= 0)
@ -77,7 +77,7 @@ recordMultipleDependencies(const ObjectAddress *depender,
/* Don't open indexes unless we need to make an update */ /* Don't open indexes unless we need to make an update */
indstate = NULL; indstate = NULL;
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
for (i = 0; i < nreferenced; i++, referenced++) for (i = 0; i < nreferenced; i++, referenced++)
{ {
@ -102,7 +102,7 @@ recordMultipleDependencies(const ObjectAddress *depender,
values[Anum_pg_depend_deptype - 1] = CharGetDatum((char) behavior); values[Anum_pg_depend_deptype - 1] = CharGetDatum((char) behavior);
tup = heap_formtuple(dependDesc->rd_att, values, nulls); tup = heap_form_tuple(dependDesc->rd_att, values, nulls);
simple_heap_insert(dependDesc, tup); simple_heap_insert(dependDesc, tup);

8
src/backend/catalog/pg_enum.c
View File

@ -7,7 +7,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/pg_enum.c,v 1.7 2008/06/19 00:46:04 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/catalog/pg_enum.c,v 1.8 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -42,7 +42,7 @@ EnumValuesCreate(Oid enumTypeOid, List *vals)
int i, int i,
n; n;
Datum values[Natts_pg_enum]; Datum values[Natts_pg_enum];
char nulls[Natts_pg_enum]; bool nulls[Natts_pg_enum];
ListCell *lc; ListCell *lc;
HeapTuple tup; HeapTuple tup;
@ -74,7 +74,7 @@ EnumValuesCreate(Oid enumTypeOid, List *vals)
qsort(oids, n, sizeof(Oid), oid_cmp); qsort(oids, n, sizeof(Oid), oid_cmp);
/* and make the entries */ /* and make the entries */
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
i = 0; i = 0;
foreach(lc, vals) foreach(lc, vals)
@ -96,7 +96,7 @@ EnumValuesCreate(Oid enumTypeOid, List *vals)
namestrcpy(&enumlabel, lab); namestrcpy(&enumlabel, lab);
values[Anum_pg_enum_enumlabel - 1] = NameGetDatum(&enumlabel); values[Anum_pg_enum_enumlabel - 1] = NameGetDatum(&enumlabel);
tup = heap_formtuple(tupDesc, values, nulls); tup = heap_form_tuple(tupDesc, values, nulls);
HeapTupleSetOid(tup, oids[i]); HeapTupleSetOid(tup, oids[i]);
simple_heap_insert(pg_enum, tup); simple_heap_insert(pg_enum, tup);

8
src/backend/catalog/pg_largeobject.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/pg_largeobject.c,v 1.30 2008/06/19 00:46:04 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/catalog/pg_largeobject.c,v 1.31 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -37,7 +37,7 @@ LargeObjectCreate(Oid loid)
Relation pg_largeobject; Relation pg_largeobject;
HeapTuple ntup; HeapTuple ntup;
Datum values[Natts_pg_largeobject]; Datum values[Natts_pg_largeobject];
char nulls[Natts_pg_largeobject]; bool nulls[Natts_pg_largeobject];
int i; int i;
pg_largeobject = heap_open(LargeObjectRelationId, RowExclusiveLock); pg_largeobject = heap_open(LargeObjectRelationId, RowExclusiveLock);
@ -48,7 +48,7 @@ LargeObjectCreate(Oid loid)
for (i = 0; i < Natts_pg_largeobject; i++) for (i = 0; i < Natts_pg_largeobject; i++)
{ {
values[i] = (Datum) NULL; values[i] = (Datum) NULL;
nulls[i] = ' '; nulls[i] = false;
} }
i = 0; i = 0;
@ -57,7 +57,7 @@ LargeObjectCreate(Oid loid)
values[i++] = DirectFunctionCall1(byteain, values[i++] = DirectFunctionCall1(byteain,
CStringGetDatum("")); CStringGetDatum(""));
ntup = heap_formtuple(pg_largeobject->rd_att, values, nulls); ntup = heap_form_tuple(pg_largeobject->rd_att, values, nulls);
/* /*
* Insert it * Insert it

10
src/backend/catalog/pg_namespace.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/pg_namespace.c,v 1.19 2008/06/19 00:46:04 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/catalog/pg_namespace.c,v 1.20 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -33,7 +33,7 @@ NamespaceCreate(const char *nspName, Oid ownerId)
Relation nspdesc; Relation nspdesc;
HeapTuple tup; HeapTuple tup;
Oid nspoid; Oid nspoid;
char nulls[Natts_pg_namespace]; bool nulls[Natts_pg_namespace];
Datum values[Natts_pg_namespace]; Datum values[Natts_pg_namespace];
NameData nname; NameData nname;
TupleDesc tupDesc; TupleDesc tupDesc;
@ -54,18 +54,18 @@ NamespaceCreate(const char *nspName, Oid ownerId)
/* initialize nulls and values */ /* initialize nulls and values */
for (i = 0; i < Natts_pg_namespace; i++) for (i = 0; i < Natts_pg_namespace; i++)
{ {
nulls[i] = ' '; nulls[i] = false;
values[i] = (Datum) NULL; values[i] = (Datum) NULL;
} }
namestrcpy(&nname, nspName); namestrcpy(&nname, nspName);
values[Anum_pg_namespace_nspname - 1] = NameGetDatum(&nname); values[Anum_pg_namespace_nspname - 1] = NameGetDatum(&nname);
values[Anum_pg_namespace_nspowner - 1] = ObjectIdGetDatum(ownerId); values[Anum_pg_namespace_nspowner - 1] = ObjectIdGetDatum(ownerId);
nulls[Anum_pg_namespace_nspacl - 1] = 'n'; nulls[Anum_pg_namespace_nspacl - 1] = true;
nspdesc = heap_open(NamespaceRelationId, RowExclusiveLock); nspdesc = heap_open(NamespaceRelationId, RowExclusiveLock);
tupDesc = nspdesc->rd_att; tupDesc = nspdesc->rd_att;
tup = heap_formtuple(tupDesc, values, nulls); tup = heap_form_tuple(tupDesc, values, nulls);
nspoid = simple_heap_insert(nspdesc, tup); nspoid = simple_heap_insert(nspdesc, tup);
Assert(OidIsValid(nspoid)); Assert(OidIsValid(nspoid));

44
src/backend/catalog/pg_operator.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/pg_operator.c,v 1.105 2008/08/16 00:01:35 tgl Exp $ * $PostgreSQL: pgsql/src/backend/catalog/pg_operator.c,v 1.106 2008/11/02 01:45:27 tgl Exp $
* *
* NOTES * NOTES
* these routines moved here from commands/define.c and somewhat cleaned up. * these routines moved here from commands/define.c and somewhat cleaned up.
@ -207,7 +207,7 @@ OperatorShellMake(const char *operatorName,
int i; int i;
HeapTuple tup; HeapTuple tup;
Datum values[Natts_pg_operator]; Datum values[Natts_pg_operator];
char nulls[Natts_pg_operator]; bool nulls[Natts_pg_operator];
NameData oname; NameData oname;
TupleDesc tupDesc; TupleDesc tupDesc;
@ -225,7 +225,7 @@ OperatorShellMake(const char *operatorName,
*/ */
for (i = 0; i < Natts_pg_operator; ++i) for (i = 0; i < Natts_pg_operator; ++i)
{ {
nulls[i] = ' '; nulls[i] = false;
values[i] = (Datum) NULL; /* redundant, but safe */ values[i] = (Datum) NULL; /* redundant, but safe */
} }
@ -259,7 +259,7 @@ OperatorShellMake(const char *operatorName,
/* /*
* create a new operator tuple * create a new operator tuple
*/ */
tup = heap_formtuple(tupDesc, values, nulls); tup = heap_form_tuple(tupDesc, values, nulls);
/* /*
* insert our "shell" operator tuple * insert our "shell" operator tuple
@ -336,8 +336,8 @@ OperatorCreate(const char *operatorName,
{ {
Relation pg_operator_desc; Relation pg_operator_desc;
HeapTuple tup; HeapTuple tup;
char nulls[Natts_pg_operator]; bool nulls[Natts_pg_operator];
char replaces[Natts_pg_operator]; bool replaces[Natts_pg_operator];
Datum values[Natts_pg_operator]; Datum values[Natts_pg_operator];
Oid operatorObjectId; Oid operatorObjectId;
bool operatorAlreadyDefined; bool operatorAlreadyDefined;
@ -483,8 +483,8 @@ OperatorCreate(const char *operatorName,
for (i = 0; i < Natts_pg_operator; ++i) for (i = 0; i < Natts_pg_operator; ++i)
{ {
values[i] = (Datum) NULL; values[i] = (Datum) NULL;
replaces[i] = 'r'; replaces[i] = true;
nulls[i] = ' '; nulls[i] = false;
} }
i = 0; i = 0;
@ -518,7 +518,7 @@ OperatorCreate(const char *operatorName,
elog(ERROR, "cache lookup failed for operator %u", elog(ERROR, "cache lookup failed for operator %u",
operatorObjectId); operatorObjectId);
tup = heap_modifytuple(tup, tup = heap_modify_tuple(tup,
RelationGetDescr(pg_operator_desc), RelationGetDescr(pg_operator_desc),
values, values,
nulls, nulls,
@ -529,7 +529,7 @@ OperatorCreate(const char *operatorName,
else else
{ {
tupDesc = pg_operator_desc->rd_att; tupDesc = pg_operator_desc->rd_att;
tup = heap_formtuple(tupDesc, values, nulls); tup = heap_form_tuple(tupDesc, values, nulls);
operatorObjectId = simple_heap_insert(pg_operator_desc, tup); operatorObjectId = simple_heap_insert(pg_operator_desc, tup);
} }
@ -639,15 +639,15 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId)
int i; int i;
Relation pg_operator_desc; Relation pg_operator_desc;
HeapTuple tup; HeapTuple tup;
char nulls[Natts_pg_operator]; bool nulls[Natts_pg_operator];
char replaces[Natts_pg_operator]; bool replaces[Natts_pg_operator];
Datum values[Natts_pg_operator]; Datum values[Natts_pg_operator];
for (i = 0; i < Natts_pg_operator; ++i) for (i = 0; i < Natts_pg_operator; ++i)
{ {
values[i] = (Datum) 0; values[i] = (Datum) 0;
replaces[i] = ' '; replaces[i] = false;
nulls[i] = ' '; nulls[i] = false;
} }
/* /*
@ -680,16 +680,16 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId)
if (!OidIsValid(t->oprnegate)) if (!OidIsValid(t->oprnegate))
{ {
values[Anum_pg_operator_oprnegate - 1] = ObjectIdGetDatum(baseId); values[Anum_pg_operator_oprnegate - 1] = ObjectIdGetDatum(baseId);
replaces[Anum_pg_operator_oprnegate - 1] = 'r'; replaces[Anum_pg_operator_oprnegate - 1] = true;
} }
if (!OidIsValid(t->oprcom)) if (!OidIsValid(t->oprcom))
{ {
values[Anum_pg_operator_oprcom - 1] = ObjectIdGetDatum(baseId); values[Anum_pg_operator_oprcom - 1] = ObjectIdGetDatum(baseId);
replaces[Anum_pg_operator_oprcom - 1] = 'r'; replaces[Anum_pg_operator_oprcom - 1] = true;
} }
tup = heap_modifytuple(tup, tup = heap_modify_tuple(tup,
RelationGetDescr(pg_operator_desc), RelationGetDescr(pg_operator_desc),
values, values,
nulls, nulls,
@ -712,9 +712,9 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId)
!(OidIsValid(((Form_pg_operator) GETSTRUCT(tup))->oprcom))) !(OidIsValid(((Form_pg_operator) GETSTRUCT(tup))->oprcom)))
{ {
values[Anum_pg_operator_oprcom - 1] = ObjectIdGetDatum(baseId); values[Anum_pg_operator_oprcom - 1] = ObjectIdGetDatum(baseId);
replaces[Anum_pg_operator_oprcom - 1] = 'r'; replaces[Anum_pg_operator_oprcom - 1] = true;
tup = heap_modifytuple(tup, tup = heap_modify_tuple(tup,
RelationGetDescr(pg_operator_desc), RelationGetDescr(pg_operator_desc),
values, values,
nulls, nulls,
@ -725,7 +725,7 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId)
CatalogUpdateIndexes(pg_operator_desc, tup); CatalogUpdateIndexes(pg_operator_desc, tup);
values[Anum_pg_operator_oprcom - 1] = (Datum) NULL; values[Anum_pg_operator_oprcom - 1] = (Datum) NULL;
replaces[Anum_pg_operator_oprcom - 1] = ' '; replaces[Anum_pg_operator_oprcom - 1] = false;
} }
/* check and update the negator, if necessary */ /* check and update the negator, if necessary */
@ -738,9 +738,9 @@ OperatorUpd(Oid baseId, Oid commId, Oid negId)
!(OidIsValid(((Form_pg_operator) GETSTRUCT(tup))->oprnegate))) !(OidIsValid(((Form_pg_operator) GETSTRUCT(tup))->oprnegate)))
{ {
values[Anum_pg_operator_oprnegate - 1] = ObjectIdGetDatum(baseId); values[Anum_pg_operator_oprnegate - 1] = ObjectIdGetDatum(baseId);
replaces[Anum_pg_operator_oprnegate - 1] = 'r'; replaces[Anum_pg_operator_oprnegate - 1] = true;
tup = heap_modifytuple(tup, tup = heap_modify_tuple(tup,
RelationGetDescr(pg_operator_desc), RelationGetDescr(pg_operator_desc),
values, values,
nulls, nulls,

30
src/backend/catalog/pg_proc.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/pg_proc.c,v 1.153 2008/07/18 03:32:52 tgl Exp $ * $PostgreSQL: pgsql/src/backend/catalog/pg_proc.c,v 1.154 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -89,9 +89,9 @@ ProcedureCreate(const char *procedureName,
Relation rel; Relation rel;
HeapTuple tup; HeapTuple tup;
HeapTuple oldtup; HeapTuple oldtup;
char nulls[Natts_pg_proc]; bool nulls[Natts_pg_proc];
Datum values[Natts_pg_proc]; Datum values[Natts_pg_proc];
char replaces[Natts_pg_proc]; bool replaces[Natts_pg_proc];
Oid relid; Oid relid;
NameData procname; NameData procname;
TupleDesc tupDesc; TupleDesc tupDesc;
@ -276,9 +276,9 @@ ProcedureCreate(const char *procedureName,
for (i = 0; i < Natts_pg_proc; ++i) for (i = 0; i < Natts_pg_proc; ++i)
{ {
nulls[i] = ' '; nulls[i] = false;
values[i] = (Datum) 0; values[i] = (Datum) 0;
replaces[i] = 'r'; replaces[i] = true;
} }
namestrcpy(&procname, procedureName); namestrcpy(&procname, procedureName);
@ -300,26 +300,26 @@ ProcedureCreate(const char *procedureName,
if (allParameterTypes != PointerGetDatum(NULL)) if (allParameterTypes != PointerGetDatum(NULL))
values[Anum_pg_proc_proallargtypes - 1] = allParameterTypes; values[Anum_pg_proc_proallargtypes - 1] = allParameterTypes;
else else
nulls[Anum_pg_proc_proallargtypes - 1] = 'n'; nulls[Anum_pg_proc_proallargtypes - 1] = true;
if (parameterModes != PointerGetDatum(NULL)) if (parameterModes != PointerGetDatum(NULL))
values[Anum_pg_proc_proargmodes - 1] = parameterModes; values[Anum_pg_proc_proargmodes - 1] = parameterModes;
else else
nulls[Anum_pg_proc_proargmodes - 1] = 'n'; nulls[Anum_pg_proc_proargmodes - 1] = true;
if (parameterNames != PointerGetDatum(NULL)) if (parameterNames != PointerGetDatum(NULL))
values[Anum_pg_proc_proargnames - 1] = parameterNames; values[Anum_pg_proc_proargnames - 1] = parameterNames;
else else
nulls[Anum_pg_proc_proargnames - 1] = 'n'; nulls[Anum_pg_proc_proargnames - 1] = true;
values[Anum_pg_proc_prosrc - 1] = CStringGetTextDatum(prosrc); values[Anum_pg_proc_prosrc - 1] = CStringGetTextDatum(prosrc);
if (probin) if (probin)
values[Anum_pg_proc_probin - 1] = CStringGetTextDatum(probin); values[Anum_pg_proc_probin - 1] = CStringGetTextDatum(probin);
else else
nulls[Anum_pg_proc_probin - 1] = 'n'; nulls[Anum_pg_proc_probin - 1] = true;
if (proconfig != PointerGetDatum(NULL)) if (proconfig != PointerGetDatum(NULL))
values[Anum_pg_proc_proconfig - 1] = proconfig; values[Anum_pg_proc_proconfig - 1] = proconfig;
else else
nulls[Anum_pg_proc_proconfig - 1] = 'n'; nulls[Anum_pg_proc_proconfig - 1] = true;
/* start out with empty permissions */ /* start out with empty permissions */
nulls[Anum_pg_proc_proacl - 1] = 'n'; nulls[Anum_pg_proc_proacl - 1] = true;
rel = heap_open(ProcedureRelationId, RowExclusiveLock); rel = heap_open(ProcedureRelationId, RowExclusiveLock);
tupDesc = RelationGetDescr(rel); tupDesc = RelationGetDescr(rel);
@ -396,11 +396,11 @@ ProcedureCreate(const char *procedureName,
} }
/* do not change existing ownership or permissions, either */ /* do not change existing ownership or permissions, either */
replaces[Anum_pg_proc_proowner - 1] = ' '; replaces[Anum_pg_proc_proowner - 1] = false;
replaces[Anum_pg_proc_proacl - 1] = ' '; replaces[Anum_pg_proc_proacl - 1] = false;
/* Okay, do it... */ /* Okay, do it... */
tup = heap_modifytuple(oldtup, tupDesc, values, nulls, replaces); tup = heap_modify_tuple(oldtup, tupDesc, values, nulls, replaces);
simple_heap_update(rel, &tup->t_self, tup); simple_heap_update(rel, &tup->t_self, tup);
ReleaseSysCache(oldtup); ReleaseSysCache(oldtup);
@ -409,7 +409,7 @@ ProcedureCreate(const char *procedureName,
else else
{ {
/* Creating a new procedure */ /* Creating a new procedure */
tup = heap_formtuple(tupDesc, values, nulls); tup = heap_form_tuple(tupDesc, values, nulls);
simple_heap_insert(rel, tup); simple_heap_insert(rel, tup);
is_update = false; is_update = false;
} }

4
src/backend/catalog/pg_shdepend.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/pg_shdepend.c,v 1.28 2008/05/12 00:00:47 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/catalog/pg_shdepend.c,v 1.29 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -239,7 +239,7 @@ shdepChangeDep(Relation sdepRel, Oid classid, Oid objid,
Datum values[Natts_pg_shdepend]; Datum values[Natts_pg_shdepend];
bool nulls[Natts_pg_shdepend]; bool nulls[Natts_pg_shdepend];
memset(nulls, 0, sizeof(nulls)); memset(nulls, false, sizeof(nulls));
values[Anum_pg_shdepend_dbid - 1] = ObjectIdGetDatum(dbid); values[Anum_pg_shdepend_dbid - 1] = ObjectIdGetDatum(dbid);
values[Anum_pg_shdepend_classid - 1] = ObjectIdGetDatum(classid); values[Anum_pg_shdepend_classid - 1] = ObjectIdGetDatum(classid);

30
src/backend/catalog/pg_type.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/catalog/pg_type.c,v 1.121 2008/08/03 15:23:58 tgl Exp $ * $PostgreSQL: pgsql/src/backend/catalog/pg_type.c,v 1.122 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -54,7 +54,7 @@ TypeShellMake(const char *typeName, Oid typeNamespace)
int i; int i;
HeapTuple tup; HeapTuple tup;
Datum values[Natts_pg_type]; Datum values[Natts_pg_type];
char nulls[Natts_pg_type]; bool nulls[Natts_pg_type];
Oid typoid; Oid typoid;
NameData name; NameData name;
@ -71,7 +71,7 @@ TypeShellMake(const char *typeName, Oid typeNamespace)
*/ */
for (i = 0; i < Natts_pg_type; ++i) for (i = 0; i < Natts_pg_type; ++i)
{ {
nulls[i] = ' '; nulls[i] = false;
values[i] = (Datum) NULL; /* redundant, but safe */ values[i] = (Datum) NULL; /* redundant, but safe */
} }
@ -111,13 +111,13 @@ TypeShellMake(const char *typeName, Oid typeNamespace)
values[i++] = ObjectIdGetDatum(InvalidOid); /* typbasetype */ values[i++] = ObjectIdGetDatum(InvalidOid); /* typbasetype */
values[i++] = Int32GetDatum(-1); /* typtypmod */ values[i++] = Int32GetDatum(-1); /* typtypmod */
values[i++] = Int32GetDatum(0); /* typndims */ values[i++] = Int32GetDatum(0); /* typndims */
nulls[i++] = 'n'; /* typdefaultbin */ nulls[i++] = true; /* typdefaultbin */
nulls[i++] = 'n'; /* typdefault */ nulls[i++] = true; /* typdefault */
/* /*
* create a new type tuple * create a new type tuple
*/ */
tup = heap_formtuple(tupDesc, values, nulls); tup = heap_form_tuple(tupDesc, values, nulls);
/* /*
* insert the tuple in the relation and get the tuple's oid. * insert the tuple in the relation and get the tuple's oid.
@ -202,8 +202,8 @@ TypeCreate(Oid newTypeOid,
Oid typeObjectId; Oid typeObjectId;
bool rebuildDeps = false; bool rebuildDeps = false;
HeapTuple tup; HeapTuple tup;
char nulls[Natts_pg_type]; bool nulls[Natts_pg_type];
char replaces[Natts_pg_type]; bool replaces[Natts_pg_type];
Datum values[Natts_pg_type]; Datum values[Natts_pg_type];
NameData name; NameData name;
int i; int i;
@ -294,12 +294,12 @@ TypeCreate(Oid newTypeOid,
errmsg("fixed-size types must have storage PLAIN"))); errmsg("fixed-size types must have storage PLAIN")));
/* /*
* initialize arrays needed for heap_formtuple or heap_modifytuple * initialize arrays needed for heap_form_tuple or heap_modify_tuple
*/ */
for (i = 0; i < Natts_pg_type; ++i) for (i = 0; i < Natts_pg_type; ++i)
{ {
nulls[i] = ' '; nulls[i] = false;
replaces[i] = 'r'; replaces[i] = true;
values[i] = (Datum) 0; values[i] = (Datum) 0;
} }
@ -342,7 +342,7 @@ TypeCreate(Oid newTypeOid,
if (defaultTypeBin) if (defaultTypeBin)
values[i] = CStringGetTextDatum(defaultTypeBin); values[i] = CStringGetTextDatum(defaultTypeBin);
else else
nulls[i] = 'n'; nulls[i] = true;
i++; /* typdefaultbin */ i++; /* typdefaultbin */
/* /*
@ -351,7 +351,7 @@ TypeCreate(Oid newTypeOid,
if (defaultTypeValue) if (defaultTypeValue)
values[i] = CStringGetTextDatum(defaultTypeValue); values[i] = CStringGetTextDatum(defaultTypeValue);
else else
nulls[i] = 'n'; nulls[i] = true;
i++; /* typdefault */ i++; /* typdefault */
/* /*
@ -390,7 +390,7 @@ TypeCreate(Oid newTypeOid,
/* /*
* Okay to update existing shell type tuple * Okay to update existing shell type tuple
*/ */
tup = heap_modifytuple(tup, tup = heap_modify_tuple(tup,
RelationGetDescr(pg_type_desc), RelationGetDescr(pg_type_desc),
values, values,
nulls, nulls,
@ -404,7 +404,7 @@ TypeCreate(Oid newTypeOid,
} }
else else
{ {
tup = heap_formtuple(RelationGetDescr(pg_type_desc), tup = heap_form_tuple(RelationGetDescr(pg_type_desc),
values, values,
nulls); nulls);

18
src/backend/commands/analyze.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/analyze.c,v 1.126 2008/10/31 15:05:00 heikki Exp $ * $PostgreSQL: pgsql/src/backend/commands/analyze.c,v 1.127 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -1277,8 +1277,8 @@ update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats)
k, k,
n; n;
Datum values[Natts_pg_statistic]; Datum values[Natts_pg_statistic];
char nulls[Natts_pg_statistic]; bool nulls[Natts_pg_statistic];
char replaces[Natts_pg_statistic]; bool replaces[Natts_pg_statistic];
/* Ignore attr if we weren't able to collect stats */ /* Ignore attr if we weren't able to collect stats */
if (!stats->stats_valid) if (!stats->stats_valid)
@ -1289,8 +1289,8 @@ update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats)
*/ */
for (i = 0; i < Natts_pg_statistic; ++i) for (i = 0; i < Natts_pg_statistic; ++i)
{ {
nulls[i] = ' '; nulls[i] = false;
replaces[i] = 'r'; replaces[i] = true;
} }
i = 0; i = 0;
@ -1326,7 +1326,7 @@ update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats)
} }
else else
{ {
nulls[i] = 'n'; nulls[i] = true;
values[i++] = (Datum) 0; values[i++] = (Datum) 0;
} }
} }
@ -1346,7 +1346,7 @@ update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats)
} }
else else
{ {
nulls[i] = 'n'; nulls[i] = true;
values[i++] = (Datum) 0; values[i++] = (Datum) 0;
} }
} }
@ -1360,7 +1360,7 @@ update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats)
if (HeapTupleIsValid(oldtup)) if (HeapTupleIsValid(oldtup))
{ {
/* Yes, replace it */ /* Yes, replace it */
stup = heap_modifytuple(oldtup, stup = heap_modify_tuple(oldtup,
RelationGetDescr(sd), RelationGetDescr(sd),
values, values,
nulls, nulls,
@ -1371,7 +1371,7 @@ update_attstats(Oid relid, int natts, VacAttrStats **vacattrstats)
else else
{ {
/* No, insert new tuple */ /* No, insert new tuple */
stup = heap_formtuple(RelationGetDescr(sd), values, nulls); stup = heap_form_tuple(RelationGetDescr(sd), values, nulls);
simple_heap_insert(sd, stup); simple_heap_insert(sd, stup);
} }

32
src/backend/commands/async.c
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/async.c,v 1.141 2008/08/30 01:39:13 tgl Exp $ * $PostgreSQL: pgsql/src/backend/commands/async.c,v 1.142 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -446,7 +446,7 @@ Exec_Listen(Relation lRel, const char *relname)
HeapScanDesc scan; HeapScanDesc scan;
HeapTuple tuple; HeapTuple tuple;
Datum values[Natts_pg_listener]; Datum values[Natts_pg_listener];
char nulls[Natts_pg_listener]; bool nulls[Natts_pg_listener];
NameData condname; NameData condname;
bool alreadyListener = false; bool alreadyListener = false;
@ -475,14 +475,14 @@ Exec_Listen(Relation lRel, const char *relname)
/* /*
* OK to insert a new tuple * OK to insert a new tuple
*/ */
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
namestrcpy(&condname, relname); namestrcpy(&condname, relname);
values[Anum_pg_listener_relname - 1] = NameGetDatum(&condname); values[Anum_pg_listener_relname - 1] = NameGetDatum(&condname);
values[Anum_pg_listener_pid - 1] = Int32GetDatum(MyProcPid); values[Anum_pg_listener_pid - 1] = Int32GetDatum(MyProcPid);
values[Anum_pg_listener_notify - 1] = Int32GetDatum(0); /* no notifies pending */ values[Anum_pg_listener_notify - 1] = Int32GetDatum(0); /* no notifies pending */
tuple = heap_formtuple(RelationGetDescr(lRel), values, nulls); tuple = heap_form_tuple(RelationGetDescr(lRel), values, nulls);
simple_heap_insert(lRel, tuple); simple_heap_insert(lRel, tuple);
@ -585,14 +585,14 @@ Send_Notify(Relation lRel)
HeapTuple lTuple, HeapTuple lTuple,
rTuple; rTuple;
Datum value[Natts_pg_listener]; Datum value[Natts_pg_listener];
char repl[Natts_pg_listener], bool repl[Natts_pg_listener],
nulls[Natts_pg_listener]; nulls[Natts_pg_listener];
/* preset data to update notify column to MyProcPid */ /* preset data to update notify column to MyProcPid */
nulls[0] = nulls[1] = nulls[2] = ' '; memset(nulls, false, sizeof(nulls));
repl[0] = repl[1] = repl[2] = ' '; memset(repl, false, sizeof(repl));
repl[Anum_pg_listener_notify - 1] = 'r'; repl[Anum_pg_listener_notify - 1] = true;
value[0] = value[1] = value[2] = (Datum) 0; memset(value, 0, sizeof(value));
value[Anum_pg_listener_notify - 1] = Int32GetDatum(MyProcPid); value[Anum_pg_listener_notify - 1] = Int32GetDatum(MyProcPid);
scan = heap_beginscan(lRel, SnapshotNow, 0, NULL); scan = heap_beginscan(lRel, SnapshotNow, 0, NULL);
@ -647,7 +647,7 @@ Send_Notify(Relation lRel)
else if (listener->notification == 0) else if (listener->notification == 0)
{ {
/* Rewrite the tuple with my PID in notification column */ /* Rewrite the tuple with my PID in notification column */
rTuple = heap_modifytuple(lTuple, tdesc, value, nulls, repl); rTuple = heap_modify_tuple(lTuple, tdesc, value, nulls, repl);
simple_heap_update(lRel, &lTuple->t_self, rTuple); simple_heap_update(lRel, &lTuple->t_self, rTuple);
#ifdef NOT_USED /* currently there are no indexes */ #ifdef NOT_USED /* currently there are no indexes */
@ -950,7 +950,7 @@ ProcessIncomingNotify(void)
HeapTuple lTuple, HeapTuple lTuple,
rTuple; rTuple;
Datum value[Natts_pg_listener]; Datum value[Natts_pg_listener];
char repl[Natts_pg_listener], bool repl[Natts_pg_listener],
nulls[Natts_pg_listener]; nulls[Natts_pg_listener];
bool catchup_enabled; bool catchup_enabled;
@ -977,10 +977,10 @@ ProcessIncomingNotify(void)
scan = heap_beginscan(lRel, SnapshotNow, 1, key); scan = heap_beginscan(lRel, SnapshotNow, 1, key);
/* Prepare data for rewriting 0 into notification field */ /* Prepare data for rewriting 0 into notification field */
nulls[0] = nulls[1] = nulls[2] = ' '; memset(nulls, false, sizeof(nulls));
repl[0] = repl[1] = repl[2] = ' '; memset(repl, false, sizeof(repl));
repl[Anum_pg_listener_notify - 1] = 'r'; repl[Anum_pg_listener_notify - 1] = true;
value[0] = value[1] = value[2] = (Datum) 0; memset(value, 0, sizeof(value));
value[Anum_pg_listener_notify - 1] = Int32GetDatum(0); value[Anum_pg_listener_notify - 1] = Int32GetDatum(0);
while ((lTuple = heap_getnext(scan, ForwardScanDirection)) != NULL) while ((lTuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
@ -1002,7 +1002,7 @@ ProcessIncomingNotify(void)
/* /*
* Rewrite the tuple with 0 in notification column. * Rewrite the tuple with 0 in notification column.
*/ */
rTuple = heap_modifytuple(lTuple, tdesc, value, nulls, repl); rTuple = heap_modify_tuple(lTuple, tdesc, value, nulls, repl);
simple_heap_update(lRel, &lTuple->t_self, rTuple); simple_heap_update(lRel, &lTuple->t_self, rTuple);
#ifdef NOT_USED /* currently there are no indexes */ #ifdef NOT_USED /* currently there are no indexes */

26
src/backend/commands/comment.c
View File

@ -7,7 +7,7 @@
* Copyright (c) 1996-2008, PostgreSQL Global Development Group * Copyright (c) 1996-2008, PostgreSQL Global Development Group
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/comment.c,v 1.104 2008/10/21 10:38:51 petere Exp $ * $PostgreSQL: pgsql/src/backend/commands/comment.c,v 1.105 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -197,8 +197,8 @@ CreateComments(Oid oid, Oid classoid, int32 subid, char *comment)
HeapTuple oldtuple; HeapTuple oldtuple;
HeapTuple newtuple = NULL; HeapTuple newtuple = NULL;
Datum values[Natts_pg_description]; Datum values[Natts_pg_description];
char nulls[Natts_pg_description]; bool nulls[Natts_pg_description];
char replaces[Natts_pg_description]; bool replaces[Natts_pg_description];
int i; int i;
/* Reduce empty-string to NULL case */ /* Reduce empty-string to NULL case */
@ -210,8 +210,8 @@ CreateComments(Oid oid, Oid classoid, int32 subid, char *comment)
{ {
for (i = 0; i < Natts_pg_description; i++) for (i = 0; i < Natts_pg_description; i++)
{ {
nulls[i] = ' '; nulls[i] = false;
replaces[i] = 'r'; replaces[i] = true;
} }
i = 0; i = 0;
values[i++] = ObjectIdGetDatum(oid); values[i++] = ObjectIdGetDatum(oid);
@ -248,7 +248,7 @@ CreateComments(Oid oid, Oid classoid, int32 subid, char *comment)
simple_heap_delete(description, &oldtuple->t_self); simple_heap_delete(description, &oldtuple->t_self);
else else
{ {
newtuple = heap_modifytuple(oldtuple, RelationGetDescr(description), values, newtuple = heap_modify_tuple(oldtuple, RelationGetDescr(description), values,
nulls, replaces); nulls, replaces);
simple_heap_update(description, &oldtuple->t_self, newtuple); simple_heap_update(description, &oldtuple->t_self, newtuple);
} }
@ -262,7 +262,7 @@ CreateComments(Oid oid, Oid classoid, int32 subid, char *comment)
if (newtuple == NULL && comment != NULL) if (newtuple == NULL && comment != NULL)
{ {
newtuple = heap_formtuple(RelationGetDescr(description), newtuple = heap_form_tuple(RelationGetDescr(description),
values, nulls); values, nulls);
simple_heap_insert(description, newtuple); simple_heap_insert(description, newtuple);
} }
@ -297,8 +297,8 @@ CreateSharedComments(Oid oid, Oid classoid, char *comment)
HeapTuple oldtuple; HeapTuple oldtuple;
HeapTuple newtuple = NULL; HeapTuple newtuple = NULL;
Datum values[Natts_pg_shdescription]; Datum values[Natts_pg_shdescription];
char nulls[Natts_pg_shdescription]; bool nulls[Natts_pg_shdescription];
char replaces[Natts_pg_shdescription]; bool replaces[Natts_pg_shdescription];
int i; int i;
/* Reduce empty-string to NULL case */ /* Reduce empty-string to NULL case */
@ -310,8 +310,8 @@ CreateSharedComments(Oid oid, Oid classoid, char *comment)
{ {
for (i = 0; i < Natts_pg_shdescription; i++) for (i = 0; i < Natts_pg_shdescription; i++)
{ {
nulls[i] = ' '; nulls[i] = false;
replaces[i] = 'r'; replaces[i] = true;
} }
i = 0; i = 0;
values[i++] = ObjectIdGetDatum(oid); values[i++] = ObjectIdGetDatum(oid);
@ -343,7 +343,7 @@ CreateSharedComments(Oid oid, Oid classoid, char *comment)
simple_heap_delete(shdescription, &oldtuple->t_self); simple_heap_delete(shdescription, &oldtuple->t_self);
else else
{ {
newtuple = heap_modifytuple(oldtuple, RelationGetDescr(shdescription), newtuple = heap_modify_tuple(oldtuple, RelationGetDescr(shdescription),
values, nulls, replaces); values, nulls, replaces);
simple_heap_update(shdescription, &oldtuple->t_self, newtuple); simple_heap_update(shdescription, &oldtuple->t_self, newtuple);
} }
@ -357,7 +357,7 @@ CreateSharedComments(Oid oid, Oid classoid, char *comment)
if (newtuple == NULL && comment != NULL) if (newtuple == NULL && comment != NULL)
{ {
newtuple = heap_formtuple(RelationGetDescr(shdescription), newtuple = heap_form_tuple(RelationGetDescr(shdescription),
values, nulls); values, nulls);
simple_heap_insert(shdescription, newtuple); simple_heap_insert(shdescription, newtuple);
} }

19
src/backend/commands/copy.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/copy.c,v 1.299 2008/05/12 20:01:59 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/commands/copy.c,v 1.300 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -1638,7 +1638,7 @@ CopyFrom(CopyState cstate)
int i; int i;
Oid in_func_oid; Oid in_func_oid;
Datum *values; Datum *values;
char *nulls; bool *nulls;
int nfields; int nfields;
char **field_strings; char **field_strings;
bool done = false; bool done = false;
@ -1872,7 +1872,7 @@ CopyFrom(CopyState cstate)
} }
values = (Datum *) palloc(num_phys_attrs * sizeof(Datum)); values = (Datum *) palloc(num_phys_attrs * sizeof(Datum));
nulls = (char *) palloc(num_phys_attrs * sizeof(char)); nulls = (bool *) palloc(num_phys_attrs * sizeof(bool));
/* create workspace for CopyReadAttributes results */ /* create workspace for CopyReadAttributes results */
nfields = file_has_oids ? (attr_count + 1) : attr_count; nfields = file_has_oids ? (attr_count + 1) : attr_count;
@ -1916,7 +1916,7 @@ CopyFrom(CopyState cstate)
/* Initialize all values for row to NULL */ /* Initialize all values for row to NULL */
MemSet(values, 0, num_phys_attrs * sizeof(Datum)); MemSet(values, 0, num_phys_attrs * sizeof(Datum));
MemSet(nulls, 'n', num_phys_attrs * sizeof(char)); MemSet(nulls, true, num_phys_attrs * sizeof(bool));
if (!cstate->binary) if (!cstate->binary)
{ {
@ -1998,7 +1998,7 @@ CopyFrom(CopyState cstate)
typioparams[m], typioparams[m],
attr[m]->atttypmod); attr[m]->atttypmod);
if (string != NULL) if (string != NULL)
nulls[m] = ' '; nulls[m] = false;
cstate->cur_attname = NULL; cstate->cur_attname = NULL;
cstate->cur_attval = NULL; cstate->cur_attval = NULL;
} }
@ -2054,8 +2054,7 @@ CopyFrom(CopyState cstate)
&in_functions[m], &in_functions[m],
typioparams[m], typioparams[m],
attr[m]->atttypmod, attr[m]->atttypmod,
&isnull); &nulls[m]);
nulls[m] = isnull ? 'n' : ' ';
cstate->cur_attname = NULL; cstate->cur_attname = NULL;
} }
} }
@ -2068,13 +2067,11 @@ CopyFrom(CopyState cstate)
for (i = 0; i < num_defaults; i++) for (i = 0; i < num_defaults; i++)
{ {
values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext, values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
&isnull, NULL); &nulls[defmap[i]], NULL);
if (!isnull)
nulls[defmap[i]] = ' ';
} }
/* And now we can form the input tuple. */ /* And now we can form the input tuple. */
tuple = heap_formtuple(tupDesc, values, nulls); tuple = heap_form_tuple(tupDesc, values, nulls);
if (cstate->oids && file_has_oids) if (cstate->oids && file_has_oids)
HeapTupleSetOid(tuple, loaded_oid); HeapTupleSetOid(tuple, loaded_oid);

54
src/backend/commands/dbcommands.c
View File

@ -13,7 +13,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/dbcommands.c,v 1.214 2008/10/09 10:34:06 heikki Exp $ * $PostgreSQL: pgsql/src/backend/commands/dbcommands.c,v 1.215 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -98,7 +98,7 @@ createdb(const CreatedbStmt *stmt)
Relation pg_database_rel; Relation pg_database_rel;
HeapTuple tuple; HeapTuple tuple;
Datum new_record[Natts_pg_database]; Datum new_record[Natts_pg_database];
char new_record_nulls[Natts_pg_database]; bool new_record_nulls[Natts_pg_database];
Oid dboid; Oid dboid;
Oid datdba; Oid datdba;
ListCell *option; ListCell *option;
@ -492,7 +492,7 @@ createdb(const CreatedbStmt *stmt)
/* Form tuple */ /* Form tuple */
MemSet(new_record, 0, sizeof(new_record)); MemSet(new_record, 0, sizeof(new_record));
MemSet(new_record_nulls, ' ', sizeof(new_record_nulls)); MemSet(new_record_nulls, false, sizeof(new_record_nulls));
new_record[Anum_pg_database_datname - 1] = new_record[Anum_pg_database_datname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(dbname)); DirectFunctionCall1(namein, CStringGetDatum(dbname));
@ -515,10 +515,10 @@ createdb(const CreatedbStmt *stmt)
* a bad idea when the owner is not the same as the template's owner. It's * a bad idea when the owner is not the same as the template's owner. It's
* more debatable whether datconfig should be copied. * more debatable whether datconfig should be copied.
*/ */
new_record_nulls[Anum_pg_database_datconfig - 1] = 'n'; new_record_nulls[Anum_pg_database_datconfig - 1] = true;
new_record_nulls[Anum_pg_database_datacl - 1] = 'n'; new_record_nulls[Anum_pg_database_datacl - 1] = true;
tuple = heap_formtuple(RelationGetDescr(pg_database_rel), tuple = heap_form_tuple(RelationGetDescr(pg_database_rel),
new_record, new_record_nulls); new_record, new_record_nulls);
HeapTupleSetOid(tuple, dboid); HeapTupleSetOid(tuple, dboid);
@ -949,8 +949,8 @@ AlterDatabase(AlterDatabaseStmt *stmt)
int connlimit = -1; int connlimit = -1;
DefElem *dconnlimit = NULL; DefElem *dconnlimit = NULL;
Datum new_record[Natts_pg_database]; Datum new_record[Natts_pg_database];
char new_record_nulls[Natts_pg_database]; bool new_record_nulls[Natts_pg_database];
char new_record_repl[Natts_pg_database]; bool new_record_repl[Natts_pg_database];
/* Extract options from the statement node tree */ /* Extract options from the statement node tree */
foreach(option, stmt->options) foreach(option, stmt->options)
@ -999,16 +999,16 @@ AlterDatabase(AlterDatabaseStmt *stmt)
* Build an updated tuple, perusing the information just obtained * Build an updated tuple, perusing the information just obtained
*/ */
MemSet(new_record, 0, sizeof(new_record)); MemSet(new_record, 0, sizeof(new_record));
MemSet(new_record_nulls, ' ', sizeof(new_record_nulls)); MemSet(new_record_nulls, false, sizeof(new_record_nulls));
MemSet(new_record_repl, ' ', sizeof(new_record_repl)); MemSet(new_record_repl, false, sizeof(new_record_repl));
if (dconnlimit) if (dconnlimit)
{ {
new_record[Anum_pg_database_datconnlimit - 1] = Int32GetDatum(connlimit); new_record[Anum_pg_database_datconnlimit - 1] = Int32GetDatum(connlimit);
new_record_repl[Anum_pg_database_datconnlimit - 1] = 'r'; new_record_repl[Anum_pg_database_datconnlimit - 1] = true;
} }
newtuple = heap_modifytuple(tuple, RelationGetDescr(rel), new_record, newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel), new_record,
new_record_nulls, new_record_repl); new_record_nulls, new_record_repl);
simple_heap_update(rel, &tuple->t_self, newtuple); simple_heap_update(rel, &tuple->t_self, newtuple);
@ -1040,8 +1040,8 @@ AlterDatabaseSet(AlterDatabaseSetStmt *stmt)
ScanKeyData scankey; ScanKeyData scankey;
SysScanDesc scan; SysScanDesc scan;
Datum repl_val[Natts_pg_database]; Datum repl_val[Natts_pg_database];
char repl_null[Natts_pg_database]; bool repl_null[Natts_pg_database];
char repl_repl[Natts_pg_database]; bool repl_repl[Natts_pg_database];
valuestr = ExtractSetVariableArgs(stmt->setstmt); valuestr = ExtractSetVariableArgs(stmt->setstmt);
@ -1067,13 +1067,13 @@ AlterDatabaseSet(AlterDatabaseSetStmt *stmt)
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_DATABASE, aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_DATABASE,
stmt->dbname); stmt->dbname);
memset(repl_repl, ' ', sizeof(repl_repl)); memset(repl_repl, false, sizeof(repl_repl));
repl_repl[Anum_pg_database_datconfig - 1] = 'r'; repl_repl[Anum_pg_database_datconfig - 1] = true;
if (stmt->setstmt->kind == VAR_RESET_ALL) if (stmt->setstmt->kind == VAR_RESET_ALL)
{ {
/* RESET ALL, so just set datconfig to null */ /* RESET ALL, so just set datconfig to null */
repl_null[Anum_pg_database_datconfig - 1] = 'n'; repl_null[Anum_pg_database_datconfig - 1] = true;
repl_val[Anum_pg_database_datconfig - 1] = (Datum) 0; repl_val[Anum_pg_database_datconfig - 1] = (Datum) 0;
} }
else else
@ -1082,7 +1082,7 @@ AlterDatabaseSet(AlterDatabaseSetStmt *stmt)
bool isnull; bool isnull;
ArrayType *a; ArrayType *a;
repl_null[Anum_pg_database_datconfig - 1] = ' '; repl_null[Anum_pg_database_datconfig - 1] = false;
/* Extract old value of datconfig */ /* Extract old value of datconfig */
datum = heap_getattr(tuple, Anum_pg_database_datconfig, datum = heap_getattr(tuple, Anum_pg_database_datconfig,
@ -1098,10 +1098,10 @@ AlterDatabaseSet(AlterDatabaseSetStmt *stmt)
if (a) if (a)
repl_val[Anum_pg_database_datconfig - 1] = PointerGetDatum(a); repl_val[Anum_pg_database_datconfig - 1] = PointerGetDatum(a);
else else
repl_null[Anum_pg_database_datconfig - 1] = 'n'; repl_null[Anum_pg_database_datconfig - 1] = true;
} }
newtuple = heap_modifytuple(tuple, RelationGetDescr(rel), newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel),
repl_val, repl_null, repl_repl); repl_val, repl_null, repl_repl);
simple_heap_update(rel, &tuple->t_self, newtuple); simple_heap_update(rel, &tuple->t_self, newtuple);
@ -1160,8 +1160,8 @@ AlterDatabaseOwner(const char *dbname, Oid newOwnerId)
if (datForm->datdba != newOwnerId) if (datForm->datdba != newOwnerId)
{ {
Datum repl_val[Natts_pg_database]; Datum repl_val[Natts_pg_database];
char repl_null[Natts_pg_database]; bool repl_null[Natts_pg_database];
char repl_repl[Natts_pg_database]; bool repl_repl[Natts_pg_database];
Acl *newAcl; Acl *newAcl;
Datum aclDatum; Datum aclDatum;
bool isNull; bool isNull;
@ -1189,10 +1189,10 @@ AlterDatabaseOwner(const char *dbname, Oid newOwnerId)
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("permission denied to change owner of database"))); errmsg("permission denied to change owner of database")));
memset(repl_null, ' ', sizeof(repl_null)); memset(repl_null, false, sizeof(repl_null));
memset(repl_repl, ' ', sizeof(repl_repl)); memset(repl_repl, false, sizeof(repl_repl));
repl_repl[Anum_pg_database_datdba - 1] = 'r'; repl_repl[Anum_pg_database_datdba - 1] = true;
repl_val[Anum_pg_database_datdba - 1] = ObjectIdGetDatum(newOwnerId); repl_val[Anum_pg_database_datdba - 1] = ObjectIdGetDatum(newOwnerId);
/* /*
@ -1207,11 +1207,11 @@ AlterDatabaseOwner(const char *dbname, Oid newOwnerId)
{ {
newAcl = aclnewowner(DatumGetAclP(aclDatum), newAcl = aclnewowner(DatumGetAclP(aclDatum),
datForm->datdba, newOwnerId); datForm->datdba, newOwnerId);
repl_repl[Anum_pg_database_datacl - 1] = 'r'; repl_repl[Anum_pg_database_datacl - 1] = true;
repl_val[Anum_pg_database_datacl - 1] = PointerGetDatum(newAcl); repl_val[Anum_pg_database_datacl - 1] = PointerGetDatum(newAcl);
} }
newtuple = heap_modifytuple(tuple, RelationGetDescr(rel), repl_val, repl_null, repl_repl); newtuple = heap_modify_tuple(tuple, RelationGetDescr(rel), repl_val, repl_null, repl_repl);
simple_heap_update(rel, &newtuple->t_self, newtuple); simple_heap_update(rel, &newtuple->t_self, newtuple);
CatalogUpdateIndexes(rel, newtuple); CatalogUpdateIndexes(rel, newtuple);

36
src/backend/commands/functioncmds.c
View File

@ -10,7 +10,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/functioncmds.c,v 1.100 2008/10/31 08:39:20 heikki Exp $ * $PostgreSQL: pgsql/src/backend/commands/functioncmds.c,v 1.101 2008/11/02 01:45:27 tgl Exp $
* *
* DESCRIPTION * DESCRIPTION
* These routines take the parse tree and pick out the * These routines take the parse tree and pick out the
@ -1104,8 +1104,8 @@ AlterFunctionOwner_internal(Relation rel, HeapTuple tup, Oid newOwnerId)
if (procForm->proowner != newOwnerId) if (procForm->proowner != newOwnerId)
{ {
Datum repl_val[Natts_pg_proc]; Datum repl_val[Natts_pg_proc];
char repl_null[Natts_pg_proc]; bool repl_null[Natts_pg_proc];
char repl_repl[Natts_pg_proc]; bool repl_repl[Natts_pg_proc];
Acl *newAcl; Acl *newAcl;
Datum aclDatum; Datum aclDatum;
bool isNull; bool isNull;
@ -1131,10 +1131,10 @@ AlterFunctionOwner_internal(Relation rel, HeapTuple tup, Oid newOwnerId)
get_namespace_name(procForm->pronamespace)); get_namespace_name(procForm->pronamespace));
} }
memset(repl_null, ' ', sizeof(repl_null)); memset(repl_null, false, sizeof(repl_null));
memset(repl_repl, ' ', sizeof(repl_repl)); memset(repl_repl, false, sizeof(repl_repl));
repl_repl[Anum_pg_proc_proowner - 1] = 'r'; repl_repl[Anum_pg_proc_proowner - 1] = true;
repl_val[Anum_pg_proc_proowner - 1] = ObjectIdGetDatum(newOwnerId); repl_val[Anum_pg_proc_proowner - 1] = ObjectIdGetDatum(newOwnerId);
/* /*
@ -1148,11 +1148,11 @@ AlterFunctionOwner_internal(Relation rel, HeapTuple tup, Oid newOwnerId)
{ {
newAcl = aclnewowner(DatumGetAclP(aclDatum), newAcl = aclnewowner(DatumGetAclP(aclDatum),
procForm->proowner, newOwnerId); procForm->proowner, newOwnerId);
repl_repl[Anum_pg_proc_proacl - 1] = 'r'; repl_repl[Anum_pg_proc_proacl - 1] = true;
repl_val[Anum_pg_proc_proacl - 1] = PointerGetDatum(newAcl); repl_val[Anum_pg_proc_proacl - 1] = PointerGetDatum(newAcl);
} }
newtuple = heap_modifytuple(tup, RelationGetDescr(rel), repl_val, newtuple = heap_modify_tuple(tup, RelationGetDescr(rel), repl_val,
repl_null, repl_repl); repl_null, repl_repl);
simple_heap_update(rel, &newtuple->t_self, newtuple); simple_heap_update(rel, &newtuple->t_self, newtuple);
@ -1259,8 +1259,8 @@ AlterFunction(AlterFunctionStmt *stmt)
bool isnull; bool isnull;
ArrayType *a; ArrayType *a;
Datum repl_val[Natts_pg_proc]; Datum repl_val[Natts_pg_proc];
char repl_null[Natts_pg_proc]; bool repl_null[Natts_pg_proc];
char repl_repl[Natts_pg_proc]; bool repl_repl[Natts_pg_proc];
/* extract existing proconfig setting */ /* extract existing proconfig setting */
datum = SysCacheGetAttr(PROCOID, tup, Anum_pg_proc_proconfig, &isnull); datum = SysCacheGetAttr(PROCOID, tup, Anum_pg_proc_proconfig, &isnull);
@ -1270,21 +1270,21 @@ AlterFunction(AlterFunctionStmt *stmt)
a = update_proconfig_value(a, set_items); a = update_proconfig_value(a, set_items);
/* update the tuple */ /* update the tuple */
memset(repl_repl, ' ', sizeof(repl_repl)); memset(repl_repl, false, sizeof(repl_repl));
repl_repl[Anum_pg_proc_proconfig - 1] = 'r'; repl_repl[Anum_pg_proc_proconfig - 1] = true;
if (a == NULL) if (a == NULL)
{ {
repl_val[Anum_pg_proc_proconfig - 1] = (Datum) 0; repl_val[Anum_pg_proc_proconfig - 1] = (Datum) 0;
repl_null[Anum_pg_proc_proconfig - 1] = 'n'; repl_null[Anum_pg_proc_proconfig - 1] = true;
} }
else else
{ {
repl_val[Anum_pg_proc_proconfig - 1] = PointerGetDatum(a); repl_val[Anum_pg_proc_proconfig - 1] = PointerGetDatum(a);
repl_null[Anum_pg_proc_proconfig - 1] = ' '; repl_null[Anum_pg_proc_proconfig - 1] = false;
} }
tup = heap_modifytuple(tup, RelationGetDescr(rel), tup = heap_modify_tuple(tup, RelationGetDescr(rel),
repl_val, repl_null, repl_repl); repl_val, repl_null, repl_repl);
} }
@ -1387,7 +1387,7 @@ CreateCast(CreateCastStmt *stmt)
Relation relation; Relation relation;
HeapTuple tuple; HeapTuple tuple;
Datum values[Natts_pg_cast]; Datum values[Natts_pg_cast];
char nulls[Natts_pg_cast]; bool nulls[Natts_pg_cast];
ObjectAddress myself, ObjectAddress myself,
referenced; referenced;
@ -1575,9 +1575,9 @@ CreateCast(CreateCastStmt *stmt)
values[Anum_pg_cast_castcontext - 1] = CharGetDatum(castcontext); values[Anum_pg_cast_castcontext - 1] = CharGetDatum(castcontext);
values[Anum_pg_cast_castmethod - 1] = CharGetDatum(castmethod); values[Anum_pg_cast_castmethod - 1] = CharGetDatum(castmethod);
MemSet(nulls, ' ', Natts_pg_cast); MemSet(nulls, false, sizeof(nulls));
tuple = heap_formtuple(RelationGetDescr(relation), values, nulls); tuple = heap_form_tuple(RelationGetDescr(relation), values, nulls);
simple_heap_insert(relation, tuple); simple_heap_insert(relation, tuple);

32
src/backend/commands/opclasscmds.c
View File

@ -9,7 +9,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/opclasscmds.c,v 1.62 2008/06/19 00:46:04 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/commands/opclasscmds.c,v 1.63 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -176,7 +176,7 @@ CreateOpFamily(char *amname, char *opfname, Oid namespaceoid, Oid amoid)
Relation rel; Relation rel;
HeapTuple tup; HeapTuple tup;
Datum values[Natts_pg_opfamily]; Datum values[Natts_pg_opfamily];
char nulls[Natts_pg_opfamily]; bool nulls[Natts_pg_opfamily];
NameData opfName; NameData opfName;
ObjectAddress myself, ObjectAddress myself,
referenced; referenced;
@ -201,7 +201,7 @@ CreateOpFamily(char *amname, char *opfname, Oid namespaceoid, Oid amoid)
* Okay, let's create the pg_opfamily entry. * Okay, let's create the pg_opfamily entry.
*/ */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
values[Anum_pg_opfamily_opfmethod - 1] = ObjectIdGetDatum(amoid); values[Anum_pg_opfamily_opfmethod - 1] = ObjectIdGetDatum(amoid);
namestrcpy(&opfName, opfname); namestrcpy(&opfName, opfname);
@ -209,7 +209,7 @@ CreateOpFamily(char *amname, char *opfname, Oid namespaceoid, Oid amoid)
values[Anum_pg_opfamily_opfnamespace - 1] = ObjectIdGetDatum(namespaceoid); values[Anum_pg_opfamily_opfnamespace - 1] = ObjectIdGetDatum(namespaceoid);
values[Anum_pg_opfamily_opfowner - 1] = ObjectIdGetDatum(GetUserId()); values[Anum_pg_opfamily_opfowner - 1] = ObjectIdGetDatum(GetUserId());
tup = heap_formtuple(rel->rd_att, values, nulls); tup = heap_form_tuple(rel->rd_att, values, nulls);
opfamilyoid = simple_heap_insert(rel, tup); opfamilyoid = simple_heap_insert(rel, tup);
@ -264,7 +264,7 @@ DefineOpClass(CreateOpClassStmt *stmt)
HeapTuple tup; HeapTuple tup;
Form_pg_am pg_am; Form_pg_am pg_am;
Datum values[Natts_pg_opclass]; Datum values[Natts_pg_opclass];
char nulls[Natts_pg_opclass]; bool nulls[Natts_pg_opclass];
AclResult aclresult; AclResult aclresult;
NameData opcName; NameData opcName;
ObjectAddress myself, ObjectAddress myself,
@ -570,7 +570,7 @@ DefineOpClass(CreateOpClassStmt *stmt)
* Okay, let's create the pg_opclass entry. * Okay, let's create the pg_opclass entry.
*/ */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
values[Anum_pg_opclass_opcmethod - 1] = ObjectIdGetDatum(amoid); values[Anum_pg_opclass_opcmethod - 1] = ObjectIdGetDatum(amoid);
namestrcpy(&opcName, opcname); namestrcpy(&opcName, opcname);
@ -582,7 +582,7 @@ DefineOpClass(CreateOpClassStmt *stmt)
values[Anum_pg_opclass_opcdefault - 1] = BoolGetDatum(stmt->isDefault); values[Anum_pg_opclass_opcdefault - 1] = BoolGetDatum(stmt->isDefault);
values[Anum_pg_opclass_opckeytype - 1] = ObjectIdGetDatum(storageoid); values[Anum_pg_opclass_opckeytype - 1] = ObjectIdGetDatum(storageoid);
tup = heap_formtuple(rel->rd_att, values, nulls); tup = heap_form_tuple(rel->rd_att, values, nulls);
opclassoid = simple_heap_insert(rel, tup); opclassoid = simple_heap_insert(rel, tup);
@ -656,7 +656,7 @@ DefineOpFamily(CreateOpFamilyStmt *stmt)
Relation rel; Relation rel;
HeapTuple tup; HeapTuple tup;
Datum values[Natts_pg_opfamily]; Datum values[Natts_pg_opfamily];
char nulls[Natts_pg_opfamily]; bool nulls[Natts_pg_opfamily];
AclResult aclresult; AclResult aclresult;
NameData opfName; NameData opfName;
ObjectAddress myself, ObjectAddress myself,
@ -719,7 +719,7 @@ DefineOpFamily(CreateOpFamilyStmt *stmt)
* Okay, let's create the pg_opfamily entry. * Okay, let's create the pg_opfamily entry.
*/ */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
values[Anum_pg_opfamily_opfmethod - 1] = ObjectIdGetDatum(amoid); values[Anum_pg_opfamily_opfmethod - 1] = ObjectIdGetDatum(amoid);
namestrcpy(&opfName, opfname); namestrcpy(&opfName, opfname);
@ -727,7 +727,7 @@ DefineOpFamily(CreateOpFamilyStmt *stmt)
values[Anum_pg_opfamily_opfnamespace - 1] = ObjectIdGetDatum(namespaceoid); values[Anum_pg_opfamily_opfnamespace - 1] = ObjectIdGetDatum(namespaceoid);
values[Anum_pg_opfamily_opfowner - 1] = ObjectIdGetDatum(GetUserId()); values[Anum_pg_opfamily_opfowner - 1] = ObjectIdGetDatum(GetUserId());
tup = heap_formtuple(rel->rd_att, values, nulls); tup = heap_form_tuple(rel->rd_att, values, nulls);
opfamilyoid = simple_heap_insert(rel, tup); opfamilyoid = simple_heap_insert(rel, tup);
@ -1226,7 +1226,7 @@ storeOperators(List *opfamilyname, Oid amoid,
{ {
Relation rel; Relation rel;
Datum values[Natts_pg_amop]; Datum values[Natts_pg_amop];
char nulls[Natts_pg_amop]; bool nulls[Natts_pg_amop];
HeapTuple tup; HeapTuple tup;
Oid entryoid; Oid entryoid;
ObjectAddress myself, ObjectAddress myself,
@ -1259,7 +1259,7 @@ storeOperators(List *opfamilyname, Oid amoid,
/* Create the pg_amop entry */ /* Create the pg_amop entry */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
values[Anum_pg_amop_amopfamily - 1] = ObjectIdGetDatum(opfamilyoid); values[Anum_pg_amop_amopfamily - 1] = ObjectIdGetDatum(opfamilyoid);
values[Anum_pg_amop_amoplefttype - 1] = ObjectIdGetDatum(op->lefttype); values[Anum_pg_amop_amoplefttype - 1] = ObjectIdGetDatum(op->lefttype);
@ -1268,7 +1268,7 @@ storeOperators(List *opfamilyname, Oid amoid,
values[Anum_pg_amop_amopopr - 1] = ObjectIdGetDatum(op->object); values[Anum_pg_amop_amopopr - 1] = ObjectIdGetDatum(op->object);
values[Anum_pg_amop_amopmethod - 1] = ObjectIdGetDatum(amoid); values[Anum_pg_amop_amopmethod - 1] = ObjectIdGetDatum(amoid);
tup = heap_formtuple(rel->rd_att, values, nulls); tup = heap_form_tuple(rel->rd_att, values, nulls);
entryoid = simple_heap_insert(rel, tup); entryoid = simple_heap_insert(rel, tup);
@ -1326,7 +1326,7 @@ storeProcedures(List *opfamilyname, Oid amoid,
{ {
Relation rel; Relation rel;
Datum values[Natts_pg_amproc]; Datum values[Natts_pg_amproc];
char nulls[Natts_pg_amproc]; bool nulls[Natts_pg_amproc];
HeapTuple tup; HeapTuple tup;
Oid entryoid; Oid entryoid;
ObjectAddress myself, ObjectAddress myself,
@ -1359,7 +1359,7 @@ storeProcedures(List *opfamilyname, Oid amoid,
/* Create the pg_amproc entry */ /* Create the pg_amproc entry */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
values[Anum_pg_amproc_amprocfamily - 1] = ObjectIdGetDatum(opfamilyoid); values[Anum_pg_amproc_amprocfamily - 1] = ObjectIdGetDatum(opfamilyoid);
values[Anum_pg_amproc_amproclefttype - 1] = ObjectIdGetDatum(proc->lefttype); values[Anum_pg_amproc_amproclefttype - 1] = ObjectIdGetDatum(proc->lefttype);
@ -1367,7 +1367,7 @@ storeProcedures(List *opfamilyname, Oid amoid,
values[Anum_pg_amproc_amprocnum - 1] = Int16GetDatum(proc->number); values[Anum_pg_amproc_amprocnum - 1] = Int16GetDatum(proc->number);
values[Anum_pg_amproc_amproc - 1] = ObjectIdGetDatum(proc->object); values[Anum_pg_amproc_amproc - 1] = ObjectIdGetDatum(proc->object);
tup = heap_formtuple(rel->rd_att, values, nulls); tup = heap_form_tuple(rel->rd_att, values, nulls);
entryoid = simple_heap_insert(rel, tup); entryoid = simple_heap_insert(rel, tup);

24
src/backend/commands/proclang.c
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/proclang.c,v 1.79 2008/06/19 00:46:04 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/commands/proclang.c,v 1.80 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -268,7 +268,7 @@ create_proc_lang(const char *languageName,
Relation rel; Relation rel;
TupleDesc tupDesc; TupleDesc tupDesc;
Datum values[Natts_pg_language]; Datum values[Natts_pg_language];
char nulls[Natts_pg_language]; bool nulls[Natts_pg_language];
NameData langname; NameData langname;
HeapTuple tup; HeapTuple tup;
ObjectAddress myself, ObjectAddress myself,
@ -281,7 +281,7 @@ create_proc_lang(const char *languageName,
tupDesc = rel->rd_att; tupDesc = rel->rd_att;
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
namestrcpy(&langname, languageName); namestrcpy(&langname, languageName);
values[Anum_pg_language_lanname - 1] = NameGetDatum(&langname); values[Anum_pg_language_lanname - 1] = NameGetDatum(&langname);
@ -290,9 +290,9 @@ create_proc_lang(const char *languageName,
values[Anum_pg_language_lanpltrusted - 1] = BoolGetDatum(trusted); values[Anum_pg_language_lanpltrusted - 1] = BoolGetDatum(trusted);
values[Anum_pg_language_lanplcallfoid - 1] = ObjectIdGetDatum(handlerOid); values[Anum_pg_language_lanplcallfoid - 1] = ObjectIdGetDatum(handlerOid);
values[Anum_pg_language_lanvalidator - 1] = ObjectIdGetDatum(valOid); values[Anum_pg_language_lanvalidator - 1] = ObjectIdGetDatum(valOid);
nulls[Anum_pg_language_lanacl - 1] = 'n'; nulls[Anum_pg_language_lanacl - 1] = true;
tup = heap_formtuple(tupDesc, values, nulls); tup = heap_form_tuple(tupDesc, values, nulls);
simple_heap_insert(rel, tup); simple_heap_insert(rel, tup);
@ -594,8 +594,8 @@ AlterLanguageOwner_internal(HeapTuple tup, Relation rel, Oid newOwnerId)
if (lanForm->lanowner != newOwnerId) if (lanForm->lanowner != newOwnerId)
{ {
Datum repl_val[Natts_pg_language]; Datum repl_val[Natts_pg_language];
char repl_null[Natts_pg_language]; bool repl_null[Natts_pg_language];
char repl_repl[Natts_pg_language]; bool repl_repl[Natts_pg_language];
Acl *newAcl; Acl *newAcl;
Datum aclDatum; Datum aclDatum;
bool isNull; bool isNull;
@ -609,10 +609,10 @@ AlterLanguageOwner_internal(HeapTuple tup, Relation rel, Oid newOwnerId)
/* Must be able to become new owner */ /* Must be able to become new owner */
check_is_member_of_role(GetUserId(), newOwnerId); check_is_member_of_role(GetUserId(), newOwnerId);
memset(repl_null, ' ', sizeof(repl_null)); memset(repl_null, false, sizeof(repl_null));
memset(repl_repl, ' ', sizeof(repl_repl)); memset(repl_repl, false, sizeof(repl_repl));
repl_repl[Anum_pg_language_lanowner - 1] = 'r'; repl_repl[Anum_pg_language_lanowner - 1] = true;
repl_val[Anum_pg_language_lanowner - 1] = ObjectIdGetDatum(newOwnerId); repl_val[Anum_pg_language_lanowner - 1] = ObjectIdGetDatum(newOwnerId);
/* /*
@ -626,11 +626,11 @@ AlterLanguageOwner_internal(HeapTuple tup, Relation rel, Oid newOwnerId)
{ {
newAcl = aclnewowner(DatumGetAclP(aclDatum), newAcl = aclnewowner(DatumGetAclP(aclDatum),
lanForm->lanowner, newOwnerId); lanForm->lanowner, newOwnerId);
repl_repl[Anum_pg_language_lanacl - 1] = 'r'; repl_repl[Anum_pg_language_lanacl - 1] = true;
repl_val[Anum_pg_language_lanacl - 1] = PointerGetDatum(newAcl); repl_val[Anum_pg_language_lanacl - 1] = PointerGetDatum(newAcl);
} }
newtuple = heap_modifytuple(tup, RelationGetDescr(rel), newtuple = heap_modify_tuple(tup, RelationGetDescr(rel),
repl_val, repl_null, repl_repl); repl_val, repl_null, repl_repl);
simple_heap_update(rel, &newtuple->t_self, newtuple); simple_heap_update(rel, &newtuple->t_self, newtuple);

16
src/backend/commands/schemacmds.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/schemacmds.c,v 1.50 2008/06/14 18:04:33 tgl Exp $ * $PostgreSQL: pgsql/src/backend/commands/schemacmds.c,v 1.51 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -366,8 +366,8 @@ AlterSchemaOwner_internal(HeapTuple tup, Relation rel, Oid newOwnerId)
if (nspForm->nspowner != newOwnerId) if (nspForm->nspowner != newOwnerId)
{ {
Datum repl_val[Natts_pg_namespace]; Datum repl_val[Natts_pg_namespace];
char repl_null[Natts_pg_namespace]; bool repl_null[Natts_pg_namespace];
char repl_repl[Natts_pg_namespace]; bool repl_repl[Natts_pg_namespace];
Acl *newAcl; Acl *newAcl;
Datum aclDatum; Datum aclDatum;
bool isNull; bool isNull;
@ -397,10 +397,10 @@ AlterSchemaOwner_internal(HeapTuple tup, Relation rel, Oid newOwnerId)
aclcheck_error(aclresult, ACL_KIND_DATABASE, aclcheck_error(aclresult, ACL_KIND_DATABASE,
get_database_name(MyDatabaseId)); get_database_name(MyDatabaseId));
memset(repl_null, ' ', sizeof(repl_null)); memset(repl_null, false, sizeof(repl_null));
memset(repl_repl, ' ', sizeof(repl_repl)); memset(repl_repl, false, sizeof(repl_repl));
repl_repl[Anum_pg_namespace_nspowner - 1] = 'r'; repl_repl[Anum_pg_namespace_nspowner - 1] = true;
repl_val[Anum_pg_namespace_nspowner - 1] = ObjectIdGetDatum(newOwnerId); repl_val[Anum_pg_namespace_nspowner - 1] = ObjectIdGetDatum(newOwnerId);
/* /*
@ -414,11 +414,11 @@ AlterSchemaOwner_internal(HeapTuple tup, Relation rel, Oid newOwnerId)
{ {
newAcl = aclnewowner(DatumGetAclP(aclDatum), newAcl = aclnewowner(DatumGetAclP(aclDatum),
nspForm->nspowner, newOwnerId); nspForm->nspowner, newOwnerId);
repl_repl[Anum_pg_namespace_nspacl - 1] = 'r'; repl_repl[Anum_pg_namespace_nspacl - 1] = true;
repl_val[Anum_pg_namespace_nspacl - 1] = PointerGetDatum(newAcl); repl_val[Anum_pg_namespace_nspacl - 1] = PointerGetDatum(newAcl);
} }
newtuple = heap_modifytuple(tup, RelationGetDescr(rel), repl_val, repl_null, repl_repl); newtuple = heap_modify_tuple(tup, RelationGetDescr(rel), repl_val, repl_null, repl_repl);
simple_heap_update(rel, &newtuple->t_self, newtuple); simple_heap_update(rel, &newtuple->t_self, newtuple);
CatalogUpdateIndexes(rel, newtuple); CatalogUpdateIndexes(rel, newtuple);

10
src/backend/commands/sequence.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/sequence.c,v 1.154 2008/07/13 20:45:47 tgl Exp $ * $PostgreSQL: pgsql/src/backend/commands/sequence.c,v 1.155 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -114,7 +114,7 @@ DefineSequence(CreateSeqStmt *seq)
HeapTuple tuple; HeapTuple tuple;
TupleDesc tupDesc; TupleDesc tupDesc;
Datum value[SEQ_COL_LASTCOL]; Datum value[SEQ_COL_LASTCOL];
char null[SEQ_COL_LASTCOL]; bool null[SEQ_COL_LASTCOL];
int i; int i;
NameData name; NameData name;
@ -136,7 +136,7 @@ DefineSequence(CreateSeqStmt *seq)
coldef->cooked_default = NULL; coldef->cooked_default = NULL;
coldef->constraints = NIL; coldef->constraints = NIL;
null[i - 1] = ' '; null[i - 1] = false;
switch (i) switch (i)
{ {
@ -222,7 +222,7 @@ DefineSequence(CreateSeqStmt *seq)
rel->rd_targblock = 0; rel->rd_targblock = 0;
/* Now form & insert sequence tuple */ /* Now form & insert sequence tuple */
tuple = heap_formtuple(tupDesc, value, null); tuple = heap_form_tuple(tupDesc, value, null);
simple_heap_insert(rel, tuple); simple_heap_insert(rel, tuple);
Assert(ItemPointerGetOffsetNumber(&(tuple->t_self)) == FirstOffsetNumber); Assert(ItemPointerGetOffsetNumber(&(tuple->t_self)) == FirstOffsetNumber);
@ -249,7 +249,7 @@ DefineSequence(CreateSeqStmt *seq)
{ {
/* /*
* Note that the "tuple" structure is still just a local tuple record * Note that the "tuple" structure is still just a local tuple record
* created by heap_formtuple; its t_data pointer doesn't point at the * created by heap_form_tuple; its t_data pointer doesn't point at the
* disk buffer. To scribble on the disk buffer we need to fetch the * disk buffer. To scribble on the disk buffer we need to fetch the
* item pointer. But do the same to the local tuple, since that will * item pointer. But do the same to the local tuple, since that will
* be the source for the WAL log record, below. * be the source for the WAL log record, below.

40
src/backend/commands/tablecmds.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/tablecmds.c,v 1.268 2008/10/21 10:38:51 petere Exp $ * $PostgreSQL: pgsql/src/backend/commands/tablecmds.c,v 1.269 2008/11/02 01:45:27 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -1670,7 +1670,7 @@ StoreCatalogInheritance1(Oid relationId, Oid parentOid,
{ {
TupleDesc desc = RelationGetDescr(inhRelation); TupleDesc desc = RelationGetDescr(inhRelation);
Datum datum[Natts_pg_inherits]; Datum datum[Natts_pg_inherits];
char nullarr[Natts_pg_inherits]; bool nullarr[Natts_pg_inherits];
ObjectAddress childobject, ObjectAddress childobject,
parentobject; parentobject;
HeapTuple tuple; HeapTuple tuple;
@ -1682,11 +1682,11 @@ StoreCatalogInheritance1(Oid relationId, Oid parentOid,
datum[1] = ObjectIdGetDatum(parentOid); /* inhparent */ datum[1] = ObjectIdGetDatum(parentOid); /* inhparent */
datum[2] = Int16GetDatum(seqNumber); /* inhseqno */ datum[2] = Int16GetDatum(seqNumber); /* inhseqno */
nullarr[0] = ' '; nullarr[0] = false;
nullarr[1] = ' '; nullarr[1] = false;
nullarr[2] = ' '; nullarr[2] = false;
tuple = heap_formtuple(desc, datum, nullarr); tuple = heap_form_tuple(desc, datum, nullarr);
simple_heap_insert(inhRelation, tuple); simple_heap_insert(inhRelation, tuple);
@ -6142,8 +6142,8 @@ ATExecChangeOwner(Oid relationOid, Oid newOwnerId, bool recursing)
if (tuple_class->relowner != newOwnerId) if (tuple_class->relowner != newOwnerId)
{ {
Datum repl_val[Natts_pg_class]; Datum repl_val[Natts_pg_class];
char repl_null[Natts_pg_class]; bool repl_null[Natts_pg_class];
char repl_repl[Natts_pg_class]; bool repl_repl[Natts_pg_class];
Acl *newAcl; Acl *newAcl;
Datum aclDatum; Datum aclDatum;
bool isNull; bool isNull;
@ -6175,10 +6175,10 @@ ATExecChangeOwner(Oid relationOid, Oid newOwnerId, bool recursing)
} }
} }
memset(repl_null, ' ', sizeof(repl_null)); memset(repl_null, false, sizeof(repl_null));
memset(repl_repl, ' ', sizeof(repl_repl)); memset(repl_repl, false, sizeof(repl_repl));
repl_repl[Anum_pg_class_relowner - 1] = 'r'; repl_repl[Anum_pg_class_relowner - 1] = true;
repl_val[Anum_pg_class_relowner - 1] = ObjectIdGetDatum(newOwnerId); repl_val[Anum_pg_class_relowner - 1] = ObjectIdGetDatum(newOwnerId);
/* /*
@ -6192,11 +6192,11 @@ ATExecChangeOwner(Oid relationOid, Oid newOwnerId, bool recursing)
{ {
newAcl = aclnewowner(DatumGetAclP(aclDatum), newAcl = aclnewowner(DatumGetAclP(aclDatum),
tuple_class->relowner, newOwnerId); tuple_class->relowner, newOwnerId);
repl_repl[Anum_pg_class_relacl - 1] = 'r'; repl_repl[Anum_pg_class_relacl - 1] = true;
repl_val[Anum_pg_class_relacl - 1] = PointerGetDatum(newAcl); repl_val[Anum_pg_class_relacl - 1] = PointerGetDatum(newAcl);
} }
newtuple = heap_modifytuple(tuple, RelationGetDescr(class_rel), repl_val, repl_null, repl_repl); newtuple = heap_modify_tuple(tuple, RelationGetDescr(class_rel), repl_val, repl_null, repl_repl);
simple_heap_update(class_rel, &newtuple->t_self, newtuple); simple_heap_update(class_rel, &newtuple->t_self, newtuple);
CatalogUpdateIndexes(class_rel, newtuple); CatalogUpdateIndexes(class_rel, newtuple);
@ -6408,8 +6408,8 @@ ATExecSetRelOptions(Relation rel, List *defList, bool isReset)
bool isnull; bool isnull;
Datum newOptions; Datum newOptions;
Datum repl_val[Natts_pg_class]; Datum repl_val[Natts_pg_class];
char repl_null[Natts_pg_class]; bool repl_null[Natts_pg_class];
char repl_repl[Natts_pg_class]; bool repl_repl[Natts_pg_class];
if (defList == NIL) if (defList == NIL)
return; /* nothing to do */ return; /* nothing to do */
@ -6453,17 +6453,17 @@ ATExecSetRelOptions(Relation rel, List *defList, bool isReset)
* propagated into relcaches during post-commit cache inval. * propagated into relcaches during post-commit cache inval.
*/ */
memset(repl_val, 0, sizeof(repl_val)); memset(repl_val, 0, sizeof(repl_val));
memset(repl_null, ' ', sizeof(repl_null)); memset(repl_null, false, sizeof(repl_null));
memset(repl_repl, ' ', sizeof(repl_repl)); memset(repl_repl, false, sizeof(repl_repl));
if (newOptions != (Datum) 0) if (newOptions != (Datum) 0)
repl_val[Anum_pg_class_reloptions - 1] = newOptions; repl_val[Anum_pg_class_reloptions - 1] = newOptions;
else else
repl_null[Anum_pg_class_reloptions - 1] = 'n'; repl_null[Anum_pg_class_reloptions - 1] = true;
repl_repl[Anum_pg_class_reloptions - 1] = 'r'; repl_repl[Anum_pg_class_reloptions - 1] = true;
newtuple = heap_modifytuple(tuple, RelationGetDescr(pgclass), newtuple = heap_modify_tuple(tuple, RelationGetDescr(pgclass),
repl_val, repl_null, repl_repl); repl_val, repl_null, repl_repl);
simple_heap_update(pgclass, &newtuple->t_self, newtuple); simple_heap_update(pgclass, &newtuple->t_self, newtuple);

24
src/backend/commands/tablespace.c
View File

@ -37,7 +37,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/tablespace.c,v 1.57 2008/06/19 00:46:04 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/commands/tablespace.c,v 1.58 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -197,7 +197,7 @@ CreateTableSpace(CreateTableSpaceStmt *stmt)
#ifdef HAVE_SYMLINK #ifdef HAVE_SYMLINK
Relation rel; Relation rel;
Datum values[Natts_pg_tablespace]; Datum values[Natts_pg_tablespace];
char nulls[Natts_pg_tablespace]; bool nulls[Natts_pg_tablespace];
HeapTuple tuple; HeapTuple tuple;
Oid tablespaceoid; Oid tablespaceoid;
char *location; char *location;
@ -278,7 +278,7 @@ CreateTableSpace(CreateTableSpaceStmt *stmt)
*/ */
rel = heap_open(TableSpaceRelationId, RowExclusiveLock); rel = heap_open(TableSpaceRelationId, RowExclusiveLock);
MemSet(nulls, ' ', Natts_pg_tablespace); MemSet(nulls, false, sizeof(nulls));
values[Anum_pg_tablespace_spcname - 1] = values[Anum_pg_tablespace_spcname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(stmt->tablespacename)); DirectFunctionCall1(namein, CStringGetDatum(stmt->tablespacename));
@ -286,9 +286,9 @@ CreateTableSpace(CreateTableSpaceStmt *stmt)
ObjectIdGetDatum(ownerId); ObjectIdGetDatum(ownerId);
values[Anum_pg_tablespace_spclocation - 1] = values[Anum_pg_tablespace_spclocation - 1] =
CStringGetTextDatum(location); CStringGetTextDatum(location);
nulls[Anum_pg_tablespace_spcacl - 1] = 'n'; nulls[Anum_pg_tablespace_spcacl - 1] = true;
tuple = heap_formtuple(rel->rd_att, values, nulls); tuple = heap_form_tuple(rel->rd_att, values, nulls);
tablespaceoid = simple_heap_insert(rel, tuple); tablespaceoid = simple_heap_insert(rel, tuple);
@ -845,8 +845,8 @@ AlterTableSpaceOwner(const char *name, Oid newOwnerId)
if (spcForm->spcowner != newOwnerId) if (spcForm->spcowner != newOwnerId)
{ {
Datum repl_val[Natts_pg_tablespace]; Datum repl_val[Natts_pg_tablespace];
char repl_null[Natts_pg_tablespace]; bool repl_null[Natts_pg_tablespace];
char repl_repl[Natts_pg_tablespace]; bool repl_repl[Natts_pg_tablespace];
Acl *newAcl; Acl *newAcl;
Datum aclDatum; Datum aclDatum;
bool isNull; bool isNull;
@ -870,10 +870,10 @@ AlterTableSpaceOwner(const char *name, Oid newOwnerId)
* anyway. * anyway.
*/ */
memset(repl_null, ' ', sizeof(repl_null)); memset(repl_null, false, sizeof(repl_null));
memset(repl_repl, ' ', sizeof(repl_repl)); memset(repl_repl, false, sizeof(repl_repl));
repl_repl[Anum_pg_tablespace_spcowner - 1] = 'r'; repl_repl[Anum_pg_tablespace_spcowner - 1] = true;
repl_val[Anum_pg_tablespace_spcowner - 1] = ObjectIdGetDatum(newOwnerId); repl_val[Anum_pg_tablespace_spcowner - 1] = ObjectIdGetDatum(newOwnerId);
/* /*
@ -888,11 +888,11 @@ AlterTableSpaceOwner(const char *name, Oid newOwnerId)
{ {
newAcl = aclnewowner(DatumGetAclP(aclDatum), newAcl = aclnewowner(DatumGetAclP(aclDatum),
spcForm->spcowner, newOwnerId); spcForm->spcowner, newOwnerId);
repl_repl[Anum_pg_tablespace_spcacl - 1] = 'r'; repl_repl[Anum_pg_tablespace_spcacl - 1] = true;
repl_val[Anum_pg_tablespace_spcacl - 1] = PointerGetDatum(newAcl); repl_val[Anum_pg_tablespace_spcacl - 1] = PointerGetDatum(newAcl);
} }
newtuple = heap_modifytuple(tup, RelationGetDescr(rel), repl_val, repl_null, repl_repl); newtuple = heap_modify_tuple(tup, RelationGetDescr(rel), repl_val, repl_null, repl_repl);
simple_heap_update(rel, &newtuple->t_self, newtuple); simple_heap_update(rel, &newtuple->t_self, newtuple);
CatalogUpdateIndexes(rel, newtuple); CatalogUpdateIndexes(rel, newtuple);

8
src/backend/commands/trigger.c
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/trigger.c,v 1.238 2008/10/24 23:42:35 tgl Exp $ * $PostgreSQL: pgsql/src/backend/commands/trigger.c,v 1.239 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -83,7 +83,7 @@ CreateTrigger(CreateTrigStmt *stmt, Oid constraintOid)
int16 tgtype; int16 tgtype;
int2vector *tgattr; int2vector *tgattr;
Datum values[Natts_pg_trigger]; Datum values[Natts_pg_trigger];
char nulls[Natts_pg_trigger]; bool nulls[Natts_pg_trigger];
Relation rel; Relation rel;
AclResult aclresult; AclResult aclresult;
Relation tgrel; Relation tgrel;
@ -310,7 +310,7 @@ CreateTrigger(CreateTrigStmt *stmt, Oid constraintOid)
/* /*
* Build the new pg_trigger tuple. * Build the new pg_trigger tuple.
*/ */
memset(nulls, ' ', Natts_pg_trigger * sizeof(char)); memset(nulls, false, sizeof(nulls));
values[Anum_pg_trigger_tgrelid - 1] = ObjectIdGetDatum(RelationGetRelid(rel)); values[Anum_pg_trigger_tgrelid - 1] = ObjectIdGetDatum(RelationGetRelid(rel));
values[Anum_pg_trigger_tgname - 1] = DirectFunctionCall1(namein, values[Anum_pg_trigger_tgname - 1] = DirectFunctionCall1(namein,
@ -374,7 +374,7 @@ CreateTrigger(CreateTrigStmt *stmt, Oid constraintOid)
tgattr = buildint2vector(NULL, 0); tgattr = buildint2vector(NULL, 0);
values[Anum_pg_trigger_tgattr - 1] = PointerGetDatum(tgattr); values[Anum_pg_trigger_tgattr - 1] = PointerGetDatum(tgattr);
tuple = heap_formtuple(tgrel->rd_att, values, nulls); tuple = heap_form_tuple(tgrel->rd_att, values, nulls);
/* force tuple to have the desired OID */ /* force tuple to have the desired OID */
HeapTupleSetOid(tuple, trigoid); HeapTupleSetOid(tuple, trigoid);

70
src/backend/commands/tsearchcmds.c
View File

@ -9,7 +9,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/tsearchcmds.c,v 1.13 2008/06/19 00:46:04 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/commands/tsearchcmds.c,v 1.14 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -167,7 +167,7 @@ DefineTSParser(List *names, List *parameters)
Relation prsRel; Relation prsRel;
HeapTuple tup; HeapTuple tup;
Datum values[Natts_pg_ts_parser]; Datum values[Natts_pg_ts_parser];
char nulls[Natts_pg_ts_parser]; bool nulls[Natts_pg_ts_parser];
NameData pname; NameData pname;
Oid prsOid; Oid prsOid;
Oid namespaceoid; Oid namespaceoid;
@ -182,7 +182,7 @@ DefineTSParser(List *names, List *parameters)
/* initialize tuple fields with name/namespace */ /* initialize tuple fields with name/namespace */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
namestrcpy(&pname, prsname); namestrcpy(&pname, prsname);
values[Anum_pg_ts_parser_prsname - 1] = NameGetDatum(&pname); values[Anum_pg_ts_parser_prsname - 1] = NameGetDatum(&pname);
@ -255,7 +255,7 @@ DefineTSParser(List *names, List *parameters)
*/ */
prsRel = heap_open(TSParserRelationId, RowExclusiveLock); prsRel = heap_open(TSParserRelationId, RowExclusiveLock);
tup = heap_formtuple(prsRel->rd_att, values, nulls); tup = heap_form_tuple(prsRel->rd_att, values, nulls);
prsOid = simple_heap_insert(prsRel, tup); prsOid = simple_heap_insert(prsRel, tup);
@ -497,7 +497,7 @@ DefineTSDictionary(List *names, List *parameters)
Relation dictRel; Relation dictRel;
HeapTuple tup; HeapTuple tup;
Datum values[Natts_pg_ts_dict]; Datum values[Natts_pg_ts_dict];
char nulls[Natts_pg_ts_dict]; bool nulls[Natts_pg_ts_dict];
NameData dname; NameData dname;
Oid templId = InvalidOid; Oid templId = InvalidOid;
List *dictoptions = NIL; List *dictoptions = NIL;
@ -547,7 +547,7 @@ DefineTSDictionary(List *names, List *parameters)
* Looks good, insert * Looks good, insert
*/ */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
namestrcpy(&dname, dictname); namestrcpy(&dname, dictname);
values[Anum_pg_ts_dict_dictname - 1] = NameGetDatum(&dname); values[Anum_pg_ts_dict_dictname - 1] = NameGetDatum(&dname);
@ -558,11 +558,11 @@ DefineTSDictionary(List *names, List *parameters)
values[Anum_pg_ts_dict_dictinitoption - 1] = values[Anum_pg_ts_dict_dictinitoption - 1] =
PointerGetDatum(serialize_deflist(dictoptions)); PointerGetDatum(serialize_deflist(dictoptions));
else else
nulls[Anum_pg_ts_dict_dictinitoption - 1] = 'n'; nulls[Anum_pg_ts_dict_dictinitoption - 1] = true;
dictRel = heap_open(TSDictionaryRelationId, RowExclusiveLock); dictRel = heap_open(TSDictionaryRelationId, RowExclusiveLock);
tup = heap_formtuple(dictRel->rd_att, values, nulls); tup = heap_form_tuple(dictRel->rd_att, values, nulls);
dictOid = simple_heap_insert(dictRel, tup); dictOid = simple_heap_insert(dictRel, tup);
@ -742,8 +742,8 @@ AlterTSDictionary(AlterTSDictionaryStmt *stmt)
Datum opt; Datum opt;
bool isnull; bool isnull;
Datum repl_val[Natts_pg_ts_dict]; Datum repl_val[Natts_pg_ts_dict];
char repl_null[Natts_pg_ts_dict]; bool repl_null[Natts_pg_ts_dict];
char repl_repl[Natts_pg_ts_dict]; bool repl_repl[Natts_pg_ts_dict];
dictId = TSDictionaryGetDictid(stmt->dictname, false); dictId = TSDictionaryGetDictid(stmt->dictname, false);
@ -813,17 +813,17 @@ AlterTSDictionary(AlterTSDictionaryStmt *stmt)
* Looks good, update * Looks good, update
*/ */
memset(repl_val, 0, sizeof(repl_val)); memset(repl_val, 0, sizeof(repl_val));
memset(repl_null, ' ', sizeof(repl_null)); memset(repl_null, false, sizeof(repl_null));
memset(repl_repl, ' ', sizeof(repl_repl)); memset(repl_repl, false, sizeof(repl_repl));
if (dictoptions) if (dictoptions)
repl_val[Anum_pg_ts_dict_dictinitoption - 1] = repl_val[Anum_pg_ts_dict_dictinitoption - 1] =
PointerGetDatum(serialize_deflist(dictoptions)); PointerGetDatum(serialize_deflist(dictoptions));
else else
repl_null[Anum_pg_ts_dict_dictinitoption - 1] = 'n'; repl_null[Anum_pg_ts_dict_dictinitoption - 1] = true;
repl_repl[Anum_pg_ts_dict_dictinitoption - 1] = 'r'; repl_repl[Anum_pg_ts_dict_dictinitoption - 1] = true;
newtup = heap_modifytuple(tup, RelationGetDescr(rel), newtup = heap_modify_tuple(tup, RelationGetDescr(rel),
repl_val, repl_null, repl_repl); repl_val, repl_null, repl_repl);
simple_heap_update(rel, &newtup->t_self, newtup); simple_heap_update(rel, &newtup->t_self, newtup);
@ -995,7 +995,7 @@ DefineTSTemplate(List *names, List *parameters)
Relation tmplRel; Relation tmplRel;
HeapTuple tup; HeapTuple tup;
Datum values[Natts_pg_ts_template]; Datum values[Natts_pg_ts_template];
char nulls[Natts_pg_ts_template]; bool nulls[Natts_pg_ts_template];
NameData dname; NameData dname;
int i; int i;
Oid dictOid; Oid dictOid;
@ -1012,7 +1012,7 @@ DefineTSTemplate(List *names, List *parameters)
for (i = 0; i < Natts_pg_ts_template; i++) for (i = 0; i < Natts_pg_ts_template; i++)
{ {
nulls[i] = ' '; nulls[i] = false;
values[i] = ObjectIdGetDatum(InvalidOid); values[i] = ObjectIdGetDatum(InvalidOid);
} }
@ -1031,13 +1031,13 @@ DefineTSTemplate(List *names, List *parameters)
{ {
values[Anum_pg_ts_template_tmplinit - 1] = values[Anum_pg_ts_template_tmplinit - 1] =
get_ts_template_func(defel, Anum_pg_ts_template_tmplinit); get_ts_template_func(defel, Anum_pg_ts_template_tmplinit);
nulls[Anum_pg_ts_template_tmplinit - 1] = ' '; nulls[Anum_pg_ts_template_tmplinit - 1] = false;
} }
else if (pg_strcasecmp(defel->defname, "lexize") == 0) else if (pg_strcasecmp(defel->defname, "lexize") == 0)
{ {
values[Anum_pg_ts_template_tmpllexize - 1] = values[Anum_pg_ts_template_tmpllexize - 1] =
get_ts_template_func(defel, Anum_pg_ts_template_tmpllexize); get_ts_template_func(defel, Anum_pg_ts_template_tmpllexize);
nulls[Anum_pg_ts_template_tmpllexize - 1] = ' '; nulls[Anum_pg_ts_template_tmpllexize - 1] = false;
} }
else else
ereport(ERROR, ereport(ERROR,
@ -1060,7 +1060,7 @@ DefineTSTemplate(List *names, List *parameters)
tmplRel = heap_open(TSTemplateRelationId, RowExclusiveLock); tmplRel = heap_open(TSTemplateRelationId, RowExclusiveLock);
tup = heap_formtuple(tmplRel->rd_att, values, nulls); tup = heap_form_tuple(tmplRel->rd_att, values, nulls);
dictOid = simple_heap_insert(tmplRel, tup); dictOid = simple_heap_insert(tmplRel, tup);
@ -1327,7 +1327,7 @@ DefineTSConfiguration(List *names, List *parameters)
Relation mapRel = NULL; Relation mapRel = NULL;
HeapTuple tup; HeapTuple tup;
Datum values[Natts_pg_ts_config]; Datum values[Natts_pg_ts_config];
char nulls[Natts_pg_ts_config]; bool nulls[Natts_pg_ts_config];
AclResult aclresult; AclResult aclresult;
Oid namespaceoid; Oid namespaceoid;
char *cfgname; char *cfgname;
@ -1403,7 +1403,7 @@ DefineTSConfiguration(List *names, List *parameters)
* Looks good, build tuple and insert * Looks good, build tuple and insert
*/ */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
namestrcpy(&cname, cfgname); namestrcpy(&cname, cfgname);
values[Anum_pg_ts_config_cfgname - 1] = NameGetDatum(&cname); values[Anum_pg_ts_config_cfgname - 1] = NameGetDatum(&cname);
@ -1413,7 +1413,7 @@ DefineTSConfiguration(List *names, List *parameters)
cfgRel = heap_open(TSConfigRelationId, RowExclusiveLock); cfgRel = heap_open(TSConfigRelationId, RowExclusiveLock);
tup = heap_formtuple(cfgRel->rd_att, values, nulls); tup = heap_form_tuple(cfgRel->rd_att, values, nulls);
cfgOid = simple_heap_insert(cfgRel, tup); cfgOid = simple_heap_insert(cfgRel, tup);
@ -1443,17 +1443,17 @@ DefineTSConfiguration(List *names, List *parameters)
Form_pg_ts_config_map cfgmap = (Form_pg_ts_config_map) GETSTRUCT(maptup); Form_pg_ts_config_map cfgmap = (Form_pg_ts_config_map) GETSTRUCT(maptup);
HeapTuple newmaptup; HeapTuple newmaptup;
Datum mapvalues[Natts_pg_ts_config_map]; Datum mapvalues[Natts_pg_ts_config_map];
char mapnulls[Natts_pg_ts_config_map]; bool mapnulls[Natts_pg_ts_config_map];
memset(mapvalues, 0, sizeof(mapvalues)); memset(mapvalues, 0, sizeof(mapvalues));
memset(mapnulls, ' ', sizeof(mapnulls)); memset(mapnulls, false, sizeof(mapnulls));
mapvalues[Anum_pg_ts_config_map_mapcfg - 1] = cfgOid; mapvalues[Anum_pg_ts_config_map_mapcfg - 1] = cfgOid;
mapvalues[Anum_pg_ts_config_map_maptokentype - 1] = cfgmap->maptokentype; mapvalues[Anum_pg_ts_config_map_maptokentype - 1] = cfgmap->maptokentype;
mapvalues[Anum_pg_ts_config_map_mapseqno - 1] = cfgmap->mapseqno; mapvalues[Anum_pg_ts_config_map_mapseqno - 1] = cfgmap->mapseqno;
mapvalues[Anum_pg_ts_config_map_mapdict - 1] = cfgmap->mapdict; mapvalues[Anum_pg_ts_config_map_mapdict - 1] = cfgmap->mapdict;
newmaptup = heap_formtuple(mapRel->rd_att, mapvalues, mapnulls); newmaptup = heap_form_tuple(mapRel->rd_att, mapvalues, mapnulls);
simple_heap_insert(mapRel, newmaptup); simple_heap_insert(mapRel, newmaptup);
@ -1911,18 +1911,18 @@ MakeConfigurationMapping(AlterTSConfigurationStmt *stmt,
if (cfgmap->mapdict == dictOld) if (cfgmap->mapdict == dictOld)
{ {
Datum repl_val[Natts_pg_ts_config_map]; Datum repl_val[Natts_pg_ts_config_map];
char repl_null[Natts_pg_ts_config_map]; bool repl_null[Natts_pg_ts_config_map];
char repl_repl[Natts_pg_ts_config_map]; bool repl_repl[Natts_pg_ts_config_map];
HeapTuple newtup; HeapTuple newtup;
memset(repl_val, 0, sizeof(repl_val)); memset(repl_val, 0, sizeof(repl_val));
memset(repl_null, ' ', sizeof(repl_null)); memset(repl_null, false, sizeof(repl_null));
memset(repl_repl, ' ', sizeof(repl_repl)); memset(repl_repl, false, sizeof(repl_repl));
repl_val[Anum_pg_ts_config_map_mapdict - 1] = ObjectIdGetDatum(dictNew); repl_val[Anum_pg_ts_config_map_mapdict - 1] = ObjectIdGetDatum(dictNew);
repl_repl[Anum_pg_ts_config_map_mapdict - 1] = 'r'; repl_repl[Anum_pg_ts_config_map_mapdict - 1] = true;
newtup = heap_modifytuple(maptup, newtup = heap_modify_tuple(maptup,
RelationGetDescr(relMap), RelationGetDescr(relMap),
repl_val, repl_null, repl_repl); repl_val, repl_null, repl_repl);
simple_heap_update(relMap, &newtup->t_self, newtup); simple_heap_update(relMap, &newtup->t_self, newtup);
@ -1943,15 +1943,15 @@ MakeConfigurationMapping(AlterTSConfigurationStmt *stmt,
for (j = 0; j < ndict; j++) for (j = 0; j < ndict; j++)
{ {
Datum values[Natts_pg_ts_config_map]; Datum values[Natts_pg_ts_config_map];
char nulls[Natts_pg_ts_config_map]; bool nulls[Natts_pg_ts_config_map];
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
values[Anum_pg_ts_config_map_mapcfg - 1] = ObjectIdGetDatum(cfgId); values[Anum_pg_ts_config_map_mapcfg - 1] = ObjectIdGetDatum(cfgId);
values[Anum_pg_ts_config_map_maptokentype - 1] = Int32GetDatum(tokens[i]); values[Anum_pg_ts_config_map_maptokentype - 1] = Int32GetDatum(tokens[i]);
values[Anum_pg_ts_config_map_mapseqno - 1] = Int32GetDatum(j + 1); values[Anum_pg_ts_config_map_mapseqno - 1] = Int32GetDatum(j + 1);
values[Anum_pg_ts_config_map_mapdict - 1] = ObjectIdGetDatum(dictIds[j]); values[Anum_pg_ts_config_map_mapdict - 1] = ObjectIdGetDatum(dictIds[j]);
tup = heap_formtuple(relMap->rd_att, values, nulls); tup = heap_form_tuple(relMap->rd_att, values, nulls);
simple_heap_insert(relMap, tup); simple_heap_insert(relMap, tup);
CatalogUpdateIndexes(relMap, tup); CatalogUpdateIndexes(relMap, tup);

32
src/backend/commands/typecmds.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/commands/typecmds.c,v 1.125 2008/10/21 10:38:51 petere Exp $ * $PostgreSQL: pgsql/src/backend/commands/typecmds.c,v 1.126 2008/11/02 01:45:28 tgl Exp $
* *
* DESCRIPTION * DESCRIPTION
* The "DefineFoo" routines take the parse tree and pick out the * The "DefineFoo" routines take the parse tree and pick out the
@ -1436,8 +1436,8 @@ AlterDomainDefault(List *names, Node *defaultRaw)
char *defaultValue; char *defaultValue;
Node *defaultExpr = NULL; /* NULL if no default specified */ Node *defaultExpr = NULL; /* NULL if no default specified */
Datum new_record[Natts_pg_type]; Datum new_record[Natts_pg_type];
char new_record_nulls[Natts_pg_type]; bool new_record_nulls[Natts_pg_type];
char new_record_repl[Natts_pg_type]; bool new_record_repl[Natts_pg_type];
HeapTuple newtuple; HeapTuple newtuple;
Form_pg_type typTup; Form_pg_type typTup;
@ -1460,8 +1460,8 @@ AlterDomainDefault(List *names, Node *defaultRaw)
/* Setup new tuple */ /* Setup new tuple */
MemSet(new_record, (Datum) 0, sizeof(new_record)); MemSet(new_record, (Datum) 0, sizeof(new_record));
MemSet(new_record_nulls, ' ', sizeof(new_record_nulls)); MemSet(new_record_nulls, false, sizeof(new_record_nulls));
MemSet(new_record_repl, ' ', sizeof(new_record_repl)); MemSet(new_record_repl, false, sizeof(new_record_repl));
/* Store the new default into the tuple */ /* Store the new default into the tuple */
if (defaultRaw) if (defaultRaw)
@ -1487,10 +1487,10 @@ AlterDomainDefault(List *names, Node *defaultRaw)
(IsA(defaultExpr, Const) &&((Const *) defaultExpr)->constisnull)) (IsA(defaultExpr, Const) &&((Const *) defaultExpr)->constisnull))
{ {
/* Default is NULL, drop it */ /* Default is NULL, drop it */
new_record_nulls[Anum_pg_type_typdefaultbin - 1] = 'n'; new_record_nulls[Anum_pg_type_typdefaultbin - 1] = true;
new_record_repl[Anum_pg_type_typdefaultbin - 1] = 'r'; new_record_repl[Anum_pg_type_typdefaultbin - 1] = true;
new_record_nulls[Anum_pg_type_typdefault - 1] = 'n'; new_record_nulls[Anum_pg_type_typdefault - 1] = true;
new_record_repl[Anum_pg_type_typdefault - 1] = 'r'; new_record_repl[Anum_pg_type_typdefault - 1] = true;
} }
else else
{ {
@ -1509,21 +1509,21 @@ AlterDomainDefault(List *names, Node *defaultRaw)
*/ */
new_record[Anum_pg_type_typdefaultbin - 1] = CStringGetTextDatum(nodeToString(defaultExpr)); new_record[Anum_pg_type_typdefaultbin - 1] = CStringGetTextDatum(nodeToString(defaultExpr));
new_record_repl[Anum_pg_type_typdefaultbin - 1] = 'r'; new_record_repl[Anum_pg_type_typdefaultbin - 1] = true;
new_record[Anum_pg_type_typdefault - 1] = CStringGetTextDatum(defaultValue); new_record[Anum_pg_type_typdefault - 1] = CStringGetTextDatum(defaultValue);
new_record_repl[Anum_pg_type_typdefault - 1] = 'r'; new_record_repl[Anum_pg_type_typdefault - 1] = true;
} }
} }
else else
{ {
/* ALTER ... DROP DEFAULT */ /* ALTER ... DROP DEFAULT */
new_record_nulls[Anum_pg_type_typdefaultbin - 1] = 'n'; new_record_nulls[Anum_pg_type_typdefaultbin - 1] = true;
new_record_repl[Anum_pg_type_typdefaultbin - 1] = 'r'; new_record_repl[Anum_pg_type_typdefaultbin - 1] = true;
new_record_nulls[Anum_pg_type_typdefault - 1] = 'n'; new_record_nulls[Anum_pg_type_typdefault - 1] = true;
new_record_repl[Anum_pg_type_typdefault - 1] = 'r'; new_record_repl[Anum_pg_type_typdefault - 1] = true;
} }
newtuple = heap_modifytuple(tup, RelationGetDescr(rel), newtuple = heap_modify_tuple(tup, RelationGetDescr(rel),
new_record, new_record_nulls, new_record, new_record_nulls,
new_record_repl); new_record_repl);

106
src/backend/commands/user.c
View File

@ -6,7 +6,7 @@
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $PostgreSQL: pgsql/src/backend/commands/user.c,v 1.182 2008/05/12 00:00:48 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/commands/user.c,v 1.183 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -78,7 +78,7 @@ CreateRole(CreateRoleStmt *stmt)
TupleDesc pg_authid_dsc; TupleDesc pg_authid_dsc;
HeapTuple tuple; HeapTuple tuple;
Datum new_record[Natts_pg_authid]; Datum new_record[Natts_pg_authid];
char new_record_nulls[Natts_pg_authid]; bool new_record_nulls[Natts_pg_authid];
Oid roleid; Oid roleid;
ListCell *item; ListCell *item;
ListCell *option; ListCell *option;
@ -295,7 +295,7 @@ CreateRole(CreateRoleStmt *stmt)
* Build a tuple to insert * Build a tuple to insert
*/ */
MemSet(new_record, 0, sizeof(new_record)); MemSet(new_record, 0, sizeof(new_record));
MemSet(new_record_nulls, ' ', sizeof(new_record_nulls)); MemSet(new_record_nulls, false, sizeof(new_record_nulls));
new_record[Anum_pg_authid_rolname - 1] = new_record[Anum_pg_authid_rolname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(stmt->role)); DirectFunctionCall1(namein, CStringGetDatum(stmt->role));
@ -324,7 +324,7 @@ CreateRole(CreateRoleStmt *stmt)
} }
} }
else else
new_record_nulls[Anum_pg_authid_rolpassword - 1] = 'n'; new_record_nulls[Anum_pg_authid_rolpassword - 1] = true;
if (validUntil) if (validUntil)
new_record[Anum_pg_authid_rolvaliduntil - 1] = new_record[Anum_pg_authid_rolvaliduntil - 1] =
@ -334,11 +334,11 @@ CreateRole(CreateRoleStmt *stmt)
Int32GetDatum(-1)); Int32GetDatum(-1));
else else
new_record_nulls[Anum_pg_authid_rolvaliduntil - 1] = 'n'; new_record_nulls[Anum_pg_authid_rolvaliduntil - 1] = true;
new_record_nulls[Anum_pg_authid_rolconfig - 1] = 'n'; new_record_nulls[Anum_pg_authid_rolconfig - 1] = true;
tuple = heap_formtuple(pg_authid_dsc, new_record, new_record_nulls); tuple = heap_form_tuple(pg_authid_dsc, new_record, new_record_nulls);
/* /*
* Insert new record in the pg_authid table * Insert new record in the pg_authid table
@ -402,8 +402,8 @@ void
AlterRole(AlterRoleStmt *stmt) AlterRole(AlterRoleStmt *stmt)
{ {
Datum new_record[Natts_pg_authid]; Datum new_record[Natts_pg_authid];
char new_record_nulls[Natts_pg_authid]; bool new_record_nulls[Natts_pg_authid];
char new_record_repl[Natts_pg_authid]; bool new_record_repl[Natts_pg_authid];
Relation pg_authid_rel; Relation pg_authid_rel;
TupleDesc pg_authid_dsc; TupleDesc pg_authid_dsc;
HeapTuple tuple, HeapTuple tuple,
@ -586,8 +586,8 @@ AlterRole(AlterRoleStmt *stmt)
* Build an updated tuple, perusing the information just obtained * Build an updated tuple, perusing the information just obtained
*/ */
MemSet(new_record, 0, sizeof(new_record)); MemSet(new_record, 0, sizeof(new_record));
MemSet(new_record_nulls, ' ', sizeof(new_record_nulls)); MemSet(new_record_nulls, false, sizeof(new_record_nulls));
MemSet(new_record_repl, ' ', sizeof(new_record_repl)); MemSet(new_record_repl, false, sizeof(new_record_repl));
/* /*
* issuper/createrole/catupdate/etc * issuper/createrole/catupdate/etc
@ -600,40 +600,40 @@ AlterRole(AlterRoleStmt *stmt)
if (issuper >= 0) if (issuper >= 0)
{ {
new_record[Anum_pg_authid_rolsuper - 1] = BoolGetDatum(issuper > 0); new_record[Anum_pg_authid_rolsuper - 1] = BoolGetDatum(issuper > 0);
new_record_repl[Anum_pg_authid_rolsuper - 1] = 'r'; new_record_repl[Anum_pg_authid_rolsuper - 1] = true;
new_record[Anum_pg_authid_rolcatupdate - 1] = BoolGetDatum(issuper > 0); new_record[Anum_pg_authid_rolcatupdate - 1] = BoolGetDatum(issuper > 0);
new_record_repl[Anum_pg_authid_rolcatupdate - 1] = 'r'; new_record_repl[Anum_pg_authid_rolcatupdate - 1] = true;
} }
if (inherit >= 0) if (inherit >= 0)
{ {
new_record[Anum_pg_authid_rolinherit - 1] = BoolGetDatum(inherit > 0); new_record[Anum_pg_authid_rolinherit - 1] = BoolGetDatum(inherit > 0);
new_record_repl[Anum_pg_authid_rolinherit - 1] = 'r'; new_record_repl[Anum_pg_authid_rolinherit - 1] = true;
} }
if (createrole >= 0) if (createrole >= 0)
{ {
new_record[Anum_pg_authid_rolcreaterole - 1] = BoolGetDatum(createrole > 0); new_record[Anum_pg_authid_rolcreaterole - 1] = BoolGetDatum(createrole > 0);
new_record_repl[Anum_pg_authid_rolcreaterole - 1] = 'r'; new_record_repl[Anum_pg_authid_rolcreaterole - 1] = true;
} }
if (createdb >= 0) if (createdb >= 0)
{ {
new_record[Anum_pg_authid_rolcreatedb - 1] = BoolGetDatum(createdb > 0); new_record[Anum_pg_authid_rolcreatedb - 1] = BoolGetDatum(createdb > 0);
new_record_repl[Anum_pg_authid_rolcreatedb - 1] = 'r'; new_record_repl[Anum_pg_authid_rolcreatedb - 1] = true;
} }
if (canlogin >= 0) if (canlogin >= 0)
{ {
new_record[Anum_pg_authid_rolcanlogin - 1] = BoolGetDatum(canlogin > 0); new_record[Anum_pg_authid_rolcanlogin - 1] = BoolGetDatum(canlogin > 0);
new_record_repl[Anum_pg_authid_rolcanlogin - 1] = 'r'; new_record_repl[Anum_pg_authid_rolcanlogin - 1] = true;
} }
if (dconnlimit) if (dconnlimit)
{ {
new_record[Anum_pg_authid_rolconnlimit - 1] = Int32GetDatum(connlimit); new_record[Anum_pg_authid_rolconnlimit - 1] = Int32GetDatum(connlimit);
new_record_repl[Anum_pg_authid_rolconnlimit - 1] = 'r'; new_record_repl[Anum_pg_authid_rolconnlimit - 1] = true;
} }
/* password */ /* password */
@ -650,14 +650,14 @@ AlterRole(AlterRoleStmt *stmt)
new_record[Anum_pg_authid_rolpassword - 1] = new_record[Anum_pg_authid_rolpassword - 1] =
CStringGetTextDatum(encrypted_password); CStringGetTextDatum(encrypted_password);
} }
new_record_repl[Anum_pg_authid_rolpassword - 1] = 'r'; new_record_repl[Anum_pg_authid_rolpassword - 1] = true;
} }
/* unset password */ /* unset password */
if (dpassword && dpassword->arg == NULL) if (dpassword && dpassword->arg == NULL)
{ {
new_record_repl[Anum_pg_authid_rolpassword - 1] = 'r'; new_record_repl[Anum_pg_authid_rolpassword - 1] = true;
new_record_nulls[Anum_pg_authid_rolpassword - 1] = 'n'; new_record_nulls[Anum_pg_authid_rolpassword - 1] = true;
} }
/* valid until */ /* valid until */
@ -668,10 +668,10 @@ AlterRole(AlterRoleStmt *stmt)
CStringGetDatum(validUntil), CStringGetDatum(validUntil),
ObjectIdGetDatum(InvalidOid), ObjectIdGetDatum(InvalidOid),
Int32GetDatum(-1)); Int32GetDatum(-1));
new_record_repl[Anum_pg_authid_rolvaliduntil - 1] = 'r'; new_record_repl[Anum_pg_authid_rolvaliduntil - 1] = true;
} }
new_tuple = heap_modifytuple(tuple, pg_authid_dsc, new_record, new_tuple = heap_modify_tuple(tuple, pg_authid_dsc, new_record,
new_record_nulls, new_record_repl); new_record_nulls, new_record_repl);
simple_heap_update(pg_authid_rel, &tuple->t_self, new_tuple); simple_heap_update(pg_authid_rel, &tuple->t_self, new_tuple);
@ -721,8 +721,8 @@ AlterRoleSet(AlterRoleSetStmt *stmt)
newtuple; newtuple;
Relation rel; Relation rel;
Datum repl_val[Natts_pg_authid]; Datum repl_val[Natts_pg_authid];
char repl_null[Natts_pg_authid]; bool repl_null[Natts_pg_authid];
char repl_repl[Natts_pg_authid]; bool repl_repl[Natts_pg_authid];
valuestr = ExtractSetVariableArgs(stmt->setstmt); valuestr = ExtractSetVariableArgs(stmt->setstmt);
@ -755,13 +755,13 @@ AlterRoleSet(AlterRoleSetStmt *stmt)
errmsg("permission denied"))); errmsg("permission denied")));
} }
memset(repl_repl, ' ', sizeof(repl_repl)); memset(repl_repl, false, sizeof(repl_repl));
repl_repl[Anum_pg_authid_rolconfig - 1] = 'r'; repl_repl[Anum_pg_authid_rolconfig - 1] = true;
if (stmt->setstmt->kind == VAR_RESET_ALL) if (stmt->setstmt->kind == VAR_RESET_ALL)
{ {
/* RESET ALL, so just set rolconfig to null */ /* RESET ALL, so just set rolconfig to null */
repl_null[Anum_pg_authid_rolconfig - 1] = 'n'; repl_null[Anum_pg_authid_rolconfig - 1] = true;
repl_val[Anum_pg_authid_rolconfig - 1] = (Datum) 0; repl_val[Anum_pg_authid_rolconfig - 1] = (Datum) 0;
} }
else else
@ -770,7 +770,7 @@ AlterRoleSet(AlterRoleSetStmt *stmt)
bool isnull; bool isnull;
ArrayType *array; ArrayType *array;
repl_null[Anum_pg_authid_rolconfig - 1] = ' '; repl_null[Anum_pg_authid_rolconfig - 1] = false;
/* Extract old value of rolconfig */ /* Extract old value of rolconfig */
datum = SysCacheGetAttr(AUTHNAME, oldtuple, datum = SysCacheGetAttr(AUTHNAME, oldtuple,
@ -786,10 +786,10 @@ AlterRoleSet(AlterRoleSetStmt *stmt)
if (array) if (array)
repl_val[Anum_pg_authid_rolconfig - 1] = PointerGetDatum(array); repl_val[Anum_pg_authid_rolconfig - 1] = PointerGetDatum(array);
else else
repl_null[Anum_pg_authid_rolconfig - 1] = 'n'; repl_null[Anum_pg_authid_rolconfig - 1] = true;
} }
newtuple = heap_modifytuple(oldtuple, RelationGetDescr(rel), newtuple = heap_modify_tuple(oldtuple, RelationGetDescr(rel),
repl_val, repl_null, repl_repl); repl_val, repl_null, repl_repl);
simple_heap_update(rel, &oldtuple->t_self, newtuple); simple_heap_update(rel, &oldtuple->t_self, newtuple);
@ -983,8 +983,8 @@ RenameRole(const char *oldname, const char *newname)
Datum datum; Datum datum;
bool isnull; bool isnull;
Datum repl_val[Natts_pg_authid]; Datum repl_val[Natts_pg_authid];
char repl_null[Natts_pg_authid]; bool repl_null[Natts_pg_authid];
char repl_repl[Natts_pg_authid]; bool repl_repl[Natts_pg_authid];
int i; int i;
Oid roleid; Oid roleid;
@ -1053,26 +1053,26 @@ RenameRole(const char *oldname, const char *newname)
/* OK, construct the modified tuple */ /* OK, construct the modified tuple */
for (i = 0; i < Natts_pg_authid; i++) for (i = 0; i < Natts_pg_authid; i++)
repl_repl[i] = ' '; repl_repl[i] = false;
repl_repl[Anum_pg_authid_rolname - 1] = 'r'; repl_repl[Anum_pg_authid_rolname - 1] = true;
repl_val[Anum_pg_authid_rolname - 1] = DirectFunctionCall1(namein, repl_val[Anum_pg_authid_rolname - 1] = DirectFunctionCall1(namein,
CStringGetDatum(newname)); CStringGetDatum(newname));
repl_null[Anum_pg_authid_rolname - 1] = ' '; repl_null[Anum_pg_authid_rolname - 1] = false;
datum = heap_getattr(oldtuple, Anum_pg_authid_rolpassword, dsc, &isnull); datum = heap_getattr(oldtuple, Anum_pg_authid_rolpassword, dsc, &isnull);
if (!isnull && isMD5(TextDatumGetCString(datum))) if (!isnull && isMD5(TextDatumGetCString(datum)))
{ {
/* MD5 uses the username as salt, so just clear it on a rename */ /* MD5 uses the username as salt, so just clear it on a rename */
repl_repl[Anum_pg_authid_rolpassword - 1] = 'r'; repl_repl[Anum_pg_authid_rolpassword - 1] = true;
repl_null[Anum_pg_authid_rolpassword - 1] = 'n'; repl_null[Anum_pg_authid_rolpassword - 1] = true;
ereport(NOTICE, ereport(NOTICE,
(errmsg("MD5 password cleared because of role rename"))); (errmsg("MD5 password cleared because of role rename")));
} }
newtuple = heap_modifytuple(oldtuple, dsc, repl_val, repl_null, repl_repl); newtuple = heap_modify_tuple(oldtuple, dsc, repl_val, repl_null, repl_repl);
simple_heap_update(rel, &oldtuple->t_self, newtuple); simple_heap_update(rel, &oldtuple->t_self, newtuple);
CatalogUpdateIndexes(rel, newtuple); CatalogUpdateIndexes(rel, newtuple);
@ -1296,8 +1296,8 @@ AddRoleMems(const char *rolename, Oid roleid,
HeapTuple authmem_tuple; HeapTuple authmem_tuple;
HeapTuple tuple; HeapTuple tuple;
Datum new_record[Natts_pg_auth_members]; Datum new_record[Natts_pg_auth_members];
char new_record_nulls[Natts_pg_auth_members]; bool new_record_nulls[Natts_pg_auth_members];
char new_record_repl[Natts_pg_auth_members]; bool new_record_repl[Natts_pg_auth_members];
/* /*
* Refuse creation of membership loops, including the trivial case * Refuse creation of membership loops, including the trivial case
@ -1333,8 +1333,8 @@ AddRoleMems(const char *rolename, Oid roleid,
/* Build a tuple to insert or update */ /* Build a tuple to insert or update */
MemSet(new_record, 0, sizeof(new_record)); MemSet(new_record, 0, sizeof(new_record));
MemSet(new_record_nulls, ' ', sizeof(new_record_nulls)); MemSet(new_record_nulls, false, sizeof(new_record_nulls));
MemSet(new_record_repl, ' ', sizeof(new_record_repl)); MemSet(new_record_repl, false, sizeof(new_record_repl));
new_record[Anum_pg_auth_members_roleid - 1] = ObjectIdGetDatum(roleid); new_record[Anum_pg_auth_members_roleid - 1] = ObjectIdGetDatum(roleid);
new_record[Anum_pg_auth_members_member - 1] = ObjectIdGetDatum(memberid); new_record[Anum_pg_auth_members_member - 1] = ObjectIdGetDatum(memberid);
@ -1343,9 +1343,9 @@ AddRoleMems(const char *rolename, Oid roleid,
if (HeapTupleIsValid(authmem_tuple)) if (HeapTupleIsValid(authmem_tuple))
{ {
new_record_repl[Anum_pg_auth_members_grantor - 1] = 'r'; new_record_repl[Anum_pg_auth_members_grantor - 1] = true;
new_record_repl[Anum_pg_auth_members_admin_option - 1] = 'r'; new_record_repl[Anum_pg_auth_members_admin_option - 1] = true;
tuple = heap_modifytuple(authmem_tuple, pg_authmem_dsc, tuple = heap_modify_tuple(authmem_tuple, pg_authmem_dsc,
new_record, new_record,
new_record_nulls, new_record_repl); new_record_nulls, new_record_repl);
simple_heap_update(pg_authmem_rel, &tuple->t_self, tuple); simple_heap_update(pg_authmem_rel, &tuple->t_self, tuple);
@ -1354,7 +1354,7 @@ AddRoleMems(const char *rolename, Oid roleid,
} }
else else
{ {
tuple = heap_formtuple(pg_authmem_dsc, tuple = heap_form_tuple(pg_authmem_dsc,
new_record, new_record_nulls); new_record, new_record_nulls);
simple_heap_insert(pg_authmem_rel, tuple); simple_heap_insert(pg_authmem_rel, tuple);
CatalogUpdateIndexes(pg_authmem_rel, tuple); CatalogUpdateIndexes(pg_authmem_rel, tuple);
@ -1453,18 +1453,18 @@ DelRoleMems(const char *rolename, Oid roleid,
/* Just turn off the admin option */ /* Just turn off the admin option */
HeapTuple tuple; HeapTuple tuple;
Datum new_record[Natts_pg_auth_members]; Datum new_record[Natts_pg_auth_members];
char new_record_nulls[Natts_pg_auth_members]; bool new_record_nulls[Natts_pg_auth_members];
char new_record_repl[Natts_pg_auth_members]; bool new_record_repl[Natts_pg_auth_members];
/* Build a tuple to update with */ /* Build a tuple to update with */
MemSet(new_record, 0, sizeof(new_record)); MemSet(new_record, 0, sizeof(new_record));
MemSet(new_record_nulls, ' ', sizeof(new_record_nulls)); MemSet(new_record_nulls, false, sizeof(new_record_nulls));
MemSet(new_record_repl, ' ', sizeof(new_record_repl)); MemSet(new_record_repl, false, sizeof(new_record_repl));
new_record[Anum_pg_auth_members_admin_option - 1] = BoolGetDatum(false); new_record[Anum_pg_auth_members_admin_option - 1] = BoolGetDatum(false);
new_record_repl[Anum_pg_auth_members_admin_option - 1] = 'r'; new_record_repl[Anum_pg_auth_members_admin_option - 1] = true;
tuple = heap_modifytuple(authmem_tuple, pg_authmem_dsc, tuple = heap_modify_tuple(authmem_tuple, pg_authmem_dsc,
new_record, new_record,
new_record_nulls, new_record_repl); new_record_nulls, new_record_repl);
simple_heap_update(pg_authmem_rel, &tuple->t_self, tuple); simple_heap_update(pg_authmem_rel, &tuple->t_self, tuple);

14
src/backend/executor/execTuples.c
View File

@ -15,7 +15,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/execTuples.c,v 1.103 2008/10/28 22:02:05 tgl Exp $ * $PostgreSQL: pgsql/src/backend/executor/execTuples.c,v 1.104 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -1126,12 +1126,12 @@ BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values)
TupleDesc tupdesc = attinmeta->tupdesc; TupleDesc tupdesc = attinmeta->tupdesc;
int natts = tupdesc->natts; int natts = tupdesc->natts;
Datum *dvalues; Datum *dvalues;
char *nulls; bool *nulls;
int i; int i;
HeapTuple tuple; HeapTuple tuple;
dvalues = (Datum *) palloc(natts * sizeof(Datum)); dvalues = (Datum *) palloc(natts * sizeof(Datum));
nulls = (char *) palloc(natts * sizeof(char)); nulls = (bool *) palloc(natts * sizeof(bool));
/* Call the "in" function for each non-dropped attribute */ /* Call the "in" function for each non-dropped attribute */
for (i = 0; i < natts; i++) for (i = 0; i < natts; i++)
@ -1144,22 +1144,22 @@ BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values)
attinmeta->attioparams[i], attinmeta->attioparams[i],
attinmeta->atttypmods[i]); attinmeta->atttypmods[i]);
if (values[i] != NULL) if (values[i] != NULL)
nulls[i] = ' '; nulls[i] = false;
else else
nulls[i] = 'n'; nulls[i] = true;
} }
else else
{ {
/* Handle dropped attributes by setting to NULL */ /* Handle dropped attributes by setting to NULL */
dvalues[i] = (Datum) 0; dvalues[i] = (Datum) 0;
nulls[i] = 'n'; nulls[i] = true;
} }
} }
/* /*
* Form a tuple * Form a tuple
*/ */
tuple = heap_formtuple(tupdesc, dvalues, nulls); tuple = heap_form_tuple(tupdesc, dvalues, nulls);
/* /*
* Release locally palloc'd space. XXX would probably be good to pfree * Release locally palloc'd space. XXX would probably be good to pfree

12
src/backend/executor/spi.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/executor/spi.c,v 1.199 2008/10/16 13:23:21 tgl Exp $ * $PostgreSQL: pgsql/src/backend/executor/spi.c,v 1.200 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -627,7 +627,7 @@ SPI_modifytuple(Relation rel, HeapTuple tuple, int natts, int *attnum,
HeapTuple mtuple; HeapTuple mtuple;
int numberOfAttributes; int numberOfAttributes;
Datum *v; Datum *v;
char *n; bool *n;
int i; int i;
if (rel == NULL || tuple == NULL || natts < 0 || attnum == NULL || Values == NULL) if (rel == NULL || tuple == NULL || natts < 0 || attnum == NULL || Values == NULL)
@ -645,10 +645,10 @@ SPI_modifytuple(Relation rel, HeapTuple tuple, int natts, int *attnum,
SPI_result = 0; SPI_result = 0;
numberOfAttributes = rel->rd_att->natts; numberOfAttributes = rel->rd_att->natts;
v = (Datum *) palloc(numberOfAttributes * sizeof(Datum)); v = (Datum *) palloc(numberOfAttributes * sizeof(Datum));
n = (char *) palloc(numberOfAttributes * sizeof(char)); n = (bool *) palloc(numberOfAttributes * sizeof(bool));
/* fetch old values and nulls */ /* fetch old values and nulls */
heap_deformtuple(tuple, rel->rd_att, v, n); heap_deform_tuple(tuple, rel->rd_att, v, n);
/* replace values and nulls */ /* replace values and nulls */
for (i = 0; i < natts; i++) for (i = 0; i < natts; i++)
@ -656,12 +656,12 @@ SPI_modifytuple(Relation rel, HeapTuple tuple, int natts, int *attnum,
if (attnum[i] <= 0 || attnum[i] > numberOfAttributes) if (attnum[i] <= 0 || attnum[i] > numberOfAttributes)
break; break;
v[attnum[i] - 1] = Values[i]; v[attnum[i] - 1] = Values[i];
n[attnum[i] - 1] = (Nulls && Nulls[i] == 'n') ? 'n' : ' '; n[attnum[i] - 1] = (Nulls && Nulls[i] == 'n') ? true : false;
} }
if (i == natts) /* no errors in *attnum */ if (i == natts) /* no errors in *attnum */
{ {
mtuple = heap_formtuple(rel->rd_att, v, n); mtuple = heap_form_tuple(rel->rd_att, v, n);
/* /*
* copy the identification info of the old tuple: t_ctid, t_self, and * copy the identification info of the old tuple: t_ctid, t_self, and

4
src/backend/optimizer/prep/preptlist.c
View File

@ -16,7 +16,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/optimizer/prep/preptlist.c,v 1.92 2008/10/21 20:42:53 tgl Exp $ * $PostgreSQL: pgsql/src/backend/optimizer/prep/preptlist.c,v 1.93 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -68,7 +68,7 @@ preprocess_targetlist(PlannerInfo *root, List *tlist)
} }
/* /*
* for heap_formtuple to work, the targetlist must match the exact order * for heap_form_tuple to work, the targetlist must match the exact order
* of the attributes. We also need to fill in any missing attributes. -ay * of the attributes. We also need to fill in any missing attributes. -ay
* 10/94 * 10/94
*/ */

24
src/backend/rewrite/rewriteDefine.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/rewrite/rewriteDefine.c,v 1.130 2008/10/04 21:56:54 tgl Exp $ * $PostgreSQL: pgsql/src/backend/rewrite/rewriteDefine.c,v 1.131 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -60,8 +60,8 @@ InsertRule(char *rulname,
char *actiontree = nodeToString((Node *) action); char *actiontree = nodeToString((Node *) action);
int i; int i;
Datum values[Natts_pg_rewrite]; Datum values[Natts_pg_rewrite];
char nulls[Natts_pg_rewrite]; bool nulls[Natts_pg_rewrite];
char replaces[Natts_pg_rewrite]; bool replaces[Natts_pg_rewrite];
NameData rname; NameData rname;
Relation pg_rewrite_desc; Relation pg_rewrite_desc;
HeapTuple tup, HeapTuple tup,
@ -74,7 +74,7 @@ InsertRule(char *rulname,
/* /*
* Set up *nulls and *values arrays * Set up *nulls and *values arrays
*/ */
MemSet(nulls, ' ', sizeof(nulls)); MemSet(nulls, false, sizeof(nulls));
i = 0; i = 0;
namestrcpy(&rname, rulname); namestrcpy(&rname, rulname);
@ -111,14 +111,14 @@ InsertRule(char *rulname,
/* /*
* When replacing, we don't need to replace every attribute * When replacing, we don't need to replace every attribute
*/ */
MemSet(replaces, ' ', sizeof(replaces)); MemSet(replaces, false, sizeof(replaces));
replaces[Anum_pg_rewrite_ev_attr - 1] = 'r'; replaces[Anum_pg_rewrite_ev_attr - 1] = true;
replaces[Anum_pg_rewrite_ev_type - 1] = 'r'; replaces[Anum_pg_rewrite_ev_type - 1] = true;
replaces[Anum_pg_rewrite_is_instead - 1] = 'r'; replaces[Anum_pg_rewrite_is_instead - 1] = true;
replaces[Anum_pg_rewrite_ev_qual - 1] = 'r'; replaces[Anum_pg_rewrite_ev_qual - 1] = true;
replaces[Anum_pg_rewrite_ev_action - 1] = 'r'; replaces[Anum_pg_rewrite_ev_action - 1] = true;
tup = heap_modifytuple(oldtup, RelationGetDescr(pg_rewrite_desc), tup = heap_modify_tuple(oldtup, RelationGetDescr(pg_rewrite_desc),
values, nulls, replaces); values, nulls, replaces);
simple_heap_update(pg_rewrite_desc, &tup->t_self, tup); simple_heap_update(pg_rewrite_desc, &tup->t_self, tup);
@ -130,7 +130,7 @@ InsertRule(char *rulname,
} }
else else
{ {
tup = heap_formtuple(pg_rewrite_desc->rd_att, values, nulls); tup = heap_form_tuple(pg_rewrite_desc->rd_att, values, nulls);
rewriteObjectId = simple_heap_insert(pg_rewrite_desc, tup); rewriteObjectId = simple_heap_insert(pg_rewrite_desc, tup);
} }

34
src/backend/storage/large_object/inv_api.c
View File

@ -24,7 +24,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/storage/large_object/inv_api.c,v 1.134 2008/06/19 00:46:05 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/storage/large_object/inv_api.c,v 1.135 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -522,8 +522,8 @@ inv_write(LargeObjectDesc *obj_desc, const char *buf, int nbytes)
char *workb = VARDATA(&workbuf.hdr); char *workb = VARDATA(&workbuf.hdr);
HeapTuple newtup; HeapTuple newtup;
Datum values[Natts_pg_largeobject]; Datum values[Natts_pg_largeobject];
char nulls[Natts_pg_largeobject]; bool nulls[Natts_pg_largeobject];
char replace[Natts_pg_largeobject]; bool replace[Natts_pg_largeobject];
CatalogIndexState indstate; CatalogIndexState indstate;
Assert(PointerIsValid(obj_desc)); Assert(PointerIsValid(obj_desc));
@ -627,11 +627,11 @@ inv_write(LargeObjectDesc *obj_desc, const char *buf, int nbytes)
* Form and insert updated tuple * Form and insert updated tuple
*/ */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
memset(replace, ' ', sizeof(replace)); memset(replace, false, sizeof(replace));
values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf); values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
replace[Anum_pg_largeobject_data - 1] = 'r'; replace[Anum_pg_largeobject_data - 1] = true;
newtup = heap_modifytuple(oldtuple, RelationGetDescr(lo_heap_r), newtup = heap_modify_tuple(oldtuple, RelationGetDescr(lo_heap_r),
values, nulls, replace); values, nulls, replace);
simple_heap_update(lo_heap_r, &newtup->t_self, newtup); simple_heap_update(lo_heap_r, &newtup->t_self, newtup);
CatalogIndexInsert(indstate, newtup); CatalogIndexInsert(indstate, newtup);
@ -671,11 +671,11 @@ inv_write(LargeObjectDesc *obj_desc, const char *buf, int nbytes)
* Form and insert updated tuple * Form and insert updated tuple
*/ */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
values[Anum_pg_largeobject_loid - 1] = ObjectIdGetDatum(obj_desc->id); values[Anum_pg_largeobject_loid - 1] = ObjectIdGetDatum(obj_desc->id);
values[Anum_pg_largeobject_pageno - 1] = Int32GetDatum(pageno); values[Anum_pg_largeobject_pageno - 1] = Int32GetDatum(pageno);
values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf); values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
newtup = heap_formtuple(lo_heap_r->rd_att, values, nulls); newtup = heap_form_tuple(lo_heap_r->rd_att, values, nulls);
simple_heap_insert(lo_heap_r, newtup); simple_heap_insert(lo_heap_r, newtup);
CatalogIndexInsert(indstate, newtup); CatalogIndexInsert(indstate, newtup);
heap_freetuple(newtup); heap_freetuple(newtup);
@ -714,8 +714,8 @@ inv_truncate(LargeObjectDesc *obj_desc, int len)
char *workb = VARDATA(&workbuf.hdr); char *workb = VARDATA(&workbuf.hdr);
HeapTuple newtup; HeapTuple newtup;
Datum values[Natts_pg_largeobject]; Datum values[Natts_pg_largeobject];
char nulls[Natts_pg_largeobject]; bool nulls[Natts_pg_largeobject];
char replace[Natts_pg_largeobject]; bool replace[Natts_pg_largeobject];
CatalogIndexState indstate; CatalogIndexState indstate;
Assert(PointerIsValid(obj_desc)); Assert(PointerIsValid(obj_desc));
@ -796,11 +796,11 @@ inv_truncate(LargeObjectDesc *obj_desc, int len)
* Form and insert updated tuple * Form and insert updated tuple
*/ */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
memset(replace, ' ', sizeof(replace)); memset(replace, false, sizeof(replace));
values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf); values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
replace[Anum_pg_largeobject_data - 1] = 'r'; replace[Anum_pg_largeobject_data - 1] = true;
newtup = heap_modifytuple(oldtuple, RelationGetDescr(lo_heap_r), newtup = heap_modify_tuple(oldtuple, RelationGetDescr(lo_heap_r),
values, nulls, replace); values, nulls, replace);
simple_heap_update(lo_heap_r, &newtup->t_self, newtup); simple_heap_update(lo_heap_r, &newtup->t_self, newtup);
CatalogIndexInsert(indstate, newtup); CatalogIndexInsert(indstate, newtup);
@ -831,11 +831,11 @@ inv_truncate(LargeObjectDesc *obj_desc, int len)
* Form and insert new tuple * Form and insert new tuple
*/ */
memset(values, 0, sizeof(values)); memset(values, 0, sizeof(values));
memset(nulls, ' ', sizeof(nulls)); memset(nulls, false, sizeof(nulls));
values[Anum_pg_largeobject_loid - 1] = ObjectIdGetDatum(obj_desc->id); values[Anum_pg_largeobject_loid - 1] = ObjectIdGetDatum(obj_desc->id);
values[Anum_pg_largeobject_pageno - 1] = Int32GetDatum(pageno); values[Anum_pg_largeobject_pageno - 1] = Int32GetDatum(pageno);
values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf); values[Anum_pg_largeobject_data - 1] = PointerGetDatum(&workbuf);
newtup = heap_formtuple(lo_heap_r->rd_att, values, nulls); newtup = heap_form_tuple(lo_heap_r->rd_att, values, nulls);
simple_heap_insert(lo_heap_r, newtup); simple_heap_insert(lo_heap_r, newtup);
CatalogIndexInsert(indstate, newtup); CatalogIndexInsert(indstate, newtup);
heap_freetuple(newtup); heap_freetuple(newtup);

88
src/backend/utils/adt/lockfuncs.c
View File

@ -6,7 +6,7 @@
* Copyright (c) 2002-2008, PostgreSQL Global Development Group * Copyright (c) 2002-2008, PostgreSQL Global Development Group
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/lockfuncs.c,v 1.34 2008/05/12 00:00:51 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/utils/adt/lockfuncs.c,v 1.35 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -144,7 +144,7 @@ pg_lock_status(PG_FUNCTION_ARGS)
const char *locktypename; const char *locktypename;
char tnbuf[32]; char tnbuf[32];
Datum values[14]; Datum values[14];
char nulls[14]; bool nulls[14];
HeapTuple tuple; HeapTuple tuple;
Datum result; Datum result;
@ -203,7 +203,7 @@ pg_lock_status(PG_FUNCTION_ARGS)
* Form tuple with appropriate data. * Form tuple with appropriate data.
*/ */
MemSet(values, 0, sizeof(values)); MemSet(values, 0, sizeof(values));
MemSet(nulls, ' ', sizeof(nulls)); MemSet(nulls, false, sizeof(nulls));
if (lock->tag.locktag_type <= LOCKTAG_LAST_TYPE) if (lock->tag.locktag_type <= LOCKTAG_LAST_TYPE)
locktypename = LockTagTypeNames[lock->tag.locktag_type]; locktypename = LockTagTypeNames[lock->tag.locktag_type];
@ -221,58 +221,58 @@ pg_lock_status(PG_FUNCTION_ARGS)
case LOCKTAG_RELATION_EXTEND: case LOCKTAG_RELATION_EXTEND:
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1); values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[2] = ObjectIdGetDatum(lock->tag.locktag_field2); values[2] = ObjectIdGetDatum(lock->tag.locktag_field2);
nulls[3] = 'n'; nulls[3] = true;
nulls[4] = 'n'; nulls[4] = true;
nulls[5] = 'n'; nulls[5] = true;
nulls[6] = 'n'; nulls[6] = true;
nulls[7] = 'n'; nulls[7] = true;
nulls[8] = 'n'; nulls[8] = true;
nulls[9] = 'n'; nulls[9] = true;
break; break;
case LOCKTAG_PAGE: case LOCKTAG_PAGE:
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1); values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[2] = ObjectIdGetDatum(lock->tag.locktag_field2); values[2] = ObjectIdGetDatum(lock->tag.locktag_field2);
values[3] = UInt32GetDatum(lock->tag.locktag_field3); values[3] = UInt32GetDatum(lock->tag.locktag_field3);
nulls[4] = 'n'; nulls[4] = true;
nulls[5] = 'n'; nulls[5] = true;
nulls[6] = 'n'; nulls[6] = true;
nulls[7] = 'n'; nulls[7] = true;
nulls[8] = 'n'; nulls[8] = true;
nulls[9] = 'n'; nulls[9] = true;
break; break;
case LOCKTAG_TUPLE: case LOCKTAG_TUPLE:
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1); values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[2] = ObjectIdGetDatum(lock->tag.locktag_field2); values[2] = ObjectIdGetDatum(lock->tag.locktag_field2);
values[3] = UInt32GetDatum(lock->tag.locktag_field3); values[3] = UInt32GetDatum(lock->tag.locktag_field3);
values[4] = UInt16GetDatum(lock->tag.locktag_field4); values[4] = UInt16GetDatum(lock->tag.locktag_field4);
nulls[5] = 'n'; nulls[5] = true;
nulls[6] = 'n'; nulls[6] = true;
nulls[7] = 'n'; nulls[7] = true;
nulls[8] = 'n'; nulls[8] = true;
nulls[9] = 'n'; nulls[9] = true;
break; break;
case LOCKTAG_TRANSACTION: case LOCKTAG_TRANSACTION:
values[6] = TransactionIdGetDatum(lock->tag.locktag_field1); values[6] = TransactionIdGetDatum(lock->tag.locktag_field1);
nulls[1] = 'n'; nulls[1] = true;
nulls[2] = 'n'; nulls[2] = true;
nulls[3] = 'n'; nulls[3] = true;
nulls[4] = 'n'; nulls[4] = true;
nulls[5] = 'n'; nulls[5] = true;
nulls[7] = 'n'; nulls[7] = true;
nulls[8] = 'n'; nulls[8] = true;
nulls[9] = 'n'; nulls[9] = true;
break; break;
case LOCKTAG_VIRTUALTRANSACTION: case LOCKTAG_VIRTUALTRANSACTION:
values[5] = VXIDGetDatum(lock->tag.locktag_field1, values[5] = VXIDGetDatum(lock->tag.locktag_field1,
lock->tag.locktag_field2); lock->tag.locktag_field2);
nulls[1] = 'n'; nulls[1] = true;
nulls[2] = 'n'; nulls[2] = true;
nulls[3] = 'n'; nulls[3] = true;
nulls[4] = 'n'; nulls[4] = true;
nulls[6] = 'n'; nulls[6] = true;
nulls[7] = 'n'; nulls[7] = true;
nulls[8] = 'n'; nulls[8] = true;
nulls[9] = 'n'; nulls[9] = true;
break; break;
case LOCKTAG_OBJECT: case LOCKTAG_OBJECT:
case LOCKTAG_USERLOCK: case LOCKTAG_USERLOCK:
@ -282,11 +282,11 @@ pg_lock_status(PG_FUNCTION_ARGS)
values[7] = ObjectIdGetDatum(lock->tag.locktag_field2); values[7] = ObjectIdGetDatum(lock->tag.locktag_field2);
values[8] = ObjectIdGetDatum(lock->tag.locktag_field3); values[8] = ObjectIdGetDatum(lock->tag.locktag_field3);
values[9] = Int16GetDatum(lock->tag.locktag_field4); values[9] = Int16GetDatum(lock->tag.locktag_field4);
nulls[2] = 'n'; nulls[2] = true;
nulls[3] = 'n'; nulls[3] = true;
nulls[4] = 'n'; nulls[4] = true;
nulls[5] = 'n'; nulls[5] = true;
nulls[6] = 'n'; nulls[6] = true;
break; break;
} }
@ -294,11 +294,11 @@ pg_lock_status(PG_FUNCTION_ARGS)
if (proc->pid != 0) if (proc->pid != 0)
values[11] = Int32GetDatum(proc->pid); values[11] = Int32GetDatum(proc->pid);
else else
nulls[11] = 'n'; nulls[11] = true;
values[12] = CStringGetTextDatum(GetLockmodeName(LOCK_LOCKMETHOD(*lock), mode)); values[12] = CStringGetTextDatum(GetLockmodeName(LOCK_LOCKMETHOD(*lock), mode));
values[13] = BoolGetDatum(granted); values[13] = BoolGetDatum(granted);
tuple = heap_formtuple(funcctx->tuple_desc, values, nulls); tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple); result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result); SRF_RETURN_NEXT(funcctx, result);
} }

46
src/backend/utils/adt/rowtypes.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/adt/rowtypes.c,v 1.22 2008/10/13 16:25:19 tgl Exp $ * $PostgreSQL: pgsql/src/backend/utils/adt/rowtypes.c,v 1.23 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -83,7 +83,7 @@ record_in(PG_FUNCTION_ARGS)
int i; int i;
char *ptr; char *ptr;
Datum *values; Datum *values;
char *nulls; bool *nulls;
StringInfoData buf; StringInfoData buf;
/* /*
@ -129,7 +129,7 @@ record_in(PG_FUNCTION_ARGS)
} }
values = (Datum *) palloc(ncolumns * sizeof(Datum)); values = (Datum *) palloc(ncolumns * sizeof(Datum));
nulls = (char *) palloc(ncolumns * sizeof(char)); nulls = (bool *) palloc(ncolumns * sizeof(bool));
/* /*
* Scan the string. We use "buf" to accumulate the de-quoted data for * Scan the string. We use "buf" to accumulate the de-quoted data for
@ -157,7 +157,7 @@ record_in(PG_FUNCTION_ARGS)
if (tupdesc->attrs[i]->attisdropped) if (tupdesc->attrs[i]->attisdropped)
{ {
values[i] = (Datum) 0; values[i] = (Datum) 0;
nulls[i] = 'n'; nulls[i] = true;
continue; continue;
} }
@ -178,7 +178,7 @@ record_in(PG_FUNCTION_ARGS)
if (*ptr == ',' || *ptr == ')') if (*ptr == ',' || *ptr == ')')
{ {
column_data = NULL; column_data = NULL;
nulls[i] = 'n'; nulls[i] = true;
} }
else else
{ {
@ -223,7 +223,7 @@ record_in(PG_FUNCTION_ARGS)
} }
column_data = buf.data; column_data = buf.data;
nulls[i] = ' '; nulls[i] = false;
} }
/* /*
@ -264,10 +264,10 @@ record_in(PG_FUNCTION_ARGS)
errmsg("malformed record literal: \"%s\"", string), errmsg("malformed record literal: \"%s\"", string),
errdetail("Junk after right parenthesis."))); errdetail("Junk after right parenthesis.")));
tuple = heap_formtuple(tupdesc, values, nulls); tuple = heap_form_tuple(tupdesc, values, nulls);
/* /*
* We cannot return tuple->t_data because heap_formtuple allocates it as * We cannot return tuple->t_data because heap_form_tuple allocates it as
* part of a larger chunk, and our caller may expect to be able to pfree * part of a larger chunk, and our caller may expect to be able to pfree
* our result. So must copy the info into a new palloc chunk. * our result. So must copy the info into a new palloc chunk.
*/ */
@ -299,7 +299,7 @@ record_out(PG_FUNCTION_ARGS)
int ncolumns; int ncolumns;
int i; int i;
Datum *values; Datum *values;
char *nulls; bool *nulls;
StringInfoData buf; StringInfoData buf;
/* Extract type info from the tuple itself */ /* Extract type info from the tuple itself */
@ -343,10 +343,10 @@ record_out(PG_FUNCTION_ARGS)
} }
values = (Datum *) palloc(ncolumns * sizeof(Datum)); values = (Datum *) palloc(ncolumns * sizeof(Datum));
nulls = (char *) palloc(ncolumns * sizeof(char)); nulls = (bool *) palloc(ncolumns * sizeof(bool));
/* Break down the tuple into fields */ /* Break down the tuple into fields */
heap_deformtuple(&tuple, tupdesc, values, nulls); heap_deform_tuple(&tuple, tupdesc, values, nulls);
/* And build the result string */ /* And build the result string */
initStringInfo(&buf); initStringInfo(&buf);
@ -369,7 +369,7 @@ record_out(PG_FUNCTION_ARGS)
appendStringInfoChar(&buf, ','); appendStringInfoChar(&buf, ',');
needComma = true; needComma = true;
if (nulls[i] == 'n') if (nulls[i])
{ {
/* emit nothing... */ /* emit nothing... */
continue; continue;
@ -453,7 +453,7 @@ record_recv(PG_FUNCTION_ARGS)
int validcols; int validcols;
int i; int i;
Datum *values; Datum *values;
char *nulls; bool *nulls;
/* /*
* Use the passed type unless it's RECORD; we can't support input of * Use the passed type unless it's RECORD; we can't support input of
@ -498,7 +498,7 @@ record_recv(PG_FUNCTION_ARGS)
} }
values = (Datum *) palloc(ncolumns * sizeof(Datum)); values = (Datum *) palloc(ncolumns * sizeof(Datum));
nulls = (char *) palloc(ncolumns * sizeof(char)); nulls = (bool *) palloc(ncolumns * sizeof(bool));
/* Fetch number of columns user thinks it has */ /* Fetch number of columns user thinks it has */
usercols = pq_getmsgint(buf, 4); usercols = pq_getmsgint(buf, 4);
@ -531,7 +531,7 @@ record_recv(PG_FUNCTION_ARGS)
if (tupdesc->attrs[i]->attisdropped) if (tupdesc->attrs[i]->attisdropped)
{ {
values[i] = (Datum) 0; values[i] = (Datum) 0;
nulls[i] = 'n'; nulls[i] = true;
continue; continue;
} }
@ -554,7 +554,7 @@ record_recv(PG_FUNCTION_ARGS)
{ {
/* -1 length means NULL */ /* -1 length means NULL */
bufptr = NULL; bufptr = NULL;
nulls[i] = 'n'; nulls[i] = true;
csave = 0; /* keep compiler quiet */ csave = 0; /* keep compiler quiet */
} }
else else
@ -576,7 +576,7 @@ record_recv(PG_FUNCTION_ARGS)
buf->data[buf->cursor] = '\0'; buf->data[buf->cursor] = '\0';
bufptr = &item_buf; bufptr = &item_buf;
nulls[i] = ' '; nulls[i] = false;
} }
/* Now call the column's receiveproc */ /* Now call the column's receiveproc */
@ -608,10 +608,10 @@ record_recv(PG_FUNCTION_ARGS)
} }
} }
tuple = heap_formtuple(tupdesc, values, nulls); tuple = heap_form_tuple(tupdesc, values, nulls);
/* /*
* We cannot return tuple->t_data because heap_formtuple allocates it as * We cannot return tuple->t_data because heap_form_tuple allocates it as
* part of a larger chunk, and our caller may expect to be able to pfree * part of a larger chunk, and our caller may expect to be able to pfree
* our result. So must copy the info into a new palloc chunk. * our result. So must copy the info into a new palloc chunk.
*/ */
@ -642,7 +642,7 @@ record_send(PG_FUNCTION_ARGS)
int validcols; int validcols;
int i; int i;
Datum *values; Datum *values;
char *nulls; bool *nulls;
StringInfoData buf; StringInfoData buf;
/* Extract type info from the tuple itself */ /* Extract type info from the tuple itself */
@ -686,10 +686,10 @@ record_send(PG_FUNCTION_ARGS)
} }
values = (Datum *) palloc(ncolumns * sizeof(Datum)); values = (Datum *) palloc(ncolumns * sizeof(Datum));
nulls = (char *) palloc(ncolumns * sizeof(char)); nulls = (bool *) palloc(ncolumns * sizeof(bool));
/* Break down the tuple into fields */ /* Break down the tuple into fields */
heap_deformtuple(&tuple, tupdesc, values, nulls); heap_deform_tuple(&tuple, tupdesc, values, nulls);
/* And build the result string */ /* And build the result string */
pq_begintypsend(&buf); pq_begintypsend(&buf);
@ -715,7 +715,7 @@ record_send(PG_FUNCTION_ARGS)
pq_sendint(&buf, column_type, sizeof(Oid)); pq_sendint(&buf, column_type, sizeof(Oid));
if (nulls[i] == 'n') if (nulls[i])
{ {
/* emit -1 data length to signify a NULL */ /* emit -1 data length to signify a NULL */
pq_sendint(&buf, -1, 4); pq_sendint(&buf, -1, 4);

14
src/backend/utils/cache/catcache.c vendored
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/utils/cache/catcache.c,v 1.144 2008/06/19 00:46:05 alvherre Exp $ * $PostgreSQL: pgsql/src/backend/utils/cache/catcache.c,v 1.145 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -1673,16 +1673,16 @@ build_dummy_tuple(CatCache *cache, int nkeys, ScanKey skeys)
HeapTuple ntp; HeapTuple ntp;
TupleDesc tupDesc = cache->cc_tupdesc; TupleDesc tupDesc = cache->cc_tupdesc;
Datum *values; Datum *values;
char *nulls; bool *nulls;
Oid tupOid = InvalidOid; Oid tupOid = InvalidOid;
NameData tempNames[4]; NameData tempNames[4];
int i; int i;
values = (Datum *) palloc(tupDesc->natts * sizeof(Datum)); values = (Datum *) palloc(tupDesc->natts * sizeof(Datum));
nulls = (char *) palloc(tupDesc->natts * sizeof(char)); nulls = (bool *) palloc(tupDesc->natts * sizeof(bool));
memset(values, 0, tupDesc->natts * sizeof(Datum)); memset(values, 0, tupDesc->natts * sizeof(Datum));
memset(nulls, 'n', tupDesc->natts * sizeof(char)); memset(nulls, true, tupDesc->natts * sizeof(bool));
for (i = 0; i < nkeys; i++) for (i = 0; i < nkeys; i++)
{ {
@ -1695,7 +1695,7 @@ build_dummy_tuple(CatCache *cache, int nkeys, ScanKey skeys)
* Here we must be careful in case the caller passed a C string * Here we must be careful in case the caller passed a C string
* where a NAME is wanted: convert the given argument to a * where a NAME is wanted: convert the given argument to a
* correctly padded NAME. Otherwise the memcpy() done in * correctly padded NAME. Otherwise the memcpy() done in
* heap_formtuple could fall off the end of memory. * heap_form_tuple could fall off the end of memory.
*/ */
if (cache->cc_isname[i]) if (cache->cc_isname[i])
{ {
@ -1705,7 +1705,7 @@ build_dummy_tuple(CatCache *cache, int nkeys, ScanKey skeys)
keyval = NameGetDatum(newval); keyval = NameGetDatum(newval);
} }
values[attindex - 1] = keyval; values[attindex - 1] = keyval;
nulls[attindex - 1] = ' '; nulls[attindex - 1] = false;
} }
else else
{ {
@ -1714,7 +1714,7 @@ build_dummy_tuple(CatCache *cache, int nkeys, ScanKey skeys)
} }
} }
ntp = heap_formtuple(tupDesc, values, nulls); ntp = heap_form_tuple(tupDesc, values, nulls);
if (tupOid != InvalidOid) if (tupOid != InvalidOid)
HeapTupleSetOid(ntp, tupOid); HeapTupleSetOid(ntp, tupOid);

11
src/include/access/htup.h
View File

@ -7,7 +7,7 @@
* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $PostgreSQL: pgsql/src/include/access/htup.h,v 1.102 2008/10/28 15:51:03 tgl Exp $ * $PostgreSQL: pgsql/src/include/access/htup.h,v 1.103 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -823,20 +823,21 @@ extern HeapTuple heap_copytuple(HeapTuple tuple);
extern void heap_copytuple_with_tuple(HeapTuple src, HeapTuple dest); extern void heap_copytuple_with_tuple(HeapTuple src, HeapTuple dest);
extern HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, extern HeapTuple heap_form_tuple(TupleDesc tupleDescriptor,
Datum *values, bool *isnull); Datum *values, bool *isnull);
extern HeapTuple heap_formtuple(TupleDesc tupleDescriptor,
Datum *values, char *nulls);
extern HeapTuple heap_modify_tuple(HeapTuple tuple, extern HeapTuple heap_modify_tuple(HeapTuple tuple,
TupleDesc tupleDesc, TupleDesc tupleDesc,
Datum *replValues, Datum *replValues,
bool *replIsnull, bool *replIsnull,
bool *doReplace); bool *doReplace);
extern void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc,
Datum *values, bool *isnull);
/* these three are deprecated versions of the three above: */
extern HeapTuple heap_formtuple(TupleDesc tupleDescriptor,
Datum *values, char *nulls);
extern HeapTuple heap_modifytuple(HeapTuple tuple, extern HeapTuple heap_modifytuple(HeapTuple tuple,
TupleDesc tupleDesc, TupleDesc tupleDesc,
Datum *replValues, Datum *replValues,
char *replNulls, char *replNulls,
char *replActions); char *replActions);
extern void heap_deform_tuple(HeapTuple tuple, TupleDesc tupleDesc,
Datum *values, bool *isnull);
extern void heap_deformtuple(HeapTuple tuple, TupleDesc tupleDesc, extern void heap_deformtuple(HeapTuple tuple, TupleDesc tupleDesc,
Datum *values, char *nulls); Datum *values, char *nulls);
extern void heap_freetuple(HeapTuple htup); extern void heap_freetuple(HeapTuple htup);

6
src/include/funcapi.h
View File

@ -9,7 +9,7 @@
* *
* Copyright (c) 2002-2008, PostgreSQL Global Development Group * Copyright (c) 2002-2008, PostgreSQL Global Development Group
* *
* $PostgreSQL: pgsql/src/include/funcapi.h,v 1.26 2008/01/01 19:45:56 momjian Exp $ * $PostgreSQL: pgsql/src/include/funcapi.h,v 1.27 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -113,7 +113,7 @@ typedef struct FuncCallContext
* *
* tuple_desc is for use when returning tuples (i.e. composite data types) * tuple_desc is for use when returning tuples (i.e. composite data types)
* and is only needed if you are going to build the tuples with * and is only needed if you are going to build the tuples with
* heap_formtuple() rather than with BuildTupleFromCStrings(). Note that * heap_form_tuple() rather than with BuildTupleFromCStrings(). Note that
* the TupleDesc pointer stored here should usually have been run through * the TupleDesc pointer stored here should usually have been run through
* BlessTupleDesc() first. * BlessTupleDesc() first.
*/ */
@ -187,7 +187,7 @@ extern TupleDesc build_function_result_tupdesc_t(HeapTuple procTuple);
* External declarations: * External declarations:
* TupleDesc BlessTupleDesc(TupleDesc tupdesc) - "Bless" a completed tuple * TupleDesc BlessTupleDesc(TupleDesc tupdesc) - "Bless" a completed tuple
* descriptor so that it can be used to return properly labeled tuples. * descriptor so that it can be used to return properly labeled tuples.
* You need to call this if you are going to use heap_formtuple directly. * You need to call this if you are going to use heap_form_tuple directly.
* TupleDescGetAttInMetadata does it for you, however, so no need to call * TupleDescGetAttInMetadata does it for you, however, so no need to call
* it if you call TupleDescGetAttInMetadata. * it if you call TupleDescGetAttInMetadata.
* AttInMetadata *TupleDescGetAttInMetadata(TupleDesc tupdesc) - Build an * AttInMetadata *TupleDescGetAttInMetadata(TupleDesc tupdesc) - Build an

48
src/pl/plpgsql/src/pl_exec.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/pl/plpgsql/src/pl_exec.c,v 1.222 2008/10/29 00:00:39 tgl Exp $ * $PostgreSQL: pgsql/src/pl/plpgsql/src/pl_exec.c,v 1.223 2008/11/02 01:45:28 tgl Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -3578,9 +3578,9 @@ exec_assign_value(PLpgSQL_execstate *estate,
int fno; int fno;
HeapTuple newtup; HeapTuple newtup;
int natts; int natts;
int i;
Datum *values; Datum *values;
char *nulls; bool *nulls;
bool *replaces;
void *mustfree; void *mustfree;
bool attisnull; bool attisnull;
Oid atttype; Oid atttype;
@ -3602,10 +3602,11 @@ exec_assign_value(PLpgSQL_execstate *estate,
/* /*
* Get the number of the records field to change and the * Get the number of the records field to change and the
* number of attributes in the tuple. * number of attributes in the tuple. Note: disallow
* system column names because the code below won't cope.
*/ */
fno = SPI_fnumber(rec->tupdesc, recfield->fieldname); fno = SPI_fnumber(rec->tupdesc, recfield->fieldname);
if (fno == SPI_ERROR_NOATTRIBUTE) if (fno <= 0)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_COLUMN), (errcode(ERRCODE_UNDEFINED_COLUMN),
errmsg("record \"%s\" has no field \"%s\"", errmsg("record \"%s\" has no field \"%s\"",
@ -3614,24 +3615,16 @@ exec_assign_value(PLpgSQL_execstate *estate,
natts = rec->tupdesc->natts; natts = rec->tupdesc->natts;
/* /*
* Set up values/datums arrays for heap_formtuple. For all * Set up values/control arrays for heap_modify_tuple. For all
* the attributes except the one we want to replace, use the * the attributes except the one we want to replace, use the
* value that's in the old tuple. * value that's in the old tuple.
*/ */
values = palloc(sizeof(Datum) * natts); values = palloc(sizeof(Datum) * natts);
nulls = palloc(natts); nulls = palloc(sizeof(bool) * natts);
replaces = palloc(sizeof(bool) * natts);
for (i = 0; i < natts; i++) memset(replaces, false, sizeof(bool) * natts);
{ replaces[fno] = true;
if (i == fno)
continue;
values[i] = SPI_getbinval(rec->tup, rec->tupdesc,
i + 1, &attisnull);
if (attisnull)
nulls[i] = 'n';
else
nulls[i] = ' ';
}
/* /*
* Now insert the new value, being careful to cast it to the * Now insert the new value, being careful to cast it to the
@ -3645,10 +3638,7 @@ exec_assign_value(PLpgSQL_execstate *estate,
atttype, atttype,
atttypmod, atttypmod,
attisnull); attisnull);
if (attisnull) nulls[fno] = attisnull;
nulls[fno] = 'n';
else
nulls[fno] = ' ';
/* /*
* Avoid leaking the result of exec_simple_cast_value, if it * Avoid leaking the result of exec_simple_cast_value, if it
@ -3660,10 +3650,11 @@ exec_assign_value(PLpgSQL_execstate *estate,
mustfree = NULL; mustfree = NULL;
/* /*
* Now call heap_formtuple() to create a new tuple that * Now call heap_modify_tuple() to create a new tuple that
* replaces the old one in the record. * replaces the old one in the record.
*/ */
newtup = heap_formtuple(rec->tupdesc, values, nulls); newtup = heap_modify_tuple(rec->tup, rec->tupdesc,
values, nulls, replaces);
if (rec->freetup) if (rec->freetup)
heap_freetuple(rec->tup); heap_freetuple(rec->tup);
@ -3673,6 +3664,7 @@ exec_assign_value(PLpgSQL_execstate *estate,
pfree(values); pfree(values);
pfree(nulls); pfree(nulls);
pfree(replaces);
if (mustfree) if (mustfree)
pfree(mustfree); pfree(mustfree);
@ -4519,12 +4511,12 @@ exec_move_row(PLpgSQL_execstate *estate,
else if (tupdesc) else if (tupdesc)
{ {
/* If we have a tupdesc but no data, form an all-nulls tuple */ /* If we have a tupdesc but no data, form an all-nulls tuple */
char *nulls; bool *nulls;
nulls = (char *) palloc(tupdesc->natts * sizeof(char)); nulls = (bool *) palloc(tupdesc->natts * sizeof(bool));
memset(nulls, 'n', tupdesc->natts * sizeof(char)); memset(nulls, true, tupdesc->natts * sizeof(bool));
tup = heap_formtuple(tupdesc, NULL, nulls); tup = heap_form_tuple(tupdesc, NULL, nulls);
pfree(nulls); pfree(nulls);
} }

32
src/pl/plpython/plpython.c
View File

@ -1,7 +1,7 @@
/********************************************************************** /**********************************************************************
* plpython.c - python as a procedural language for PostgreSQL * plpython.c - python as a procedural language for PostgreSQL
* *
* $PostgreSQL: pgsql/src/pl/plpython/plpython.c,v 1.114 2008/10/11 00:09:33 alvherre Exp $ * $PostgreSQL: pgsql/src/pl/plpython/plpython.c,v 1.115 2008/11/02 01:45:28 tgl Exp $
* *
********************************************************************* *********************************************************************
*/ */
@ -1766,7 +1766,7 @@ PLyMapping_ToTuple(PLyTypeInfo * info, PyObject * mapping)
TupleDesc desc; TupleDesc desc;
HeapTuple tuple; HeapTuple tuple;
Datum *values; Datum *values;
char *nulls; bool *nulls;
volatile int i; volatile int i;
Assert(PyMapping_Check(mapping)); Assert(PyMapping_Check(mapping));
@ -1778,7 +1778,7 @@ PLyMapping_ToTuple(PLyTypeInfo * info, PyObject * mapping)
/* Build tuple */ /* Build tuple */
values = palloc(sizeof(Datum) * desc->natts); values = palloc(sizeof(Datum) * desc->natts);
nulls = palloc(sizeof(char) * desc->natts); nulls = palloc(sizeof(bool) * desc->natts);
for (i = 0; i < desc->natts; ++i) for (i = 0; i < desc->natts; ++i)
{ {
char *key; char *key;
@ -1793,7 +1793,7 @@ PLyMapping_ToTuple(PLyTypeInfo * info, PyObject * mapping)
if (value == Py_None) if (value == Py_None)
{ {
values[i] = (Datum) NULL; values[i] = (Datum) NULL;
nulls[i] = 'n'; nulls[i] = true;
} }
else if (value) else if (value)
{ {
@ -1810,7 +1810,7 @@ PLyMapping_ToTuple(PLyTypeInfo * info, PyObject * mapping)
,-1); ,-1);
Py_DECREF(so); Py_DECREF(so);
so = NULL; so = NULL;
nulls[i] = ' '; nulls[i] = false;
} }
else else
ereport(ERROR, ereport(ERROR,
@ -1831,7 +1831,7 @@ PLyMapping_ToTuple(PLyTypeInfo * info, PyObject * mapping)
PG_END_TRY(); PG_END_TRY();
} }
tuple = heap_formtuple(desc, values, nulls); tuple = heap_form_tuple(desc, values, nulls);
ReleaseTupleDesc(desc); ReleaseTupleDesc(desc);
pfree(values); pfree(values);
pfree(nulls); pfree(nulls);
@ -1846,7 +1846,7 @@ PLySequence_ToTuple(PLyTypeInfo * info, PyObject * sequence)
TupleDesc desc; TupleDesc desc;
HeapTuple tuple; HeapTuple tuple;
Datum *values; Datum *values;
char *nulls; bool *nulls;
volatile int i; volatile int i;
Assert(PySequence_Check(sequence)); Assert(PySequence_Check(sequence));
@ -1868,7 +1868,7 @@ PLySequence_ToTuple(PLyTypeInfo * info, PyObject * sequence)
/* Build tuple */ /* Build tuple */
values = palloc(sizeof(Datum) * desc->natts); values = palloc(sizeof(Datum) * desc->natts);
nulls = palloc(sizeof(char) * desc->natts); nulls = palloc(sizeof(bool) * desc->natts);
for (i = 0; i < desc->natts; ++i) for (i = 0; i < desc->natts; ++i)
{ {
PyObject *volatile value, PyObject *volatile value,
@ -1882,7 +1882,7 @@ PLySequence_ToTuple(PLyTypeInfo * info, PyObject * sequence)
if (value == Py_None) if (value == Py_None)
{ {
values[i] = (Datum) NULL; values[i] = (Datum) NULL;
nulls[i] = 'n'; nulls[i] = true;
} }
else if (value) else if (value)
{ {
@ -1898,7 +1898,7 @@ PLySequence_ToTuple(PLyTypeInfo * info, PyObject * sequence)
,-1); ,-1);
Py_DECREF(so); Py_DECREF(so);
so = NULL; so = NULL;
nulls[i] = ' '; nulls[i] = false;
} }
Py_XDECREF(value); Py_XDECREF(value);
@ -1913,7 +1913,7 @@ PLySequence_ToTuple(PLyTypeInfo * info, PyObject * sequence)
PG_END_TRY(); PG_END_TRY();
} }
tuple = heap_formtuple(desc, values, nulls); tuple = heap_form_tuple(desc, values, nulls);
ReleaseTupleDesc(desc); ReleaseTupleDesc(desc);
pfree(values); pfree(values);
pfree(nulls); pfree(nulls);
@ -1928,7 +1928,7 @@ PLyObject_ToTuple(PLyTypeInfo * info, PyObject * object)
TupleDesc desc; TupleDesc desc;
HeapTuple tuple; HeapTuple tuple;
Datum *values; Datum *values;
char *nulls; bool *nulls;
volatile int i; volatile int i;
desc = lookup_rowtype_tupdesc(info->out.d.typoid, -1); desc = lookup_rowtype_tupdesc(info->out.d.typoid, -1);
@ -1938,7 +1938,7 @@ PLyObject_ToTuple(PLyTypeInfo * info, PyObject * object)
/* Build tuple */ /* Build tuple */
values = palloc(sizeof(Datum) * desc->natts); values = palloc(sizeof(Datum) * desc->natts);
nulls = palloc(sizeof(char) * desc->natts); nulls = palloc(sizeof(bool) * desc->natts);
for (i = 0; i < desc->natts; ++i) for (i = 0; i < desc->natts; ++i)
{ {
char *key; char *key;
@ -1953,7 +1953,7 @@ PLyObject_ToTuple(PLyTypeInfo * info, PyObject * object)
if (value == Py_None) if (value == Py_None)
{ {
values[i] = (Datum) NULL; values[i] = (Datum) NULL;
nulls[i] = 'n'; nulls[i] = true;
} }
else if (value) else if (value)
{ {
@ -1969,7 +1969,7 @@ PLyObject_ToTuple(PLyTypeInfo * info, PyObject * object)
,-1); ,-1);
Py_DECREF(so); Py_DECREF(so);
so = NULL; so = NULL;
nulls[i] = ' '; nulls[i] = false;
} }
else else
ereport(ERROR, ereport(ERROR,
@ -1991,7 +1991,7 @@ PLyObject_ToTuple(PLyTypeInfo * info, PyObject * object)
PG_END_TRY(); PG_END_TRY();
} }
tuple = heap_formtuple(desc, values, nulls); tuple = heap_form_tuple(desc, values, nulls);
ReleaseTupleDesc(desc); ReleaseTupleDesc(desc);
pfree(values); pfree(values);
pfree(nulls); pfree(nulls);