real affect now.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.44 1999/04/25 19:27:43 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.45 1999/05/10 00:44:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return OidIsValid(*typOutput);
}
- elog(ERROR, "getTypeOutAndElem: Cache lookup of type %d failed", type);
+ elog(ERROR, "getTypeOutAndElem: Cache lookup of type %u failed", type);
*typOutput = InvalidOid;
*typElem = InvalidOid;
0, 0, 0);
itupform = (Form_pg_index) GETSTRUCT(htup);
if (!HeapTupleIsValid(htup))
- elog(ERROR, "initGISTstate: index %d not found",
+ elog(ERROR, "initGISTstate: index %u not found",
RelationGetRelid(index));
giststate->haskeytype = itupform->indhaskeytype;
if (giststate->haskeytype)
0, 0);
if (!HeapTupleIsValid(htup))
{
- elog(ERROR, "initGISTstate: no attribute tuple %d %d",
+ elog(ERROR, "initGISTstate: no attribute tuple %u %d",
itupform->indexrelid, FirstOffsetNumber);
return;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v 1.24 1999/02/13 23:14:51 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v 1.25 1999/05/10 00:44:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
id = heap_create_with_catalog(LexIDStr($3),
tupdesc, RELKIND_RELATION, false);
if (!Quiet)
- printf("CREATED relation %s with OID %d\n",
+ printf("CREATED relation %s with OID %u\n",
LexIDStr($3), id);
}
DO_END;
* Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.58 1999/04/20 02:19:53 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.59 1999/05/10 00:44:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (DebugMode)
{
- printf("InsertOneTuple oid %d, %d attrs\n", objectid, numattr);
+ printf("InsertOneTuple oid %u, %d attrs\n", objectid, numattr);
fflush(stdout);
}
pfree(tuple);
if (DebugMode)
{
- printf("End InsertOneTuple, objectid=%d\n", objectid);
+ printf("End InsertOneTuple, objectid=%u\n", objectid);
fflush(stdout);
}
ap = *app;
if (ap == NULL)
{
- printf("Unable to find atttypid in Typ list! %d\n",
+ printf("Unable to find atttypid in Typ list! %u\n",
reldesc->rd_att->attrs[i]->atttypid
);
Assert(0);
{
typeindex = attrtypes[i]->atttypid - FIRST_TYPE_OID;
if (DebugMode)
- printf("Typ == NULL, typeindex = %d idx = %d\n", typeindex, i);
+ printf("Typ == NULL, typeindex = %u idx = %d\n", typeindex, i);
values[i] = fmgr(Procid[typeindex].inproc, value,
Procid[typeindex].elem, -1);
prt = fmgr(Procid[typeindex].outproc, values[i],
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.20 1999/03/17 22:52:47 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.21 1999/05/10 00:44:53 momjian Exp $
*
* NOTES
* See acl.h.
owner_id = ((Form_pg_type) GETSTRUCT(tuple))->typowner;
break;
default:
- elog(ERROR, "pg_ownercheck: invalid cache id: %d",
- cacheid);
+ elog(ERROR, "pg_ownercheck: invalid cache id: %d", cacheid);
break;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.77 1999/04/15 04:08:07 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.78 1999/05/10 00:44:54 momjian Exp $
*
*
* INTERFACE ROUTINES
typeLen(typeidType(OIDOID)), /* external size */
'c', /* type-type (catalog) */
',', /* default array delimiter */
- "int4in", /* input procedure */
- "int4out", /* output procedure */
- "int4in", /* receive procedure */
- "int4out", /* send procedure */
+ "oidin", /* input procedure */
+ "oidout", /* output procedure */
+ "oidin", /* receive procedure */
+ "oidout", /* send procedure */
NULL, /* array element type - irrelevent */
"-", /* default type value */
(bool) 1, /* passed by value */
heap_endscan(scan);
heap_close(catalogRelation);
- elog(ERROR, "Relation '%d' inherits '%s'",
+ elog(ERROR, "Relation '%u' inherits '%s'",
((Form_pg_inherits) GETSTRUCT(tuple))->inhrel,
RelationGetRelationName(relation));
}
heap_endscan(pg_attribute_scan);
heap_close(pg_attribute_desc);
- elog(ERROR, "DeleteTypeTuple: att of type %s exists in relation %d",
+ elog(ERROR, "DeleteTypeTuple: att of type %s exists in relation %u",
&rel->rd_rel->relname, relid);
}
heap_endscan(pg_attribute_scan);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.70 1999/02/13 23:14:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.71 1999/05/10 00:44:55 momjian Exp $
*
*
* INTERFACE ROUTINES
whichRel = RelationIdGetRelation(relid);
if (!RelationIsValid(whichRel))
- elog(ERROR, "UpdateStats: cannot open relation id %d", relid);
+ elog(ERROR, "UpdateStats: cannot open relation id %u", relid);
/* ----------------
* Find the RELATION relation tuple for the given relation.
0, 0, 0);
if (!HeapTupleIsValid(tuple))
{
- elog(ERROR, "IndexIsUnique: can't find index id %d",
+ elog(ERROR, "IndexIsUnique: can't find index id %u",
indexId);
}
index = (Form_pg_index) GETSTRUCT(tuple);
/* NO CACHE */
tuple = heap_getnext(scandesc, 0);
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "IndexIsUniqueNoCache: can't find index id %d", indexId);
+ elog(ERROR, "IndexIsUniqueNoCache: can't find index id %u", indexId);
index = (Form_pg_index) GETSTRUCT(tuple);
Assert(index->indexrelid == indexId);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.36 1999/02/13 23:14:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.37 1999/05/10 00:44:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (!HeapTupleIsValid(htup))
{
- elog(NOTICE, "CatalogHasIndex: no relation with oid %d", catId);
+ elog(NOTICE, "CatalogHasIndex: no relation with oid %u", catId);
return false;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.35 1999/04/23 00:50:57 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.36 1999/05/10 00:44:56 momjian Exp $
*
* NOTES
* these routines moved here from commands/define.c and somewhat cleaned up.
setheapoverride(false);
}
else
- elog(ERROR, "OperatorDef: no operator %d", operatorObjectId);
+ elog(ERROR, "OperatorDef: no operator %u", operatorObjectId);
heap_endscan(pg_operator_scan);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.43 1999/04/13 19:04:33 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.44 1999/05/10 00:44:56 momjian Exp $
*
* NOTES
* The PortalExecutorHeapMemory crap needs to be eliminated
rel = heap_open(childrelid);
if (!RelationIsValid(rel))
{
- elog(ERROR, "PerformAddAttribute: can't find catalog entry for inheriting class with oid %d",
+ elog(ERROR, "PerformAddAttribute: can't find catalog entry for inheriting class with oid %u",
childrelid);
}
PerformAddAttribute((rel->rd_rel->relname).data,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.75 1999/05/03 19:09:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.76 1999/05/10 00:44:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (HeapTupleIsValid(typeTuple))
return (int) ((Form_pg_type) GETSTRUCT(typeTuple))->typoutput;
- elog(ERROR, "GetOutputFunction: Cache lookup of type %d failed", type);
+ elog(ERROR, "GetOutputFunction: Cache lookup of type %u failed", type);
return InvalidOid;
}
if (HeapTupleIsValid(typeTuple))
return (int) ((Form_pg_type) GETSTRUCT(typeTuple))->typinput;
- elog(ERROR, "GetInputFunction: Cache lookup of type %d failed", type);
+ elog(ERROR, "GetInputFunction: Cache lookup of type %u failed", type);
return InvalidOid;
}
if (HeapTupleIsValid(typeTuple))
return (int) ((Form_pg_type) GETSTRUCT(typeTuple))->typbyval;
- elog(ERROR, "GetInputFunction: Cache lookup of type %d failed", type);
+ elog(ERROR, "GetInputFunction: Cache lookup of type %u failed", type);
return InvalidOid;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/dbcommands.c,v 1.33 1999/03/16 04:25:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/dbcommands.c,v 1.34 1999/05/10 00:44:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* permissions problems
*/
snprintf(buf, 512,
- "delete from pg_database where pg_database.oid = \'%d\'::oid", db_id);
+ "delete from pg_database where pg_database.oid = \'%u\'::oid", db_id);
pg_exec_query_dest(buf ,dest, false);
/* drop pages for this database that are in the shared buffer cache */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.2 1999/03/14 05:23:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.3 1999/05/10 00:44:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (nargs > INDEX_MAX_KEYS)
{
elog(ERROR,
- "Too many args to function, limit of %d",
- INDEX_MAX_KEYS);
+ "Too many args to function, limit of %d", INDEX_MAX_KEYS);
}
FIsetnArgs(&fInfo, nargs);
if (attribute->class == NULL)
{
elog(ERROR,
- "Can't find a default operator class for type %d.",
+ "Can't find a default operator class for type %u.",
attform->atttypid);
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/rename.c,v 1.22 1999/03/17 22:52:52 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/rename.c,v 1.23 1999/05/10 00:44:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
0, 0, 0);
if (!HeapTupleIsValid(reltup))
{
- elog(ERROR, "renameatt: can't find catalog entry for inheriting class with oid %d",
+ elog(ERROR, "renameatt: can't find catalog entry for inheriting class with oid %u",
childrelid);
}
/* make copy of cache value, could disappear in call */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.101 1999/05/09 14:00:29 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.102 1999/05/10 00:44:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
ObjectIdGetDatum(relid),
0, 0, 0);
if (!HeapTupleIsValid(ctup))
- elog(ERROR, "pg_class entry for relid %d vanished during vacuuming",
+ elog(ERROR, "pg_class entry for relid %u vanished during vacuuming",
relid);
rd = heap_openr(RelationRelationName);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: execAmi.c,v 1.33 1999/03/23 16:50:47 momjian Exp $
+ * $Id: execAmi.c,v 1.34 1999/05/10 00:45:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
Relation relDesc;
- EU3_printf("ExecCreatR: %s type=%d oid=%d\n",
+ EU3_printf("ExecCreatR: %s type=%d oid=%u\n",
"entering: ", tupType, relationOid);
CXT1_printf("ExecCreatR: context is %d\n", CurrentMemoryContext);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.82 1999/03/23 16:50:47 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.83 1999/05/10 00:45:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
ObjectIdGetDatum(relid),
0, 0, 0);
if (!HeapTupleIsValid(htup))
- elog(ERROR, "ExecCheckPerms: bogus RT relid: %d",
- relid);
+ elog(ERROR, "ExecCheckPerms: bogus RT relid: %u", relid);
StrNCpy(rname.data,
((Form_pg_class) GETSTRUCT(htup))->relname.data,
NAMEDATALEN);
ObjectIdGetDatum(relid),
0, 0, 0);
if (!HeapTupleIsValid(htup))
- elog(ERROR, "ExecCheckPerms: bogus RT relid: %d",
- relid);
+ elog(ERROR, "ExecCheckPerms: bogus RT relid: %u", relid);
StrNCpy(rname.data,
((Form_pg_class) GETSTRUCT(htup))->relname.data,
NAMEDATALEN);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeIndexscan.c,v 1.34 1999/04/13 17:18:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeIndexscan.c,v 1.35 1999/05/10 00:45:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
run_keys = (n_keys <= 0) ? NULL :
(int *) palloc(n_keys * sizeof(int));
- CXT1_printf("ExecInitIndexScan: context is %d\n",
- CurrentMemoryContext);
+ CXT1_printf("ExecInitIndexScan: context is %d\n",CurrentMemoryContext);
/* ----------------
* for each opclause in the given qual,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.25 1999/02/28 00:36:05 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.26 1999/05/10 00:45:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
optup = get_operator_tuple(op->opno);
if (!HeapTupleIsValid(optup)) /* shouldn't happen */
- elog(ERROR, "MJFormSkipQual: operator %d not found", op->opno);
+ elog(ERROR, "MJFormSkipQual: operator %u not found", op->opno);
opform = (Form_pg_operator) GETSTRUCT(optup);
oprleft = opform->oprleft;
oprright = opform->oprright;
CharGetDatum('b'));
if (!HeapTupleIsValid(optup))
elog(ERROR,
- "MJFormSkipQual: mergejoin operator %d has no matching %s op",
+ "MJFormSkipQual: mergejoin operator %u has no matching %s op",
op->opno, replaceopname);
opform = (Form_pg_operator) GETSTRUCT(optup);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: be-dumpdata.c,v 1.22 1999/02/13 23:15:39 momjian Exp $
+ * $Id: be-dumpdata.c,v 1.23 1999/05/10 00:45:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (be_portalcnt == 0)
be_portaloid = newoid();
be_portalcnt++;
- snprintf(buf, PortalNameLength, "be_%d_%d", be_portaloid, be_portalcnt);
+ snprintf(buf, PortalNameLength, "be_%u_%d", be_portaloid, be_portalcnt);
/* ----------------
* initialize the new portal entry and keep track
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/libpq/be-fsstubs.c,v 1.31 1999/05/09 15:00:18 ishii Exp $
+ * $Header: /cvsroot/pgsql/src/backend/libpq/be-fsstubs.c,v 1.32 1999/05/10 00:45:09 momjian Exp $
*
* NOTES
* This should be moved to a more appropriate place. It is here
MemoryContext currentContext;
#if FSDB
- elog(NOTICE, "LOopen(%d,%d)", lobjId, mode);
+ elog(NOTICE, "LOopen(%u,%d)", lobjId, mode);
#endif
if (fscxt == NULL)
{ /* lookup failed */
MemoryContextSwitchTo(currentContext);
#if FSDB
- elog(NOTICE, "cannot open large object %d", lobjId);
+ elog(NOTICE, "cannot open large object %u", lobjId);
#endif
return -1;
}
lobj = inv_open(lobjId, INV_READ);
if (lobj == NULL)
{
- elog(ERROR, "lo_export: can't open inv object %d",
- lobjId);
+ elog(ERROR, "lo_export: can't open inv object %u", lobjId);
}
/*
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: outfuncs.c,v 1.79 1999/04/25 03:19:15 tgl Exp $
+ * $Id: outfuncs.c,v 1.80 1999/05/10 00:45:10 momjian Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
}
appendStringInfo(str,
- " :resultRelation %d :into %s :isPortal %s :isBinary %s :isTemp %s :unionall %s ",
+ " :resultRelation %u :into %s :isPortal %s :isBinary %s :isTemp %s :unionall %s ",
node->resultRelation,
stringStringInfo(node->into),
node->isPortal ? "true" : "false",
_outNode(str, node->unionrtables);
appendStringInfo(str,
- " :inheritrelid %d :inheritrtable ",
+ " :inheritrelid %u :inheritrtable ",
node->inheritrelid);
_outNode(str, node->inheritrtable);
appendStringInfo(str, " SCAN ");
_outPlanInfo(str, (Plan *) node);
- appendStringInfo(str, " :scanrelid %d ", node->scanrelid);
+ appendStringInfo(str, " :scanrelid %u ", node->scanrelid);
}
/*
appendStringInfo(str, " SEQSCAN ");
_outPlanInfo(str, (Plan *) node);
- appendStringInfo(str, " :scanrelid %d ", node->scanrelid);
+ appendStringInfo(str, " :scanrelid %u ", node->scanrelid);
}
/*
appendStringInfo(str, " INDEXSCAN ");
_outPlanInfo(str, (Plan *) node);
- appendStringInfo(str, " :scanrelid %d :indxid ", node->scan.scanrelid);
+ appendStringInfo(str, " :scanrelid %u :indxid ", node->scan.scanrelid);
_outIntList(str, node->indxid);
appendStringInfo(str, " :indxqual ");
_outMergeOrder(StringInfo str, MergeOrder *node)
{
appendStringInfo(str,
- " MERGEORDER :join_operator %d :left_operator %d :right_operator %d ",
+ " MERGEORDER :join_operator %u :left_operator %u :right_operator %u ",
node->join_operator,
node->left_operator,
node->right_operator);
appendStringInfo(str,
- " :left_type %d :right_type %d ",
+ " :left_type %u :right_type %u ",
node->left_type,
node->right_type);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.26 1999/03/23 16:50:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.27 1999/05/10 00:45:13 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
{
RangeTblEntry *rte = lfirst(l);
- printf("%d\t%s(%s)\t%d\t%d\t%s\n",
+ printf("%d\t%s(%s)\t%u\t%d\t%s\n",
i, rte->relname, rte->refname, rte->relid,
rte->inFromCl,
(rte->inh ? "inh" : ""));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/_deadcode/Attic/xfunc.c,v 1.1 1999/02/18 00:49:24 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/_deadcode/Attic/xfunc.c,v 1.2 1999/05/10 00:45:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
ObjectIdGetDatum(funcid),
0, 0, 0);
if (!HeapTupleIsValid(tupl))
- elog(ERROR, "Cache lookup failed for procedure %d", funcid);
+ elog(ERROR, "Cache lookup failed for procedure %u", funcid);
proc = (Form_pg_proc) GETSTRUCT(tupl);
/*
ObjectIdGetDatum(get_vartype((Var) clause)),
0, 0, 0);
if (!HeapTupleIsValid(tupl))
- elog(ERROR, "Cache lookup failed for type %d",
+ elog(ERROR, "Cache lookup failed for type %u",
get_vartype((Var) clause));
type = (Form_pg_type) GETSTRUCT(tupl);
if (get_varattno((Var) clause) == 0)
ObjectIdGetDatum(get_opno((Oper) get_op(clause))),
0, 0, 0);
if (!HeapTupleIsValid(tupl))
- elog(ERROR, "Cache lookup failed for procedure %d",
+ elog(ERROR, "Cache lookup failed for procedure %u",
get_opno((Oper) get_op(clause)));
return (xfunc_func_width
((RegProcedure) (((Form_pg_operator) (GETSTRUCT(tupl)))->oprcode),
ObjectIdGetDatum(funcid),
0, 0, 0);
if (!HeapTupleIsValid(tupl))
- elog(ERROR, "Cache lookup failed for procedure %d", funcid);
+ elog(ERROR, "Cache lookup failed for procedure %u", funcid);
proc = (Form_pg_proc) GETSTRUCT(tupl);
/* if function returns a tuple, get the width of that */
ObjectIdGetDatum(proc->prorettype),
0, 0, 0);
if (!HeapTupleIsValid(tupl))
- elog(ERROR, "Cache lookup failed for type %d", proc->prorettype);
+ elog(ERROR, "Cache lookup failed for type %u", proc->prorettype);
type = (Form_pg_type) GETSTRUCT(tupl);
/* if the type length is known, return that */
if (type->typlen != -1)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.53 1999/05/06 01:30:58 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.54 1999/05/10 00:45:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
ObjectIdGetDatum(lfirsti(ixid)),
0, 0, 0);
if (!HeapTupleIsValid(indexTuple))
- elog(ERROR, "create_plan: index %d not found",
- lfirsti(ixid));
+ elog(ERROR, "create_plan: index %u not found", lfirsti(ixid));
index = (Form_pg_index) GETSTRUCT(indexTuple);
if (index->indislossy)
lossy = TRUE;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.49 1999/05/04 00:00:20 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.50 1999/05/10 00:45:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* by here, the function is declared to return some type */
if ((typ = typeidType(rettype)) == NULL)
- elog(ERROR, "can't find return type %d for function\n", rettype);
+ elog(ERROR, "can't find return type %u for function\n", rettype);
/*
* test 3: if the function is declared to return a value, then the
reln = heap_open(typeTypeRelid(typ));
if (!RelationIsValid(reln))
- elog(ERROR, "cannot open relation relid %d", typeTypeRelid(typ));
+ elog(ERROR, "cannot open relation relid %u", typeTypeRelid(typ));
relid = reln->rd_id;
relnatts = reln->rd_rel->relnatts;
htup = SearchSysCacheTuple(INDEXRELID,
ObjectIdGetDatum(indexId), 0, 0, 0);
if (!HeapTupleIsValid(htup)) {
- elog(ERROR, "cache lookup for index %d failed", indexId);
+ elog(ERROR, "cache lookup for index %u failed", indexId);
}
index_tup = (Form_pg_index) GETSTRUCT(htup);
}
}
else
- elog(ERROR, "_finalize_primnode: can't handle node %d",
- nodeTag(expr));
+ elog(ERROR, "_finalize_primnode: can't handle node %d", nodeTag(expr));
return result;
}
else if (is_subplan(expr))
return lcons(((Expr *) expr)->oper, NULL);
else
- elog(ERROR, "SS_pull_subplan: can't handle node %d",
- nodeTag(expr));
+ elog(ERROR, "SS_pull_subplan: can't handle node %d", nodeTag(expr));
return result;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.32 1999/03/01 00:10:35 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.33 1999/05/10 00:45:24 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
get_operator_tuple(get_commutator(((Oper *) ((Expr *) clause)->oper)->opno));
if (heapTup == (HeapTuple) NULL)
- elog(ERROR, "CommuteClause: no commutator for operator %d",
+ elog(ERROR, "CommuteClause: no commutator for operator %u",
((Oper *) ((Expr *) clause)->oper)->opno);
commuTup = (Form_pg_operator) GETSTRUCT(heapTup);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.28 1999/03/18 19:59:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.29 1999/05/10 00:45:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
else
{
- elog(ERROR, "RelationCatalogInformation: Relation %d not found",
+ elog(ERROR, "RelationCatalogInformation: Relation %u not found",
relationObjectId);
}
UInt16GetDatum(amstrategy),
0);
if (!HeapTupleIsValid(amopTuple))
- elog(ERROR, "index_info: no amop %d %d %d",
+ elog(ERROR, "index_info: no amop %u %u %d",
relam, index->indclass[i], amstrategy);
info->orderOprs[i] = ((Form_pg_amop) GETSTRUCT(amopTuple))->amopopr;
}
ObjectIdGetDatum(indexrelid),
0, 0, 0);
if (!HeapTupleIsValid(indRel))
- elog(ERROR, "IndexSelectivity: index %d not found",
+ elog(ERROR, "IndexSelectivity: index %u not found",
indexrelid);
relam = ((Form_pg_class) GETSTRUCT(indRel))->relam;
ObjectIdGetDatum(indexrelid),
0, 0, 0);
if (!HeapTupleIsValid(indexTuple))
- elog(ERROR, "IndexSelectivity: index %d not found",
+ elog(ERROR, "IndexSelectivity: index %u not found",
indexrelid);
index = (Form_pg_index) GETSTRUCT(indexTuple);
* clause and so had no variable to match to the index key ...
* if not we are in trouble.
*/
- elog(NOTICE, "IndexSelectivity: no key %d in index %d",
+ elog(NOTICE, "IndexSelectivity: no key %d in index %u",
varAttributeNumbers[n], indexrelid);
continue;
}
ObjectIdGetDatum(relam),
0);
if (!HeapTupleIsValid(amopTuple))
- elog(ERROR, "IndexSelectivity: no amop %d %d",
+ elog(ERROR, "IndexSelectivity: no amop %u %u",
indclass, operatorObjectIds[n]);
amop = (Form_pg_amop) GETSTRUCT(amopTuple);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.11 1999/02/21 03:49:03 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.12 1999/05/10 00:45:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Datum val;
#ifdef PARSEDEBUG
- printf("coerce_type: argument types are %d -> %d\n",
- inputTypeId, targetTypeId);
+ printf("coerce_type: argument types are %d -> %u\n",
+ inputTypeId, targetTypeId);
#endif
if (targetTypeId == InvalidOid)
else
{
#ifdef PARSEDEBUG
- printf("coerce_type: argument type IDs %d match\n", inputTypeId);
+ printf("coerce_type: argument type IDs %u match\n", inputTypeId);
#endif
result = node;
for (i = 0; i < nargs; i++)
{
#ifdef PARSEDEBUG
- printf("can_coerce_type: argument #%d types are %d -> %d\n",
+ printf("can_coerce_type: argument #%d types are %u -> %u\n",
i, input_typeids[i], func_typeids[i]);
#endif
if (input_typeids[i] != func_typeids[i])
else if (func_typeids[i] == InvalidOid)
{
#ifdef PARSEDEBUG
- printf("can_coerce_type: output OID func_typeids[%d] is zero\n", i);
+ printf("can_coerce_type: output OID func_typeids[%u] is zero\n", i);
#endif
return false;
}
else if (input_typeids[i] == InvalidOid)
{
#ifdef PARSEDEBUG
- printf("can_coerce_type: input OID input_typeids[%d] is zero\n", i);
+ printf("can_coerce_type: input OID input_typeids[%u] is zero\n", i);
#endif
return false;
}
else
{
#ifdef PARSEDEBUG
- printf("can_coerce_type: argument #%d type is %d (UNKNOWN)\n",
+ printf("can_coerce_type: argument #%d type is %u (UNKNOWN)\n",
i, input_typeids[i]);
#endif
}
else
{
#ifdef PARSEDEBUG
- printf("can_coerce_type: argument #%d type IDs %d match\n",
+ printf("can_coerce_type: argument #%d type IDs %u match\n",
i, input_typeids[i]);
#endif
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.42 1999/03/16 20:15:06 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.43 1999/05/10 00:45:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
0, 0, 0);
if (!HeapTupleIsValid(func_tuple))
- elog(ERROR, "Function OID %d does not exist", funcid);
+ elog(ERROR, "Function OID %u does not exist", funcid);
funcrettype = (Oid)
((Form_pg_proc) GETSTRUCT(func_tuple))->prorettype;
/* save the type id, rather than the relation id */
if ((rd = heap_open(qentry->sqe_relid)) == (Relation) NULL)
- elog(ERROR, "Relid %d does not exist", qentry->sqe_relid);
+ elog(ERROR, "Relid %u does not exist", qentry->sqe_relid);
qentry->sqe_relid = typeTypeId(typenameType(RelationGetRelationName(rd)->data));
heap_close(rd);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.24 1999/02/13 23:17:09 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.25 1999/05/10 00:45:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
0, 0, 0);
if (!HeapTupleIsValid(type_tuple))
- elog(ERROR, "make_array_ref: Cache lookup failed for type %d\n",
+ elog(ERROR, "make_array_ref: Cache lookup failed for type %u\n",
typearray);
/* get the array type struct from the type tuple */
ObjectIdGetDatum(type_struct_array->typelem),
0, 0, 0);
if (!HeapTupleIsValid(type_tuple))
- elog(ERROR, "make_array_ref: Cache lookup failed for type %d\n",
+ elog(ERROR, "make_array_ref: Cache lookup failed for type %u\n",
typearray);
type_struct_element = (Form_pg_type) GETSTRUCT(type_tuple);
0, 0, 0);
if (!HeapTupleIsValid(type_tuple))
- elog(ERROR, "make_array_ref: Cache lookup failed for type %d\n",
+ elog(ERROR, "make_array_ref: Cache lookup failed for type %u\n",
typearray);
/* get the array type struct from the type tuple */
0, 0, 0);
if (!HeapTupleIsValid(type_tuple))
- elog(ERROR, "make_array_ref: Cache lookup failed for type %d\n",
+ elog(ERROR, "make_array_ref: Cache lookup failed for type %u\n",
typearray);
type_struct_element = (Form_pg_type) GETSTRUCT(type_tuple);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.23 1998/12/13 23:54:40 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.24 1999/05/10 00:45:29 momjian Exp $
*
*-------------------------------------------------------------------------
*/
ncandidates = unary_oper_get_candidates(op, arg, &candidates, 'r');
if (ncandidates == 0)
{
- elog(ERROR, "Can't find right op '%s' for type %d", op, arg);
+ elog(ERROR, "Can't find right op '%s' for type %u", op, arg);
return NULL;
}
else if (ncandidates == 1)
ncandidates = unary_oper_get_candidates(op, arg, &candidates, 'l');
if (ncandidates == 0)
{
- elog(ERROR, "Can't find left op '%s' for type %d", op, arg);
+ elog(ERROR, "Can't find left op '%s' for type %u", op, arg);
return NULL;
}
else if (ncandidates == 1)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.19 1999/02/23 07:53:01 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.20 1999/05/10 00:45:29 momjian Exp $
*
*-------------------------------------------------------------------------
*/
0, 0, 0);
if (!HeapTupleIsValid(type_tuple))
- elog(ERROR, "GetArrayElementType: Cache lookup failed for type %d",
+ elog(ERROR, "GetArrayElementType: Cache lookup failed for type %u",
typearray);
/* get the array type struct from the type tuple */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteDefine.c,v 1.26 1999/02/21 03:49:17 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteDefine.c,v 1.27 1999/05/10 00:45:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
template = "INSERT INTO pg_rewrite \
(rulename, ev_type, ev_class, ev_attr, ev_action, ev_qual, is_instead) VALUES \
-('%s', %d::char, %d::oid, %d::int2, '%s'::text, '%s'::text, \
+('%s', %d::char, %u::oid, %d::int2, '%s'::text, '%s'::text, \
'%s'::bool);";
if (strlen(template) + strlen(rulname) + strlen(actionbuf) +
strlen(qualbuf) + 20 /* fudge fac */ > RULE_PLAN_SIZE)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.22 1999/02/13 23:17:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.23 1999/05/10 00:45:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
PointerGetDatum(eventrel),
0, 0, 0);
if (!HeapTupleIsValid(htup))
- elog(ERROR, "Class '%d' not found",
- eventrel);
+ elog(ERROR, "Class '%u' not found", eventrel);
+
return ((Form_pg_class) GETSTRUCT(htup))->relname.data;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.50 1999/03/28 20:32:17 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.51 1999/05/10 00:45:35 momjian Exp $
*
*-------------------------------------------------------------------------
*/
tb = &TraceBuf[i];
if (tb->bmt_op != BMT_NOTUSED)
{
- fprintf(fp, " [%3d]%spid %d buf %2d for <%d,%d,%d> ",
+ fprintf(fp, " [%3d]%spid %d buf %2d for <%d,%u,%d> ",
i, (i == cur ? " ---> " : "\t"),
tb->bmt_pid, tb->bmt_buf,
tb->bmt_dbid, tb->bmt_relid, tb->bmt_blkno);
}
fprintf(fp, "\noperation causing error:\n");
- fprintf(fp, "\tpid %d buf %d for <%d,%d,%d> ",
+ fprintf(fp, "\tpid %d buf %d for <%d,%u,%d> ",
getpid(), bufNo, dbId, relId, blkNo);
switch (allocType)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/localbuf.c,v 1.21 1999/02/13 23:18:00 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/localbuf.c,v 1.22 1999/05/10 00:45:36 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
#ifdef LBDEBUG
- fprintf(stderr, "LB ALLOC (%d,%d) %d\n",
+ fprintf(stderr, "LB ALLOC (%u,%d) %d\n",
RelationGetRelid(reln), blockNum, -i - 1);
#endif
LocalRefCount[i]++;
}
#ifdef LBDEBUG
- fprintf(stderr, "LB ALLOC (%d,%d) %d\n",
+ fprintf(stderr, "LB ALLOC (%u,%d) %d\n",
RelationGetRelid(reln), blockNum, -nextFreeLocalBuf - 1);
#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/sinvaladt.c,v 1.17 1999/02/19 06:06:03 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/sinvaladt.c,v 1.18 1999/05/10 00:45:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
if (segInOutP->procState[index].tag == backendTag)
{
- elog(FATAL, "SIAssignBackendId: tag %d found twice",
- backendTag);
+ elog(FATAL, "SIAssignBackendId: tag %d found twice", backendTag);
}
}
if (stateP->tag != InvalidBackendTag)
{
if (stateP->tag == backendTag)
- {
- elog(NOTICE, "SIAssignBackendId: reusing tag %d",
- backendTag);
- }
+ elog(NOTICE, "SIAssignBackendId: reusing tag %d", backendTag);
else
{
- elog(NOTICE,
- "SIAssignBackendId: discarding tag %d",
- stateP->tag);
+ elog(NOTICE, "SIAssignBackendId: discarding tag %d", stateP->tag);
return InvalidBackendTag;
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.51 1999/03/14 16:08:17 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.52 1999/05/10 00:45:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
file_oid = newoid() + 1;
/* come up with some table names */
- sprintf(objname, "xinv%d", file_oid);
- sprintf(indname, "xinx%d", file_oid);
+ sprintf(objname, "xinv%u", file_oid);
+ sprintf(indname, "xinx%u", file_oid);
if (RelnameFindRelid(objname) != InvalidOid)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.50 1999/05/07 01:23:03 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.51 1999/05/10 00:45:43 momjian Exp $
*
* NOTES
* Outside modules can create a lock table and acquire/release
#define LOCK_PRINT_AUX(where,lock,type) \
TPRINTF(TRACE_ALL, \
- "%s: lock(%x) tbl(%d) rel(%d) db(%d) obj(%u) mask(%x) " \
+ "%s: lock(%x) tbl(%d) rel(%u) db(%d) obj(%u) mask(%x) " \
"hold(%d,%d,%d,%d,%d)=%d " \
"act(%d,%d,%d,%d,%d)=%d wait(%d) type(%s)", \
where, \
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.23 1999/04/25 03:19:10 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.24 1999/05/10 00:45:46 momjian Exp $
*
* NOTES
* This cruft is the server side of PQfn.
0, 0, 0);
if (!HeapTupleIsValid(func_htp))
{
- elog(ERROR, "update_fp_info: cache lookup for function %d failed",
+ elog(ERROR, "update_fp_info: cache lookup for function %u failed",
func_id);
}
pp = (Form_pg_proc) GETSTRUCT(func_htp);
0, 0, 0);
if (!HeapTupleIsValid(type_htp))
{
- elog(ERROR, "update_fp_info: bad argument type %d for %d",
+ elog(ERROR, "update_fp_info: bad argument type %u for %u",
argtypes[i], func_id);
}
tp = (Form_pg_type) GETSTRUCT(type_htp);
0, 0, 0);
if (!HeapTupleIsValid(type_htp))
{
- elog(ERROR, "update_fp_info: bad return type %d for %d",
+ elog(ERROR, "update_fp_info: bad return type %u for %u",
rettype, func_id);
}
tp = (Form_pg_type) GETSTRUCT(type_htp);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tioga/Attic/tgRecipe.c,v 1.11 1999/02/13 23:18:53 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tioga/Attic/tgRecipe.c,v 1.12 1999/05/10 00:45:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
tn = malloc(sizeof(TgNode));
/* generate a name for the tee node table */
tn->nodeName = malloc(50);
- sprintf(tn->nodeName, "tee_%d", newoid());
+ sprintf(tn->nodeName, "tee_%u", newoid());
/* tn->nodeName = NULL; */
tn->nodeType = TG_TEE_NODE;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.41 1999/05/05 21:38:37 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.42 1999/05/10 00:45:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (!HeapTupleIsValid(typeTuple))
{
- elog(ERROR, "array_out: Cache lookup failed for type %d\n",
+ elog(ERROR, "array_out: Cache lookup failed for type %u\n",
element_type);
return;
}
char saveName[NAME_LEN];
p = (char *) palloc(NAME_LEN);
- sprintf(p, "/Arry.%d", newoid());
+ sprintf(p, "/Arry.%u", newoid());
strcpy(saveName, p);
#ifdef LOARRAY
if ((*fd = LOcreat(saveName, 0600, flag)) < 0)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.22 1999/02/13 23:19:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.23 1999/05/10 00:45:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return NULL;
result = (Oid *) palloc(sizeof(Oid[8]));
- if ((nums = sscanf(oidString, "%d%d%d%d%d%d%d%d",
+ if ((nums = sscanf(oidString, "%u%u%u%u%u%u%u%u",
&result[0],
&result[1],
&result[2],
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.35 1999/02/15 16:29:32 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.36 1999/05/10 00:45:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (!isnull)
StrNCpy(result, s, NAMEDATALEN);
else
- elog(FATAL, "regprocout: null procedure %d", proid);
+ elog(FATAL, "regprocout: null procedure %u", proid);
}
else
{
* out of it's tuple
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.10 1999/05/03 19:10:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.11 1999/05/10 00:45:59 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
ht_idx = SearchSysCacheTuple(INDEXRELID,
ObjectIdGetDatum(indexrelid), 0, 0, 0);
if (!HeapTupleIsValid(ht_idx))
- elog(ERROR, "syscache lookup for index %d failed", indexrelid);
+ elog(ERROR, "syscache lookup for index %u failed", indexrelid);
idxrec = (Form_pg_index)GETSTRUCT(ht_idx);
/* ----------
ht_idxrel = SearchSysCacheTuple(RELOID,
ObjectIdGetDatum(idxrec->indexrelid), 0, 0, 0);
if (!HeapTupleIsValid(ht_idxrel))
- elog(ERROR, "syscache lookup for relid %d failed", idxrec->indexrelid);
+ elog(ERROR, "syscache lookup for relid %u failed", idxrec->indexrelid);
idxrelrec = (Form_pg_class)GETSTRUCT(ht_idxrel);
/* ----------
ht_indrel = SearchSysCacheTuple(RELOID,
ObjectIdGetDatum(idxrec->indrelid), 0, 0, 0);
if (!HeapTupleIsValid(ht_indrel))
- elog(ERROR, "syscache lookup for relid %d failed", idxrec->indrelid);
+ elog(ERROR, "syscache lookup for relid %u failed", idxrec->indrelid);
indrelrec = (Form_pg_class)GETSTRUCT(ht_indrel);
/* ----------
spi_nulls[1] = '\0';
spirc = SPI_execp(plan_getopclass, spi_args, spi_nulls, 1);
if (spirc != SPI_OK_SELECT)
- elog(ERROR, "failed to get pg_opclass tuple %d", idxrec->indclass[keyno]);
+ elog(ERROR, "failed to get pg_opclass tuple %u", idxrec->indclass[keyno]);
if (SPI_processed != 1)
- elog(ERROR, "failed to get pg_opclass tuple %d", idxrec->indclass[keyno]);
+ elog(ERROR, "failed to get pg_opclass tuple %u", idxrec->indclass[keyno]);
spi_tup = SPI_tuptable->vals[0];
spi_ttc = SPI_tuptable->tupdesc;
spi_fno = SPI_fnumber(spi_ttc, "opcname");
proctup = SearchSysCacheTuple(PROOID,
ObjectIdGetDatum(idxrec->indproc), 0, 0, 0);
if (!HeapTupleIsValid(proctup))
- elog(ERROR, "cache lookup for proc %d failed", idxrec->indproc);
+ elog(ERROR, "cache lookup for proc %u failed", idxrec->indproc);
procStruct = (Form_pg_proc) GETSTRUCT(proctup);
strcat(buf, "\"");
spi_nulls[1] = '\0';
spirc = SPI_execp(plan_getopclass, spi_args, spi_nulls, 1);
if (spirc != SPI_OK_SELECT)
- elog(ERROR, "failed to get pg_opclass tuple %d", idxrec->indclass[0]);
+ elog(ERROR, "failed to get pg_opclass tuple %u", idxrec->indclass[0]);
if (SPI_processed != 1)
- elog(ERROR, "failed to get pg_opclass tuple %d", idxrec->indclass[0]);
+ elog(ERROR, "failed to get pg_opclass tuple %u", idxrec->indclass[0]);
spi_tup = SPI_tuptable->vals[0];
spi_ttc = SPI_tuptable->tupdesc;
spi_fno = SPI_fnumber(spi_ttc, "opcname");
proctup = SearchSysCacheTuple(PROOID,
ObjectIdGetDatum(func->funcid), 0, 0, 0);
if (!HeapTupleIsValid(proctup))
- elog(ERROR, "cache lookup for proc %d failed", func->funcid);
+ elog(ERROR, "cache lookup for proc %u failed", func->funcid);
procStruct = (Form_pg_proc) GETSTRUCT(proctup);
proname = nameout(&(procStruct->proname));
proctup = SearchSysCacheTuple(PROOID,
ObjectIdGetDatum(func->funcid), 0, 0, 0);
if (!HeapTupleIsValid(proctup))
- elog(ERROR, "cache lookup for proc %d failed", func->funcid);
+ elog(ERROR, "cache lookup for proc %u failed", func->funcid);
procStruct = (Form_pg_proc) GETSTRUCT(proctup);
classtup = SearchSysCacheTuple(RELOID,
ObjectIdGetDatum(relid), 0, 0, 0);
if (!HeapTupleIsValid(classtup))
- elog(ERROR, "cache lookup of relation %d failed", relid);
+ elog(ERROR, "cache lookup of relation %u failed", relid);
classStruct = (Form_pg_class) GETSTRUCT(classtup);
return nameout(&(classStruct->relname));
atttup = SearchSysCacheTuple(ATTNUM,
ObjectIdGetDatum(relid), (Datum) attnum, 0, 0);
if (!HeapTupleIsValid(atttup))
- elog(ERROR, "cache lookup of attribute %d in relation %d failed",
+ elog(ERROR, "cache lookup of attribute %d in relation %u failed",
attnum, relid);
attStruct = (Form_pg_attribute) GETSTRUCT(atttup);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.26 1999/03/18 19:59:55 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.27 1999/05/10 00:46:00 momjian Exp $
*
*-------------------------------------------------------------------------
*/
0, 0);
if (!HeapTupleIsValid(atp))
{
- elog(ERROR, "getattdisbursion: no attribute tuple %d %d",
+ elog(ERROR, "getattdisbursion: no attribute tuple %u %d",
relid, attnum);
return 0;
}
*/
if (!HeapTupleIsValid(atp))
{
- elog(ERROR, "getattdisbursion: no relation tuple %d", relid);
+ elog(ERROR, "getattdisbursion: no relation tuple %u", relid);
return 0;
}
ntuples = ((Form_pg_class) GETSTRUCT(atp))->reltuples;
0, 0, 0);
if (!HeapTupleIsValid(atp))
{
- elog(ERROR, "btreenpage: no index tuple %d", indexrelid);
+ elog(ERROR, "btreenpage: no index tuple %u", indexrelid);
return 0;
}
0, 0, 0);
if (!HeapTupleIsValid(atp))
{
- elog(ERROR, "hashsel: no index tuple %d", indexrelid);
+ elog(ERROR, "hashsel: no index tuple %u", indexrelid);
return 0;
}
ntuples = ((Form_pg_class) GETSTRUCT(atp))->reltuples;
0, 0, 0);
if (!HeapTupleIsValid(atp))
{
- elog(ERROR, "hashsel: no index tuple %d", indexrelid);
+ elog(ERROR, "hashsel: no index tuple %u", indexrelid);
return 0;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.39 1999/02/13 23:19:39 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.40 1999/05/10 00:46:03 momjian Exp $
*
* Notes:
* XXX This needs to use exception.h to handle recovery when
cache->relationId = RelationGetRelid(relation);
tupdesc = cache->cc_tupdesc = RelationGetDescr(relation);
- CACHE3_elog(DEBUG, "CatalogCacheInitializeCache: relid %d, %d keys",
+ CACHE3_elog(DEBUG, "CatalogCacheInitializeCache: relid %u, %d keys",
cache->relationId, cache->cc_nkeys);
/* ----------------
#ifdef CACHEDEBUG
#define InitSysCache_DEBUG1 \
do { \
- elog(DEBUG, "InitSysCache: rid=%d id=%d nkeys=%d size=%d\n", \
+ elog(DEBUG, "InitSysCache: rid=%u id=%d nkeys=%d size=%d\n", \
cp->relationId, cp->id, cp->cc_nkeys, cp->cc_size); \
for (i = 0; i < nkeys; i += 1) \
{ \
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/fcache.c,v 1.21 1999/02/13 23:19:40 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/fcache.c,v 1.22 1999/05/10 00:46:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (!HeapTupleIsValid(procedureTuple))
elog(ERROR,
- "init_fcache: %s %d",
+ "init_fcache: %s %u",
"Cache lookup failed for procedure", foid);
/* ----------------
if (!HeapTupleIsValid(typeTuple))
elog(ERROR,
- "init_fcache: %s %d",
+ "init_fcache: %s %u",
"Cache lookup failed for type",
(procedureStruct)->prorettype);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/inval.c,v 1.21 1999/02/13 23:19:41 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/inval.c,v 1.22 1999/05/10 00:46:07 momjian Exp $
*
* Note - this code is real crufty...
*
* ----------------
*/
#ifdef INVALIDDEBUG
- elog(DEBUG, "RelationRegisterLocalInvalid(%d, %d)", relationId,
+ elog(DEBUG, "RelationRegisterLocalInvalid(%u, %u)", relationId,
objectId);
#endif /* defined(INVALIDDEBUG) */
ItemPointerGetOffsetNumber(&message->any.catalog.pointerData))
#define InvalidationMessageRegisterSharedInvalid_DEBUG2 \
elog(DEBUG, \
- "InvalidationMessageRegisterSharedInvalid(r, %d, %d)", \
+ "InvalidationMessageRegisterSharedInvalid(r, %u, %u)", \
message->any.relation.relationId, \
message->any.relation.objectId)
#else
ItemPointerGetBlockNumber(&message->any.catalog.pointerData),\
ItemPointerGetOffsetNumber(&message->any.catalog.pointerData))
#define InvalidationMessageCacheInvalidate_DEBUG2 \
- elog(DEBUG, "InvalidationMessageCacheInvalidate(r, %d, %d)", \
+ elog(DEBUG, "InvalidationMessageCacheInvalidate(r, %u, %u)", \
message->any.relation.relationId, \
message->any.relation.objectId)
#else
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.25 1999/02/21 03:49:33 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.26 1999/05/10 00:46:07 momjian Exp $
*
* NOTES
* Eventually, the index information should go through here, too.
PointerGetDatum(attname),
0, 0);
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "get_attisset: no attribute %s in relation %d",
+ elog(ERROR, "get_attisset: no attribute %s in relation %u",
attname, relid);
if (heap_attisnull(tuple, attno))
return false;
{
/* don't throw an error anymore; we want to continue... */
#ifdef NOT_USED
- elog(ERROR, "can't look up operator %d\n", opno);
+ elog(ERROR, "can't look up operator %u\n", opno);
#endif
return NULL;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.60 1999/05/01 19:09:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.61 1999/05/10 00:46:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
switch (buildinfo.infotype)
{
case INFO_RELID:
- sprintf(errBuf, "(relation id %d)", buildinfo.i.info_id);
+ sprintf(errBuf, "(relation id %u)", buildinfo.i.info_id);
break;
case INFO_RELNAME:
sprintf(errBuf, "(relation name %s)", buildinfo.i.info_name);
}
if (need > 0)
- elog(ERROR, "catalog is missing %d attribute%s for relid %d",
+ elog(ERROR, "catalog is missing %d attribute%s for relid %u",
need, (need == 1 ? "" : "s"), RelationGetRelid(relation));
/* ----------------
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.43 1999/04/25 21:50:57 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.44 1999/05/10 00:46:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
fd = fileno(stderr);
if (fcntl(fd, F_GETFD, 0) < 0)
{
- sprintf(OutputFileName, "%s/pg.errors.%d",
- DataDir, (int) MyProcPid);
+ sprintf(OutputFileName, "%s/pg.errors.%d", DataDir, (int) MyProcPid);
fd = open(OutputFileName, O_CREAT | O_APPEND | O_WRONLY, 0666);
}
if (fd < 0)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/dfmgr.c,v 1.23 1999/02/13 23:19:51 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/dfmgr.c,v 1.24 1999/05/10 00:46:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
0, 0, 0);
if (!HeapTupleIsValid(procedureTuple))
{
- elog(ERROR, "fmgr: Cache lookup failed for procedure %d\n",
+ elog(ERROR, "fmgr: Cache lookup failed for procedure %u\n",
procedureId);
return (func_ptr) NULL;
}
if (!PointerIsValid(probinattr) /* || isnull */ )
{
heap_close(rel);
- elog(ERROR, "fmgr: Could not extract probin for %d from %s",
+ elog(ERROR, "fmgr: Could not extract probin for %u from %s",
procedureId, ProcedureRelationName);
return (func_ptr) NULL;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.25 1999/04/09 22:35:42 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.26 1999/05/10 00:46:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (n_arguments > 1)
{
if (n_arguments > MAXFMGRARGS)
- elog(ERROR, "fmgr_pl: function %d: too many arguments (%d > %d)",
+ elog(ERROR, "fmgr_pl: function %u: too many arguments (%d > %d)",
fmgr_pl_finfo->fn_oid, n_arguments, MAXFMGRARGS);
va_start(pvar, arg0);
for (i = 1; i < n_arguments; i++)
values->data[8]);
break;
default:
- elog(ERROR, "fmgr_c: function %d: too many arguments (%d > %d)",
+ elog(ERROR, "fmgr_c: function %u: too many arguments (%d > %d)",
finfo->fn_oid, n_arguments, MAXFMGRARGS);
break;
}
0, 0, 0);
if (!HeapTupleIsValid(procedureTuple))
{
- elog(ERROR, "fmgr_info: function %d: cache lookup failed",
+ elog(ERROR, "fmgr_info: function %u: cache lookup failed",
procedureId);
}
procedureStruct = (FormData_pg_proc *) GETSTRUCT(procedureTuple);
0, 0, 0);
if (!HeapTupleIsValid(languageTuple))
{
- elog(ERROR, "fmgr_info: %s %ld",
- "Cache lookup for language %d failed",
- ObjectIdGetDatum(procedureStruct->prolang));
+ elog(ERROR, "fmgr_info: %u",
+ "Cache lookup for language failed",
+ DatumGetObjectId(procedureStruct->prolang));
}
languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
if (languageStruct->lanispl)
}
else
{
- elog(ERROR, "fmgr_info: function %d: unknown language %d",
+ elog(ERROR, "fmgr_info: function %u: unknown language %d",
procedureId, language);
}
break;
pronargs = finfo.fn_nargs;
if (pronargs > MAXFMGRARGS)
- elog(ERROR, "fmgr: function %d: too many arguments (%d > %d)",
+ elog(ERROR, "fmgr: function %u: too many arguments (%d > %d)",
procedureId, pronargs, MAXFMGRARGS);
va_start(pvar, procedureId);
local_finfo->fn_nargs = n_arguments;
if (n_arguments > MAXFMGRARGS)
{
- elog(ERROR, "fmgr_ptr: function %d: too many arguments (%d > %d)",
+ elog(ERROR, "fmgr_ptr: function %u: too many arguments (%d > %d)",
func_id, n_arguments, MAXFMGRARGS);
}
for (i = 0; i < n_arguments; ++i)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.104 1999/05/04 15:47:35 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.105 1999/05/10 00:46:18 momjian Exp $
*
* Modifications - 6/10/96 - dave@bensoft.com - version 1.13.dhb
*
if (!dataOnly)
{
if (g_verbose)
- fprintf(stderr, "%s last builtin oid is %d %s\n",
+ fprintf(stderr, "%s last builtin oid is %u %s\n",
g_comment_start, g_last_builtin_oid, g_comment_end);
tblinfo = dumpSchema(g_fout, &numTables, tablename, aclsOption);
}
"SELECT pg_proc.oid, proname, prolang, pronargs, prorettype, "
"proretset, proargtypes, prosrc, probin, usename "
"from pg_proc, pg_user "
- "where pg_proc.oid > '%d'::oid and proowner = usesysid",
+ "where pg_proc.oid > '%u'::oid and proowner = usesysid",
g_last_builtin_oid);
res = PQexec(g_conn, query);
"a.amname as indamname, i.indisunique "
"from pg_index i, pg_class t1, pg_class t2, pg_am a "
"where t1.oid = i.indexrelid and t2.oid = i.indrelid "
- "and t1.relam = a.oid and i.indexrelid > '%d'::oid "
+ "and t1.relam = a.oid and i.indexrelid > '%u'::oid "
"and t2.relname !~ '^pg_' and t1.relkind != 'l'",
g_last_builtin_oid);
PQclear(res);
sprintf(query, "SELECT lanname FROM pg_language "
- "WHERE oid = %d",
+ "WHERE oid = %u",
finfo[i].lang);
res = PQexec(g_conn, query);
if (!res ||
}
PQclear(res);
if (g_verbose)
- fprintf(stderr, "%s maximum system oid is %d %s\n",
+ fprintf(stderr, "%s maximum system oid is %u %s\n",
g_comment_start, max_oid, g_comment_end);
fprintf(fout, "CREATE TABLE pgdump_oid (dummy int4);\n");
fprintf(fout, "COPY pgdump_oid WITH OIDS FROM stdin;\n");
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_type.h,v 1.59 1999/05/03 19:10:20 momjian Exp $
+ * $Id: pg_type.h,v 1.60 1999/05/10 00:46:20 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
DESCR("native variable-length string");
#define TEXTOID 25
-DATA(insert OID = 26 ( oid PGUID 4 10 t b t \054 0 0 int4in int4out int4in int4out i _null_ ));
+DATA(insert OID = 26 ( oid PGUID 4 10 t b t \054 0 0 oidin oidout oidin oidout i _null_ ));
DESCR("object identifier type");
#define OIDOID 26
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpgtcl/Attic/pgtclCmds.c,v 1.41 1999/02/13 23:22:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpgtcl/Attic/pgtclCmds.c,v 1.42 1999/05/10 00:46:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
sprintf(interp->result, "Pg_lo_import of '%s' failed", filename);
return TCL_ERROR;
}
- sprintf(interp->result, "%d", lobjId);
+ sprintf(interp->result, "%u", lobjId);
return TCL_OK;
}
retval = lo_export(conn, lobjId, filename);
if (retval == -1)
{
- sprintf(interp->result, "Pg_lo_export %d %s failed", lobjId, filename);
+ sprintf(interp->result, "Pg_lo_export %u %s failed", lobjId, filename);
return TCL_ERROR;
}
return TCL_OK;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-auth.c,v 1.27 1999/03/14 16:06:43 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-auth.c,v 1.28 1999/05/10 00:46:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (code = krb5_cc_resolve(tktbuf, &ccache))
{
(void) sprintf(PQerrormsg,
- "pg_krb5_init: Kerberos error %d in krb5_cc_resolve\n",
- code);
+ "pg_krb5_init: Kerberos error %d in krb5_cc_resolve\n", code);
com_err("pg_krb5_init", code, "in krb5_cc_resolve");
return (krb5_ccache) NULL;
}
if (code = krb5_cc_get_principal(ccache, &principal))
{
(void) sprintf(PQerrormsg,
- "pg_krb5_authname: Kerberos error %d in krb5_cc_get_principal\n",
- code);
+ "pg_krb5_authname: Kerberos error %d in krb5_cc_get_principal\n", code);
com_err("pg_krb5_authname", code, "in krb5_cc_get_principal");
return (char *) NULL;
}
if (code = krb5_unparse_name(principal, &authname))
{
(void) sprintf(PQerrormsg,
- "pg_krb5_authname: Kerberos error %d in krb5_unparse_name\n",
- code);
+ "pg_krb5_authname: Kerberos error %d in krb5_unparse_name\n", code);
com_err("pg_krb5_authname", code, "in krb5_unparse_name");
krb5_free_principal(principal);
return (char *) NULL;
if (code = krb5_cc_get_principal(ccache, &client))
{
(void) sprintf(PQerrormsg,
- "pg_krb5_sendauth: Kerberos error %d in krb5_cc_get_principal\n",
- code);
+ "pg_krb5_sendauth: Kerberos error %d in krb5_cc_get_principal\n", code);
com_err("pg_krb5_sendauth", code, "in krb5_cc_get_principal");
return STATUS_ERROR;
}
if (code = krb5_parse_name(servbuf, &server))
{
(void) sprintf(PQerrormsg,
- "pg_krb5_sendauth: Kerberos error %d in krb5_parse_name\n",
- code);
+ "pg_krb5_sendauth: Kerberos error %d in krb5_parse_name\n", code);
com_err("pg_krb5_sendauth", code, "in krb5_parse_name");
krb5_free_principal(client);
return STATUS_ERROR;
else
{
(void) sprintf(PQerrormsg,
- "pg_krb5_sendauth: Kerberos error %d in krb5_sendauth\n",
- code);
+ "pg_krb5_sendauth: Kerberos error %d in krb5_sendauth\n", code);
com_err("pg_krb5_sendauth", code, "in krb5_sendauth");
}
}
default:
(void) sprintf(PQerrormsg,
"fe_getauthname: invalid authentication system: %d\n",
- authsvc);
+ authsvc);
break;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-lobj.c,v 1.19 1999/02/13 23:22:41 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-lobj.c,v 1.20 1999/05/10 00:46:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (lobj == -1)
{
sprintf(conn->errorMessage,
- "lo_import: could not open inv object oid %d", lobjOid);
+ "lo_import: could not open inv object oid %u", lobjOid);
return InvalidOid;
}
if (lobj == -1)
{
sprintf(conn->errorMessage,
- "lo_export: can't open inv object %d", lobjId);
+ "lo_export: can't open inv object %u", lobjId);
return -1;
}
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_comp.c,v 1.5 1999/01/28 11:48:31 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_comp.c,v 1.6 1999/05/10 00:46:29 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
if (!HeapTupleIsValid(typeTup))
{
plpgsql_comperrinfo();
- elog(ERROR, "cache lookup for return type %d failed",
+ elog(ERROR, "cache lookup for return type %u failed",
procStruct->prorettype);
}
typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
if (!HeapTupleIsValid(typeTup))
{
plpgsql_comperrinfo();
- elog(ERROR, "cache lookup for argument type %d failed",
+ elog(ERROR, "cache lookup for argument type %u failed",
procStruct->proargtypes[i]);
}
typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
break;
default:
- elog(ERROR, "unknown function type %d in plpgsql_compile()",
+ elog(ERROR, "unknown function type %u in plpgsql_compile()",
functype);
break;
}
if (!HeapTupleIsValid(typetup))
{
plpgsql_comperrinfo();
- elog(ERROR, "cache lookup for type %d of %s.%s failed",
+ elog(ERROR, "cache lookup for type %u of %s.%s failed",
attrStruct->atttypid, word1, word2);
}
if (!HeapTupleIsValid(typetup))
{
plpgsql_comperrinfo();
- elog(ERROR, "cache lookup for type %d of %s.%s failed",
+ elog(ERROR, "cache lookup for type %u of %s.%s failed",
attrStruct->atttypid, word1,
nameout(&(attrStruct->attname)));
}
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_exec.c,v 1.9 1999/04/20 02:19:57 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_exec.c,v 1.10 1999/05/10 00:46:30 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
typetup = SearchSysCacheTuple(TYPOID,
ObjectIdGetDatum(var->datatype->typoid), 0, 0, 0);
if (!HeapTupleIsValid(typetup))
- elog(ERROR, "cache lookup for type %d failed (1)", var->datatype->typoid);
+ elog(ERROR, "cache lookup for type %u failed (1)", var->datatype->typoid);
typeStruct = (Form_pg_type) GETSTRUCT(typetup);
fmgr_info(typeStruct->typoutput, &finfo_output);
typetup = SearchSysCacheTuple(TYPOID,
ObjectIdGetDatum(atttype), 0, 0, 0);
if (!HeapTupleIsValid(typetup))
- elog(ERROR, "cache lookup for type %d failed", atttype);
+ elog(ERROR, "cache lookup for type %u failed", atttype);
typeStruct = (Form_pg_type) GETSTRUCT(typetup);
fmgr_info(typeStruct->typinput, &finfo_input);
typetup = SearchSysCacheTuple(TYPOID,
ObjectIdGetDatum(valtype), 0, 0, 0);
if (!HeapTupleIsValid(typetup))
- elog(ERROR, "cache lookup for type %d failed", valtype);
+ elog(ERROR, "cache lookup for type %u failed", valtype);
typeStruct = (Form_pg_type) GETSTRUCT(typetup);
fmgr_info(typeStruct->typoutput, &finfo_output);
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_funcs.c,v 1.3 1999/01/28 11:48:31 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_funcs.c,v 1.4 1999/05/10 00:46:31 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
{
PLpgSQL_var *var = (PLpgSQL_var *) d;
- printf("VAR %-16s type %s (typoid %d) atttypmod %d\n",
+ printf("VAR %-16s type %s (typoid %u) atttypmod %d\n",
var->refname, var->datatype->typname,
var->datatype->typoid,
var->datatype->atttypmod);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/test/examples/testlo.c,v 1.10 1999/02/13 23:22:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/test/examples/testlo.c,v 1.11 1999/05/10 00:46:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
lobj_fd = lo_open(conn, lobjId, INV_READ);
if (lobj_fd < 0)
{
- fprintf(stderr, "can't open large object %d",
- lobjId);
+ fprintf(stderr, "can't open large object %u", lobjId);
}
lo_lseek(conn, lobj_fd, start, SEEK_SET);
lobj_fd = lo_open(conn, lobjId, INV_READ);
if (lobj_fd < 0)
{
- fprintf(stderr, "can't open large object %d",
- lobjId);
+ fprintf(stderr, "can't open large object %u", lobjId);
}
lo_lseek(conn, lobj_fd, start, SEEK_SET);
lobj_fd = lo_open(conn, lobjId, INV_READ);
if (lobj_fd < 0)
{
- fprintf(stderr, "can't open large object %d",
- lobjId);
+ fprintf(stderr, "can't open large object %u", lobjId);
}
/*
if (lobjOid == 0)
fprintf(stderr, "%s\n", PQerrorMessage(conn));
/*
- printf("\tas large object %d.\n", lobjOid);
+ printf("\tas large object %u.\n", lobjOid);
printf("picking out bytes 1000-2000 of the large object\n");
pickout(conn, lobjOid, 1000, 1000);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/test/examples/Attic/testlo2.c,v 1.9 1999/02/13 23:22:46 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/test/examples/Attic/testlo2.c,v 1.10 1999/05/10 00:46:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
lobj_fd = lo_open(conn, lobjId, INV_READ);
if (lobj_fd < 0)
{
- fprintf(stderr, "can't open large object %d",
- lobjId);
+ fprintf(stderr, "can't open large object %u", lobjId);
}
lo_lseek(conn, lobj_fd, start, SEEK_SET);
lobj_fd = lo_open(conn, lobjId, INV_READ);
if (lobj_fd < 0)
{
- fprintf(stderr, "can't open large object %d",
- lobjId);
+ fprintf(stderr, "can't open large object %u", lobjId);
}
lo_lseek(conn, lobj_fd, start, SEEK_SET);
lobj_fd = lo_open(conn, lobjId, INV_READ);
if (lobj_fd < 0)
{
- fprintf(stderr, "can't open large object %d",
- lobjId);
+ fprintf(stderr, "can't open large object %u", lobjId);
}
/*
/* lobjOid = importFile(conn, in_filename); */
lobjOid = lo_import(conn, in_filename);
/*
- printf("\tas large object %d.\n", lobjOid);
+ printf("\tas large object %u.\n", lobjOid);
printf("picking out bytes 1000-2000 of the large object\n");
pickout(conn, lobjOid, 1000, 1000);
OSDN Git Service
