docs that CLIENT/LOG_MIN_MESSAGES now controls debug_* output location.
Doc changes included.
initStringInfo(&bbb);
for (l = 0; l < min(num, ARRNELEMS(a)); l++)
appendStringInfo(&bbb, "%d ", d[l]);
- elog(DEBUG3, "\t\t%s", bbb.data);
+ elog(DEBUG4, "\t\t%s", bbb.data);
pfree(bbb.data);
}
static void
str[SIGLENBIT] = '\0';
LOOPBIT(str[i] = (GETBIT(bv, i)) ? '1' : '0');
- elog(DEBUG3, "BV: %s", str);
+ elog(DEBUG4, "BV: %s", str);
}
#endif
db = ARRPTR(b);
#ifdef GIST_DEBUG
- elog(DEBUG3, "contains %d %d", na, nb);
+ elog(DEBUG4, "contains %d %d", na, nb);
#endif
i = j = n = 0;
db = ARRPTR(b);
#ifdef GIST_DEBUG
- elog(DEBUG3, "g_int_overlap");
+ elog(DEBUG4, "g_int_overlap");
#endif
i = j = 0;
ArrayType *tmp;
#ifdef GIST_DEBUG
- elog(DEBUG3, "_int_common_union in");
+ elog(DEBUG4, "_int_common_union in");
#endif
numranges = (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY);
{
pfree(out);
#ifdef GIST_DEBUG
- elog(DEBUG3, "_int_common_union out1");
+ elog(DEBUG4, "_int_common_union out1");
#endif
return NULL;
}
#ifdef GIST_DEBUG
- elog(DEBUG3, "_int_common_union out");
+ elog(DEBUG4, "_int_common_union out");
#endif
return (out);
tmp2;
#ifdef GIST_DEBUG
- elog(DEBUG3, "penalty");
+ elog(DEBUG4, "penalty");
#endif
ud = (*unionf) ((ArrayType *) DatumGetPointer(origentry->key),
(ArrayType *) DatumGetPointer(newentry->key));
pfree(ud);
#ifdef GIST_DEBUG
- elog(DEBUG3, "--penalty\t%g", *result);
+ elog(DEBUG4, "--penalty\t%g", *result);
#endif
return (result);
SPLITCOST *costvector;
#ifdef GIST_DEBUG
- elog(DEBUG3, "--------picksplit %d", (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY));
+ elog(DEBUG4, "--------picksplit %d", (VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY));
#endif
maxoff = ((VARSIZE(entryvec) - VARHDRSZ) / sizeof(GISTENTRY)) - 2;
v->spl_rdatum = PointerGetDatum(datum_r);
#ifdef GIST_DEBUG
- elog(DEBUG3, "--------ENDpicksplit %d %d", v->spl_nleft, v->spl_nright);
+ elog(DEBUG4, "--------ENDpicksplit %d %d", v->spl_nleft, v->spl_nright);
#endif
return v;
}
findoprnd(ITEM * ptr, int4 *pos)
{
#ifdef BS_DEBUG
- elog(DEBUG3, (ptr[*pos].type == OPR) ?
+ elog(DEBUG4, (ptr[*pos].type == OPR) ?
"%d %c" : "%d %d ", *pos, ptr[*pos].val);
#endif
if (ptr[*pos].type == VAL)
else
appendStringInfo(&pbuf, "%d ", ptr[i].val);
}
- elog(DEBUG3, "POR: %s", pbuf.data);
+ elog(DEBUG4, "POR: %s", pbuf.data);
pfree(pbuf.data);
#endif
GetCurrentTransactionId(), deleted, rel->rd_id, okey);
if (debug)
- elog(DEBUG3, "sql: %s", sql);
+ elog(DEBUG4, "sql: %s", sql);
ret = SPI_exec(sql, 0);
deleted, okey);
if (debug)
- elog(DEBUG3, "sql: %s", sql);
+ elog(DEBUG4, "sql: %s", sql);
ret = SPI_exec(sql, 0);
rel->rd_id, GetCurrentTransactionId(), okey);
if (debug)
- elog(DEBUG3, "sql: %s", sql);
+ elog(DEBUG4, "sql: %s", sql);
ret = SPI_exec(sql, 0);
int i;
#ifdef DEBUG_QUERY
- elog(DEBUG3, "Check_primary_key Enter Function");
+ elog(DEBUG4, "Check_primary_key Enter Function");
#endif
/*
r;
#ifdef DEBUG_QUERY
- elog(DEBUG3, "Check_foreign_key Enter Function");
+ elog(DEBUG4, "Check_foreign_key Enter Function");
#endif
/*
strcmp(type, "date") && strcmp(type, "timestamp")) == 0)
is_char_type = 1;
#ifdef DEBUG_QUERY
- elog(DEBUG3, "Check_foreign_key Debug value %s type %s %d",
+ elog(DEBUG4, "Check_foreign_key Debug value %s type %s %d",
nv, type, is_char_type);
#endif
}
plan->nplans = nrefs;
#ifdef DEBUG_QUERY
- elog(DEBUG3, "Check_foreign_key Debug Query is : %s ", sql);
+ elog(DEBUG4, "Check_foreign_key Debug Query is : %s ", sql);
#endif
}
findoprnd(ITEM * ptr, int4 *pos)
{
#ifdef BS_DEBUG
- elog(DEBUG3, (ptr[*pos].type == OPR) ?
+ elog(DEBUG4, (ptr[*pos].type == OPR) ?
"%d %c" : "%d %d ", *pos, ptr[*pos].val);
#endif
if (ptr[*pos].type == VAL || ptr[*pos].type == VALTRUE)
sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance);
cur = strchr(cur, '\0');
}
- elog(DEBUG3, "POR: %s", pbuf);
+ elog(DEBUG4, "POR: %s", pbuf);
#endif
return query;
sprintf(cur, "%d(%s) ", ptr[i].val, GETOPERAND(query) + ptr[i].distance);
cur = strchr(cur, '\0');
}
- elog(DEBUG3, "POR: %s", pbuf);
+ elog(DEBUG4, "POR: %s", pbuf);
#endif
pfree(res);
PG_RETURN_POINTER(query);
These options enable various debugging output to be sent to the
- server log. For each executed query, they print the resulting parse
- tree, the query rewriter output, or the execution plan.
+ client or server log. For each executed query, they print the resulting
+ parse tree, the query rewriter output, or the execution plan.
indents these displays to
produce a more readable but much longer output format.
+ or
+ must be DEBUG1 or lower to send output to the client
+ or server logs.
Generates a great amount of debugging output for the
LISTEN and NOTIFY
commands.
+ or
+ must be DEBUG1 or lower to send output to the client
+ or server logs.
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.102 2003/03/10 22:28:18 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.103 2003/05/27 17:49:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
maxoff = PageGetMaxOffsetNumber(page);
- elog(DEBUG3, "%sPage: %d %s blk: %d maxoff: %d free: %d", pred,
+ elog(DEBUG4, "%sPage: %d %s blk: %d maxoff: %d free: %d", pred,
coff, (opaque->flags & F_LEAF) ? "LEAF" : "INTE", (int) blk,
(int) maxoff, PageGetFreeSpace(page));
which = (IndexTuple) PageGetItem(page, iid);
cblk = ItemPointerGetBlockNumber(&(which->t_tid));
#ifdef PRINTTUPLE
- elog(DEBUG3, "%s Tuple. blk: %d size: %d", pred, (int) cblk,
+ elog(DEBUG4, "%s Tuple. blk: %d size: %d", pred, (int) cblk,
IndexTupleSize(which));
#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.99 2003/02/23 06:17:13 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.100 2003/05/27 17:49:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
BTPageOpaque lpageop;
if (!InRecovery)
- elog(DEBUG1, "_bt_insert_parent: concurrent ROOT page split");
+ elog(DEBUG2, "_bt_insert_parent: concurrent ROOT page split");
lpageop = (BTPageOpaque) PageGetSpecialPointer(page);
/* Find the leftmost page at the next level up */
pbuf = _bt_get_endpoint(rel, lpageop->btpo.level + 1, false);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.64 2003/03/04 21:51:20 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.65 2003/05/27 17:49:45 momjian Exp $
*
* NOTES
* Postgres btree pages look like ordinary relation pages. The opaque
_bt_pageinit(page, BufferGetPageSize(buf));
return buf;
}
- elog(DEBUG1, "_bt_getbuf: FSM returned nonrecyclable page");
+ elog(DEBUG2, "_bt_getbuf: FSM returned nonrecyclable page");
_bt_relbuf(rel, buf);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v 1.56 2003/05/14 03:26:00 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v 1.57 2003/05/27 17:49:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
do_start()
{
StartTransactionCommand();
- elog(DEBUG3, "start transaction");
+ elog(DEBUG4, "start transaction");
}
do_end()
{
CommitTransactionCommand();
- elog(DEBUG3, "commit transaction");
+ elog(DEBUG4, "commit transaction");
if (isatty(0))
{
printf("bootstrap> ");
{
do_start();
numattr = 0;
- elog(DEBUG3, "creating%s%s relation %s...",
+ elog(DEBUG4, "creating%s%s relation %s...",
$2 ? " bootstrap" : "",
$3 ? " shared" : "",
LexIDStr($5));
{
if (boot_reldesc)
{
- elog(DEBUG3, "create bootstrap: warning, open relation exists, closing first");
+ elog(DEBUG4, "create bootstrap: warning, open relation exists, closing first");
closerel(NULL);
}
$3,
true,
true);
- elog(DEBUG3, "bootstrap relation created");
+ elog(DEBUG4, "bootstrap relation created");
}
else
{
$3,
ONCOMMIT_NOOP,
true);
- elog(DEBUG3, "relation created with oid %u", id);
+ elog(DEBUG4, "relation created with oid %u", id);
}
do_end();
}
{
do_start();
if ($2)
- elog(DEBUG3, "inserting row with oid %u...", $2);
+ elog(DEBUG4, "inserting row with oid %u...", $2);
else
- elog(DEBUG3, "inserting row...");
+ elog(DEBUG4, "inserting row...");
num_columns_read = 0;
}
LPAREN boot_tuplelist RPAREN
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.157 2003/05/14 03:26:00 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.158 2003/05/27 17:49:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (boot_reldesc != NULL)
closerel(NULL);
- elog(DEBUG3, "open relation %s, attrsize %d", relname ? relname : "(null)",
+ elog(DEBUG4, "open relation %s, attrsize %d", relname ? relname : "(null)",
(int) ATTRIBUTE_TUPLE_SIZE);
boot_reldesc = heap_openr(relname, NoLock);
{
Form_pg_attribute at = attrtypes[i];
- elog(DEBUG3, "create attribute %d name %s len %d num %d type %u",
+ elog(DEBUG4, "create attribute %d name %s len %d num %d type %u",
i, NameStr(at->attname), at->attlen, at->attnum,
at->atttypid);
}
elog(ERROR, "no open relation to close");
else
{
- elog(DEBUG3, "close relation %s", relname ? relname : "(null)");
+ elog(DEBUG4, "close relation %s", relname ? relname : "(null)");
heap_close(boot_reldesc, NoLock);
boot_reldesc = (Relation) NULL;
}
MemSet(attrtypes[attnum], 0, ATTRIBUTE_TUPLE_SIZE);
namestrcpy(&attrtypes[attnum]->attname, name);
- elog(DEBUG3, "column %s %s", NameStr(attrtypes[attnum]->attname), type);
+ elog(DEBUG4, "column %s %s", NameStr(attrtypes[attnum]->attname), type);
attrtypes[attnum]->attnum = attnum + 1; /* fillatt */
typeoid = gettype(type);
TupleDesc tupDesc;
int i;
- elog(DEBUG3, "inserting row oid %u, %d columns", objectid, numattr);
+ elog(DEBUG4, "inserting row oid %u, %d columns", objectid, numattr);
tupDesc = CreateTupleDesc(numattr,
RelationGetForm(boot_reldesc)->relhasoids,
simple_heap_insert(boot_reldesc, tuple);
heap_freetuple(tuple);
- elog(DEBUG3, "row inserted");
+ elog(DEBUG4, "row inserted");
/*
* Reset blanks for next tuple
AssertArg(i >= 0 || i < MAXATTR);
- elog(DEBUG3, "inserting column %d value '%s'", i, value);
+ elog(DEBUG4, "inserting column %d value '%s'", i, value);
if (Typ != (struct typmap **) NULL)
{
struct typmap *ap;
- elog(DEBUG3, "Typ != NULL");
+ elog(DEBUG4, "Typ != NULL");
app = Typ;
while (*app && (*app)->am_oid != boot_reldesc->rd_att->attrs[i]->atttypid)
++app;
values[i],
ObjectIdGetDatum(ap->am_typ.typelem),
Int32GetDatum(-1)));
- elog(DEBUG3, " -> %s", prt);
+ elog(DEBUG4, " -> %s", prt);
pfree(prt);
}
else
}
if (typeindex >= n_types)
elog(ERROR, "type oid %u not found", attrtypes[i]->atttypid);
- elog(DEBUG3, "Typ == NULL, typeindex = %u", typeindex);
+ elog(DEBUG4, "Typ == NULL, typeindex = %u", typeindex);
values[i] = OidFunctionCall3(Procid[typeindex].inproc,
CStringGetDatum(value),
ObjectIdGetDatum(Procid[typeindex].elem),
values[i],
ObjectIdGetDatum(Procid[typeindex].elem),
Int32GetDatum(-1)));
- elog(DEBUG3, " -> %s", prt);
+ elog(DEBUG4, " -> %s", prt);
pfree(prt);
}
- elog(DEBUG3, "inserted");
+ elog(DEBUG4, "inserted");
}
/* ----------------
void
InsertOneNull(int i)
{
- elog(DEBUG3, "inserting column %d NULL", i);
+ elog(DEBUG4, "inserting column %d NULL", i);
Assert(i >= 0 || i < MAXATTR);
values[i] = PointerGetDatum(NULL);
Blanks[i] = 'n';
if (strncmp(type, Procid[i].name, NAMEDATALEN) == 0)
return i;
}
- elog(DEBUG3, "external type: %s", type);
+ elog(DEBUG4, "external type: %s", type);
rel = heap_openr(TypeRelationName, NoLock);
scan = heap_beginscan(rel, SnapshotNow, 0, (ScanKey) NULL);
i = 0;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.80 2003/01/23 23:38:55 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.81 2003/05/27 17:49:45 momjian Exp $
*
* NOTES
* See acl.h.
int i;
AclItem *aip;
- elog(DEBUG1, "acl size = %d, # acls = %d",
+ elog(DEBUG2, "acl size = %d, # acls = %d",
ACL_SIZE(acl), ACL_NUM(acl));
aip = ACL_DAT(acl);
for (i = 0; i < ACL_NUM(acl); ++i)
- elog(DEBUG1, " acl[%d]: %s", i,
+ elog(DEBUG2, " acl[%d]: %s", i,
DatumGetCString(DirectFunctionCall1(aclitemout,
PointerGetDatum(aip + i))));
}
!usecatupd)
{
#ifdef ACLDEBUG
- elog(DEBUG1, "pg_class_aclcheck: catalog update: permission denied");
+ elog(DEBUG2, "pg_class_aclcheck: catalog update: permission denied");
#endif
ReleaseSysCache(tuple);
return ACLCHECK_NO_PRIV;
if (usesuper)
{
#ifdef ACLDEBUG
- elog(DEBUG1, "pg_class_aclcheck: %u is superuser", userid);
+ elog(DEBUG2, "pg_class_aclcheck: %u is superuser", userid);
#endif
ReleaseSysCache(tuple);
return ACLCHECK_OK;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/dependency.c,v 1.23 2003/03/06 22:54:49 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/dependency.c,v 1.24 2003/05/27 17:49:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
if (!deleteDependentObjects(object, objDescription,
DROP_CASCADE,
- showNotices ? NOTICE : DEBUG1,
+ showNotices ? NOTICE : DEBUG2,
&oktodelete, depRel))
elog(ERROR, "Failed to drop all objects depending on %s",
objDescription);
if (amOwned)
{
if (object_address_present(&owningObject, oktodelete))
- elog(DEBUG1, "Drop auto-cascades to %s",
+ elog(DEBUG2, "Drop auto-cascades to %s",
getObjectDescription(&owningObject));
else if (behavior == DROP_RESTRICT)
{
* In that case, act like this link is AUTO, too.
*/
if (object_address_present(&otherObject, oktodelete))
- elog(DEBUG1, "Drop auto-cascades to %s",
+ elog(DEBUG2, "Drop auto-cascades to %s",
getObjectDescription(&otherObject));
else if (behavior == DROP_RESTRICT)
{
* RESTRICT case. (However, normal dependencies on the
* component object could still cause failure.)
*/
- elog(DEBUG1, "Drop auto-cascades to %s",
+ elog(DEBUG2, "Drop auto-cascades to %s",
getObjectDescription(&otherObject));
if (!recursiveDeletion(&otherObject, behavior, msglevel,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/analyze.c,v 1.53 2003/04/25 21:29:18 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/analyze.c,v 1.54 2003/05/27 17:49:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (vacstmt->verbose)
elevel = INFO;
else
- elevel = DEBUG1;
+ elevel = DEBUG2;
/*
* Use the current context for storing analysis info. vacuum.c
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.94 2003/05/14 03:26:01 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.95 2003/05/27 17:49:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Async_Notify(char *relname)
{
if (Trace_notify)
- elog(LOG, "Async_Notify: %s", relname);
+ elog(DEBUG1, "Async_Notify: %s", relname);
/* no point in making duplicate entries in the list ... */
if (!AsyncExistsPendingNotify(relname))
bool alreadyListener = false;
if (Trace_notify)
- elog(LOG, "Async_Listen: %s", relname);
+ elog(DEBUG1, "Async_Listen: %s", relname);
lRel = heap_openr(ListenerRelationName, AccessExclusiveLock);
}
if (Trace_notify)
- elog(LOG, "Async_Unlisten %s", relname);
+ elog(DEBUG1, "Async_Unlisten %s", relname);
lRel = heap_openr(ListenerRelationName, AccessExclusiveLock);
ScanKeyData key[1];
if (Trace_notify)
- elog(LOG, "Async_UnlistenAll");
+ elog(DEBUG1, "Async_UnlistenAll");
lRel = heap_openr(ListenerRelationName, AccessExclusiveLock);
tdesc = RelationGetDescr(lRel);
}
if (Trace_notify)
- elog(LOG, "AtCommit_Notify");
+ elog(DEBUG1, "AtCommit_Notify");
/* preset data to update notify column to MyProcPid */
nulls[0] = nulls[1] = nulls[2] = ' ';
*/
if (Trace_notify)
- elog(LOG, "AtCommit_Notify: notifying self");
+ elog(DEBUG1, "AtCommit_Notify: notifying self");
NotifyMyFrontEnd(relname, listenerPID);
}
else
{
if (Trace_notify)
- elog(LOG, "AtCommit_Notify: notifying pid %d",
+ elog(DEBUG1, "AtCommit_Notify: notifying pid %d",
listenerPID);
/*
ClearPendingNotifies();
if (Trace_notify)
- elog(LOG, "AtCommit_Notify: done");
+ elog(DEBUG1, "AtCommit_Notify: done");
}
/*
{
/* Here, it is finally safe to do stuff. */
if (Trace_notify)
- elog(LOG, "Async_NotifyHandler: perform async notify");
+ elog(DEBUG1, "Async_NotifyHandler: perform async notify");
ProcessIncomingNotify();
if (Trace_notify)
- elog(LOG, "Async_NotifyHandler: done");
+ elog(DEBUG1, "Async_NotifyHandler: done");
}
}
if (notifyInterruptOccurred)
{
if (Trace_notify)
- elog(LOG, "EnableNotifyInterrupt: perform async notify");
+ elog(DEBUG1, "EnableNotifyInterrupt: perform async notify");
ProcessIncomingNotify();
if (Trace_notify)
- elog(LOG, "EnableNotifyInterrupt: done");
+ elog(DEBUG1, "EnableNotifyInterrupt: done");
}
}
}
nulls[Natts_pg_listener];
if (Trace_notify)
- elog(LOG, "ProcessIncomingNotify");
+ elog(DEBUG1, "ProcessIncomingNotify");
set_ps_display("async_notify");
/* Notify the frontend */
if (Trace_notify)
- elog(LOG, "ProcessIncomingNotify: received %s from %d",
+ elog(DEBUG1, "ProcessIncomingNotify: received %s from %d",
relname, (int) sourcePID);
NotifyMyFrontEnd(relname, sourcePID);
set_ps_display("idle");
if (Trace_notify)
- elog(LOG, "ProcessIncomingNotify: done");
+ elog(DEBUG1, "ProcessIncomingNotify: done");
}
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.253 2003/05/14 03:26:01 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.254 2003/05/27 17:49:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (vacstmt->verbose)
elevel = INFO;
else
- elevel = DEBUG1;
+ elevel = DEBUG2;
/*
* We cannot run VACUUM inside a user transaction block; if we were
/* Quick exit if we have no vtlinks to search in */
if (vacrelstats->vtlinks == NULL)
{
- elog(DEBUG1, "Parent item in update-chain not found - can't continue repair_frag");
+ elog(DEBUG2, "Parent item in update-chain not found - can't continue repair_frag");
break; /* out of walk-along-page loop */
}
* in scan_heap(), but it's not implemented at the
* moment and so we just stop shrinking here.
*/
- elog(DEBUG1, "Child itemid in update-chain marked as unused - can't continue repair_frag");
+ elog(DEBUG2, "Child itemid in update-chain marked as unused - can't continue repair_frag");
chain_move_failed = true;
break; /* out of loop to move to chain end */
}
if (vtlp == NULL)
{
/* see discussion above */
- elog(DEBUG1, "Parent item in update-chain not found - can't continue repair_frag");
+ elog(DEBUG2, "Parent item in update-chain not found - can't continue repair_frag");
chain_move_failed = true;
break; /* out of check-all-items loop */
}
HeapTupleHeaderGetXmin(tp.t_data))))
{
ReleaseBuffer(Pbuf);
- elog(DEBUG1, "Too old parent tuple found - can't continue repair_frag");
+ elog(DEBUG2, "Too old parent tuple found - can't continue repair_frag");
chain_move_failed = true;
break; /* out of check-all-items loop */
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/vacuumlazy.c,v 1.27 2003/03/04 21:51:21 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/vacuumlazy.c,v 1.28 2003/05/27 17:49:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (vacstmt->verbose)
elevel = INFO;
else
- elevel = DEBUG1;
+ elevel = DEBUG2;
vacuum_set_xid_limits(vacstmt, onerel->rd_rel->relisshared,
&OldestXmin, &FreezeLimit);
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.70 2003/03/10 03:53:49 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.71 2003/05/27 17:49:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
default:
/* don't make hard error unless caller asks to restore... */
- elog(DEBUG1, "ExecMarkPos: node type %d not supported",
+ elog(DEBUG2, "ExecMarkPos: node type %d not supported",
nodeTag(node));
break;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/libpq/be-fsstubs.c,v 1.63 2002/09/02 02:47:02 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/libpq/be-fsstubs.c,v 1.64 2003/05/27 17:49:46 momjian Exp $
*
* NOTES
* This should be moved to a more appropriate place. It is here
MemoryContext currentContext;
#if FSDB
- elog(DEBUG3, "lo_open(%u,%d)", lobjId, mode);
+ elog(DEBUG4, "lo_open(%u,%d)", lobjId, mode);
#endif
if (fscxt == NULL)
{ /* lookup failed */
MemoryContextSwitchTo(currentContext);
#if FSDB
- elog(DEBUG3, "cannot open large object %u", lobjId);
+ elog(DEBUG4, "cannot open large object %u", lobjId);
#endif
PG_RETURN_INT32(-1);
}
PG_RETURN_INT32(-1);
}
#if FSDB
- elog(DEBUG3, "lo_close(%d)", fd);
+ elog(DEBUG4, "lo_close(%d)", fd);
#endif
Assert(fscxt != NULL);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/libpq/be-secure.c,v 1.32 2003/05/15 16:35:28 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/libpq/be-secure.c,v 1.33 2003/05/27 17:49:46 momjian Exp $
*
* Since the server static private key ($DataDir/server.key)
* will normally be stored unencrypted so that the database
return NULL;
dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
if (dh == NULL)
- elog(DEBUG1, "DH load buffer: %s", SSLerrmessage());
+ elog(DEBUG2, "DH load buffer: %s", SSLerrmessage());
BIO_free(bio);
return dh;
/* this may take a long time, but it may be necessary... */
if (r == NULL || 8 * DH_size(r) < keylength)
{
- elog(DEBUG1, "DH: generating parameters (%d bits)....", keylength);
+ elog(DEBUG2, "DH: generating parameters (%d bits)....", keylength);
r = DH_generate_parameters(keylength, DH_GENERATOR_2, NULL, NULL);
}
switch (type)
{
case SSL_CB_HANDSHAKE_START:
- elog(DEBUG3, "SSL: handshake start");
+ elog(DEBUG4, "SSL: handshake start");
break;
case SSL_CB_HANDSHAKE_DONE:
- elog(DEBUG3, "SSL: handshake done");
+ elog(DEBUG4, "SSL: handshake done");
break;
case SSL_CB_ACCEPT_LOOP:
- elog(DEBUG3, "SSL: accept loop");
+ elog(DEBUG4, "SSL: accept loop");
break;
case SSL_CB_ACCEPT_EXIT:
- elog(DEBUG3, "SSL: accept exit (%d)", args);
+ elog(DEBUG4, "SSL: accept exit (%d)", args);
break;
case SSL_CB_CONNECT_LOOP:
- elog(DEBUG3, "SSL: connect loop");
+ elog(DEBUG4, "SSL: connect loop");
break;
case SSL_CB_CONNECT_EXIT:
- elog(DEBUG3, "SSL: connect exit (%d)", args);
+ elog(DEBUG4, "SSL: connect exit (%d)", args);
break;
case SSL_CB_READ_ALERT:
- elog(DEBUG3, "SSL: read alert (0x%04x)", args);
+ elog(DEBUG4, "SSL: read alert (0x%04x)", args);
break;
case SSL_CB_WRITE_ALERT:
- elog(DEBUG3, "SSL: write alert (0x%04x)", args);
+ elog(DEBUG4, "SSL: write alert (0x%04x)", args);
break;
}
}
NID_commonName, port->peer_cn, sizeof(port->peer_cn));
port->peer_cn[sizeof(port->peer_cn) - 1] = '\0';
}
- elog(DEBUG1, "secure connection from '%s'", port->peer_cn);
+ elog(DEBUG2, "secure connection from '%s'", port->peer_cn);
/* set up debugging/info callback */
SSL_CTX_set_info_callback(SSL_context, info_cb);
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/optimizer/geqo/geqo_main.c,v 1.34 2003/01/20 18:54:49 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/geqo/geqo_main.c,v 1.35 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
daddy = alloc_chromo(pool->string_length);
#if defined (ERX)
- elog(DEBUG1, "geqo_main: using edge recombination crossover [ERX]");
+ elog(DEBUG2, "geqo_main: using edge recombination crossover [ERX]");
/* allocate edge table memory */
edge_table = alloc_edge_table(pool->string_length);
#elif defined(PMX)
- elog(DEBUG1, "geqo_main: using partially matched crossover [PMX]");
+ elog(DEBUG2, "geqo_main: using partially matched crossover [PMX]");
/* allocate chromosome kid memory */
kid = alloc_chromo(pool->string_length);
#elif defined(CX)
- elog(DEBUG1, "geqo_main: using cycle crossover [CX]");
+ elog(DEBUG2, "geqo_main: using cycle crossover [CX]");
/* allocate city table memory */
kid = alloc_chromo(pool->string_length);
city_table = alloc_city_table(pool->string_length);
#elif defined(PX)
- elog(DEBUG1, "geqo_main: using position crossover [PX]");
+ elog(DEBUG2, "geqo_main: using position crossover [PX]");
/* allocate city table memory */
kid = alloc_chromo(pool->string_length);
city_table = alloc_city_table(pool->string_length);
#elif defined(OX1)
- elog(DEBUG1, "geqo_main: using order crossover [OX1]");
+ elog(DEBUG2, "geqo_main: using order crossover [OX1]");
/* allocate city table memory */
kid = alloc_chromo(pool->string_length);
city_table = alloc_city_table(pool->string_length);
#elif defined(OX2)
- elog(DEBUG1, "geqo_main: using order crossover [OX2]");
+ elog(DEBUG2, "geqo_main: using order crossover [OX2]");
/* allocate city table memory */
kid = alloc_chromo(pool->string_length);
city_table = alloc_city_table(pool->string_length);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.57 2003/02/03 21:15:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/clausesel.c,v 1.58 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
#ifdef SELECTIVITY_DEBUG
- elog(DEBUG3, "clause_selectivity: s1 %f", s1);
+ elog(DEBUG4, "clause_selectivity: s1 %f", s1);
#endif /* SELECTIVITY_DEBUG */
return s1;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.140 2003/05/26 00:11:27 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.141 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (isNull)
{
/* Treat a null result as false ... but it's a tad fishy ... */
- elog(DEBUG1, "pred_test_simple_clause: null test result");
+ elog(DEBUG2, "pred_test_simple_clause: null test result");
return false;
}
return DatumGetBool(test_result);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.328 2003/05/15 16:35:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.329 2003/05/27 17:49:46 momjian Exp $
*
* NOTES
*
extern char **environ;
char **p;
- elog(DEBUG2, "%s: PostmasterMain: initial environ dump:", progname);
- elog(DEBUG2, "-----------------------------------------");
+ elog(DEBUG3, "%s: PostmasterMain: initial environ dump:", progname);
+ elog(DEBUG3, "-----------------------------------------");
for (p = environ; *p; ++p)
- elog(DEBUG2, "\t%s", *p);
- elog(DEBUG2, "-----------------------------------------");
+ elog(DEBUG3, "\t%s", *p);
+ elog(DEBUG3, "-----------------------------------------");
}
/*
if (backendPID == CheckPointPID)
{
- elog(DEBUG1, "processCancelRequest: CheckPointPID in cancel request for process %d", backendPID);
+ elog(DEBUG2, "processCancelRequest: CheckPointPID in cancel request for process %d", backendPID);
return;
}
else if (ExecBackend)
if (bp->cancel_key == cancelAuthCode)
{
/* Found a match; signal that backend to cancel current op */
- elog(DEBUG1, "processing cancel request: sending SIGINT to process %d",
+ elog(DEBUG2, "processing cancel request: sending SIGINT to process %d",
backendPID);
kill(bp->pid, SIGINT);
}
else
/* Right PID, wrong key: no way, Jose */
- elog(DEBUG1, "bad key in cancel request for process %d",
+ elog(DEBUG2, "bad key in cancel request for process %d",
backendPID);
return;
}
}
/* No matching backend */
- elog(DEBUG1, "bad pid in cancel request for process %d", backendPID);
+ elog(DEBUG2, "bad pid in cancel request for process %d", backendPID);
}
/*
PG_SETMASK(&BlockSig);
- elog(DEBUG1, "pmdie %d", postgres_signal_arg);
+ elog(DEBUG2, "pmdie %d", postgres_signal_arg);
switch (postgres_signal_arg)
{
PG_SETMASK(&BlockSig);
- elog(DEBUG3, "reaping dead processes");
+ elog(DEBUG4, "reaping dead processes");
#ifdef HAVE_WAITPID
while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
{
*next;
Backend *bp;
- LogChildExit(DEBUG1, gettext("child process"), pid, exitstatus);
+ LogChildExit(DEBUG2, gettext("child process"), pid, exitstatus);
/*
* If a backend dies in an ugly way (i.e. exit status not 0) then we
*/
if (!FatalError)
{
- elog(DEBUG1, "CleanupProc: sending %s to process %d",
+ elog(DEBUG2, "CleanupProc: sending %s to process %d",
(SendStop ? "SIGSTOP" : "SIGQUIT"), (int) bp->pid);
kill(bp->pid, (SendStop ? SIGSTOP : SIGQUIT));
}
if (bp->pid != MyProcPid)
{
- elog(DEBUG1, "SignalChildren: sending signal %d to process %d",
+ elog(DEBUG2, "SignalChildren: sending signal %d to process %d",
signal, (int) bp->pid);
kill(bp->pid, signal);
}
}
/* in parent, normal */
- elog(DEBUG1, "BackendStartup: forked pid=%d socket=%d", (int) pid,
+ elog(DEBUG2, "BackendStartup: forked pid=%d socket=%d", (int) pid,
port->sock);
/*
/*
* Debug: print arguments being passed to backend
*/
- elog(DEBUG2, "%s child[%d]: starting with (", progname, MyProcPid);
+ elog(DEBUG3, "%s child[%d]: starting with (", progname, MyProcPid);
for (i = 0; i < ac; ++i)
- elog(DEBUG2, "\t%s", av[i]);
- elog(DEBUG2, ")");
+ elog(DEBUG3, "\t%s", av[i]);
+ elog(DEBUG3, ")");
ClientAuthInProgress = false; /* client_min_messages is active
* now */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.81 2002/09/04 20:31:25 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.82 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
InterruptHoldoffCount = 1;
CritSectionCount = 0;
- elog(DEBUG2, "proc_exit(%d)", code);
+ elog(DEBUG3, "proc_exit(%d)", code);
/* do our shared memory exits first */
shmem_exit(code);
(*on_proc_exit_list[on_proc_exit_index].function) (code,
on_proc_exit_list[on_proc_exit_index].arg);
- elog(DEBUG2, "exit(%d)", code);
+ elog(DEBUG3, "exit(%d)", code);
exit(code);
}
void
shmem_exit(int code)
{
- elog(DEBUG2, "shmem_exit(%d)", code);
+ elog(DEBUG3, "shmem_exit(%d)", code);
/*
* call all the registered callbacks.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipci.c,v 1.52 2003/05/03 03:52:07 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipci.c,v 1.53 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* might as well round it off to a multiple of a typical page size */
size += 8192 - (size % 8192);
- elog(DEBUG2, "invoking IpcMemoryCreate(size=%d)", size);
+ elog(DEBUG3, "invoking IpcMemoryCreate(size=%d)", size);
/*
* Create the shmem segment
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmqueue.c,v 1.23 2003/01/07 22:23:17 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmqueue.c,v 1.24 2003/05/27 17:49:46 momjian Exp $
*
* NOTES
*
}
snprintf(elem, sizeof(elem), "--->%lx", MAKE_OFFSET(q));
strcat(buf, elem);
- elog(DEBUG1, "%s: %s", s, buf);
+ elog(DEBUG2, "%s: %s", s, buf);
snprintf(buf, sizeof(buf), "q nexts: %lx", MAKE_OFFSET(q));
count = 0;
}
snprintf(elem, sizeof(elem), "--->%lx", MAKE_OFFSET(q));
strcat(buf, elem);
- elog(DEBUG1, "%s: %s", s, buf);
+ elog(DEBUG2, "%s: %s", s, buf);
}
#endif /* SHMQUEUE_DEBUG */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/sinval.c,v 1.54 2003/02/23 23:20:52 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/sinval.c,v 1.55 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
insertOK = SIInsertDataEntry(shmInvalBuffer, msg);
LWLockRelease(SInvalLock);
if (!insertOK)
- elog(DEBUG3, "SendSharedInvalidMessage: SI buffer overflow");
+ elog(DEBUG4, "SendSharedInvalidMessage: SI buffer overflow");
}
/*
if (getResult < 0)
{
/* got a reset message */
- elog(DEBUG3, "ReceiveSharedInvalidMessages: cache state reset");
+ elog(DEBUG4, "ReceiveSharedInvalidMessages: cache state reset");
resetFunction();
}
else
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/sinvaladt.c,v 1.49 2002/11/21 06:36:08 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/sinvaladt.c,v 1.50 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
MyBackendId = (stateP - &segP->procState[0]) + 1;
#ifdef INVALIDDEBUG
- elog(DEBUG1, "SIBackendInit: backend id %d", MyBackendId);
+ elog(DEBUG2, "SIBackendInit: backend id %d", MyBackendId);
#endif /* INVALIDDEBUG */
/* Reduce free slot count */
if (numMsgs == (MAXNUMMESSAGES * 70 / 100) &&
IsUnderPostmaster)
{
- elog(DEBUG3, "SIInsertDataEntry: table is 70%% full, signaling postmaster");
+ elog(DEBUG4, "SIInsertDataEntry: table is 70%% full, signaling postmaster");
SendPostmasterSignal(PMSIGNAL_WAKEN_CHILDREN);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.345 2003/05/14 18:40:37 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.346 2003/05/27 17:49:46 momjian Exp $
*
* NOTES
* this is the "main" module of the postgres backend and
Query *querytree = (Query *) lfirst(list_item);
if (Debug_print_parse)
- elog_node_display(LOG, "parse tree", querytree,
+ elog_node_display(DEBUG1, "parse tree", querytree,
Debug_pretty_print);
if (querytree->commandType == CMD_UTILITY)
#endif
if (Debug_print_rewritten)
- elog_node_display(LOG, "rewritten parse tree", querytree_list,
+ elog_node_display(DEBUG1, "rewritten parse tree", querytree_list,
Debug_pretty_print);
return querytree_list;
* Print plan if debugging.
*/
if (Debug_print_plan)
- elog_node_display(LOG, "plan", plan, Debug_pretty_print);
+ elog_node_display(DEBUG1, "plan", plan, Debug_pretty_print);
return plan;
}
{
if (!xact_started)
{
- elog(DEBUG2, "StartTransactionCommand");
+ elog(DEBUG3, "StartTransactionCommand");
StartTransactionCommand();
/* Set statement timeout running, if any */
disable_sig_alarm(true);
/* Now commit the command */
- elog(DEBUG2, "CommitTransactionCommand");
+ elog(DEBUG3, "CommitTransactionCommand");
CommitTransactionCommand();
* putting it inside InitPostgres() instead. In particular, anything
* that involves database access should be there, not here.
*/
- elog(DEBUG2, "InitPostgres");
+ elog(DEBUG3, "InitPostgres");
InitPostgres(dbname, username);
SetProcessingMode(NormalProcessing);
if (!IsUnderPostmaster)
{
puts("\nPOSTGRES backend interactive interface ");
- puts("$Revision: 1.345 $ $Date: 2003/05/14 18:40:37 $\n");
+ puts("$Revision: 1.346 $ $Date: 2003/05/27 17:49:46 $\n");
}
/*
MemoryContextSwitchTo(ErrorContext);
/* Do the recovery */
- elog(DEBUG1, "AbortCurrentTransaction");
+ elog(DEBUG2, "AbortCurrentTransaction");
AbortCurrentTransaction();
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.64 2003/05/08 18:16:36 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.65 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
Node *utilityStmt = query->utilityStmt;
- elog(DEBUG2, "ProcessUtility");
+ elog(DEBUG3, "ProcessUtility");
/*
* Set snapshot if utility stmt needs one. Most reliable
/*
* process a plannable query.
*/
- elog(DEBUG2, "ProcessQuery");
+ elog(DEBUG3, "ProcessQuery");
/* Must always set snapshot for plannable queries */
SetQuerySnapshot();
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/varbit.c,v 1.30 2003/05/12 23:08:50 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/varbit.c,v 1.31 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
mask2 = end_mask << (BITS_PER_BYTE - is);
is_match = mask2 == 0;
#if 0
- elog(DEBUG3, "S. %d %d em=%2x sm=%2x r=%d",
+ elog(DEBUG4, "S. %d %d em=%2x sm=%2x r=%d",
i, is, end_mask, mask2, is_match);
#endif
break;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.102 2002/11/13 00:39:47 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.103 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
uint32 hashValue = 0;
- CACHE4_elog(DEBUG1, "CatalogCacheComputeHashValue %s %d %p",
+ CACHE4_elog(DEBUG2, "CatalogCacheComputeHashValue %s %d %p",
cache->cc_relname,
nkeys,
cache);
long cc_lsearches = 0;
long cc_lhits = 0;
- elog(DEBUG1, "Catcache stats dump: %d/%d tuples in catcaches",
+ elog(DEBUG2, "Catcache stats dump: %d/%d tuples in catcaches",
CacheHdr->ch_ntup, CacheHdr->ch_maxtup);
for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
{
if (cache->cc_ntup == 0 && cache->cc_searches == 0)
continue; /* don't print unused caches */
- elog(DEBUG1, "Catcache %s/%s: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld discards, %ld lsrch, %ld lhits",
+ elog(DEBUG2, "Catcache %s/%s: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld discards, %ld lsrch, %ld lhits",
cache->cc_relname,
cache->cc_indname,
cache->cc_ntup,
cc_lsearches += cache->cc_lsearches;
cc_lhits += cache->cc_lhits;
}
- elog(DEBUG1, "Catcache totals: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld discards, %ld lsrch, %ld lhits",
+ elog(DEBUG2, "Catcache totals: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld discards, %ld lsrch, %ld lhits",
CacheHdr->ch_ntup,
cc_searches,
cc_hits,
* sanity checks
*/
Assert(ItemPointerIsValid(pointer));
- CACHE1_elog(DEBUG1, "CatalogCacheIdInvalidate: called");
+ CACHE1_elog(DEBUG2, "CatalogCacheIdInvalidate: called");
/*
* inspect caches to find the proper cache
ct->dead = true;
else
CatCacheRemoveCTup(ccp, ct);
- CACHE1_elog(DEBUG1, "CatalogCacheIdInvalidate: invalidated");
+ CACHE1_elog(DEBUG2, "CatalogCacheIdInvalidate: invalidated");
#ifdef CATCACHE_STATS
ccp->cc_invals++;
#endif
{
CatCache *cache;
- CACHE1_elog(DEBUG1, "ResetCatalogCaches called");
+ CACHE1_elog(DEBUG2, "ResetCatalogCaches called");
for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
ResetCatalogCache(cache);
- CACHE1_elog(DEBUG1, "end of ResetCatalogCaches call");
+ CACHE1_elog(DEBUG2, "end of ResetCatalogCaches call");
}
/*
{
CatCache *cache;
- CACHE2_elog(DEBUG1, "CatalogCacheFlushRelation called for %u", relId);
+ CACHE2_elog(DEBUG2, "CatalogCacheFlushRelation called for %u", relId);
for (cache = CacheHdr->ch_caches; cache; cache = cache->cc_next)
{
}
}
- CACHE1_elog(DEBUG1, "end of CatalogCacheFlushRelation call");
+ CACHE1_elog(DEBUG2, "end of CatalogCacheFlushRelation call");
}
/*
* structure initialized on the first access.
*/
#ifdef CACHEDEBUG
-#define InitCatCache_DEBUG1 \
+#define InitCatCache_DEBUG2 \
do { \
- elog(DEBUG1, "InitCatCache: rel=%s id=%d nkeys=%d size=%d\n", \
+ elog(DEBUG2, "InitCatCache: rel=%s id=%d nkeys=%d size=%d\n", \
cp->cc_relname, cp->id, cp->cc_nkeys, cp->cc_nbuckets); \
} while(0)
#else
-#define InitCatCache_DEBUG1
+#define InitCatCache_DEBUG2
#endif
CatCache *
* new cache is initialized as far as we can go for now. print some
* debugging information, if appropriate.
*/
- InitCatCache_DEBUG1;
+ InitCatCache_DEBUG2;
/*
* add completed cache to top of group header's list
* that the relcache entry can be opened at this point!
*/
#ifdef CACHEDEBUG
-#define CatalogCacheInitializeCache_DEBUG1 \
- elog(DEBUG1, "CatalogCacheInitializeCache: cache @%p %s", cache, \
+#define CatalogCacheInitializeCache_DEBUG2 \
+ elog(DEBUG2, "CatalogCacheInitializeCache: cache @%p %s", cache, \
cache->cc_relname)
#define CatalogCacheInitializeCache_DEBUG2 \
do { \
if (cache->cc_key[i] > 0) { \
- elog(DEBUG1, "CatalogCacheInitializeCache: load %d/%d w/%d, %u", \
+ elog(DEBUG2, "CatalogCacheInitializeCache: load %d/%d w/%d, %u", \
i+1, cache->cc_nkeys, cache->cc_key[i], \
tupdesc->attrs[cache->cc_key[i] - 1]->atttypid); \
} else { \
- elog(DEBUG1, "CatalogCacheInitializeCache: load %d/%d w/%d", \
+ elog(DEBUG2, "CatalogCacheInitializeCache: load %d/%d w/%d", \
i+1, cache->cc_nkeys, cache->cc_key[i]); \
} \
} while(0)
#else
-#define CatalogCacheInitializeCache_DEBUG1
+#define CatalogCacheInitializeCache_DEBUG2
#define CatalogCacheInitializeCache_DEBUG2
#endif
TupleDesc tupdesc;
int i;
- CatalogCacheInitializeCache_DEBUG1;
+ CatalogCacheInitializeCache_DEBUG2;
/*
* Open the relation without locking --- we only need the tupdesc,
heap_close(relation, NoLock);
- CACHE3_elog(DEBUG1, "CatalogCacheInitializeCache: %s, %d keys",
+ CACHE3_elog(DEBUG2, "CatalogCacheInitializeCache: %s, %d keys",
cache->cc_relname, cache->cc_nkeys);
/*
/* Initialize sk_attno suitably for HeapKeyTest() and heap scans */
cache->cc_skey[i].sk_attno = cache->cc_key[i];
- CACHE4_elog(DEBUG1, "CatalogCacheInit %s %d %p",
+ CACHE4_elog(DEBUG2, "CatalogCacheInit %s %d %p",
cache->cc_relname,
i,
cache);
{
ct->refcount++;
- CACHE3_elog(DEBUG1, "SearchCatCache(%s): found in bucket %d",
+ CACHE3_elog(DEBUG2, "SearchCatCache(%s): found in bucket %d",
cache->cc_relname, hashIndex);
#ifdef CATCACHE_STATS
}
else
{
- CACHE3_elog(DEBUG1, "SearchCatCache(%s): found neg entry in bucket %d",
+ CACHE3_elog(DEBUG2, "SearchCatCache(%s): found neg entry in bucket %d",
cache->cc_relname, hashIndex);
#ifdef CATCACHE_STATS
true);
heap_freetuple(ntp);
- CACHE4_elog(DEBUG1, "SearchCatCache(%s): Contains %d/%d tuples",
+ CACHE4_elog(DEBUG2, "SearchCatCache(%s): Contains %d/%d tuples",
cache->cc_relname, cache->cc_ntup, CacheHdr->ch_ntup);
- CACHE3_elog(DEBUG1, "SearchCatCache(%s): put neg entry in bucket %d",
+ CACHE3_elog(DEBUG2, "SearchCatCache(%s): put neg entry in bucket %d",
cache->cc_relname, hashIndex);
/*
return NULL;
}
- CACHE4_elog(DEBUG1, "SearchCatCache(%s): Contains %d/%d tuples",
+ CACHE4_elog(DEBUG2, "SearchCatCache(%s): Contains %d/%d tuples",
cache->cc_relname, cache->cc_ntup, CacheHdr->ch_ntup);
- CACHE3_elog(DEBUG1, "SearchCatCache(%s): put in bucket %d",
+ CACHE3_elog(DEBUG2, "SearchCatCache(%s): put in bucket %d",
cache->cc_relname, hashIndex);
#ifdef CATCACHE_STATS
/* Bump the list's refcount and return it */
cl->refcount++;
- CACHE2_elog(DEBUG1, "SearchCatCacheList(%s): found list",
+ CACHE2_elog(DEBUG2, "SearchCatCacheList(%s): found list",
cache->cc_relname);
#ifdef CATCACHE_STATS
DLAddHead(&cache->cc_lists, &cl->cache_elem);
- CACHE3_elog(DEBUG1, "SearchCatCacheList(%s): made list of %d members",
+ CACHE3_elog(DEBUG2, "SearchCatCacheList(%s): made list of %d members",
cache->cc_relname, nmembers);
return cl;
if (oldct->refcount == 0)
{
- CACHE2_elog(DEBUG1, "CatCacheCreateEntry(%s): Overflow, LRU removal",
+ CACHE2_elog(DEBUG2, "CatCacheCreateEntry(%s): Overflow, LRU removal",
cache->cc_relname);
#ifdef CATCACHE_STATS
oldct->my_cache->cc_discards++;
CatCache *ccp;
Oid reloid;
- CACHE1_elog(DEBUG1, "PrepareToInvalidateCacheTuple: called");
+ CACHE1_elog(DEBUG2, "PrepareToInvalidateCacheTuple: called");
/*
* sanity checks
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/dfmgr.c,v 1.59 2003/04/05 19:54:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/dfmgr.c,v 1.60 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
sprintf(full, "%s/%s", mangled, basename);
pfree(mangled);
- elog(DEBUG2, "find_in_dynamic_libpath: trying %s", full);
+ elog(DEBUG3, "find_in_dynamic_libpath: trying %s", full);
if (file_exists(full))
return full;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/init/Attic/findbe.c,v 1.33 2003/05/15 16:35:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/Attic/findbe.c,v 1.34 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
if (stat(path, &buf) < 0)
{
- elog(DEBUG2, "ValidateBinary: can't stat \"%s\"", path);
+ elog(DEBUG3, "ValidateBinary: can't stat \"%s\"", path);
return -1;
}
if ((buf.st_mode & S_IFMT) != S_IFREG)
{
- elog(DEBUG2, "ValidateBinary: \"%s\" is not a regular file", path);
+ elog(DEBUG3, "ValidateBinary: \"%s\" is not a regular file", path);
return -1;
}
is_r = buf.st_mode & S_IRUSR;
is_x = buf.st_mode & S_IXUSR;
if (!(is_r && is_x))
- elog(DEBUG2, "ValidateBinary: \"%s\" is not user read/execute", path);
+ elog(DEBUG3, "ValidateBinary: \"%s\" is not user read/execute", path);
return is_x ? (is_r ? 0 : -2) : -1;
}
pwp = getpwuid(euid);
is_r = buf.st_mode & S_IRGRP;
is_x = buf.st_mode & S_IXGRP;
if (!(is_r && is_x))
- elog(DEBUG2, "ValidateBinary: \"%s\" is not group read/execute",
+ elog(DEBUG3, "ValidateBinary: \"%s\" is not group read/execute",
path);
return is_x ? (is_r ? 0 : -2) : -1;
}
is_r = buf.st_mode & S_IROTH;
is_x = buf.st_mode & S_IXOTH;
if (!(is_r && is_x))
- elog(DEBUG2, "ValidateBinary: \"%s\" is not other read/execute",
+ elog(DEBUG3, "ValidateBinary: \"%s\" is not other read/execute",
path);
return is_x ? (is_r ? 0 : -2) : -1;
#endif
if (ValidateBinary(buf) == 0)
{
strncpy(full_path, buf, MAXPGPATH);
- elog(DEBUG1, "FindExec: found \"%s\" using argv[0]", full_path);
+ elog(DEBUG2, "FindExec: found \"%s\" using argv[0]", full_path);
return 0;
}
elog(LOG, "FindExec: invalid binary \"%s\"", buf);
*/
if ((p = getenv("PATH")) && *p)
{
- elog(DEBUG1, "FindExec: searching PATH ...");
+ elog(DEBUG2, "FindExec: searching PATH ...");
path = strdup(p); /* make a modifiable copy */
for (startp = path, endp = strchr(path, ':');
startp && *startp;
{
case 0: /* found ok */
strncpy(full_path, buf, MAXPGPATH);
- elog(DEBUG1, "FindExec: found \"%s\" using PATH",
+ elog(DEBUG2, "FindExec: found \"%s\" using PATH",
full_path);
free(path);
return 0;
*
* Copyright 2000 by PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/src/backend/utils/misc/guc-file.l,v 1.14 2002/11/08 20:23:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/misc/guc-file.l,v 1.15 2003/05/27 17:49:46 momjian Exp $
*/
%{
Assert(context == PGC_POSTMASTER || context == PGC_BACKEND
|| context == PGC_SIGHUP);
Assert(DataDir);
- elevel = (context == PGC_SIGHUP) ? DEBUG3 : ERROR;
+ elevel = (context == PGC_SIGHUP) ? DEBUG4 : ERROR;
/*
* Open file
* Written by Peter Eisentraut
. *
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/misc/guc.c,v 1.124 2003/05/14 03:26:02 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/misc/guc.c,v 1.125 2003/05/27 17:49:46 momjian Exp $
*
*--------------------------------------------------------------------
*/
bool makeDefault;
if (context == PGC_SIGHUP || source == PGC_S_DEFAULT)
- elevel = DEBUG1;
+ elevel = DEBUG2;
else if (source == PGC_S_DATABASE || source == PGC_S_USER)
elevel = INFO;
else
{
if (DoIt && !makeDefault)
{
- elog(DEBUG2, "%s: setting ignored because previous source is higher priority",
+ elog(DEBUG3, "%s: setting ignored because previous source is higher priority",
name);
return true;
}
Assert(context == PGC_POSTMASTER || context == PGC_SIGHUP);
Assert(DataDir);
- elevel = (context == PGC_SIGHUP) ? DEBUG3 : ERROR;
+ elevel = (context == PGC_SIGHUP) ? DEBUG4 : ERROR;
/*
* Open file
if (strcasecmp(newval, "debug") == 0)
{
if (doit)
- (*var) = DEBUG1;
+ (*var) = DEBUG2;
}
else if (strcasecmp(newval, "debug5") == 0)
{
* Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: elog.h,v 1.43 2003/05/22 17:20:43 petere Exp $
+ * $Id: elog.h,v 1.44 2003/05/27 17:49:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define DEBUG4 11
#define DEBUG3 12
#define DEBUG2 13
-#define DEBUG1 14
+#define DEBUG1 14 /* used by GUC debug_* variables */
#define LOG 15 /* Server operational messages; sent only
* to server log by default. */
#define COMMERROR 16 /* Client communication problems; same as
int
elog_DEBUG(void)
{
- return DEBUG1;
+ return DEBUG2;
}
int
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/gram.y,v 1.43 2003/05/05 16:46:27 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/gram.y,v 1.44 2003/05/27 17:49:47 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
}
| K_DEBUG
{
- $$ = DEBUG1;
+ $$ = DEBUG2;
}
;
* MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpython/plpython.c,v 1.31 2003/03/10 22:28:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpython/plpython.c,v 1.32 2003/05/27 17:49:47 momjian Exp $
*
*********************************************************************
*/
PyObject *
PLy_debug(PyObject * self, PyObject * args)
{
- return PLy_output(DEBUG1, self, args);
+ return PLy_output(DEBUG2, self, args);
}
PyObject *
-/* $Header: /cvsroot/pgsql/src/pl/plpython/Attic/plpython.h,v 1.6 2002/03/06 06:10:48 momjian Exp $ */
+/* $Header: /cvsroot/pgsql/src/pl/plpython/Attic/plpython.h,v 1.7 2003/05/27 17:49:47 momjian Exp $ */
#ifndef PLPYTHON_H
#define PLPYTHON_H
#if DEBUG_LEVEL
#define CALL_LEVEL_INC() do { PLy_call_level += 1; \
- elog(DEBUG3, "Level: %d", PLy_call_level); } while (0)
-#define CALL_LEVEL_DEC() do { elog(DEBUG3, "Level: %d", PLy_call_level); \
+ elog(DEBUG4, "Level: %d", PLy_call_level); } while (0)
+#define CALL_LEVEL_DEC() do { elog(DEBUG4, "Level: %d", PLy_call_level); \
PLy_call_level -= 1; } while (0)
#else
#define CALL_LEVEL_INC() do { PLy_call_level += 1; } while (0)
/* temporary debugging macros
*/
#if DEBUG_LEVEL
-#define enter() elog(DEBUG3, "Enter(%d): %s", func_enter_calls++,__FUNCTION__)
-#define leave() elog(DEBUG3, "Leave(%d): %s", func_leave_calls++,__FUNCTION__)
-#define mark() elog(DEBUG3, "Mark: %s:%d", __FUNCTION__, __LINE__);
-#define refc(O) elog(DEBUG3, "Ref<%p>:<%d>:%s:%d", (O), (((O) == NULL) ? -1 : (O)->ob_refcnt), __FUNCTION__, __LINE__)
+#define enter() elog(DEBUG4, "Enter(%d): %s", func_enter_calls++,__FUNCTION__)
+#define leave() elog(DEBUG4, "Leave(%d): %s", func_leave_calls++,__FUNCTION__)
+#define mark() elog(DEBUG4, "Mark: %s:%d", __FUNCTION__, __LINE__);
+#define refc(O) elog(DEBUG4, "Ref<%p>:<%d>:%s:%d", (O), (((O) == NULL) ? -1 : (O)->ob_refcnt), __FUNCTION__, __LINE__)
#else
#define enter()
#define leave()
* ENHANCEMENTS, OR MODIFICATIONS.
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.70 2003/05/16 13:37:00 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.71 2003/05/27 17:49:47 momjian Exp $
*
**********************************************************************/
}
if (strcmp(argv[1], "DEBUG") == 0)
- level = DEBUG1;
+ level = DEBUG2;
else if (strcmp(argv[1], "LOG") == 0)
level = LOG;
else if (strcmp(argv[1], "INFO") == 0)
/*
- * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.55 2003/03/20 04:52:35 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.56 2003/05/27 17:49:47 momjian Exp $
*/
#include "postgres.h"
))));
}
- elog(DEBUG3, "funny_dup17 (fired %s) on level %3d: %d/%d tuples inserted/selected",
+ elog(DEBUG4, "funny_dup17 (fired %s) on level %3d: %d/%d tuples inserted/selected",
when, *level, inserted, selected);
SPI_finish();
projects / postgresql.git / commitdiff