*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.29 1998/01/05 03:28:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.30 1998/01/07 21:00:40 momjian Exp $
*
* NOTES
* The old interface functions have been converted to macros
break;
default:
if (att[i]->attlen < sizeof(int32))
- elog(ABORT, "ComputeDataSize: attribute %d has len %d",
+ elog(ERROR, "ComputeDataSize: attribute %d has len %d",
i, att[i]->attlen);
if (att[i]->attalign == 'd')
data_length = DOUBLEALIGN(data_length) + att[i]->attlen;
break;
default:
if (att[i]->attlen < sizeof(int32))
- elog(ABORT, "DataFill: attribute %d has len %d",
+ elog(ERROR, "DataFill: attribute %d has len %d",
i, att[i]->attlen);
if (att[i]->attalign == 'd')
{
break;
case 0:
- elog(ABORT, "heap_attisnull: zero attnum disallowed");
+ elog(ERROR, "heap_attisnull: zero attnum disallowed");
default:
- elog(ABORT, "heap_attisnull: undefined negative attnum");
+ elog(ERROR, "heap_attisnull: undefined negative attnum");
}
return (0);
return sizeof f->t_cmax;
default:
- elog(ABORT, "sysattrlen: System attribute number %d unknown.", attno);
+ elog(ERROR, "sysattrlen: System attribute number %d unknown.", attno);
return 0;
}
}
break;
default:
byval = true;
- elog(ABORT, "sysattrbyval: System attribute number %d unknown.",
+ elog(ERROR, "sysattrbyval: System attribute number %d unknown.",
attno);
break;
}
case MaxCommandIdAttributeNumber:
return ((Datum) (long) tup->t_cmax);
default:
- elog(ABORT, "heap_getsysattr: undefined attnum %d", attnum);
+ elog(ERROR, "heap_getsysattr: undefined attnum %d", attnum);
}
return ((Datum) NULL);
}
default:
if (att[j]->attlen < sizeof(int32))
{
- elog(ABORT,
+ elog(ERROR,
"fastgetattr: attribute %d has len %d",
j, att[j]->attlen);
}
break;
default:
if (att[i]->attlen < sizeof(int32))
- elog(ABORT,
+ elog(ERROR,
"fastgetattr2: attribute %d has len %d",
i, att[i]->attlen);
if (att[i]->attalign == 'd')
break;
default:
if (att[attnum]->attlen < sizeof(int32))
- elog(ABORT, "fastgetattr3: attribute %d has len %d",
+ elog(ERROR, "fastgetattr3: attribute %d has len %d",
attnum, att[attnum]->attlen);
if (att[attnum]->attalign == 'd')
off = DOUBLEALIGN(off);
/* XXX For now, just prevent an undetectable executor related error */
if (tuple->t_len > MAXTUPLEN)
{
- elog(ABORT, "palloctup: cannot handle length %d tuples",
+ elog(ERROR, "palloctup: cannot handle length %d tuples",
tuple->t_len);
}
}
if (numberOfAttributes > MaxHeapAttributeNumber)
- elog(ABORT, "heap_formtuple: numberOfAttributes of %d > %d",
+ elog(ERROR, "heap_formtuple: numberOfAttributes of %d > %d",
numberOfAttributes, MaxHeapAttributeNumber);
if (hasnull)
}
else if (repl[attoff] != 'r')
{
- elog(ABORT, "heap_modifytuple: repl is \\%3d", repl[attoff]);
+ elog(ERROR, "heap_modifytuple: repl is \\%3d", repl[attoff]);
}
else
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.21 1998/01/05 03:28:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.22 1998/01/07 21:00:43 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int numberOfAttributes = tupleDescriptor->natts;
if (numberOfAttributes > MaxIndexAttributeNumber)
- elog(ABORT, "index_formtuple: numberOfAttributes of %d > %d",
+ elog(ERROR, "index_formtuple: numberOfAttributes of %d > %d",
numberOfAttributes, MaxIndexAttributeNumber);
*/
if (size & 0xE000)
- elog(ABORT, "index_formtuple: data takes %d bytes: too big", size);
+ elog(ERROR, "index_formtuple: data takes %d bytes: too big", size);
infomask |= size;
off = (att[j]->attalign == 'd') ?
DOUBLEALIGN(off) : LONGALIGN(off);
else
- elog(ABORT, "fastgetiattr: attribute %d has len %d",
+ elog(ERROR, "fastgetiattr: attribute %d has len %d",
j, att[j]->attlen);
break;
DOUBLEALIGN(off) + att[i]->attlen :
LONGALIGN(off) + att[i]->attlen;
else
- elog(ABORT, "fastgetiattr2: attribute %d has len %d",
+ elog(ERROR, "fastgetiattr2: attribute %d has len %d",
i, att[i]->attlen);
break;
break;
default:
if (att[attnum]->attlen < sizeof(int32))
- elog(ABORT, "fastgetattr3: attribute %d has len %d",
+ elog(ERROR, "fastgetattr3: attribute %d has len %d",
attnum, att[attnum]->attlen);
if (att[attnum]->attalign == 'd')
off = DOUBLEALIGN(off);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.21 1998/01/05 03:29:00 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.22 1998/01/07 21:00:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return ((Oid)
((TypeTupleForm) GETSTRUCT(typeTuple))->typoutput);
- elog(ABORT, "typtoout: Cache lookup of type %d failed", type);
+ elog(ERROR, "typtoout: Cache lookup of type %d failed", type);
return (InvalidOid);
}
return ((Oid)
((TypeTupleForm) GETSTRUCT(typeTuple))->typelem);
- elog(ABORT, "typtoout: Cache lookup of type %d failed", type);
+ elog(ERROR, "typtoout: Cache lookup of type %d failed", type);
return (InvalidOid);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.30 1998/01/05 03:29:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.31 1998/01/07 21:00:45 momjian Exp $
*
* NOTES
* some of the executor utility code such as "ExecTypeFromTL" should be
* RelationNameCreateHeapRelation() calls BuildDesc() which
* calls this routine and since EMP does not exist yet, the
* system cache lookup below fails. That's fine, but rather
- * then doing a elog(ABORT) we just leave that information
+ * then doing a elog(ERROR) we just leave that information
* uninitialized, return false, then fix things up later.
* -cim 6/14/90
* ----------------
TupleDescMakeSelfReference(desc, attnum, relname);
}
else
- elog(ABORT, "DefineRelation: no such type %s",
+ elog(ERROR, "DefineRelation: no such type %s",
typename);
}
*/
if (oldPred == NULL && (nb = RelationGetNumberOfBlocks(index)) != 0)
- elog(ABORT, "%.16s already contains data", &(index->rd_rel->relname.data[0]));
+ elog(ERROR, "%.16s already contains data", &(index->rd_rel->relname.data[0]));
/* initialize the root page (if this is a new index) */
if (oldPred == NULL)
0, 0, 0);
itupform = (IndexTupleForm) GETSTRUCT(htup);
if (!HeapTupleIsValid(htup))
- elog(ABORT, "initGISTstate: index %d not found", index->rd_id);
+ elog(ERROR, "initGISTstate: index %d not found", index->rd_id);
giststate->haskeytype = itupform->indhaskeytype;
if (giststate->haskeytype)
{
0, 0);
if (!HeapTupleIsValid(htup))
{
- elog(ABORT, "initGISTstate: no attribute tuple %d %d",
+ elog(ERROR, "initGISTstate: no attribute tuple %d %d",
itupform->indexrelid, FirstOffsetNumber);
return;
}
if (!IndexScanIsValid(s))
{
- elog(ABORT, "gistrescan: invalid scan.");
+ elog(ERROR, "gistrescan: invalid scan.");
return;
}
}
if (l == (GISTScanList) NULL)
- elog(ABORT, "GiST scan list corrupted -- cannot find 0x%lx", s);
+ elog(ERROR, "GiST scan list corrupted -- cannot find 0x%lx", s);
if (prev == (GISTScanList) NULL)
GISTScans = l->gsl_next;
break;
default:
- elog(ABORT, "Bad operation in GiST scan adjust: %d", op);
+ elog(ERROR, "Bad operation in GiST scan adjust: %d", op);
}
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hashinsert.c,v 1.11 1998/01/05 03:29:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hashinsert.c,v 1.12 1998/01/07 21:00:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* we need a scan key to do our search, so build one */
itup = &(hitem->hash_itup);
if ((natts = rel->rd_rel->relnatts) != 1)
- elog(ABORT, "Hash indices valid for only one index key.");
+ elog(ERROR, "Hash indices valid for only one index key.");
itup_scankey = _hash_mkscankey(rel, itup, metap);
/*
if (PageGetFreeSpace(page) < itemsz)
{
/* it doesn't fit on an empty page -- give up */
- elog(ABORT, "hash item too large");
+ elog(ERROR, "hash item too large");
}
}
_hash_checkpage(page, LH_OVERFLOW_PAGE);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hashovfl.c,v 1.14 1998/01/05 03:29:20 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hashovfl.c,v 1.15 1998/01/07 21:01:00 momjian Exp $
*
* NOTES
* Overflow pages look like ordinary relation pages.
oaddr = _hash_getovfladdr(rel, metabufp);
if (oaddr == InvalidOvflAddress)
{
- elog(ABORT, "_hash_addovflpage: problem with _hash_getovfladdr.");
+ elog(ERROR, "_hash_addovflpage: problem with _hash_getovfladdr.");
}
ovflblkno = OADDR_TO_BLKNO(OADDR_OF(SPLITNUM(oaddr), OPAGENUM(oaddr)));
Assert(BlockNumberIsValid(ovflblkno));
{
if (++splitnum >= NCACHED)
{
- elog(ABORT, OVMSG);
+ elog(ERROR, OVMSG);
}
metap->OVFL_POINT = splitnum;
metap->SPARES[splitnum] = metap->SPARES[splitnum - 1];
free_page++;
if (free_page >= NCACHED)
{
- elog(ABORT, OVMSG);
+ elog(ERROR, OVMSG);
}
/*
if (_hash_initbitmap(rel, metap, OADDR_OF(splitnum, offset),
1, free_page))
{
- elog(ABORT, "overflow_page: problem with _hash_initbitmap.");
+ elog(ERROR, "overflow_page: problem with _hash_initbitmap.");
}
metap->SPARES[splitnum]++;
offset++;
{
if (++splitnum >= NCACHED)
{
- elog(ABORT, OVMSG);
+ elog(ERROR, OVMSG);
}
metap->OVFL_POINT = splitnum;
metap->SPARES[splitnum] = metap->SPARES[splitnum - 1];
offset = (i ? bit - metap->SPARES[i - 1] : bit);
if (offset >= SPLITMASK)
{
- elog(ABORT, OVMSG);
+ elog(ERROR, OVMSG);
}
/* initialize this page */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hashpage.c,v 1.14 1998/01/05 03:29:22 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hashpage.c,v 1.15 1998/01/07 21:01:08 momjian Exp $
*
* NOTES
* Postgres hash pages look like ordinary relation pages. The opaque
if ((nblocks = RelationGetNumberOfBlocks(rel)) != 0)
{
- elog(ABORT, "Cannot initialize non-empty hash table %s",
+ elog(ERROR, "Cannot initialize non-empty hash table %s",
RelationGetRelationName(rel));
}
* created the first two buckets above.
*/
if (_hash_initbitmap(rel, metap, OADDR_OF(lg2nelem, 1), lg2nelem + 1, 0))
- elog(ABORT, "Problem with _hash_initbitmap.");
+ elog(ERROR, "Problem with _hash_initbitmap.");
/* all done */
_hash_wrtnorelbuf(rel, metabuf);
if (blkno == P_NEW)
{
- elog(ABORT, "_hash_getbuf: internal error: hash AM does not use P_NEW");
+ elog(ERROR, "_hash_getbuf: internal error: hash AM does not use P_NEW");
}
switch (access)
{
_hash_setpagelock(rel, blkno, access);
break;
default:
- elog(ABORT, "_hash_getbuf: invalid access (%d) on new blk: %s",
+ elog(ERROR, "_hash_getbuf: invalid access (%d) on new blk: %s",
access, RelationGetRelationName(rel));
break;
}
_hash_unsetpagelock(rel, blkno, access);
break;
default:
- elog(ABORT, "_hash_relbuf: invalid access (%d) on blk %x: %s",
+ elog(ERROR, "_hash_relbuf: invalid access (%d) on blk %x: %s",
access, blkno, RelationGetRelationName(rel));
}
_hash_relbuf(rel, *bufp, from_access);
break;
default:
- elog(ABORT, "_hash_chgbufaccess: invalid access (%d) on blk %x: %s",
+ elog(ERROR, "_hash_chgbufaccess: invalid access (%d) on blk %x: %s",
from_access, blkno, RelationGetRelationName(rel));
break;
}
RelationSetSingleRLockPage(rel, &iptr);
break;
default:
- elog(ABORT, "_hash_setpagelock: invalid access (%d) on blk %x: %s",
+ elog(ERROR, "_hash_setpagelock: invalid access (%d) on blk %x: %s",
access, blkno, RelationGetRelationName(rel));
break;
}
RelationUnsetSingleRLockPage(rel, &iptr);
break;
default:
- elog(ABORT, "_hash_unsetpagelock: invalid access (%d) on blk %x: %s",
+ elog(ERROR, "_hash_unsetpagelock: invalid access (%d) on blk %x: %s",
access, blkno, RelationGetRelationName(rel));
break;
}
_hash_checkpage(opage, LH_OVERFLOW_PAGE);
if (PageIsEmpty(opage))
{
- elog(ABORT, "_hash_splitpage: empty overflow page %d", oblkno);
+ elog(ERROR, "_hash_splitpage: empty overflow page %d", oblkno);
}
oopaque = (HashPageOpaque) PageGetSpecialPointer(opage);
}
/* we're guaranteed that an ovfl page has at least 1 tuple */
if (PageIsEmpty(opage))
{
- elog(ABORT, "_hash_splitpage: empty ovfl page %d!",
+ elog(ERROR, "_hash_splitpage: empty ovfl page %d!",
oblkno);
}
ooffnum = FirstOffsetNumber;
oopaque = (HashPageOpaque) PageGetSpecialPointer(opage);
if (PageIsEmpty(opage))
{
- elog(ABORT, "_hash_splitpage: empty overflow page %d",
+ elog(ERROR, "_hash_splitpage: empty overflow page %d",
oblkno);
}
ooffnum = FirstOffsetNumber;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hashscan.c,v 1.12 1998/01/05 03:29:24 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hashscan.c,v 1.13 1998/01/07 21:01:13 momjian Exp $
*
* NOTES
* Because we can be doing an index scan on a relation while we
}
if (chk == (HashScanList) NULL)
- elog(ABORT, "hash scan list trashed; can't find 0x%lx", scan);
+ elog(ERROR, "hash scan list trashed; can't find 0x%lx", scan);
if (last == (HashScanList) NULL)
HashScans = chk->hashsl_next;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hashutil.c,v 1.12 1998/01/05 03:29:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hashutil.c,v 1.13 1998/01/07 21:01:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* disallow nulls in hash keys */
if (itup->t_info & INDEX_NULL_MASK)
- elog(ABORT, "hash indices cannot include null keys");
+ elog(ERROR, "hash indices cannot include null keys");
/* make a copy of the index tuple with room for the sequence number */
tuplen = IndexTupleSize(itup);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.24 1998/01/05 03:29:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.25 1998/01/07 21:01:20 momjian Exp $
*
*
* INTERFACE ROUTINES
#ifndef NO_BUFFERISVALID
if (!BufferIsValid(*b))
- elog(ABORT, "heapgettup: failed ReadBuffer");
+ elog(ERROR, "heapgettup: failed ReadBuffer");
#endif
dp = (Page) BufferGetPage(*b);
#ifndef NO_BUFFERISVALID
if (!BufferIsValid(*b))
{
- elog(ABORT, "heapgettup: failed ReadBuffer");
+ elog(ERROR, "heapgettup: failed ReadBuffer");
}
#endif
#ifndef NO_BUFFERISVALID
if (!BufferIsValid(*b))
{
- elog(ABORT, "heapgettup: failed ReadBuffer");
+ elog(ERROR, "heapgettup: failed ReadBuffer");
}
#endif
#ifndef NO_BUFFERISVALID
if (!BufferIsValid(*b))
{
- elog(ABORT, "heapgettup: failed ReadBuffer");
+ elog(ERROR, "heapgettup: failed ReadBuffer");
}
#endif
dp = (Page) BufferGetPage(*b);
if (RelationIsValid(r) && r->rd_rel->relkind == RELKIND_INDEX)
{
- elog(ABORT, "%s is an index relation", r->rd_rel->relname.data);
+ elog(ERROR, "%s is an index relation", r->rd_rel->relname.data);
}
return (r);
if (RelationIsValid(r) && r->rd_rel->relkind == RELKIND_INDEX)
{
- elog(ABORT, "%s is an index relation", r->rd_rel->relname.data);
+ elog(ERROR, "%s is an index relation", r->rd_rel->relname.data);
}
return (r);
* ----------------
*/
if (RelationIsValid(relation) == false)
- elog(ABORT, "heap_beginscan: !RelationIsValid(relation)");
+ elog(ERROR, "heap_beginscan: !RelationIsValid(relation)");
/* ----------------
* set relation level read lock
* ----------------
*/
if (sdesc == NULL)
- elog(ABORT, "heap_getnext: NULL relscan");
+ elog(ERROR, "heap_getnext: NULL relscan");
/* ----------------
* initialize return buffer to InvalidBuffer
#ifndef NO_BUFFERISVALID
if (!BufferIsValid(buffer))
{
- elog(ABORT, "heap_fetch: %s relation: ReadBuffer(%lx) failed",
+ elog(ERROR, "heap_fetch: %s relation: ReadBuffer(%lx) failed",
&relation->rd_rel->relname, (long) tid);
}
#endif
#ifndef NO_BUFFERISVALID
if (!BufferIsValid(b))
{ /* XXX L_SH better ??? */
- elog(ABORT, "heap_delete: failed ReadBuffer");
+ elog(ERROR, "heap_delete: failed ReadBuffer");
}
#endif /* NO_BUFFERISVALID */
/* XXX call something else */
ReleaseBuffer(b);
- elog(ABORT, "heap_delete: (am)invalid tid");
+ elog(ERROR, "heap_delete: (am)invalid tid");
}
/* ----------------
if (!BufferIsValid(buffer))
{
/* XXX L_SH better ??? */
- elog(ABORT, "amreplace: failed ReadBuffer");
+ elog(ERROR, "amreplace: failed ReadBuffer");
}
#endif /* NO_BUFFERISVALID */
if (!tuple)
{
ReleaseBuffer(buffer);
- elog(ABORT, "heap_replace: (am)invalid otid");
+ elog(ERROR, "heap_replace: (am)invalid otid");
}
/* XXX order problems if not atomic assignment ??? */
*
*
* IDENTIFICATION
- * $Id: hio.c,v 1.12 1998/01/05 03:29:30 momjian Exp $
+ * $Id: hio.c,v 1.13 1998/01/07 21:01:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef NO_BUFFERISVALID
if (!BufferIsValid(buffer))
{
- elog(ABORT, "RelationPutHeapTuple: no buffer for %ld in %s",
+ elog(ERROR, "RelationPutHeapTuple: no buffer for %ld in %s",
blockIndex, &relation->rd_rel->relname);
}
#endif
PageInit(pageHeader, BufferGetPageSize(buffer), 0);
if (len > PageGetFreeSpace(pageHeader))
- elog(ABORT, "Tuple is too big: size %d", len);
+ elog(ERROR, "Tuple is too big: size %d", len);
}
offnum = PageAddItem((Page) pageHeader, (Item) tuple,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.10 1998/01/05 03:29:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.11 1998/01/07 21:01:35 momjian Exp $
*
* NOTES
* many of the old access method routines have been turned into
IndexScanDesc scan;
if (!RelationIsValid(relation))
- elog(ABORT, "RelationGetIndexScan: relation invalid");
+ elog(ERROR, "RelationGetIndexScan: relation invalid");
scan = (IndexScanDesc) palloc(sizeof(IndexScanDescData));
ScanKey key)
{
if (!IndexScanIsValid(scan))
- elog(ABORT, "IndexScanRestart: invalid scan");
+ elog(ERROR, "IndexScanRestart: invalid scan");
ItemPointerSetInvalid(&scan->previousItemData);
ItemPointerSetInvalid(&scan->currentItemData);
IndexScanEnd(IndexScanDesc scan)
{
if (!IndexScanIsValid(scan))
- elog(ABORT, "IndexScanEnd: invalid scan");
+ elog(ERROR, "IndexScanEnd: invalid scan");
pfree(scan);
}
IndexScanRestorePosition(IndexScanDesc scan)
{
if (scan->flags & ScanUnmarked)
- elog(ABORT, "IndexScanRestorePosition: no mark to restore");
+ elog(ERROR, "IndexScanRestorePosition: no mark to restore");
scan->previousItemData = scan->previousMarkData;
scan->currentItemData = scan->currentMarkData;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.18 1998/01/05 03:29:34 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.19 1998/01/07 21:01:42 momjian Exp $
*
* INTERFACE ROUTINES
* index_open - open an index relation by relationId
#define GET_REL_PROCEDURE(x,y) \
procedure = relation->rd_am->y; \
if (! RegProcedureIsValid(procedure)) \
- elog(ABORT, "index_%s: invalid %s regproc", \
+ elog(ERROR, "index_%s: invalid %s regproc", \
CppAsString(x), CppAsString(y))
#define GET_SCAN_PROCEDURE(x,y) \
procedure = scan->relation->rd_am->y; \
if (! RegProcedureIsValid(procedure)) \
- elog(ABORT, "index_%s: invalid %s regproc", \
+ elog(ERROR, "index_%s: invalid %s regproc", \
CppAsString(x), CppAsString(y))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.14 1998/01/05 03:29:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.15 1998/01/07 21:01:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
if (!StrategyNumberIsValid(strategy))
{
- elog(ABORT, "RelationGetStrategy: corrupted evaluation");
+ elog(ERROR, "RelationGetStrategy: corrupted evaluation");
}
}
}
}
- elog(ABORT, "RelationInvokeStrategy: cannot evaluate strategy %d",
+ elog(ERROR, "RelationInvokeStrategy: cannot evaluate strategy %d",
strategy);
/* not reached, just to make compiler happy */
tuple = heap_getnext(scan, false, (Buffer *) NULL);
if (!HeapTupleIsValid(tuple))
{
- elog(ABORT, "OperatorObjectIdFillScanKeyEntry: unknown operator %lu",
+ elog(ERROR, "OperatorObjectIdFillScanKeyEntry: unknown operator %lu",
(uint32) operatorObjectId);
}
if (!RegProcedureIsValid(entry->sk_procedure))
{
- elog(ABORT,
+ elog(ERROR,
"OperatorObjectIdFillScanKeyEntry: no procedure for operator %lu",
(uint32) operatorObjectId);
}
scan = heap_beginscan(relation, false, false, 1, entry);
tuple = heap_getnext(scan, 0, (Buffer *) NULL);
if (!HeapTupleIsValid(tuple))
- elog(ABORT, "IndexSupportInitialize: corrupted catalogs");
+ elog(ERROR, "IndexSupportInitialize: corrupted catalogs");
/*
* XXX note that the following assumes the INDEX tuple is well formed
{
if (attributeIndex == 0)
{
- elog(ABORT, "IndexSupportInitialize: no pg_index tuple");
+ elog(ERROR, "IndexSupportInitialize: no pg_index tuple");
}
break;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.23 1998/01/05 03:29:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.24 1998/01/07 21:01:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
htup = heap_fetch(heapRel, true, &(itup->t_tid), NULL);
if (htup != (HeapTuple) NULL)
{ /* it is a duplicate */
- elog(ABORT, "Cannot insert a duplicate key into a unique index");
+ elog(ERROR, "Cannot insert a duplicate key into a unique index");
}
/* get next offnum */
if (offset < maxoff)
* if(IndexTupleDSize(newItem->bti_itup) >
* IndexTupleDSize(item->bti_itup)) { elog(NOTICE, "trying to
* overwrite a smaller value with a bigger one in _bt_updateitem");
- * elog(ABORT, "this is not good."); }
+ * elog(ERROR, "this is not good."); }
*/
oldIndexTuple = &(item->bti_itup);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.14 1998/01/05 03:29:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.15 1998/01/07 21:01:53 momjian Exp $
*
* NOTES
* Postgres btree pages look like ordinary relation pages. The opaque
if ((nblocks = RelationGetNumberOfBlocks(rel)) != 0)
{
- elog(ABORT, "Cannot initialize non-empty btree %s",
+ elog(ERROR, "Cannot initialize non-empty btree %s",
RelationGetRelationName(rel));
}
op = (BTPageOpaque) PageGetSpecialPointer(metap);
if (!(op->btpo_flags & BTP_META))
{
- elog(ABORT, "Invalid metapage for index %s",
+ elog(ERROR, "Invalid metapage for index %s",
RelationGetRelationName(rel));
}
metad = BTPageGetMeta(metap);
if (metad->btm_magic != BTREE_MAGIC)
{
- elog(ABORT, "Index %s is not a btree",
+ elog(ERROR, "Index %s is not a btree",
RelationGetRelationName(rel));
}
if (metad->btm_version != BTREE_VERSION)
{
- elog(ABORT, "Version mismatch on %s: version %d file, version %d code",
+ elog(ERROR, "Version mismatch on %s: version %d file, version %d code",
RelationGetRelationName(rel),
metad->btm_version, BTREE_VERSION);
}
if (metad->btm_magic != BTREE_MAGIC)
{
- elog(ABORT, "Index %s is not a btree",
+ elog(ERROR, "Index %s is not a btree",
RelationGetRelationName(rel));
}
if (metad->btm_version != BTREE_VERSION)
{
- elog(ABORT, "Version mismatch on %s: version %d file, version %d code",
+ elog(ERROR, "Version mismatch on %s: version %d file, version %d code",
RelationGetRelationName(rel),
metad->btm_version, BTREE_VERSION);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtscan.c,v 1.11 1998/01/05 03:29:52 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtscan.c,v 1.12 1998/01/07 21:01:54 momjian Exp $
*
*
* NOTES
}
if (chk == (BTScanList) NULL)
- elog(ABORT, "btree scan list trashed; can't find 0x%lx", scan);
+ elog(ERROR, "btree scan list trashed; can't find 0x%lx", scan);
if (last == (BTScanList) NULL)
BTScans = chk->btsl_next;
_bt_step(scan, &buf, BackwardScanDirection);
break;
default:
- elog(ABORT, "_bt_scandel: bad operation '%d'", op);
+ elog(ERROR, "_bt_scandel: bad operation '%d'", op);
/* NOTREACHED */
}
so->btso_curbuf = buf;
_bt_step(scan, &buf, BackwardScanDirection);
break;
default:
- elog(ABORT, "_bt_scandel: bad operation '%d'", op);
+ elog(ERROR, "_bt_scandel: bad operation '%d'", op);
/* NOTREACHED */
}
so->btso_mrkbuf = buf;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.28 1998/01/05 03:29:53 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.29 1998/01/07 21:01:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
if (!P_RIGHTMOST(opaque))
{
- elog(ABORT, "_bt_compare: invalid comparison to high key");
+ elog(ERROR, "_bt_compare: invalid comparison to high key");
}
#if 0
/* _bt_orderkeys disallows it, but it's place to add some code latter */
if (so->keyData[0].sk_flags & SK_ISNULL)
{
- elog(ABORT, "_bt_first: btree doesn't support is(not)null, yet");
+ elog(ERROR, "_bt_first: btree doesn't support is(not)null, yet");
return ((RetrieveIndexResult) NULL);
}
proc = index_getprocid(rel, 1, BTORDER_PROC);
* us up less often since they're only done by the vacuum daemon.
*/
- elog(ABORT, "btree synchronization error: concurrent update botched scan");
+ elog(ERROR, "btree synchronization error: concurrent update botched scan");
return (false);
}
if (ScanDirectionIsForward(dir))
{
if (!P_LEFTMOST(opaque))/* non-leftmost page ? */
- elog(ABORT, "_bt_endpoint: leftmost page (%u) has not leftmost flag", blkno);
+ elog(ERROR, "_bt_endpoint: leftmost page (%u) has not leftmost flag", blkno);
start = P_RIGHTMOST(opaque) ? P_HIKEY : P_FIRSTKEY;
/*
if (PageIsEmpty(page))
{
if (start != P_HIKEY) /* non-rightmost page */
- elog(ABORT, "_bt_endpoint: non-rightmost page (%u) is empty", blkno);
+ elog(ERROR, "_bt_endpoint: non-rightmost page (%u) is empty", blkno);
/*
* It's left- & right- most page - root page, - and it's
}
else
{
- elog(ABORT, "Illegal scan direction %d", dir);
+ elog(ERROR, "Illegal scan direction %d", dir);
}
btitem = (BTItem) PageGetItem(page, PageGetItemId(page, start));
*
*
* IDENTIFICATION
- * $Id: nbtsort.c,v 1.25 1998/01/05 03:29:55 momjian Exp $
+ * $Id: nbtsort.c,v 1.26 1998/01/07 21:01:59 momjian Exp $
*
* NOTES
*
if (_bt_inspool->isunique && !equal_isnull)
{
_bt_spooldestroy((void *) _bt_inspool);
- elog(ABORT, "Cannot create unique index. Table contains non-unique values");
+ elog(ERROR, "Cannot create unique index. Table contains non-unique values");
}
return (0); /* 1 = 2 */
}
if (q->btpq_nelem >= MAXELEM)
{
- elog(ABORT, "_bt_pqadd: queue overflow");
+ elog(ERROR, "_bt_pqadd: queue overflow");
}
child = q->btpq_nelem++;
if (tape == (BTTapeBlock *) NULL)
{
- elog(ABORT, "_bt_tapecreate: out of memory");
+ elog(ERROR, "_bt_tapecreate: out of memory");
}
tape->bttb_magic = BTTAPEMAGIC;
if (btspool == (BTSpool *) NULL || fname == (char *) NULL)
{
- elog(ABORT, "_bt_spoolinit: out of memory");
+ elog(ERROR, "_bt_spoolinit: out of memory");
}
MemSet((char *) btspool, 0, sizeof(BTSpool));
btspool->bts_ntapes = ntapes;
if (btspool->bts_itape == (BTTapeBlock **) NULL ||
btspool->bts_otape == (BTTapeBlock **) NULL)
{
- elog(ABORT, "_bt_spoolinit: out of memory");
+ elog(ERROR, "_bt_spoolinit: out of memory");
}
for (i = 0; i < ntapes; ++i)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.16 1998/01/05 03:29:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.17 1998/01/07 21:02:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
cur = &key[0];
if (cur->sk_attno != 1)
- elog(ABORT, "_bt_orderkeys: key(s) for attribute 1 missed");
+ elog(ERROR, "_bt_orderkeys: key(s) for attribute 1 missed");
if (numberOfKeys == 1)
{
{
if (cur->sk_attno != attno + 1 && i < numberOfKeys)
{
- elog(ABORT, "_bt_orderkeys: key(s) for attribute %d missed", attno + 1);
+ elog(ERROR, "_bt_orderkeys: key(s) for attribute %d missed", attno + 1);
}
/*
/*
* see comments in btbuild
*
- * if (itup->t_info & INDEX_NULL_MASK) elog(ABORT, "btree indices cannot
+ * if (itup->t_info & INDEX_NULL_MASK) elog(ERROR, "btree indices cannot
* include null keys");
*/
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtproc.c,v 1.14 1998/01/07 18:46:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtproc.c,v 1.15 1998/01/07 21:02:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
BOX *n;
if ((n = (BOX *) palloc(sizeof(*n))) == (BOX *) NULL)
- elog(ABORT, "Cannot allocate box for union");
+ elog(ERROR, "Cannot allocate box for union");
n->high.x = Max(a->high.x, b->high.x);
n->high.y = Max(a->high.y, b->high.y);
BOX *n;
if ((n = (BOX *) palloc(sizeof(*n))) == (BOX *) NULL)
- elog(ABORT, "Cannot allocate box for union");
+ elog(ERROR, "Cannot allocate box for union");
n->high.x = Min(a->high.x, b->high.x);
n->high.y = Min(a->high.y, b->high.y);
p = (POLYGON *) palloc(sizeof(POLYGON));
if (!PointerIsValid(p))
- elog(ABORT, "Cannot allocate polygon for union");
+ elog(ERROR, "Cannot allocate polygon for union");
MemSet((char *) p, 0, sizeof(POLYGON)); /* zero any holes */
p->size = sizeof(POLYGON);
p = (POLYGON *) palloc(sizeof(POLYGON));
if (!PointerIsValid(p))
- elog(ABORT, "Cannot allocate polygon for intersection");
+ elog(ERROR, "Cannot allocate polygon for intersection");
MemSet((char *) p, 0, sizeof(POLYGON)); /* zero any holes */
p->size = sizeof(POLYGON);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.20 1998/01/05 03:30:02 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.21 1998/01/07 21:02:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
if (oldPred == NULL && (nb = RelationGetNumberOfBlocks(index)) != 0)
- elog(ABORT, "%s already contains data", index->rd_rel->relname.data);
+ elog(ERROR, "%s already contains data", index->rd_rel->relname.data);
/* initialize the root page (if this is a new index) */
if (oldPred == NULL)
*/
if (IndexTupleSize(old) != IndexTupleSize(ltup))
- elog(ABORT, "Variable-length rtree keys are not supported.");
+ elog(ERROR, "Variable-length rtree keys are not supported.");
/* install pointer to left child */
memmove(old, ltup, IndexTupleSize(ltup));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.14 1998/01/05 03:30:05 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.15 1998/01/07 21:02:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (!IndexScanIsValid(s))
{
- elog(ABORT, "rtrescan: invalid scan.");
+ elog(ERROR, "rtrescan: invalid scan.");
return;
}
}
if (l == (RTScanList) NULL)
- elog(ABORT, "rtree scan list corrupted -- cannot find 0x%lx", s);
+ elog(ERROR, "rtree scan list corrupted -- cannot find 0x%lx", s);
if (prev == (RTScanList) NULL)
RTScans = l->rtsl_next;
break;
default:
- elog(ABORT, "Bad operation in rtree scan adjust: %d", op);
+ elog(ERROR, "Bad operation in rtree scan adjust: %d", op);
}
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.15 1998/01/05 03:30:07 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.16 1998/01/07 21:02:17 momjian Exp $
*
* NOTES
* This file contains the high level access-method interface to the
* here the block didn't contain the information we wanted
* ----------------
*/
- elog(ABORT, "TransactionLogTest: failed to get xidstatus");
+ elog(ERROR, "TransactionLogTest: failed to get xidstatus");
/*
* so lint is happy...
*/
TransGetLastRecordedTransaction(logRelation, logLastXid, &fail);
if (fail == true)
- elog(ABORT, "TransRecover: failed TransGetLastRecordedTransaction");
+ elog(ERROR, "TransRecover: failed TransGetLastRecordedTransaction");
/* ----------------
* next get the "last" and "next" variables
* ----------------
*/
if (TransactionIdIsLessThan(varNextXid, logLastXid))
- elog(ABORT, "TransRecover: varNextXid < logLastXid");
+ elog(ERROR, "TransRecover: varNextXid < logLastXid");
/* ----------------
* intregity test (2)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/transsup.c,v 1.15 1998/01/05 03:30:10 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/transsup.c,v 1.16 1998/01/07 21:02:19 momjian Exp $
*
* NOTES
* This file contains support functions for the high
if (relation == LogRelation)
itemsPerBlock = TP_NumXidStatusPerBlock;
else
- elog(ABORT, "TransComputeBlockNumber: unknown relation");
+ elog(ERROR, "TransComputeBlockNumber: unknown relation");
/* ----------------
* warning! if the transaction id's get too large
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/varsup.c,v 1.14 1998/01/05 03:30:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/varsup.c,v 1.15 1998/01/07 21:02:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (!BufferIsValid(buf))
{
SpinRelease(OidGenLockId);
- elog(ABORT, "VariableRelationGetNextXid: ReadBuffer failed");
+ elog(ERROR, "VariableRelationGetNextXid: ReadBuffer failed");
}
var = (VariableRelationContents) BufferGetBlock(buf);
if (!BufferIsValid(buf))
{
SpinRelease(OidGenLockId);
- elog(ABORT, "VariableRelationPutNextXid: ReadBuffer failed");
+ elog(ERROR, "VariableRelationPutNextXid: ReadBuffer failed");
}
var = (VariableRelationContents) BufferGetBlock(buf);
if (!BufferIsValid(buf))
{
SpinRelease(OidGenLockId);
- elog(ABORT, "VariableRelationGetNextXid: ReadBuffer failed");
+ elog(ERROR, "VariableRelationGetNextXid: ReadBuffer failed");
}
var = (VariableRelationContents) BufferGetBlock(buf);
if (!PointerIsValid(oidP))
{
SpinRelease(OidGenLockId);
- elog(ABORT, "VariableRelationPutNextOid: invalid oid pointer");
+ elog(ERROR, "VariableRelationPutNextOid: invalid oid pointer");
}
/* ----------------
if (!BufferIsValid(buf))
{
SpinRelease(OidGenLockId);
- elog(ABORT, "VariableRelationPutNextOid: ReadBuffer failed");
+ elog(ERROR, "VariableRelationPutNextOid: ReadBuffer failed");
}
var = (VariableRelationContents) BufferGetBlock(buf);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.18 1998/01/05 03:30:13 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.19 1998/01/07 21:02:24 momjian Exp $
*
* NOTES
* Transaction aborts can now occur two ways:
if (CurrentTransactionStateData.commandId == FirstCommandId)
{
CommandIdCounterOverflowFlag = true;
- elog(ABORT, "You may only have 2^32-1 commands per transaction");
+ elog(ERROR, "You may only have 2^32-1 commands per transaction");
}
CurrentTransactionStateData.scanCommandId =
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v 1.12 1998/01/06 18:51:55 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v 1.13 1998/01/07 21:02:29 momjian Exp $
*
*-------------------------------------------------------------------------
*/
LPAREN boot_tuplelist RPAREN
{
if (num_tuples_read != numattr)
- elog(ABORT,"incorrect number of values for tuple");
+ elog(ERROR,"incorrect number of values for tuple");
if (reldesc == (Relation)NULL)
{
- elog(ABORT,"must OPEN RELATION before INSERT\n");
+ elog(ERROR,"must OPEN RELATION before INSERT\n");
err_out();
}
if (DebugMode)
* Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.31 1998/01/05 03:30:18 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.32 1998/01/07 21:02:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (reldesc)
{
if (namestrcmp(RelationGetRelationName(reldesc), name) != 0)
- elog(ABORT, "closerel: close of '%s' when '%s' was expected",
+ elog(ERROR, "closerel: close of '%s' when '%s' was expected",
name, relname ? relname : "(null)");
}
else
- elog(ABORT, "closerel: close of '%s' before any relation was opened",
+ elog(ERROR, "closerel: close of '%s' before any relation was opened",
name);
}
if (reldesc == NULL)
{
- elog(ABORT, "Warning: no opened relation to close.\n");
+ elog(ERROR, "Warning: no opened relation to close.\n");
}
else
{
heap_close(rdesc);
return (gettype(type));
}
- elog(ABORT, "Error: unknown type '%s'.\n", type);
+ elog(ERROR, "Error: unknown type '%s'.\n", type);
err_out();
/* not reached, here to make compiler happy */
return 0;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.13 1998/01/05 03:31:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.14 1998/01/07 21:02:36 momjian Exp $
*
*-------------------------------------------------------------------------
*/
break;
default:
- elog(ABORT, "ExecReScan: not a seqscan or indexscan node.");
+ elog(ERROR, "ExecReScan: not a seqscan or indexscan node.");
return;
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.36 1998/01/05 03:31:06 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.37 1998/01/07 21:02:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
ObjectIdGetDatum(relid),
0, 0, 0);
if (!HeapTupleIsValid(htp))
- elog(ABORT, "ExecCheckPerms: bogus RT relid: %d",
+ elog(ERROR, "ExecCheckPerms: bogus RT relid: %d",
relid);
StrNCpy(rname.data,
((Form_pg_class) GETSTRUCT(htp))->relname.data,
opstr = "write";
break;
default:
- elog(ABORT, "ExecCheckPerms: bogus operation %d",
+ elog(ERROR, "ExecCheckPerms: bogus operation %d",
operation);
}
}
}
if (!ok)
{
- elog(ABORT, "%s: %s", rname.data, aclcheck_error_strings[aclcheck_result]);
+ elog(ERROR, "%s: %s", rname.data, aclcheck_error_strings[aclcheck_result]);
}
}
resultRelationDesc = heap_open(resultRelationOid);
if (resultRelationDesc->rd_rel->relkind == RELKIND_SEQUENCE)
- elog(ABORT, "You can't change sequence relation %s",
+ elog(ERROR, "You can't change sequence relation %s",
resultRelationDesc->rd_rel->relname.data);
/*
"ctid",
&datum,
&isNull))
- elog(ABORT, "ExecutePlan: NO (junk) `ctid' was found!");
+ elog(ERROR, "ExecutePlan: NO (junk) `ctid' was found!");
if (isNull)
- elog(ABORT, "ExecutePlan: (junk) `ctid' is NULL!");
+ elog(ERROR, "ExecutePlan: (junk) `ctid' is NULL!");
tupleid = (ItemPointer) DatumGetPointer(datum);
tuple_ctid = *tupleid; /* make sure we don't free the
for (attrChk = 1; attrChk <= rel->rd_att->natts; attrChk++)
{
if (rel->rd_att->attrs[attrChk - 1]->attnotnull && heap_attisnull(tuple, attrChk))
- elog(ABORT, "%s: Fail to add null value in not null attribute %s",
+ elog(ERROR, "%s: Fail to add null value in not null attribute %s",
caller, rel->rd_att->attrs[attrChk - 1]->attname.data);
}
}
char *failed;
if ((failed = ExecRelCheck(rel, tuple)) != NULL)
- elog(ABORT, "%s: rejected due to CHECK constraint %s", caller, failed);
+ elog(ERROR, "%s: rejected due to CHECK constraint %s", caller, failed);
}
return (newtuple);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execProcnode.c,v 1.6 1998/01/05 03:31:08 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execProcnode.c,v 1.7 1998/01/07 21:02:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return ExecCountSlotsTee((Tee *) node);
default:
- elog(ABORT, "ExecCountSlotsNode: node not yet supported: %d",
+ elog(ERROR, "ExecCountSlotsNode: node not yet supported: %d",
nodeTag(node));
break;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.21 1998/01/05 03:31:11 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.22 1998/01/07 21:02:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return (Datum) NULL;
}
if (i != j)
- elog(ABORT,
+ elog(ERROR,
"ExecEvalArrayRef: upper and lower indices mismatch");
lIndex = lower.indx;
}
*/
if (strcmp(paramList->name, thisParameterName) != 0)
{
- elog(ABORT,
+ elog(ERROR,
"ExecEvalParam: new/old params with same id & diff names");
}
}
/*
* oops! this is not supposed to happen!
*/
- elog(ABORT, "ExecEvalParam: invalid paramkind %d",
+ elog(ERROR, "ExecEvalParam: invalid paramkind %d",
thisParameterKind);
}
if (!matchFound)
* ooops! we couldn't find this parameter in the parameter list.
* Signal an error
*/
- elog(ABORT, "ExecEvalParam: Unknown value for parameter %s",
+ elog(ERROR, "ExecEvalParam: Unknown value for parameter %s",
thisParameterName);
}
Datum retval;
if (!AttributeNumberIsValid(attrno))
- elog(ABORT, "GetAttributeByNum: Invalid attribute number");
+ elog(ERROR, "GetAttributeByNum: Invalid attribute number");
if (!AttrNumberIsForUserDefinedAttr(attrno))
- elog(ABORT, "GetAttributeByNum: cannot access system attributes here");
+ elog(ERROR, "GetAttributeByNum: cannot access system attributes here");
if (isNull == (bool *) NULL)
- elog(ABORT, "GetAttributeByNum: a NULL isNull flag was passed");
+ elog(ERROR, "GetAttributeByNum: a NULL isNull flag was passed");
if (TupIsNull(slot))
{
int i;
if (attname == NULL)
- elog(ABORT, "GetAttributeByName: Invalid attribute name");
+ elog(ERROR, "GetAttributeByName: Invalid attribute name");
if (isNull == (bool *) NULL)
- elog(ABORT, "GetAttributeByName: a NULL isNull flag was passed");
+ elog(ERROR, "GetAttributeByName: a NULL isNull flag was passed");
if (TupIsNull(slot))
{
}
if (attrno == InvalidAttrNumber)
- elog(ABORT, "GetAttributeByName: attribute %s not found", attname);
+ elog(ERROR, "GetAttributeByName: attribute %s not found", attname);
retval = heap_getattr(slot->val,
slot->ttc_buffer,
bool argDone;
if (fcache->nargs > MAXFMGRARGS)
- elog(ABORT, "ExecMakeFunctionResult: too many arguments");
+ elog(ERROR, "ExecMakeFunctionResult: too many arguments");
/*
* If the setArg in the fcache is set we have an argument
retDatum = (Datum) ExecEvalNot(expr, econtext, isNull);
break;
default:
- elog(ABORT, "ExecEvalExpr: unknown expression type");
+ elog(ERROR, "ExecEvalExpr: unknown expression type");
break;
}
break;
}
default:
- elog(ABORT, "ExecEvalExpr: unknown expression type");
+ elog(ERROR, "ExecEvalExpr: unknown expression type");
break;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execTuples.c,v 1.14 1998/01/05 03:31:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execTuples.c,v 1.15 1998/01/07 21:02:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* table->size = newsize;
*/
elog(NOTICE, "Plan requires more slots than are available");
- elog(ABORT, "send mail to your local executor guru to fix this");
+ elog(ERROR, "send mail to your local executor guru to fix this");
}
/* ----------------
* should never get here
* ----------------
*/
- elog(ABORT, "NodeGetResultTupleSlot: node not yet supported: %d ",
+ elog(ERROR, "NodeGetResultTupleSlot: node not yet supported: %d ",
nodeTag(node));
return NULL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.22 1998/01/05 03:31:13 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.23 1998/01/07 21:02:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
att = typeInfo[index];
if (att == NULL)
- elog(ABORT, "ExecSetTypeInfo: trying to assign through NULL");
+ elog(ERROR, "ExecSetTypeInfo: trying to assign through NULL");
/* ----------------
* assign values to the tuple descriptor, being careful not
heap_close(rd);
}
else
- elog(ABORT, "setVarAttrLenForCreateTable: can't get length for variable-length field");
+ elog(ERROR, "setVarAttrLenForCreateTable: can't get length for variable-length field");
}
tl = lnext(tl);
}
ObjectIdGetDatum(agg->basetype),
0, 0);
if (!HeapTupleIsValid(aggTuple))
- elog(ABORT, "ExecAgg: cache lookup failed for aggregate \"%s\"(%s)",
+ elog(ERROR, "ExecAgg: cache lookup failed for aggregate \"%s\"(%s)",
aggname,
typeidTypeName(agg->basetype));
aggp = (Form_pg_aggregate) GETSTRUCT(aggTuple);
* ------------------------------------------
*/
if (isNull2)
- elog(ABORT, "ExecAgg: agginitval2 is null");
+ elog(ERROR, "ExecAgg: agginitval2 is null");
}
if (OidIsValid(xfn1_oid))
&isNull, &isDone);
break;
default:
- elog(ABORT, "ExecAgg: Bad Agg->Target for Agg %d", i);
+ elog(ERROR, "ExecAgg: Bad Agg->Target for Agg %d", i);
}
if (isNull && !aggregates[i]->usenulls)
break;
default:
- elog(ABORT, "ExecAgg: Bad Agg->Target for Agg %d", i);
+ elog(ERROR, "ExecAgg: Bad Agg->Target for Agg %d", i);
}
if (attlen == -1)
{
args[0] = (char *) value2[i];
}
else
- elog(ABORT, "ExecAgg: no valid transition functions??");
+ elog(ERROR, "ExecAgg: no valid transition functions??");
value1[i] =
(Datum) fmgr_c(aggfns->finalfn, aggfns->finalfn_oid,
aggfns->finalfn_nargs, (FmgrValues *) args,
value1[i] = value2[i];
}
else
- elog(ABORT, "ExecAgg: no valid transition functions??");
+ elog(ERROR, "ExecAgg: no valid transition functions??");
}
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeHash.c,v 1.14 1998/01/05 03:31:16 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeHash.c,v 1.15 1998/01/07 21:02:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
hashtable = node->hashtable;
if (hashtable == NULL)
- elog(ABORT, "ExecHash: hash table is NULL.");
+ elog(ERROR, "ExecHash: hash table is NULL.");
nbatch = hashtable->nbatch;
if (hashtable == NULL)
{
- elog(ABORT, "not enough memory for hashjoin.");
+ elog(ERROR, "not enough memory for hashjoin.");
}
/* ----------------
* initialize the hash table header
if (hashtable == NULL)
{
perror("repalloc");
- elog(ABORT, "can't expand hashtable.");
+ elog(ERROR, "can't expand hashtable.");
}
#else
/* ------------------
* - Chris Dunlop, <chris@onthe.net.au>
* ------------------
*/
- elog(ABORT, "hash table out of memory. Use -B parameter to increase buffers.");
+ elog(ERROR, "hash table out of memory. Use -B parameter to increase buffers.");
#endif
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeIndexscan.c,v 1.12 1998/01/05 03:31:18 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeIndexscan.c,v 1.13 1998/01/07 21:02:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
op = (Oper *) clause->oper;
if (!IsA(op, Oper))
- elog(ABORT, "ExecInitIndexScan: op not an Oper!");
+ elog(ERROR, "ExecInitIndexScan: op not an Oper!");
opid = op->opid;
* ----------------
*/
if (scanvar == LEFT_OP)
- elog(ABORT, "ExecInitIndexScan: %s",
+ elog(ERROR, "ExecInitIndexScan: %s",
"both left and right op's are rel-vars");
/* ----------------
* ----------------
*/
if (scanvar == LEFT_OP)
- elog(ABORT, "ExecInitIndexScan: %s",
+ elog(ERROR, "ExecInitIndexScan: %s",
"both left and right ops are rel-vars");
varattno = 1;
* ----------------
*/
if (scanvar == NO_OP)
- elog(ABORT, "ExecInitIndexScan: %s",
+ elog(ERROR, "ExecInitIndexScan: %s",
"neither leftop nor rightop refer to scan relation");
/* ----------------
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeSort.c,v 1.11 1998/01/05 03:31:20 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeSort.c,v 1.12 1998/01/07 21:02:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* ----------------
*/
if (keycount <= 0)
- elog(ABORT, "FormSortKeys: keycount <= 0");
+ elog(ERROR, "FormSortKeys: keycount <= 0");
sortkeys = (ScanKey) palloc(keycount * sizeof(ScanKeyData));
/* ----------------
* ExecEndTee
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/Attic/nodeTee.c,v 1.14 1998/01/05 03:31:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/Attic/nodeTee.c,v 1.15 1998/01/07 21:02:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
else
{
- elog(ABORT, "A Tee node can only be executed from its left or right parent\n");
+ elog(ERROR, "A Tee node can only be executed from its left or right parent\n");
return NULL;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/lib/stringinfo.c,v 1.8 1998/01/07 15:32:19 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/lib/stringinfo.c,v 1.9 1998/01/07 21:03:04 momjian Exp $
*
*-------------------------------------------------------------------------
*/
res = (StringInfo) palloc(sizeof(StringInfoData));
if (res == NULL)
{
- elog(ABORT, "makeStringInfo: Out of memory!");
+ elog(ERROR, "makeStringInfo: Out of memory!");
}
size = 100;
res->data = palloc(size);
if (res->data == NULL)
{
- elog(ABORT,
+ elog(ERROR,
"makeStringInfo: Out of memory! (%ld bytes requested)", size);
}
res->maxlen = size;
s = palloc(newlen);
if (s == NULL)
{
- elog(ABORT,
+ elog(ERROR,
"appendStringInfo: Out of memory (%d bytes requested)",
newlen);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/libpq/be-fsstubs.c,v 1.18 1998/01/05 03:31:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/libpq/be-fsstubs.c,v 1.19 1998/01/07 21:03:12 momjian Exp $
*
* NOTES
* This should be moved to a more appropriate place. It is here
if (fd >= MAX_LOBJ_FDS)
{
- elog(ABORT, "lo_close: large obj descriptor (%d) out of range", fd);
+ elog(ERROR, "lo_close: large obj descriptor (%d) out of range", fd);
return -2;
}
if (cookies[fd] == NULL)
{
- elog(ABORT, "lo_close: invalid large obj descriptor (%d)", fd);
+ elog(ERROR, "lo_close: invalid large obj descriptor (%d)", fd);
return -3;
}
#if FSDB
if (fd >= MAX_LOBJ_FDS)
{
- elog(ABORT, "lo_seek: large obj descriptor (%d) out of range", fd);
+ elog(ERROR, "lo_seek: large obj descriptor (%d) out of range", fd);
return -2;
}
{
if (fd >= MAX_LOBJ_FDS)
{
- elog(ABORT, "lo_tell: large object descriptor (%d) out of range", fd);
+ elog(ERROR, "lo_tell: large object descriptor (%d) out of range", fd);
return -2;
}
if (cookies[fd] == NULL)
{
- elog(ABORT, "lo_tell: invalid large object descriptor (%d)", fd);
+ elog(ERROR, "lo_tell: invalid large object descriptor (%d)", fd);
return -3;
}
return inv_tell(cookies[fd]);
fd = open(fnamebuf, O_RDONLY, 0666);
if (fd < 0)
{ /* error */
- elog(ABORT, "be_lo_import: can't open unix file\"%s\"\n",
+ elog(ERROR, "be_lo_import: can't open unix file\"%s\"\n",
fnamebuf);
}
lobj = inv_create(INV_READ | INV_WRITE);
if (lobj == NULL)
{
- elog(ABORT, "lo_import: can't create inv object for \"%s\"",
+ elog(ERROR, "lo_import: can't create inv object for \"%s\"",
fnamebuf);
}
tmp = inv_write(lobj, buf, nbytes);
if (tmp < nbytes)
{
- elog(ABORT, "lo_import: error while reading \"%s\"",
+ elog(ERROR, "lo_import: error while reading \"%s\"",
fnamebuf);
}
}
lobj = inv_open(lobjId, INV_READ);
if (lobj == NULL)
{
- elog(ABORT, "lo_export: can't open inv object %d",
+ elog(ERROR, "lo_export: can't open inv object %d",
lobjId);
}
umask(oumask);
if (fd < 0)
{ /* error */
- elog(ABORT, "lo_export: can't open unix file\"%s\"",
+ elog(ERROR, "lo_export: can't open unix file\"%s\"",
fnamebuf);
}
tmp = write(fd, buf, nbytes);
if (tmp < nbytes)
{
- elog(ABORT, "lo_export: error while writing \"%s\"",
+ elog(ERROR, "lo_export: error while writing \"%s\"",
fnamebuf);
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/libpq/Attic/be-pqexec.c,v 1.12 1998/01/05 03:31:28 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/libpq/Attic/be-pqexec.c,v 1.13 1998/01/07 21:03:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
else if (args[i].len > sizeof(int4))
{
- elog(ABORT, "arg_length of argument %d too long", i);
+ elog(ERROR, "arg_length of argument %d too long", i);
}
else
{
* If a query is does not return tuples, return "C query-command".
* If there is an error: return "E error-message".
*
- * Note: if we get a serious error or an elog(ABORT), then PQexec never
+ * Note: if we get a serious error or an elog(ERROR), then PQexec never
* returns because the system longjmp's back to the main loop.
* ----------------
*/
case 'P':
a = PQparray(&res[1]);
if (a == NULL)
- elog(ABORT, "pqtest_PQexec: PQparray could not find portal %s",
+ elog(ERROR, "pqtest_PQexec: PQparray could not find portal %s",
res);
t = PQntuples(a);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/libpq/pqcomm.c,v 1.32 1998/01/05 03:31:30 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/libpq/pqcomm.c,v 1.33 1998/01/07 21:03:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
(struct sockaddr *) & port->raddr,
&addrlen)) < 0)
{
- elog(ABORT, "postmaster: StreamConnection: accept: %m");
+ elog(ERROR, "postmaster: StreamConnection: accept: %m");
return (STATUS_ERROR);
}
if (getsockname(port->sock, (struct sockaddr *) & port->laddr,
&addrlen) < 0)
{
- elog(ABORT, "postmaster: StreamConnection: getsockname: %m");
+ elog(ERROR, "postmaster: StreamConnection: getsockname: %m");
return (STATUS_ERROR);
}
if (family == AF_INET)
pe = getprotobyname("TCP");
if (pe == NULL)
{
- elog(ABORT, "postmaster: getprotobyname failed");
+ elog(ERROR, "postmaster: getprotobyname failed");
return (STATUS_ERROR);
}
if (setsockopt(port->sock, pe->p_proto, TCP_NODELAY,
&on, sizeof(on)) < 0)
{
- elog(ABORT, "postmaster: setsockopt failed");
+ elog(ERROR, "postmaster: setsockopt failed");
return (STATUS_ERROR);
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.11 1998/01/05 03:31:34 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.12 1998/01/07 21:03:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return (true);
break;
default:
- elog(ABORT, "_equalParam: Invalid paramkind value: %d",
+ elog(ERROR, "_equalParam: Invalid paramkind value: %d",
a->paramkind);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.9 1998/01/05 03:31:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.10 1998/01/07 21:03:29 momjian Exp $
*
* NOTES
* XXX a few of the following functions are duplicated to handle
if (l2 == NIL)
return l1;
if (l1 == l2)
- elog(ABORT, "tryout to nconc a list to itself");
+ elog(ERROR, "tryout to nconc a list to itself");
for (temp = l1; lnext(temp) != NULL; temp = lnext(temp))
;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/read.c,v 1.9 1998/01/07 15:32:31 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/read.c,v 1.10 1998/01/07 21:03:34 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
make_dotted_pair_cell = true;
break;
default:
- elog(ABORT, "nodeRead: Bad type %d", type);
+ elog(ERROR, "nodeRead: Bad type %d", type);
break;
}
if (make_dotted_pair_cell)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.16 1998/01/07 08:08:02 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.17 1998/01/07 21:03:37 momjian Exp $
*
* NOTES
* Most of the read functions for plan nodes are tested. (In fact, they
}
else
{
- elog(ABORT, "badly formatted planstring \"%.10s\"...\n", token);
+ elog(ERROR, "badly formatted planstring \"%.10s\"...\n", token);
}
return ((Node *) return_value);
{
if (length > sizeof(Datum))
{
- elog(ABORT, "readValue: byval & length = %d", length);
+ elog(ERROR, "readValue: byval & length = %d", length);
}
s = (char *) (&res);
for (i = 0; i < sizeof(Datum); i++)
token = lsptok(NULL, &tokenLength); /* skip the ']' */
if (token[0] != ']')
{
- elog(ABORT, "readValue: ']' expected, length =%d", length);
+ elog(ERROR, "readValue: ']' expected, length =%d", length);
}
return (res);
* geqo_erx.c--
* edge recombination crossover [ER]
*
-* $Id: geqo_erx.c,v 1.6 1998/01/05 03:31:48 momjian Exp $
+* $Id: geqo_erx.c,v 1.7 1998/01/07 21:03:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
minimum_count = 1;
}
else if (minimum_count == -1)
- elog(ABORT, "gimme_gene: Internal error - minimum_count not set");
+ elog(ERROR, "gimme_gene: Internal error - minimum_count not set");
else if (edge_table[(int) friend].unused_edges == minimum_edges)
minimum_count++;
}
/* ... should never be reached */
- elog(ABORT, "gimme_gene: neither shared nor minimum number nor random edge found");
+ elog(ERROR, "gimme_gene: neither shared nor minimum number nor random edge found");
return 0; /* to keep the compiler quiet */
}
/* ... should never be reached */
- elog(ABORT, "edge_failure: no edge detected");
+ elog(ERROR, "edge_failure: no edge detected");
return 0; /* to keep the compiler quiet */
}
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: geqo_eval.c,v 1.16 1998/01/05 03:31:49 momjian Exp $
+ * $Id: geqo_eval.c,v 1.17 1998/01/07 21:03:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return lfirst(r);
i++;
}
- elog(ABORT, "geqo_nth: Internal error - ran off end of list");
+ elog(ERROR, "geqo_nth: Internal error - ran off end of list");
return NULL; /* to keep compiler happy */
}
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: geqo_misc.c,v 1.6 1998/01/05 03:31:51 momjian Exp $
+ * $Id: geqo_misc.c,v 1.7 1998/01/07 21:03:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
double cumulative = 0.0;
if (pool->size == 0)
- elog(ABORT, "avg_pool: pool_size of zero");
+ elog(ERROR, "avg_pool: pool_size of zero");
for (i = 0; i < pool->size; i++)
cumulative = cumulative + pool->data[i].worth;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/predmig.c,v 1.7 1998/01/05 03:31:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/predmig.c,v 1.8 1998/01/07 21:03:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* sanity check */
if ((!streamroot && laststream) ||
(streamroot && !laststream))
- elog(ABORT, "called xfunc_predmig with bad inputs");
+ elog(ERROR, "called xfunc_predmig with bad inputs");
if (streamroot)
Assert(xfunc_check_stream(streamroot));
orignode = (Stream) get_downstream(orignode))
/* empty body in for loop */ ;
if (!orignode)
- elog(ABORT, "Didn't find matching node in original stream");
+ elog(ERROR, "Didn't find matching node in original stream");
/* pull up this node as far as it should go */
{
if ((Stream) get_upstream((Stream) get_downstream(temp)) != temp)
{
- elog(ABORT, "bad pointers in stream");
+ elog(ERROR, "bad pointers in stream");
return (false);
}
if (!is_clause(temp))
{
if ((tmp = xfunc_num_relids(temp)) >= numrelids)
{
- elog(ABORT, "Joins got reordered!");
+ elog(ERROR, "Joins got reordered!");
return (false);
}
numrelids = tmp;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.10 1998/01/06 18:52:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/prune.c,v 1.11 1998/01/07 21:03:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
rel->size = compute_joinrel_size(cheapest);
}
else
- elog(ABORT, "non JoinPath called");
+ elog(ERROR, "non JoinPath called");
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.10 1998/01/05 03:31:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/xfunc.c,v 1.11 1998/01/07 21:03:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
else
{
- elog(ABORT, "Clause node of undetermined type");
+ elog(ERROR, "Clause node of undetermined type");
return (-1);
}
}
{
/* don't trust the opid in the Oper node. Use the opno. */
if (!(funcid = get_opcode(get_opno((Oper) node))))
- elog(ABORT, "Oper's function is undefined");
+ elog(ERROR, "Oper's function is undefined");
}
else
{
/* look up tuple in cache */
tupl = SearchSysCacheTuple(PROOID, ObjectIdGetDatum(funcid), 0, 0, 0);
if (!HeapTupleIsValid(tupl))
- elog(ABORT, "Cache lookup failed for procedure %d", funcid);
+ elog(ERROR, "Cache lookup failed for procedure %d", funcid);
proc = (Form_pg_proc) GETSTRUCT(tupl);
/*
PointerGetDatum(get_vartype((Var) clause)),
0, 0, 0);
if (!HeapTupleIsValid(tupl))
- elog(ABORT, "Cache lookup failed for type %d",
+ elog(ERROR, "Cache lookup failed for type %d",
get_vartype((Var) clause));
type = (TypeTupleForm) GETSTRUCT(tupl);
if (get_varattno((Var) clause) == 0)
ObjectIdGetDatum(get_opno((Oper) get_op(clause))),
0, 0, 0);
if (!HeapTupleIsValid(tupl))
- elog(ABORT, "Cache lookup failed for procedure %d",
+ elog(ERROR, "Cache lookup failed for procedure %d",
get_opno((Oper) get_op(clause)));
return (xfunc_func_width
((RegProcedure) (((OperatorTupleForm) (GETSTRUCT(tupl)))->oprcode),
}
else
{
- elog(ABORT, "Clause node of undetermined type");
+ elog(ERROR, "Clause node of undetermined type");
return (-1);
}
}
else
{
- elog(ABORT, "Clause node of undetermined type");
+ elog(ERROR, "Clause node of undetermined type");
return ((List) LispNil);
}
}
xfunc_fixvars(lfirst(tmpclause), rel, varno);
else
{
- elog(ABORT, "Clause node of undetermined type");
+ elog(ERROR, "Clause node of undetermined type");
}
}
Assert(RegProcedureIsValid(funcid));
tupl = SearchSysCacheTuple(PROOID, ObjectIdGetDatum(funcid), 0, 0, 0);
if (!HeapTupleIsValid(tupl))
- elog(ABORT, "Cache lookup failed for procedure %d", funcid);
+ elog(ERROR, "Cache lookup failed for procedure %d", 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(ABORT, "Cache lookup failed for type %d", proc->prorettype);
+ elog(ERROR, "Cache lookup failed for type %d", proc->prorettype);
type = (TypeTupleForm) GETSTRUCT(tupl);
/* if the type length is known, return that */
if (type->typlen != -1)
sanity = true; /* found a matching item to remove! */
if (!sanity)
- elog(ABORT, "xfunc_LispRemove: didn't find a match!");
+ elog(ERROR, "xfunc_LispRemove: didn't find a match!");
return (result);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.21 1998/01/05 03:31:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.22 1998/01/07 21:04:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
break;
default:
- elog(ABORT, "create_scan_node: unknown node type",
+ elog(ERROR, "create_scan_node: unknown node type",
best_path->pathtype);
break;
}
break;
default:
/* do nothing */
- elog(ABORT, "create_join_node: unknown node type",
+ elog(ERROR, "create_join_node: unknown node type",
best_path->path.pathtype);
}
temp = best_path->parent->relids;
if (temp == NULL)
- elog(ABORT, "scanrelid is empty");
+ elog(ERROR, "scanrelid is empty");
else
scan_relid = (Index) lfirsti(temp); /* ??? who takes care of
* lnext? - ay */
ObjectIdGetDatum(lfirsti(ixid)),
0, 0, 0);
if (!HeapTupleIsValid(indexTuple))
- elog(ABORT, "create_plan: index %d not found",
+ elog(ERROR, "create_plan: index %d not found",
lfirsti(ixid));
index = (IndexTupleForm) GETSTRUCT(indexTuple);
if (index->indislossy)
break;
default:
- elog(ABORT, "make_temp: unknown temp type %d", temptype);
+ elog(ERROR, "make_temp: unknown temp type %d", temptype);
}
return (retval);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.14 1998/01/05 03:32:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.15 1998/01/07 21:04:04 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (length(glc) != 0)
{
- elog(ABORT, "group attribute disappeared from target list");
+ elog(ERROR, "group attribute disappeared from target list");
}
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.19 1998/01/05 03:32:04 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.20 1998/01/07 21:04:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (rettype == InvalidOid)
return;
else
- elog(ABORT, "return type mismatch in function decl: final query is a catalog utility");
+ elog(ERROR, "return type mismatch in function decl: final query is a catalog utility");
}
/* okay, it's an ordinary query */
if (rettype == InvalidOid)
{
if (cmd == CMD_SELECT)
- elog(ABORT,
+ elog(ERROR,
"function declared with no return type, but final query is a retrieve");
else
return;
/* by here, the function is declared to return some type */
if ((typ = typeidType(rettype)) == NULL)
- elog(ABORT, "can't find return type %d for function\n", rettype);
+ elog(ERROR, "can't find return type %d for function\n", rettype);
/*
* test 3: if the function is declared to return a value, then the
* final query had better be a retrieve.
*/
if (cmd != CMD_SELECT)
- elog(ABORT, "function declared to return type %s, but final query is not a retrieve", typeTypeName(typ));
+ elog(ERROR, "function declared to return type %s, but final query is not a retrieve", typeTypeName(typ));
/*
* test 4: for base type returns, the target list should have exactly
if (typeTypeRelid(typ) == InvalidOid)
{
if (exec_tlist_length(tlist) > 1)
- elog(ABORT, "function declared to return %s returns multiple values in final retrieve", typeTypeName(typ));
+ elog(ERROR, "function declared to return %s returns multiple values in final retrieve", typeTypeName(typ));
resnode = (Resdom *) ((TargetEntry *) lfirst(tlist))->resdom;
if (resnode->restype != rettype)
- elog(ABORT, "return type mismatch in function: declared to return %s, returns %s", typeTypeName(typ), typeidTypeName(resnode->restype));
+ elog(ERROR, "return type mismatch in function: declared to return %s, returns %s", typeTypeName(typ), typeidTypeName(resnode->restype));
/* by here, base return types match */
return;
reln = heap_open(typeTypeRelid(typ));
if (!RelationIsValid(reln))
- elog(ABORT, "cannot open relation relid %d", typeTypeRelid(typ));
+ elog(ERROR, "cannot open relation relid %d", typeTypeRelid(typ));
relid = reln->rd_id;
relnatts = reln->rd_rel->relnatts;
if (exec_tlist_length(tlist) != relnatts)
- elog(ABORT, "function declared to return type %s does not retrieve (%s.*)", typeTypeName(typ), typeTypeName(typ));
+ elog(ERROR, "function declared to return type %s does not retrieve (%s.*)", typeTypeName(typ), typeTypeName(typ));
/* expect attributes 1 .. n in order */
for (i = 1; i <= relnatts; i++)
else if (IsA(thenode, Func))
tletype = (Oid) get_functype((Func *) thenode);
else
- elog(ABORT, "function declared to return type %s does not retrieve (%s.all)", typeTypeName(typ), typeTypeName(typ));
+ elog(ERROR, "function declared to return type %s does not retrieve (%s.all)", typeTypeName(typ), typeTypeName(typ));
}
else
- elog(ABORT, "function declared to return type %s does not retrieve (%s.all)", typeTypeName(typ), typeTypeName(typ));
+ elog(ERROR, "function declared to return type %s does not retrieve (%s.all)", typeTypeName(typ), typeTypeName(typ));
#endif
/* reach right in there, why don't you? */
if (tletype != reln->rd_att->attrs[i - 1]->atttypid)
- elog(ABORT, "function declared to return type %s does not retrieve (%s.all)", typeTypeName(typ), typeTypeName(typ));
+ elog(ERROR, "function declared to return type %s does not retrieve (%s.all)", typeTypeName(typ), typeTypeName(typ));
}
heap_close(reln);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.11 1998/01/05 03:32:05 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.12 1998/01/07 21:04:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
else
{
- elog(ABORT, "calling set_temp_tlist_references with empty lefttree");
+ elog(ERROR, "calling set_temp_tlist_references with empty lefttree");
}
}
/*
* Ooops! we can not handle that!
*/
- elog(ABORT, "replace_result_clause: Can not handle this tlist!\n");
+ elog(ERROR, "replace_result_clause: Can not handle this tlist!\n");
}
}
/*
* Ooops! we can not handle that!
*/
- elog(ABORT, "replace_agg_clause: Can not handle this tlist!\n");
+ elog(ERROR, "replace_agg_clause: Can not handle this tlist!\n");
}
}
/*
* Ooops! we can not handle that!
*/
- elog(ABORT, "del_agg_clause: Can not handle this tlist!\n");
+ elog(ERROR, "del_agg_clause: Can not handle this tlist!\n");
}
return NULL;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.12 1998/01/05 03:32:09 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.13 1998/01/07 21:04:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
else
{
- elog(ABORT, "RelationCatalogInformation: Relation %d not found",
+ elog(ERROR, "RelationCatalogInformation: Relation %d not found",
relationObjectId);
}
1, &indexKey);
}
if (!HeapScanIsValid(scan))
- elog(ABORT, "index_info: scan not started");
+ elog(ERROR, "index_info: scan not started");
indexTuple = heap_getnext(scan, 0, (Buffer *) NULL);
if (!HeapTupleIsValid(indexTuple))
{
UInt16GetDatum(amstrategy),
0);
if (!HeapTupleIsValid(amopTuple))
- elog(ABORT, "index_info: no amop %d %d %d",
+ elog(ERROR, "index_info: no amop %d %d %d",
relam, index->indclass[i], amstrategy);
info->orderOprs[i] =
((Form_pg_amop) GETSTRUCT(amopTuple))->amopopr;
(char *) constFlag,
NULL);
if (!PointerIsValid(result))
- elog(ABORT, "RestrictionClauseSelectivity: bad pointer");
+ elog(ERROR, "RestrictionClauseSelectivity: bad pointer");
if (*result < 0.0 || *result > 1.0)
- elog(ABORT, "RestrictionClauseSelectivity: bad value %lf",
+ elog(ERROR, "RestrictionClauseSelectivity: bad value %lf",
*result);
return ((Cost) *result);
(char *) (int) attributeNumber2,
NULL);
if (!PointerIsValid(result))
- elog(ABORT, "JoinClauseSelectivity: bad pointer");
+ elog(ERROR, "JoinClauseSelectivity: bad pointer");
if (*result < 0.0 || *result > 1.0)
- elog(ABORT, "JoinClauseSelectivity: bad value %lf",
+ elog(ERROR, "JoinClauseSelectivity: bad value %lf",
*result);
return ((Cost) *result);
ObjectIdGetDatum(indexrelid),
0, 0, 0);
if (!HeapTupleIsValid(indRel))
- elog(ABORT, "IndexSelectivity: index %d not found",
+ elog(ERROR, "IndexSelectivity: index %d not found",
indexrelid);
relam = ((Form_pg_class) GETSTRUCT(indRel))->relam;
ObjectIdGetDatum(indexrelid),
0, 0, 0);
if (!HeapTupleIsValid(indexTuple))
- elog(ABORT, "IndexSelectivity: index %d not found",
+ elog(ERROR, "IndexSelectivity: index %d not found",
indexrelid);
index = (IndexTupleForm) GETSTRUCT(indexTuple);
ObjectIdGetDatum(relam),
0);
if (!HeapTupleIsValid(amopTuple))
- elog(ABORT, "IndexSelectivity: no amop %d %d",
+ elog(ERROR, "IndexSelectivity: no amop %d %d",
indclass, operatorObjectIds[n]);
amop = (Form_pg_amop) GETSTRUCT(amopTuple);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/port/dynloader/linux.c,v 1.5 1998/01/05 03:32:39 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/port/dynloader/linux.c,v 1.6 1998/01/07 21:04:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
pg_dlopen(char *filename)
{
#ifndef HAVE_DLD_H
- elog(ABORT, "dynamic load not supported");
+ elog(ERROR, "dynamic load not supported");
return (NULL);
#else
static int dl_initialized = 0;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteDefine.c,v 1.12 1998/01/07 15:32:37 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteDefine.c,v 1.13 1998/01/07 21:04:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
eventrel = heap_openr(evobj);
if (eventrel == NULL)
{
- elog(ABORT, "rules cannot be defined on relations not in schema");
+ elog(ERROR, "rules cannot be defined on relations not in schema");
}
eventrel_oid = RelationGetRelationId(eventrel);
evqual = "<>";
if (IsDefinedRewriteRule(rulname))
- elog(ABORT, "Attempt to insert rule '%s' failed: already exists",
+ elog(ERROR, "Attempt to insert rule '%s' failed: already exists",
rulname);
strcpyq(actionbuf, actiontree);
strcpyq(qualbuf, evqual);
if (strlen(template) + strlen(rulname) + strlen(actionbuf) +
strlen(qualbuf) + 20 /* fudge fac */ > RULE_PLAN_SIZE)
{
- elog(ABORT, "DefineQueryRewrite: rule plan string too big.");
+ elog(ERROR, "DefineQueryRewrite: rule plan string too big.");
}
sprintf(rulebuf, template,
rulname, evtype, eventrel_oid, evslot_index, actionbuf,
if (((event_type == CMD_INSERT) || (event_type == CMD_DELETE)) &&
eslot_string)
{
- elog(ABORT,
+ elog(ERROR,
"rules not allowed for insert or delete events to an attribute");
}
if (event_qual && !*action && is_instead)
- elog(ABORT,
+ elog(ERROR,
"event_quals on 'instead nothing' rules not currently supported");
#if 0
event_relation = heap_openr(event_obj->relname);
if (event_relation == NULL)
{
- elog(ABORT, "virtual relations not supported yet");
+ elog(ERROR, "virtual relations not supported yet");
}
ev_relid = RelationGetRelationId(event_relation);
/* what is the max size of type text? XXX -- glass */
if (length(action) > 15)
- elog(ABORT, "max # of actions exceeded");
+ elog(ERROR, "max # of actions exceeded");
prs2_addToRelation(ev_relid, ruleId, event_type, event_attno,
is_instead, event_qual, action);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.8 1998/01/05 03:32:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.9 1998/01/07 21:04:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (++numQueryRewriteInvoked > REWRITE_INVOKE_MAX)
{
- elog(ABORT, "query rewritten %d times, may contain cycles",
+ elog(ERROR, "query rewritten %d times, may contain cycles",
numQueryRewriteInvoked - 1);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.8 1998/01/05 03:32:46 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.9 1998/01/07 21:04:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
htp = SearchSysCacheTuple(REWRITENAME, PointerGetDatum(rulename),
0, 0, 0);
if (!HeapTupleIsValid(htp))
- elog(ABORT, "RewriteGetRuleEventRel: rule \"%s\" not found",
+ elog(ERROR, "RewriteGetRuleEventRel: rule \"%s\" not found",
rulename);
eventrel = ((Form_pg_rewrite) GETSTRUCT(htp))->ev_class;
htp = SearchSysCacheTuple(RELOID, PointerGetDatum(eventrel),
0, 0, 0);
if (!HeapTupleIsValid(htp))
- elog(ABORT, "RewriteGetRuleEventRel: class %d not found",
+ elog(ERROR, "RewriteGetRuleEventRel: class %d not found",
eventrel);
return ((Form_pg_class) GETSTRUCT(htp))->relname.data;
}
if (!HeapTupleIsValid(tuple))
{
heap_close(RewriteRelation);
- elog(ABORT, "No rule with name = '%s' was found.\n", ruleName);
+ elog(ERROR, "No rule with name = '%s' was found.\n", ruleName);
}
/*
if (isNull)
{
/* XXX strange!!! */
- elog(ABORT, "RemoveRewriteRule: null event target relation!");
+ elog(ERROR, "RemoveRewriteRule: null event target relation!");
}
eventRelationOid = DatumGetObjectId(eventRelationOidDatum);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.13 1998/01/05 03:32:47 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.14 1998/01/07 21:04:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
ObjectIdGetDatum(ruleoid),
0, 0, 0);
if (ruletuple == NULL)
- elog(ABORT, "rule %u isn't in rewrite system relation", ruleoid);
+ elog(ERROR, "rule %u isn't in rewrite system relation", ruleoid);
ruleaction = (char *)heap_getattr(ruletuple,
InvalidBuffer,
if (action_is_null || instead_is_null)
{
- elog(ABORT, "internal error: rewrite rule not properly set up");
+ elog(ERROR, "internal error: rewrite rule not properly set up");
}
ruleaction = textout((struct varlena *) ruleaction);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_init.c,v 1.16 1998/01/05 03:32:51 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_init.c,v 1.17 1998/01/07 21:04:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
if (sizeof(struct sbufdesc) != PADDED_SBUFDESC_SIZE ||
sizeof(struct sbufdesc_unpadded) > PADDED_SBUFDESC_SIZE)
- elog(ABORT, "Internal error: sbufdesc does not have the proper size, "
+ elog(ERROR, "Internal error: sbufdesc does not have the proper size, "
"contact the Postgres developers");
if (sizeof(struct sbufdesc_unpadded) <= PADDED_SBUFDESC_SIZE / 2)
- elog(ABORT, "Internal error: sbufdesc is greatly over-sized, "
+ elog(ERROR, "Internal error: sbufdesc is greatly over-sized, "
"contact the Postgres developers");
Data_Descriptors = NBuffers;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_table.c,v 1.9 1998/01/05 03:32:52 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_table.c,v 1.10 1998/01/07 21:04:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (!result)
{
- elog(ABORT, "BufTableLookup: BufferLookup table corrupted");
+ elog(ERROR, "BufTableLookup: BufferLookup table corrupted");
return (NULL);
}
if (!found)
if (!(result && found))
{
- elog(ABORT, "BufTableDelete: BufferLookup table corrupted");
+ elog(ERROR, "BufTableDelete: BufferLookup table corrupted");
return (FALSE);
}
if (!result)
{
Assert(0);
- elog(ABORT, "BufTableInsert: BufferLookup table corrupted");
+ elog(ERROR, "BufTableInsert: BufferLookup table corrupted");
return (FALSE);
}
/* found something else in the table ! */
if (found)
{
Assert(0);
- elog(ABORT, "BufTableInsert: BufferLookup table corrupted");
+ elog(ERROR, "BufTableInsert: BufferLookup table corrupted");
return (FALSE);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.30 1998/01/05 03:32:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.31 1998/01/07 21:04:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* But it can return buf == NULL if we are in aborting transaction
- * now and so elog(ABORT,...) in GetFreeBuffer will not abort
+ * now and so elog(ERROR,...) in GetFreeBuffer will not abort
* again.
*/
if (buf == NULL)
if (status == SM_FAIL)
{
- elog(ABORT, "FlushBuffer: cannot flush block %u of the relation %s",
+ elog(ERROR, "FlushBuffer: cannot flush block %u of the relation %s",
bufHdr->tag.blockNum, bufHdr->sb_relname);
return (STATUS_ERROR);
}
UnpinBuffer(bufHdr);
if (bufHdr->flags & BM_IO_ERROR)
{
- elog(ABORT, "BufferSync: write error %u for %s",
+ elog(ERROR, "BufferSync: write error %u for %s",
bufHdr->tag.blockNum, bufHdr->sb_relname);
}
if (reln != (Relation) NULL)
if (status == SM_FAIL)
{
bufHdr->flags |= BM_IO_ERROR;
- elog(ABORT, "BufferSync: cannot write %u for %s",
+ elog(ERROR, "BufferSync: cannot write %u for %s",
bufHdr->tag.blockNum, bufHdr->sb_relname);
}
BufferFlushCount++;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/freelist.c,v 1.8 1998/01/05 03:32:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/freelist.c,v 1.9 1998/01/07 21:04:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
/* queue is empty. All buffers in the buffer pool are pinned. */
- elog(ABORT, "out of free buffers: time to abort !\n");
+ elog(ERROR, "out of free buffers: time to abort !\n");
return (NULL);
}
buf = &(BufferDescriptors[SharedFreeList->freeNext]);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/localbuf.c,v 1.15 1998/01/05 03:32:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/localbuf.c,v 1.16 1998/01/07 21:04:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
}
if (bufHdr == NULL)
- elog(ABORT, "no empty local buffer.");
+ elog(ERROR, "no empty local buffer.");
/*
* this buffer is not referenced but it might still be dirty (the last
* Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Id: fd.c,v 1.28 1998/01/05 03:33:00 momjian Exp $
+ * $Id: fd.c,v 1.29 1998/01/07 21:04:58 momjian Exp $
*
* NOTES:
*
if (fileName == NULL)
{
- elog(ABORT, "fileNameOpenFile: NULL fname");
+ elog(ERROR, "fileNameOpenFile: NULL fname");
}
vfdP->fileName = malloc(strlen(fileName) + 1);
strcpy(vfdP->fileName, fileName);
lseek(VfdCache[file].fd, offset, whence);
return returnCode;
default:
- elog(ABORT, "FileSeek: invalid whence: %d", whence);
+ elog(ERROR, "FileSeek: invalid whence: %d", whence);
break;
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.17 1998/01/05 03:33:04 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.18 1998/01/07 21:05:03 momjian Exp $
*
* NOTES
*
IpcPrivateMem[memid].id = memid;
IpcPrivateMem[memid].memptr = malloc(size);
if (IpcPrivateMem[memid].memptr == NULL)
- elog(ABORT, "PrivateMemoryCreate: not enough memory to malloc");
+ elog(ERROR, "PrivateMemoryCreate: not enough memory to malloc");
MemSet(IpcPrivateMem[memid].memptr, 0, size); /* XXX PURIFY */
return (memid++);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.15 1998/01/05 03:33:06 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.16 1998/01/07 21:05:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
SpinRelease(BindingLock);
- elog(ABORT, "ShmemInitPID: BindingTable corrupted");
+ elog(ERROR, "ShmemInitPID: BindingTable corrupted");
return (FALSE);
}
if (!result)
{
- elog(ABORT, "ShmemPIDDestroy: PID table corrupted");
+ elog(ERROR, "ShmemPIDDestroy: PID table corrupted");
return (INVALID_OFFSET);
}
SpinRelease(BindingLock);
- elog(ABORT, "ShmemInitStruct: Binding Table corrupted");
+ elog(ERROR, "ShmemInitStruct: Binding Table corrupted");
return (NULL);
}
}
SpinRelease(BindingLock);
- elog(ABORT, "TransactionIdIsInProgress: BindingTable corrupted");
+ elog(ERROR, "TransactionIdIsInProgress: BindingTable corrupted");
return (false);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.25 1998/01/05 03:33:09 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.26 1998/01/07 21:05:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (SearchSysCacheTuple(RELNAME, PointerGetDatum(objname),
0, 0, 0) != NULL)
{
- elog(ABORT,
+ elog(ERROR,
"internal error: %s already exists -- cannot create large obj",
objname);
}
if (SearchSysCacheTuple(RELNAME, PointerGetDatum(indname),
0, 0, 0) != NULL)
{
- elog(ABORT,
+ elog(ERROR,
"internal error: %s already exists -- cannot create large obj",
indname);
}
if (!RelationIsValid(r))
{
- elog(ABORT, "cannot create large object on %s under inversion",
+ elog(ERROR, "cannot create large object on %s under inversion",
smgrout(DEFAULT_SMGR));
}
if (!RelationIsValid(indr))
{
- elog(ABORT, "cannot create index for large obj on %s under inversion",
+ elog(ERROR, "cannot create index for large obj on %s under inversion",
smgrout(DEFAULT_SMGR));
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.10 1998/01/05 03:33:16 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.11 1998/01/07 21:05:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
if (!LockInfoIsValid(linfo))
{
- elog(ABORT,
+ elog(ERROR,
"Releasing a lock on %s with invalid lock information",
RelationGetRelationName(relation));
}
if (!LockInfoIsValid(linfo))
{
- elog(ABORT,
+ elog(ERROR,
"Releasing a lock on %s with invalid lock information",
RelationGetRelationName(relation));
}
return;
if (!LockInfoIsValid(relation->lockInfo))
- elog(ABORT,
+ elog(ERROR,
"Releasing a lock on %s with invalid lock information",
RelationGetRelationName(relation));
return;
if (!LockInfoIsValid(relation->lockInfo))
- elog(ABORT,
+ elog(ERROR,
"Releasing a lock on %s with invalid lock information",
RelationGetRelationName(relation));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.17 1998/01/05 03:33:22 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.18 1998/01/07 21:05:32 momjian Exp $
*
* NOTES
* Outside modules can create a lock table and acquire/release
lock->holders[lockt]--;
LOCK_DUMP_AUX("WaitOnLock: aborting on lock", lock, lockt);
SpinRelease(ltable->ctl->masterLock);
- elog(ABORT, "WaitOnLock: error on wakeup - Aborting this transaction");
+ elog(ERROR, "WaitOnLock: error on wakeup - Aborting this transaction");
}
LOCK_DUMP_AUX("WaitOnLock: wakeup on lock", lock, lockt);
#endif
/*
- * let the caller print its own error message, too. Do not elog(ABORT).
+ * let the caller print its own error message, too. Do not elog(ERROR).
*/
if (!lock)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/multi.c,v 1.9 1998/01/05 03:33:25 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/multi.c,v 1.10 1998/01/07 21:05:35 momjian Exp $
*
* NOTES:
* (1) The lock.c module assumes that the caller here is doing
MultiTableId = tableId;
if (!(MultiTableId))
{
- elog(ABORT, "InitMultiLockm: couldnt initialize lock table");
+ elog(ERROR, "InitMultiLockm: couldnt initialize lock table");
}
/* -----------------------
* No short term lock table for now. -Jeff 15 July 1991
*
* ShortTermTableId = LockTabRename(tableId);
* if (! (ShortTermTableId)) {
- * elog(ABORT,"InitMultiLockm: couldnt rename lock table");
+ * elog(ERROR,"InitMultiLockm: couldnt rename lock table");
* }
* -----------------------
*/
locks[2] = lockt;
break;
default:
- elog(ABORT, "MultiAcquire: bad lock level");
+ elog(ERROR, "MultiAcquire: bad lock level");
return (FALSE);
}
locks[2] = lockt;
break;
default:
- elog(ABORT, "MultiRelease: bad lockt");
+ elog(ERROR, "MultiRelease: bad lockt");
}
/*
status = LockRelease(tableId, tmpTag, locks[i]);
if (!status)
{
- elog(ABORT, "MultiRelease: couldn't release after error");
+ elog(ERROR, "MultiRelease: couldn't release after error");
}
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.24 1998/01/05 03:33:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.25 1998/01/07 21:05:36 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* This is so that we can support more backends. (system-wide semaphore
* sets run out pretty fast.) -ay 4/95
*
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.24 1998/01/05 03:33:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.25 1998/01/07 21:05:36 momjian Exp $
*/
#include <sys/time.h>
#include <unistd.h>
if (!found)
{
/* this should not happen. InitProcGlobal() is called before this. */
- elog(ABORT, "InitProcess: Proc Header uninitialized");
+ elog(ERROR, "InitProcess: Proc Header uninitialized");
}
if (MyProc != NULL)
{
SpinRelease(ProcStructLock);
- elog(ABORT, "ProcInit: you already exist");
+ elog(ERROR, "ProcInit: you already exist");
return;
}
}
/* if we reach here, all the semaphores are in use. */
- elog(ABORT, "InitProc: cannot allocate a free semaphore");
+ elog(ERROR, "InitProc: cannot allocate a free semaphore");
}
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/page/bufpage.c,v 1.12 1998/01/05 03:33:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/page/bufpage.c,v 1.13 1998/01/07 21:05:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (((*itemId).lp_flags & LP_USED) ||
((*itemId).lp_len != 0))
{
- elog(ABORT, "PageAddItem: tried overwrite of used ItemId");
+ elog(ERROR, "PageAddItem: tried overwrite of used ItemId");
return (InvalidOffsetNumber);
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.25 1998/01/05 03:33:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/smgr/md.c,v 1.26 1998/01/07 21:05:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
v->mdfd_chain = _mdfd_openseg(reln, segno, O_CREAT);
if (v->mdfd_chain == (MdfdVec *) NULL)
- elog(ABORT, "cannot count blocks for %.16s -- open failed",
+ elog(ERROR, "cannot count blocks for %.16s -- open failed",
RelationGetRelationName(reln));
}
if (fd < 0)
{
if ((fd = mdopen(reln)) < 0)
- elog(ABORT, "cannot open relation %.16s",
+ elog(ERROR, "cannot open relation %.16s",
RelationGetRelationName(reln));
reln->rd_fd = fd;
}
v->mdfd_chain = _mdfd_openseg(reln, i, oflag);
if (v->mdfd_chain == (MdfdVec *) NULL)
- elog(ABORT, "cannot open segment %d of relation %.16s",
+ elog(ERROR, "cannot open segment %d of relation %.16s",
i, RelationGetRelationName(reln));
}
v = v->mdfd_chain;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgr.c,v 1.12 1998/01/05 03:33:33 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgr.c,v 1.13 1998/01/07 21:05:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int fd;
if ((fd = (*(smgrsw[which].smgr_create)) (reln)) < 0)
- elog(ABORT, "cannot open %s",
+ elog(ERROR, "cannot open %s",
&(reln->rd_rel->relname.data[0]));
return (fd);
int status;
if ((status = (*(smgrsw[which].smgr_unlink)) (reln)) == SM_FAIL)
- elog(ABORT, "cannot unlink %s",
+ elog(ERROR, "cannot unlink %s",
&(reln->rd_rel->relname.data[0]));
return (status);
status = (*(smgrsw[which].smgr_extend)) (reln, buffer);
if (status == SM_FAIL)
- elog(ABORT, "%s: cannot extend",
+ elog(ERROR, "%s: cannot extend",
&(reln->rd_rel->relname.data[0]));
return (status);
int fd;
if ((fd = (*(smgrsw[which].smgr_open)) (reln)) < 0)
- elog(ABORT, "cannot open %s",
+ elog(ERROR, "cannot open %s",
&(reln->rd_rel->relname.data[0]));
return (fd);
smgrclose(int16 which, Relation reln)
{
if ((*(smgrsw[which].smgr_close)) (reln) == SM_FAIL)
- elog(ABORT, "cannot close %s",
+ elog(ERROR, "cannot close %s",
&(reln->rd_rel->relname.data[0]));
return (SM_SUCCESS);
status = (*(smgrsw[which].smgr_read)) (reln, blocknum, buffer);
if (status == SM_FAIL)
- elog(ABORT, "cannot read block %d of %s",
+ elog(ERROR, "cannot read block %d of %s",
blocknum, &(reln->rd_rel->relname.data[0]));
return (status);
status = (*(smgrsw[which].smgr_write)) (reln, blocknum, buffer);
if (status == SM_FAIL)
- elog(ABORT, "cannot write block %d of %s",
+ elog(ERROR, "cannot write block %d of %s",
blocknum, &(reln->rd_rel->relname.data[0]));
return (status);
status = (*(smgrsw[which].smgr_flush)) (reln, blocknum, buffer);
if (status == SM_FAIL)
- elog(ABORT, "cannot flush block %d of %s to stable store",
+ elog(ERROR, "cannot flush block %d of %s to stable store",
blocknum, &(reln->rd_rel->relname.data[0]));
return (status);
blkno, buffer);
if (status == SM_FAIL)
- elog(ABORT, "cannot write block %d of %s [%s] blind",
+ elog(ERROR, "cannot write block %d of %s [%s] blind",
blkno, relstr, dbstr);
pfree(dbstr);
int nblocks;
if ((nblocks = (*(smgrsw[which].smgr_nblocks)) (reln)) < 0)
- elog(ABORT, "cannot count blocks for %s",
+ elog(ERROR, "cannot count blocks for %s",
&(reln->rd_rel->relname.data[0]));
return (nblocks);
if (smgrsw[which].smgr_truncate)
{
if ((newblks = (*(smgrsw[which].smgr_truncate)) (reln, nblocks)) < 0)
- elog(ABORT, "cannot truncate %s to %d blocks",
+ elog(ERROR, "cannot truncate %s to %d blocks",
&(reln->rd_rel->relname.data[0]), nblocks);
}
smgriswo(int16 smgrno)
{
if (smgrno < 0 || smgrno >= NSmgr)
- elog(ABORT, "illegal storage manager number %d", smgrno);
+ elog(ERROR, "illegal storage manager number %d", smgrno);
return (smgrwo[smgrno]);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgrtype.c,v 1.6 1998/01/05 03:33:35 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgrtype.c,v 1.7 1998/01/07 21:05:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (strcmp(s, StorageManager[i].smgr_name) == 0)
return ((int2) i);
}
- elog(ABORT, "smgrin: illegal storage manager name %s", s);
+ elog(ERROR, "smgrin: illegal storage manager name %s", s);
return 0;
}
char *s;
if (i >= NStorageManagers || i < 0)
- elog(ABORT, "Illegal storage manager id %d", i);
+ elog(ERROR, "Illegal storage manager id %d", i);
s = (char *) palloc(strlen(StorageManager[i].smgr_name) + 1);
strcpy(s, StorageManager[i].smgr_name);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.9 1998/01/05 03:33:44 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.10 1998/01/07 21:05:54 momjian Exp $
*
* NOTES
* This cruft is the server side of PQfn.
* Since the validity of this structure is determined by whether the
* funcid is OK, we clear the funcid here. It must not be set to the
* correct value until we are about to return with a good struct
- * fp_info, since we can be interrupted (i.e., with an elog(ABORT,
+ * fp_info, since we can be interrupted (i.e., with an elog(ERROR,
* ...)) at any time.
*/
MemSet((char *) fip, 0, (int) sizeof(struct fp_info));
0, 0, 0);
if (!HeapTupleIsValid(func_htp))
{
- elog(ABORT, "update_fp_info: cache lookup for function %d failed",
+ elog(ERROR, "update_fp_info: cache lookup for function %d failed",
func_id);
}
pp = (Form_pg_proc) GETSTRUCT(func_htp);
0, 0, 0);
if (!HeapTupleIsValid(type_htp))
{
- elog(ABORT, "update_fp_info: bad argument type %d for %d",
+ elog(ERROR, "update_fp_info: bad argument type %d for %d",
argtypes[i], func_id);
}
tp = (TypeTupleForm) GETSTRUCT(type_htp);
0, 0, 0);
if (!HeapTupleIsValid(type_htp))
{
- elog(ABORT, "update_fp_info: bad return type %d for %d",
+ elog(ERROR, "update_fp_info: bad return type %d for %d",
rettype, func_id);
}
tp = (TypeTupleForm) GETSTRUCT(type_htp);
*
* RETURNS:
* nothing of significance.
- * All errors result in elog(ABORT,...).
+ * All errors result in elog(ERROR,...).
*/
int
HandleFunctionRequest()
if (fip->nargs != nargs)
{
- elog(ABORT, "HandleFunctionRequest: actual arguments (%d) != registered arguments (%d)",
+ elog(ERROR, "HandleFunctionRequest: actual arguments (%d) != registered arguments (%d)",
nargs, fip->nargs);
}
{ /* ... varlena */
if (!(p = palloc(argsize + VARHDRSZ)))
{
- elog(ABORT, "HandleFunctionRequest: palloc failed");
+ elog(ERROR, "HandleFunctionRequest: palloc failed");
}
VARSIZE(p) = argsize + VARHDRSZ;
pq_getnchar(VARDATA(p), 0, argsize);
/* XXX cross our fingers and trust "argsize" */
if (!(p = palloc(argsize)))
{
- elog(ABORT, "HandleFunctionRequest: palloc failed");
+ elog(ERROR, "HandleFunctionRequest: palloc failed");
}
pq_getnchar(p, 0, argsize);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.58 1998/01/05 03:33:46 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.59 1998/01/07 21:06:00 momjian Exp $
*
* NOTES
* this is the "main" module of the postgres backend and
sigjmp_buf Warn_restart;
#endif /* defined(nextstep) */
-int InErrorOrAbort;
+int InError;
extern int NBuffers;
* signal handler routines used in PostgresMain()
*
* handle_warn() is used to catch kill(getpid(),1) which
- * occurs when elog(ABORT) is called.
+ * occurs when elog(ERROR) is called.
*
* quickdie() occurs when signalled by the postmaster.
* Some backend has bought the farm,
static void
FloatExceptionHandler(SIGNAL_ARGS)
{
- elog(ABORT, "floating point exception!"
+ elog(ERROR, "floating point exception!"
" The last floating point operation either exceeded legal ranges"
" or was a divide by zero");
}
* so that the slaves signal the master to abort the transaction
* rather than calling AbortCurrentTransaction() themselves.
*
- * Note: elog(ABORT) causes a kill(getpid(),1) to occur sending
+ * Note: elog(ERROR) causes a kill(getpid(),1) to occur sending
* us back here.
* ----------------
*/
if (sigsetjmp(Warn_restart, 1) != 0)
{
- InErrorOrAbort = 1;
+ InError = 1;
time(&tim);
AbortCurrentTransaction();
}
- InErrorOrAbort = 0;
+ InError = 0;
/* ----------------
* POSTGRES main processing loop begins here
if (IsUnderPostmaster == false)
{
puts("\nPOSTGRES backend interactive interface");
- puts("$Revision: 1.58 $ $Date: 1998/01/05 03:33:46 $");
+ puts("$Revision: 1.59 $ $Date: 1998/01/07 21:06:00 $");
}
/* ----------------
break;
default:
- elog(ABORT, "unknown frontend message was recieved");
+ elog(ERROR, "unknown frontend message was recieved");
}
/* ----------------
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.12 1998/01/05 03:33:48 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.13 1998/01/07 21:06:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
if (PortalNameIsSpecial(portalName))
- elog(ABORT,
+ elog(ERROR,
"The portal name %s is reserved for internal use",
portalName);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.19 1998/01/05 03:34:22 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.20 1998/01/07 21:06:08 momjian Exp $
*
* Notes:
* XXX This needs to use exception.h to handle recovery when
CACHE1_elog(DEBUG, "ResetSystemCache called");
if (DisableCache)
{
- elog(ABORT, "ResetSystemCache: Called while cache disabled");
+ elog(ERROR, "ResetSystemCache: Called while cache disabled");
return;
}
nextelt = DLGetSucc(elt);
CatCacheRemoveCTup(cache, elt);
if (cache->cc_ntup == -1)
- elog(ABORT, "ResetSystemCache: cc_ntup<0 (software error)");
+ elog(ERROR, "ResetSystemCache: cc_ntup<0 (software error)");
}
}
cache->cc_ntup = 0; /* in case of WARN error above */
if (DisableCache)
{
- elog(ABORT, "SearchSysCache: Called while cache disabled");
+ elog(ERROR, "SearchSysCache: Called while cache disabled");
return ((HeapTuple) NULL);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/fcache.c,v 1.8 1998/01/05 03:34:24 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/fcache.c,v 1.9 1998/01/07 21:06:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
tup = SearchSysCacheTuple(TYPNAME, PointerGetDatum(relname),
0, 0, 0);
if (!tup)
- elog(ABORT, "Lookup failed on type tuple for class %s",
+ elog(ERROR, "Lookup failed on type tuple for class %s",
relname);
return tup->t_oid;
retval = (FunctionCachePtr) palloc(sizeof(FunctionCache));
if (!use_syscache)
- elog(ABORT, "what the ????, init the fcache without the catalogs?");
+ elog(ERROR, "what the ????, init the fcache without the catalogs?");
procedureTuple = SearchSysCacheTuple(PROOID,
ObjectIdGetDatum(foid),
0, 0, 0);
if (!HeapTupleIsValid(procedureTuple))
- elog(ABORT,
+ elog(ERROR,
"init_fcache: %s %d",
"Cache lookup failed for procedure", foid);
0, 0, 0);
if (!HeapTupleIsValid(typeTuple))
- elog(ABORT,
+ elog(ERROR,
"init_fcache: %s %d",
"Cache lookup failed for type",
(procedureStruct)->prorettype);
}
else
{
- elog(ABORT, "init_fcache: node must be Oper or Func!");
+ elog(ERROR, "init_fcache: node must be Oper or Func!");
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.8 1998/01/05 03:34:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.9 1998/01/07 21:06:12 momjian Exp $
*
* NOTES
* Eventually, the index information should go through here, too.
PointerGetDatum(attname),
0, 0);
if (!HeapTupleIsValid(htup))
- elog(ABORT, "get_attisset: no attribute %s in relation %d",
+ elog(ERROR, "get_attisset: no attribute %s in relation %d",
attname, relid);
if (heap_attisnull(htup, attno))
return (false);
return (pstrdup(optup.oprname.data));
else
{
- elog(ABORT, "can't look up operator %d\n", opno);
+ elog(ERROR, "can't look up operator %d\n", opno);
return NULL;
}
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.31 1998/01/05 03:34:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.32 1998/01/07 21:06:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
break;
default:
- elog(ABORT, "ScanPgRelation: bad buildinfo");
+ elog(ERROR, "ScanPgRelation: bad buildinfo");
return NULL;
}
break;
default:
- elog(ABORT, "ScanPgRelation: bad buildinfo");
+ elog(ERROR, "ScanPgRelation: bad buildinfo");
/*
* XXX I hope this is right. It seems better than returning
}
if (need > 0)
- elog(ABORT, "catalog is missing %d attribute%s for relid %d",
+ elog(ERROR, "catalog is missing %d attribute%s for relid %d",
need, (need == 1 ? "" : "s"), relation->rd_id);
/* ----------------
atttup = (HeapTuple) AttributeNumIndexScan(attrel, relation->rd_id, i);
if (!HeapTupleIsValid(atttup))
- elog(ABORT, "cannot find attribute %d of relation %.*s", i,
+ elog(ERROR, "cannot find attribute %d of relation %.*s", i,
NAMEDATALEN, &(relation->rd_rel->relname.data[0]));
attp = (AttributeTupleForm) GETSTRUCT(atttup);
if (adform->adnum != attrdef[i].adnum)
continue;
if (attrdef[i].adsrc != NULL)
- elog(ABORT, "AttrDefaultFetch: second record found for attr %.*s in rel %.*s",
+ elog(ERROR, "AttrDefaultFetch: second record found for attr %.*s in rel %.*s",
NAMEDATALEN, relation->rd_att->attrs[adform->adnum - 1]->attname.data,
NAMEDATALEN, relation->rd_rel->relname.data);
Anum_pg_attrdef_adbin,
adrel->rd_att, &isnull);
if (isnull)
- elog(ABORT, "AttrDefaultFetch: adbin IS NULL for attr %.*s in rel %.*s",
+ elog(ERROR, "AttrDefaultFetch: adbin IS NULL for attr %.*s in rel %.*s",
NAMEDATALEN, relation->rd_att->attrs[adform->adnum - 1]->attname.data,
NAMEDATALEN, relation->rd_rel->relname.data);
attrdef[i].adbin = textout(val);
Anum_pg_attrdef_adsrc,
adrel->rd_att, &isnull);
if (isnull)
- elog(ABORT, "AttrDefaultFetch: adsrc IS NULL for attr %.*s in rel %.*s",
+ elog(ERROR, "AttrDefaultFetch: adsrc IS NULL for attr %.*s in rel %.*s",
NAMEDATALEN, relation->rd_att->attrs[adform->adnum - 1]->attname.data,
NAMEDATALEN, relation->rd_rel->relname.data);
attrdef[i].adsrc = textout(val);
}
if (i >= ndef)
- elog(ABORT, "AttrDefaultFetch: unexpected record found for attr %d in rel %.*s",
+ elog(ERROR, "AttrDefaultFetch: unexpected record found for attr %d in rel %.*s",
adform->adnum,
NAMEDATALEN, relation->rd_rel->relname.data);
ReleaseBuffer(buffer);
}
if (found < ndef)
- elog(ABORT, "AttrDefaultFetch: %d record not found for rel %.*s",
+ elog(ERROR, "AttrDefaultFetch: %d record not found for rel %.*s",
ndef - found,
NAMEDATALEN, relation->rd_rel->relname.data);
if (!HeapTupleIsValid(tuple))
continue;
if (found == ncheck)
- elog(ABORT, "RelCheckFetch: unexpected record found for rel %.*s",
+ elog(ERROR, "RelCheckFetch: unexpected record found for rel %.*s",
NAMEDATALEN, relation->rd_rel->relname.data);
rcname = (Name) fastgetattr(tuple,
Anum_pg_relcheck_rcname,
rcrel->rd_att, &isnull);
if (isnull)
- elog(ABORT, "RelCheckFetch: rcname IS NULL for rel %.*s",
+ elog(ERROR, "RelCheckFetch: rcname IS NULL for rel %.*s",
NAMEDATALEN, relation->rd_rel->relname.data);
check[found].ccname = nameout(rcname);
val = (struct varlena *) fastgetattr(tuple,
Anum_pg_relcheck_rcbin,
rcrel->rd_att, &isnull);
if (isnull)
- elog(ABORT, "RelCheckFetch: rcbin IS NULL for rel %.*s",
+ elog(ERROR, "RelCheckFetch: rcbin IS NULL for rel %.*s",
NAMEDATALEN, relation->rd_rel->relname.data);
check[found].ccbin = textout(val);
val = (struct varlena *) fastgetattr(tuple,
Anum_pg_relcheck_rcsrc,
rcrel->rd_att, &isnull);
if (isnull)
- elog(ABORT, "RelCheckFetch: rcsrc IS NULL for rel %.*s",
+ elog(ERROR, "RelCheckFetch: rcsrc IS NULL for rel %.*s",
NAMEDATALEN, relation->rd_rel->relname.data);
check[found].ccsrc = textout(val);
found++;
}
if (found < ncheck)
- elog(ABORT, "RelCheckFetch: %d record not found for rel %.*s",
+ elog(ERROR, "RelCheckFetch: %d record not found for rel %.*s",
ncheck - found,
NAMEDATALEN, relation->rd_rel->relname.data);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.11 1998/01/05 03:34:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.12 1998/01/07 21:06:15 momjian Exp $
*
* NOTES
* These routines allow the parser/planner/executor to perform
cacheinfo[cacheId].iScanFunc);
if (!PointerIsValid((char *) SysCache[cacheId]))
{
- elog(ABORT,
+ elog(ERROR,
"InitCatalogCache: Can't init cache %.16s(%d)",
cacheinfo[cacheId].name,
cacheId);
if (cacheId < 0 || cacheId >= SysCacheSize)
{
- elog(ABORT, "SearchSysCacheTuple: Bad cache id %d", cacheId);
+ elog(ERROR, "SearchSysCacheTuple: Bad cache id %d", cacheId);
return ((HeapTuple) NULL);
}
cacheinfo[cacheId].iScanFunc);
if (!PointerIsValid(SysCache[cacheId]))
{
- elog(ABORT,
+ elog(ERROR,
"InitCatalogCache: Can't init cache %.16s(%d)",
cacheinfo[cacheId].name,
cacheId);
if (!PointerIsValid(returnStruct))
{
- elog(ABORT, "SearchSysCacheStruct: No receiving struct");
+ elog(ERROR, "SearchSysCacheStruct: No receiving struct");
return (0);
}
tp = SearchSysCacheTuple(cacheId, key1, key2, key3, key4);
}
else
{
- elog(ABORT,
+ elog(ERROR,
"SearchSysCacheGetAttribute: Bad attr # %d in %s(%d)",
attributeNumber, cacheName, cacheId);
return (NULL);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.23 1998/01/05 04:10:07 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/elog.c,v 1.24 1998/01/07 21:06:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
case ERROR:
cp = "ERROR: ";
break;
- case ABORT:
- cp = "ABORT: ";
- break;
default:
sprintf(line, "FATAL %d: ", lev);
cp = line;
}
#endif /* !PG_STANDALONE */
- if (lev == ERROR || lev == ABORT)
+ if (lev == ERROR)
{
- extern int InErrorOrAbort;
+ extern int InError;
ProcReleaseSpins(NULL); /* get rid of spinlocks we hold */
- if (!InErrorOrAbort)
+ if (!InError)
{
kill(getpid(), 1); /* abort to traffic cop */
pause();
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/dfmgr.c,v 1.15 1998/01/05 03:34:41 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/dfmgr.c,v 1.16 1998/01/07 21:06:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
0, 0, 0);
if (!HeapTupleIsValid(procedureTuple))
{
- elog(ABORT, "fmgr: Cache lookup failed for procedure %d\n",
+ elog(ERROR, "fmgr: Cache lookup failed for procedure %d\n",
procedureId);
return ((func_ptr) NULL);
}
rdesc = heap_openr(ProcedureRelationName);
if (!RelationIsValid(rdesc))
{
- elog(ABORT, "fmgr: Could not open relation %s",
+ elog(ERROR, "fmgr: Could not open relation %s",
ProcedureRelationName);
return ((func_ptr) NULL);
}
if (!PointerIsValid(probinattr) /* || isnull */ )
{
heap_close(rdesc);
- elog(ABORT, "fmgr: Could not extract probin for %d from %s",
+ elog(ERROR, "fmgr: Could not extract probin for %d from %s",
procedureId, ProcedureRelationName);
return ((func_ptr) NULL);
}
{
if (stat(filename, &stat_buf) == -1)
{
- elog(ABORT, "stat failed on file %s", filename);
+ elog(ERROR, "stat failed on file %s", filename);
}
for (file_scanner = file_list;
}
free((char *) file_scanner);
- elog(ABORT, "Load of file %s failed: %s", filename, load_error);
+ elog(ERROR, "Load of file %s failed: %s", filename, load_error);
}
/*
if (retval == (func_ptr) NULL)
{
- elog(ABORT, "Can't find function %s in file %s", funcname, filename);
+ elog(ERROR, "Can't find function %s in file %s", funcname, filename);
}
return (retval);
if (stat(filename, &stat_buf) == -1)
{
- elog(ABORT, "stat failed on file %s", filename);
+ elog(ERROR, "stat failed on file %s", filename);
}
if (file_list != (DynamicFileList *) NULL
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.8 1998/01/05 03:34:44 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.9 1998/01/07 21:06:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
0, 0, 0);
if (!HeapTupleIsValid(procedureTuple))
{
- elog(ABORT, "fmgr_pl(): Cache lookup of procedure %ld failed.",
+ elog(ERROR, "fmgr_pl(): Cache lookup of procedure %ld failed.",
ObjectIdGetDatum(func_id));
}
procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
0, 0, 0);
if (!HeapTupleIsValid(languageTuple))
{
- elog(ABORT, "fmgr_pl(): Cache lookup of language %ld for procedure %ld failed.",
+ elog(ERROR, "fmgr_pl(): Cache lookup of language %ld for procedure %ld failed.",
ObjectIdGetDatum(procedureStruct->prolang),
ObjectIdGetDatum(func_id));
}
fmgr_info(languageStruct->lanplcallfoid, &plcall_fn, &plcall_nargs);
if (plcall_fn == NULL)
{
- elog(ABORT, "fmgr_pl(): failed to load PL handler for procedure %ld.",
+ elog(ERROR, "fmgr_pl(): failed to load PL handler for procedure %ld.",
ObjectIdGetDatum(func_id));
}
values->data[8]);
break;
default:
- elog(ABORT, "fmgr_c: function %d: too many arguments (%d > %d)",
+ elog(ERROR, "fmgr_c: function %d: too many arguments (%d > %d)",
func_id, n_arguments, MAXFMGRARGS);
break;
}
0, 0, 0);
if (!HeapTupleIsValid(procedureTuple))
{
- elog(ABORT, "fmgr_info: function %d: cache lookup failed\n",
+ elog(ERROR, "fmgr_info: function %d: cache lookup failed\n",
procedureId);
}
procedureStruct = (FormData_pg_proc *)
case INTERNALlanguageId:
user_fn = fmgr_lookupByName(procedureStruct->proname.data);
if (!user_fn)
- elog(ABORT, "fmgr_info: function %s: not in internal table",
+ elog(ERROR, "fmgr_info: function %s: not in internal table",
procedureStruct->proname.data);
break;
case ClanguageId:
0, 0, 0);
if (!HeapTupleIsValid(languageTuple))
{
- elog(ABORT, "fmgr_info: %s %ld",
+ elog(ERROR, "fmgr_info: %s %ld",
"Cache lookup for language %d failed",
ObjectIdGetDatum(procedureStruct->prolang));
}
}
else
{
- elog(ABORT, "fmgr_info: function %d: unknown language %d",
+ elog(ERROR, "fmgr_info: function %d: unknown language %d",
procedureId, language);
}
break;
if (pronargs > MAXFMGRARGS)
{
- elog(ABORT, "fmgr: function %d: too many arguments (%d > %d)",
+ elog(ERROR, "fmgr: function %d: too many arguments (%d > %d)",
procedureId, pronargs, MAXFMGRARGS);
}
for (i = 0; i < pronargs; ++i)
n_arguments = va_arg(pvar, int);
if (n_arguments > MAXFMGRARGS)
{
- elog(ABORT, "fmgr_ptr: function %d: too many arguments (%d > %d)",
+ elog(ERROR, "fmgr_ptr: function %d: too many arguments (%d > %d)",
func_id, n_arguments, MAXFMGRARGS);
}
for (i = 0; i < n_arguments; ++i)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/misc/Attic/database.c,v 1.4 1998/01/05 03:34:49 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/misc/Attic/database.c,v 1.5 1998/01/07 21:06:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
scan = heap_beginscan(dbrel, 0, false, 1, &scanKey);
if (!HeapScanIsValid(scan))
- elog(ABORT, "GetDatabaseInfo: cannot begin scan of %s", DatabaseRelationName);
+ elog(ERROR, "GetDatabaseInfo: cannot begin scan of %s", DatabaseRelationName);
/*
* Since we're going to close the relation, copy the tuple.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/psort.c,v 1.29 1998/01/05 03:34:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/psort.c,v 1.30 1998/01/07 21:06:39 momjian Exp $
*
* NOTES
* Sorts the first relation into the second relation.
PS(node)->Tape[0].tp_prev = tp;
if (PS(node)->TapeRange <= 1)
- elog(ABORT, "inittapes: Could only allocate %d < 3 tapes\n",
+ elog(ERROR, "inittapes: Could only allocate %d < 3 tapes\n",
PS(node)->TapeRange + 1);
PS(node)->Level = 1;
file = AllocateFile(tp->tl_name, "w+");
if (file == NULL)
- elog(ABORT, "Open: %s in %s line %d, %s", tp->tl_name,
+ elog(ERROR, "Open: %s in %s line %d, %s", tp->tl_name,
__FILE__, __LINE__, strerror(errno));
tp->tl_fd = fileno(file);
for (tp = Tapes; tp != NULL && tp->tl_fd != fd; tp = tp->tl_next)
;
if (tp == NULL)
- elog(ABORT, "resettape: tape not found");
+ elog(ERROR, "resettape: tape not found");
file = freopen(tp->tl_name, "w+", file);
if (file == NULL)
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: elog.h,v 1.6 1998/01/05 03:35:05 momjian Exp $
+ * $Id: elog.h,v 1.7 1998/01/07 21:06:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define ELOG_H
#define NOTICE 0 /* random info - no special action */
-#define ERROR -2 /* user error - return to known state */
-#define ABORT -1 /* system error - return to known state */
+#define ERROR -1 /* user error - return to known state */
#define FATAL 1 /* Fatal error - abort process */
-#define DEBUG -3 /* debug message */
-#define NOIND -4 /* debug message, don't indent as far */
+#define DEBUG -2 /* debug message */
+#define NOIND -3 /* debug message, don't indent as far */
#ifdef NOT_USED
#define PTIME 0x100 /* prepend time to message */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/tutorial/C-code/Attic/beard.c,v 1.4 1998/01/05 03:35:52 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/tutorial/C-code/Attic/beard.c,v 1.5 1998/01/07 21:07:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int cc;
if ((pic_fd = lo_open(picture, INV_READ)) == -1)
- elog(ABORT, "Cannot access picture large object");
+ elog(ERROR, "Cannot access picture large object");
if (lo_read(pic_fd, (char *) &ihdr, sizeof(ihdr)) != sizeof(ihdr))
- elog(ABORT, "Picture large object corrupted");
+ elog(ERROR, "Picture large object corrupted");
beardOffset = (ihdr.size / 3) * 2;
* new large object
*/
if ((beard = lo_creat(INV_MD)) == 0) /* ?? is this right? */
- elog(ABORT, "Cannot create new large object");
+ elog(ERROR, "Cannot create new large object");
if ((beard_fd = lo_open(beard, INV_WRITE)) == -1)
- elog(ABORT, "Cannot access beard large object");
+ elog(ERROR, "Cannot access beard large object");
lo_lseek(pic_fd, beardOffset, SET_CUR);
while ((cc = lo_read(pic_fd, buf, BUFSIZE)) > 0)
{
if (lo_write(beard_fd, buf, cc) != cc)
- elog(ABORT, "error while writing large object");
+ elog(ERROR, "error while writing large object");
}
lo_close(pic_fd);
if (sscanf(str, " ( %lf , %lf )", &x, &y) != 2)
{
- elog(ABORT, "complex_in: error in parsing \"%s\"", str);
+ elog(ERROR, "complex_in: error in parsing \"%s\"", str);
return NULL;
}
result = (Complex *) palloc(sizeof(Complex));
projects / thirdparty / postgresql.git / commitdiff
