*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.18 1996/12/09 01:22:17 bryanh Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/heaptuple.c,v 1.19 1997/08/19 21:28:49 momjian Exp $
*
* NOTES
* The old interface functions have been converted to macros
#define register
#endif /* !NO_ASSERT_CHECKING && sparc && sunos4 */
+static char *heap_getsysattr(HeapTuple tup, Buffer b, int attnum);
+
/* ----------------------------------------------------------------
* misc support routines
* ----------------------------------------------------------------
* heap_getsysattr
* ----------------
*/
-char *
+static char *
heap_getsysattr(HeapTuple tup, Buffer b, int attnum)
{
switch (attnum) {
return(newTuple);
}
+#ifdef NOT_USED
/* ----------------
* heap_deformtuple
*
nulls[i] = ' ';
}
}
+#endif
/* ----------------
* heap_formtuple
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.14 1997/06/12 15:41:52 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/indextuple.c,v 1.15 1997/08/19 21:28:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#endif
static Size IndexInfoFindDataOffset(unsigned short t_info);
+static char *fastgetiattr(IndexTuple tup, int attnum,
+ TupleDesc att, bool *isnull);
/* ----------------------------------------------------------------
* index_ tuple interface routines
* the same attribute descriptor will go much quicker. -cim 5/4/91
* ----------------
*/
-char *
+static char *
fastgetiattr(IndexTuple tup,
int attnum,
TupleDesc tupleDesc,
static int gistnospace(Page p, IndexTuple it);
void gistdelete(Relation r, ItemPointer tid);
static IndexTuple gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t);
-
+static void gistcentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr,
+ Relation r, Page pg, OffsetNumber o, int b, bool l) ;
+static char *int_range_out(INTRANGE *r);
/*
** routine to build an index. Basically calls insert over and over
/*
** initialize a GiST entry with a compressed version of pred
*/
-void
+static void
gistcentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr, Relation r,
Page pg, OffsetNumber o, int b, bool l)
{
}
}
-char *text_range_out(TXTRANGE *r)
+#ifdef NOT_USED
+static char *text_range_out(TXTRANGE *r)
{
char *result;
char *lower, *upper;
pfree(upper);
return(result);
}
+#endif
-char *
+static char *
int_range_out(INTRANGE *r)
{
char *result;
static RetrieveIndexResult gistfirst(IndexScanDesc s, ScanDirection dir);
static RetrieveIndexResult gistnext(IndexScanDesc s, ScanDirection dir);
static ItemPointer gistheapptr(Relation r, ItemPointer itemp);
+static bool gistindex_keytest(IndexTuple tuple, TupleDesc tupdesc,
+ int scanKeySize, ScanKey key, GISTSTATE *giststate,
+ Relation r, Page p, OffsetNumber offset);
RetrieveIndexResult
}
/* Similar to index_keytest, but decompresses the key in the IndexTuple */
-bool
+static bool
gistindex_keytest(IndexTuple tuple,
TupleDesc tupdesc,
int scanKeySize,
return (RelationGetStrategy(r, attnum, &GISTEvaluationData, proc));
}
+#ifdef NOT_USED
bool
RelationInvokeGISTStrategy(Relation r,
AttrNumber attnum,
return (RelationInvokeStrategy(r, &GISTEvaluationData, attnum, s,
left, right));
}
-
+#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/Attic/hashstrat.c,v 1.7 1996/11/05 09:40:24 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/Attic/hashstrat.c,v 1.8 1997/08/19 21:29:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
InvalidStrategy
};
+#ifdef NOT_USED
static StrategyEvaluationData HTEvaluationData = {
/* XXX static for simplicity */
(StrategyTransformMap)HTNegateCommute,
{NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL}
};
+#endif
/* ----------------------------------------------------------------
* RelationGetHashStrategy
* ----------------------------------------------------------------
*/
-StrategyNumber
+#ifdef NOT_USED
+static StrategyNumber
_hash_getstrat(Relation rel,
AttrNumber attno,
RegProcedure proc)
return (strat);
}
+#endif
-bool
+#ifdef NOT_USED
+static bool
_hash_invokestrat(Relation rel,
AttrNumber attno,
StrategyNumber strat,
return (RelationInvokeStrategy(rel, &HTEvaluationData, attno, strat,
left, right));
}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.13 1997/08/12 22:51:40 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.14 1997/08/19 21:29:17 momjian Exp $
*
*
* INTERFACE ROUTINES
* HeapScanIsValid is now a macro in relscan.h -cim 4/27/91
*/
+#ifdef NOT_USED
/* ----------------
* SetHeapAccessMethodImmediateInvalidation
* ----------------
{
ImmediateInvalidation = on;
}
+#endif
/* ----------------------------------------------------------------
* heap access method interface
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/heap/Attic/stats.c,v 1.10 1997/08/12 22:51:44 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/heap/Attic/stats.c,v 1.11 1997/08/19 21:29:21 momjian Exp $
*
* NOTES
* initam should be moved someplace else.
# include
#endif
+static void InitHeapAccessStatistics(void);
+
/* ----------------
* InitHeapAccessStatistics
* ----------------
*/
HeapAccessStatistics heap_access_stats = (HeapAccessStatistics) NULL;
-void
+static void
InitHeapAccessStatistics()
{
MemoryContext oldContext;
heap_access_stats = stats;
}
+#ifdef NOT_USED
/* ----------------
* ResetHeapAccessStatistics
* ----------------
time(&stats->local_reset_timestamp);
time(&stats->last_request_timestamp);
}
+#endif
+#ifdef NOT_USED
/* ----------------
* GetHeapAccessStatistics
* ----------------
return stats;
}
+#endif
+#ifdef NOT_USED
/* ----------------
* PrintHeapAccessStatistics
* ----------------
printf("\n");
}
+#endif
+#ifdef NOT_USED
/* ----------------
* PrintAndFreeHeapAccessStatistics
* ----------------
if (stats != NULL)
pfree(stats);
}
+#endif
/* ----------------------------------------------------------------
* access method initialization
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.6 1996/11/05 10:02:02 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/genam.c,v 1.7 1997/08/19 21:29:26 momjian Exp $
*
* NOTES
* many of the old access method routines have been turned into
return (scan);
}
+#ifdef NOT_USED
/* ----------------
* IndexScanRestart -- Restart an index scan.
*
key,
scan->numberOfKeys * sizeof(ScanKeyData));
}
+#endif
+#ifdef NOT_USED
/* ----------------
* IndexScanEnd -- End and index scan.
*
pfree(scan);
}
+#endif
/* ----------------
* IndexScanMarkPosition -- Mark current position in a scan.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.11 1997/08/12 22:51:48 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.12 1997/08/19 21:29:30 momjian Exp $
*
* INTERFACE ROUTINES
* index_open - open an index relation by relationId
RelationUnsetRIntentLock(scan->relation);
}
+#ifdef NOT_USED
/* ----------------
* index_markpos - mark a scan position
* ----------------
fmgr(procedure, scan);
}
+#endif
+#ifdef NOT_USED
/* ----------------
* index_restrpos - restore a scan position
* ----------------
fmgr(procedure, scan);
}
+#endif
/* ----------------
* index_getnext - get the next tuple from a scan
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.7 1996/11/05 10:02:06 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.8 1997/08/19 21:29:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
+static bool StrategyEvaluationIsValid(StrategyEvaluation evaluation);
+static bool StrategyExpressionIsValid(StrategyExpression expression,
+ StrategyNumber maxStrategy);
+static ScanKey StrategyMapGetScanKeyEntry(StrategyMap map,
+ StrategyNumber strategyNumber);
+static bool StrategyOperatorIsValid(StrategyOperator operator,
+ StrategyNumber maxStrategy);
+static bool StrategyTermIsValid(StrategyTerm term,
+ StrategyNumber maxStrategy);
+
/* ----------------------------------------------------------------
* misc strategy support routines
* ----------------------------------------------------------------
* Assumes that the index strategy number is valid.
* Bounds checking should be done outside this routine.
*/
-ScanKey
+static ScanKey
StrategyMapGetScanKeyEntry(StrategyMap map,
StrategyNumber strategyNumber)
{
* StrategyOperatorIsValid
* ----------------
*/
-bool
+static bool
StrategyOperatorIsValid(StrategyOperator operator,
StrategyNumber maxStrategy)
{
* StrategyTermIsValid
* ----------------
*/
-bool
+static bool
StrategyTermIsValid(StrategyTerm term,
StrategyNumber maxStrategy)
{
* StrategyExpressionIsValid
* ----------------
*/
-bool
+static bool
StrategyExpressionIsValid(StrategyExpression expression,
StrategyNumber maxStrategy)
{
* StrategyEvaluationIsValid
* ----------------
*/
-bool
+static bool
StrategyEvaluationIsValid(StrategyEvaluation evaluation)
{
Index index;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.8 1997/05/30 18:35:33 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.9 1997/08/19 21:29:36 momjian Exp $
*
* NOTES
* Postgres btree pages look like ordinary relation pages. The opaque
# include
#endif
+static void _bt_setpagelock(Relation rel, BlockNumber blkno, int access);
+static void _bt_unsetpagelock(Relation rel, BlockNumber blkno, int access);
+
#define BTREE_METAPAGE 0
#define BTREE_MAGIC 0x053162
RelationUnsetLockForWrite(rel);
}
+#ifdef NOT_USED
/*
* _bt_checkmeta() -- Verify that the metadata stored in a btree are
* reasonable.
_bt_relbuf(rel, metabuf, BT_READ);
}
+#endif
/*
* _bt_getroot() -- Get the root page of the btree.
}
}
-void
+static void
_bt_setpagelock(Relation rel, BlockNumber blkno, int access)
{
ItemPointerData iptr;
}
}
-void
+static void
_bt_unsetpagelock(Relation rel, BlockNumber blkno, int access)
{
ItemPointerData iptr;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.22 1997/08/12 22:51:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.23 1997/08/19 21:29:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static OffsetNumber
_bt_firsteq(Relation rel, TupleDesc itupdesc, Page page,
Size keysz, ScanKey scankey, OffsetNumber offnum);
-int
+static int
_bt_compare(Relation rel, TupleDesc itupdesc, Page page,
int keysz, ScanKey scankey, OffsetNumber offnum);
static bool
* but not "any time a new min key is inserted" (see _bt_insertonpg).
* - vadim 12/05/96
*/
-int
+static int
_bt_compare(Relation rel,
TupleDesc itupdesc,
Page page,
*
*
* IDENTIFICATION
- * $Id: nbtsort.c,v 1.18 1997/08/12 22:51:52 momjian Exp $
+ * $Id: nbtsort.c,v 1.19 1997/08/19 21:29:46 momjian Exp $
*
* NOTES
*
extern int ShowExecutorStats;
#endif
+static BTItem _bt_buildadd(Relation index, void *pstate, BTItem bti, int flags);
+static BTItem _bt_minitem(Page opage, BlockNumber oblkno, int atend);
+static void *_bt_pagestate(Relation index, int flags, int level, bool doupper);
+static void _bt_uppershutdown(Relation index, BTPageState *state);
+
/*
* turn on debugging output.
*
* allocate and initialize a new BTPageState. the returned structure
* is suitable for immediate use by _bt_buildadd.
*/
-void *
+static void *
_bt_pagestate(Relation index, int flags, int level, bool doupper)
{
BTPageState *state = (BTPageState *) palloc(sizeof(BTPageState));
* the page to which the item used to point, e.g., a heap page if
* 'opage' is a leaf page).
*/
-BTItem
+static BTItem
_bt_minitem(Page opage, BlockNumber oblkno, int atend)
{
OffsetNumber off;
*
* if all keys are unique, 'first' will always be the same as 'last'.
*/
-BTItem
+static BTItem
_bt_buildadd(Relation index, void *pstate, BTItem bti, int flags)
{
BTPageState *state = (BTPageState *) pstate;
return(last_bti);
}
-void
+static void
_bt_uppershutdown(Relation index, BTPageState *state)
{
BTPageState *s;
* which case we can just build the upper levels as we create the
* sorted bottom level). it is only used for index recycling.
*/
+#ifdef NOT_USED
void
_bt_upperbuild(Relation index)
{
_bt_uppershutdown(index, state);
}
+#endif
/*
* given a spool loading by successive calls to _bt_spool, create an
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.10 1997/04/16 01:48:29 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.11 1997/08/19 21:29:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return (btitem);
}
+#ifdef NOT_USED
bool
_bt_checkqual(IndexScanDesc scan, IndexTuple itup)
{
else
return (true);
}
+#endif
+#ifdef NOT_USED
bool
_bt_checkforkeys(IndexScanDesc scan, IndexTuple itup, Size keysz)
{
else
return (true);
}
+#endif
bool
_bt_checkkeys (IndexScanDesc scan, IndexTuple tuple, Size *keysok)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtstrat.c,v 1.5 1996/11/05 10:54:20 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtstrat.c,v 1.6 1997/08/19 21:29:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
+static StrategyNumber RelationGetRTStrategy(Relation r,
+ AttrNumber attnum, RegProcedure proc);
+
/*
* Note: negate, commute, and negatecommute all assume that operators are
* ordered as follows in the strategy map:
RTOverlapStrategyNumber
};
-StrategyNumber
+static StrategyNumber
RelationGetRTStrategy(Relation r,
AttrNumber attnum,
RegProcedure proc)
return (RelationGetStrategy(r, attnum, &RTEvaluationData, proc));
}
+#ifdef NOT_USED
bool
RelationInvokeRTStrategy(Relation r,
AttrNumber attnum,
return (RelationInvokeStrategy(r, &RTEvaluationData, attnum, s,
left, right));
}
+#endif
RegProcedure
RTMapOperator(Relation r,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.8 1996/11/27 15:15:54 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.9 1997/08/19 21:29:59 momjian Exp $
*
* NOTES
* This file contains the high level access-method interface to the
#include
#include
+static int RecoveryCheckingEnabled(void);
+static void TransRecover(Relation logRelation);
+static bool TransactionLogTest(TransactionId transactionId, XidStatus status);
+static void TransactionLogUpdate(TransactionId transactionId,
+ XidStatus status);
+
/* ----------------
* global variables holding pointers to relations used
* by the transaction system. These are initialized by
* recovery checking accessors
* ----------------
*/
-int
+static int
RecoveryCheckingEnabled(void)
{
return RecoveryCheckingEnableState;
}
-void
+#ifdef NOT_USED
+static void
SetRecoveryCheckingEnabled(bool state)
{
RecoveryCheckingEnableState = (state == true);
}
+#endif
/* ----------------------------------------------------------------
* postgres log/time access method interface
* --------------------------------
*/
-bool /* true/false: does transaction id have specified status? */
+static bool /* true/false: does transaction id have specified status? */
TransactionLogTest(TransactionId transactionId, /* transaction id to test */
XidStatus status) /* transaction status */
{
* TransactionLogUpdate
* --------------------------------
*/
-void
+static void
TransactionLogUpdate(TransactionId transactionId, /* trans id to update */
XidStatus status) /* new trans status */
{
* passed a flag on the command line.
* --------------------------------
*/
-void
+static void
TransRecover(Relation logRelation)
{
#if 0
TransactionLogUpdate(transactionId, XID_ABORT);
}
+#ifdef NOT_USED
void
TransactionIdSetInProgress(TransactionId transactionId)
{
TransactionLogUpdate(transactionId, XID_INPROGRESS);
}
+#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/transsup.c,v 1.8 1997/08/12 22:51:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/transsup.c,v 1.9 1997/08/19 21:30:12 momjian Exp $
*
* NOTES
* This file contains support functions for the high
#include
+static AbsoluteTime TransBlockGetCommitTime(Block tblock,
+ TransactionId transactionId);
+static XidStatus TransBlockGetXidStatus(Block tblock,
+ TransactionId transactionId);
+static void TransBlockSetCommitTime(Block tblock,
+ TransactionId transactionId, AbsoluteTime commitTime);
+static void TransBlockSetXidStatus(Block tblock,
+ TransactionId transactionId, XidStatus xstatus);
+
/* ----------------------------------------------------------------
* general support routines
* ----------------------------------------------------------------
* --------------------------------
*/
-XidStatus
+#ifdef NOT_USED
+static XidStatus
TransBlockGetLastTransactionIdStatus(Block tblock,
TransactionId baseXid,
TransactionId *returnXidP)
*/
return xstatus;
}
+#endif
/* --------------------------------
* TransBlockGetXidStatus
* --------------------------------
*/
-XidStatus
+static XidStatus
TransBlockGetXidStatus(Block tblock,
TransactionId transactionId)
{
* This sets the status of the desired transaction
* --------------------------------
*/
-void
+static void
TransBlockSetXidStatus(Block tblock,
TransactionId transactionId,
XidStatus xstatus)
* specified transaction id in the trans block.
* --------------------------------
*/
-AbsoluteTime
+static AbsoluteTime
TransBlockGetCommitTime(Block tblock,
TransactionId transactionId)
{
* This sets the commit time of the specified transaction
* --------------------------------
*/
-void
+static void
TransBlockSetCommitTime(Block tblock,
TransactionId transactionId,
AbsoluteTime commitTime)
* TransGetLastRecordedTransaction
* --------------------------------
*/
+#ifdef NOT_USED
void
TransGetLastRecordedTransaction(Relation relation,
TransactionId xid, /* return: transaction id */
*/
RelationUnsetLockForRead(relation);
}
+#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/varsup.c,v 1.8 1997/08/12 22:51:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/varsup.c,v 1.9 1997/08/19 21:30:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
+static void GetNewObjectIdBlock(Oid *oid_return, int oid_block_size);
+static void VariableRelationGetNextOid(Oid *oid_return);
+static void VariableRelationGetNextXid(TransactionId *xidP);
+static void VariableRelationPutLastXid(TransactionId xid);
+static void VariableRelationPutNextOid(Oid *oidP);
+static void VariableRelationGetLastXid(TransactionId *xidP);
+
/* ---------------------
* spin lock for oid generation
* ---------------------
* VariableRelationGetNextXid
* --------------------------------
*/
-void
+static void
VariableRelationGetNextXid(TransactionId *xidP)
{
Buffer buf;
* VariableRelationGetLastXid
* --------------------------------
*/
-void
+static void
VariableRelationGetLastXid(TransactionId *xidP)
{
Buffer buf;
* VariableRelationPutLastXid
* --------------------------------
*/
-void
+static void
VariableRelationPutLastXid(TransactionId xid)
{
Buffer buf;
* VariableRelationGetNextOid
* --------------------------------
*/
-void
+static void
VariableRelationGetNextOid(Oid *oid_return)
{
Buffer buf;
* VariableRelationPutNextOid
* --------------------------------
*/
-void
+static void
VariableRelationPutNextOid(Oid *oidP)
{
Buffer buf;
* id assignments should use this
* ----------------
*/
-void
+static void
GetNewObjectIdBlock(Oid *oid_return, /* place to return the new object id */
int oid_block_size) /* number of oids desired */
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.11 1997/08/12 22:52:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.12 1997/08/19 21:30:19 momjian Exp $
*
* NOTES
* Transaction aborts can now occur two ways:
#include
#include
+static void AbortTransaction(void);
+static void AtAbort_Cache(void);
+static void AtAbort_Locks(void);
+static void AtAbort_Memory(void);
+static void AtCommit_Cache(void);
+static void AtCommit_Locks(void);
+static void AtCommit_Memory(void);
+static void AtStart_Cache(void);
+static void AtStart_Locks(void);
+static void AtStart_Memory(void);
+static void CommitTransaction(void);
+static void RecordTransactionAbort(void);
+static void RecordTransactionCommit(void);
+static void StartTransaction(void);
+
/* ----------------
* global variables holding the current transaction state.
*
return TransactionFlushState;
}
+#ifdef NOT_USED
void
SetTransactionFlushEnabled(bool state)
{
TransactionFlushState = (state == true);
}
+#endif
/* --------------------------------
* IsTransactionState
* ClearCommandIdCounterOverflowFlag
* --------------------------------
*/
+#ifdef NOT_USED
void
ClearCommandIdCounterOverflowFlag()
{
CommandIdCounterOverflowFlag = false;
}
-
+#endif
/* --------------------------------
* CommandCounterIncrement
* AtStart_Cache
* --------------------------------
*/
-void
+static void
AtStart_Cache()
{
DiscardInvalid();
* AtStart_Locks
* --------------------------------
*/
-void
+static void
AtStart_Locks()
{
/*
* AtStart_Memory
* --------------------------------
*/
-void
+static void
AtStart_Memory()
{
Portal portal;
* -cim 3/18/90
* --------------------------------
*/
-void
+static void
RecordTransactionCommit()
{
TransactionId xid;
* AtCommit_Cache
* --------------------------------
*/
-void
+static void
AtCommit_Cache()
{
/* ----------------
* AtCommit_Locks
* --------------------------------
*/
-void
+static void
AtCommit_Locks()
{
/* ----------------
* AtCommit_Memory
* --------------------------------
*/
-void
+static void
AtCommit_Memory()
{
/* ----------------
* RecordTransactionAbort
* --------------------------------
*/
-void
+static void
RecordTransactionAbort()
{
TransactionId xid;
* AtAbort_Cache
* --------------------------------
*/
-void
+static void
AtAbort_Cache()
{
RegisterInvalid(false);
* AtAbort_Locks
* --------------------------------
*/
-void
+static void
AtAbort_Locks()
{
/* ----------------
* AtAbort_Memory
* --------------------------------
*/
-void
+static void
AtAbort_Memory()
{
/* ----------------
*
* --------------------------------
*/
-void
+static void
StartTransaction()
{
TransactionState s = CurrentTransactionState;
*
* --------------------------------
*/
-void
+static void
CommitTransaction()
{
TransactionState s = CurrentTransactionState;
*
* --------------------------------
*/
-void
+static void
AbortTransaction()
{
TransactionState s = CurrentTransactionState;
* AbortTransactionBlock
* --------------------------------
*/
-void
+#ifdef NOT_USED
+static void
AbortTransactionBlock(void)
{
TransactionState s = CurrentTransactionState;
AbortTransaction();
s->blockState = TBLOCK_ENDABORT;
}
+#endif
/* --------------------------------
* UserAbortTransactionBlock
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/xid.c,v 1.6 1997/08/12 22:52:02 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/xid.c,v 1.7 1997/08/19 21:30:20 momjian Exp $
*
* OLD COMMENTS
* XXX WARNING
* TransactionIdIncrement
* ----------------------------------------------------------------
*/
+#ifdef NOT_USED
void
TransactionIdIncrement(TransactionId *transactionId)
{
elog(FATAL, "TransactionIdIncrement: exhausted XID's");
return;
}
+#endif
/* ----------------------------------------------------------------
* TransactionIdAdd
* Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.20 1997/08/18 20:51:44 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.21 1997/08/19 21:30:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define ALLOC(t, c) (t *)calloc((unsigned)(c), sizeof(t))
#define FIRST_TYPE_OID 16 /* OID of the first type */
- extern int Int_yyparse (void);
+extern int Int_yyparse (void);
+static hashnode *AddStr(char *str, int strlength, int mderef);
+static AttributeTupleForm AllocateAttribute(void);
+static bool BootstrapAlreadySeen(Oid id);
+static int CompHash (char *str, int len);
+static hashnode *FindStr (char *str, int length, hashnode *mderef);
+static int gettype(char *type);
+static void cleanup(void);
/* ----------------
* global variables
#define MORE_THAN_THE_NUMBER_OF_CATALOGS 256
-bool
+static bool
BootstrapAlreadySeen(Oid id)
{
static Oid seenArray[MORE_THAN_THE_NUMBER_OF_CATALOGS];
* cleanup
* ----------------
*/
-void
+static void
cleanup()
{
static int beenhere = 0;
* gettype
* ----------------
*/
-int
+static int
gettype(char *type)
{
int i;
* AllocateAttribute
* ----------------
*/
-AttributeTupleForm /* XXX */
+static AttributeTupleForm /* XXX */
AllocateAttribute()
{
AttributeTupleForm attribute =
* are mod'ing by a prime number.
* ----------------
*/
-int
+static int
CompHash(char *str, int len)
{
register int result;
* or NULL if the string is not in the table.
* ----------------
*/
-hashnode *
+static hashnode *
FindStr(char *str, int length, hashnode *mderef)
{
hashnode *node;
* has assigned to this string.
* ----------------
*/
-hashnode *
+static hashnode *
AddStr(char *str, int strlength, int mderef)
{
hashnode *temp, *trail, *newnode;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.16 1997/08/19 04:42:54 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.17 1997/08/19 21:30:30 momjian Exp $
*
* INTERFACE ROUTINES
* heap_creatr() - Create an uncataloged heap relation
# include
#endif
+static void AddPgRelationTuple(Relation pg_class_desc,
+ Relation new_rel_desc, Oid new_rel_oid, int arch, unsigned natts);
+static void AddToTempRelList(Relation r);
+static void DeletePgAttributeTuples(Relation rdesc);
+static void DeletePgRelationTuple(Relation rdesc);
+static void DeletePgTypeTuple(Relation rdesc);
+static int RelationAlreadyExists(Relation pg_class_desc, char relname[]);
+static void RelationRemoveIndexes(Relation relation);
+static void RelationRemoveInheritance(Relation relation);
+static void RemoveFromTempRelList(Relation r);
+static void addNewRelationType(char *typeName, Oid new_rel_oid);
+
+
/* ----------------------------------------------------------------
* XXX UGLY HARD CODED BADNESS FOLLOWS XXX
*
* has to open pg_class and pass an open descriptor.
* --------------------------------
*/
-int
+static int
RelationAlreadyExists(Relation pg_class_desc, char relname[])
{
ScanKeyData key;
* adding a tuple to pg_class.
* --------------------------------
*/
-void
+static void
AddPgRelationTuple(Relation pg_class_desc,
Relation new_rel_desc,
Oid new_rel_oid,
* define a complex type corresponding to the new relation
* --------------------------------
*/
-void
+static void
addNewRelationType(char *typeName, Oid new_rel_oid)
{
Oid new_type_oid;
* lots of work.
* --------------------------------
*/
-void
+static void
RelationRemoveInheritance(Relation relation)
{
Relation catalogRelation;
*
* --------------------------------
*/
-void
+static void
RelationRemoveIndexes(Relation relation)
{
Relation indexRelation;
*
* --------------------------------
*/
-void
+static void
DeletePgRelationTuple(Relation rdesc)
{
Relation pg_class_desc;
*
* --------------------------------
*/
-void
+static void
DeletePgAttributeTuples(Relation rdesc)
{
Relation pg_attribute_desc;
* special. presently we disallow the destroy.
* --------------------------------
*/
-void
+static void
DeletePgTypeTuple(Relation rdesc)
{
Relation pg_type_desc;
we don't really remove it, just mark it as NULL
and DestroyTempRels will look for NULLs
*/
-void
+static void
RemoveFromTempRelList(Relation r)
{
int i;
MODIFIES the global variable tempRels
*/
-void
+static void
AddToTempRelList(Relation r)
{
if (!tempRels)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.6 1997/08/12 22:52:13 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.7 1997/08/19 21:30:38 momjian Exp $
*
*-------------------------------------------------------------------------
*/
# include
#endif
+static Oid TypeShellMakeWithOpenRelation(Relation pg_type_desc,
+ char *typeName);
+
/* ----------------------------------------------------------------
* TypeGetWithOpenRelation
*
*
* ----------------------------------------------------------------
*/
-Oid
+static Oid
TypeShellMakeWithOpenRelation(Relation pg_type_desc, char *typeName)
{
register int i;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/_deadcode/Attic/version.c,v 1.4 1997/08/12 20:15:13 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/_deadcode/Attic/version.c,v 1.5 1997/08/19 21:30:47 momjian Exp $
*
* NOTES
* At the point the version is defined, 2 physical relations are created
#define MAX_QUERY_LEN 1024
char rule_buf[MAX_QUERY_LEN];
+#ifdef NOT_USED
static char attr_list[MAX_QUERY_LEN];
-
-static void setAttrList(char *bname);
+#endif
/*
* problem: the version system assumes that the rules it declares will
* DO NOT COMMIT THE XACT, just increase the Cid counter!
* _sp.
*/
+#ifdef NOT_USED
static void
eval_as_new_xact(char *query)
{
CommandCounterIncrement();
pg_eval(query, (char **) NULL, (Oid *) NULL, 0);
}
-
+#endif
/*
* Define a version.
*/
+#ifdef NOT_USED
void
DefineVersion(char *name, char *fromRelname, char *date)
{
VersionReplace (name, saved_basename,saved_snapshot);
VersionRetrieve (name, saved_basename, saved_snapshot);
}
-
+#endif
/*
* Creates the deltas.
*/
+#ifdef NOT_USED
void
VersionCreate(char *vname, char *bname)
{
sprintf (query_buf, "CREATE TABLE %s_del (DOID oid)", vname);
eval_as_new_xact (query_buf);
}
+#endif
/*
* sets the global variable 'attr_list' with the list of attributes (names)
* for that relation.
*/
+#ifdef NOT_USED
static void
setAttrList(char *bname)
{
return;
}
+#endif
/*
* This routine defines the rule governing the append semantics of
* versions. All tuples appended to a version gets appended to the
* _added relation.
*/
-void
+#ifdef NOT_USED
+static void
VersionAppend(char *vname, char *bname)
{
sprintf(rule_buf,
eval_as_new_xact(rule_buf);
}
-
+#endif
/*
* This routine defines the rule governing the retrieval semantics of
* 2. Retrieve all tuples in the base relation which are not in
* the _del relation.
*/
+#ifdef NOT_USED
void
VersionRetrieve(char *vname, char *bname, char *snapshot)
{
/* printf("%s\n",rule_buf); */
}
+#endif
/*
* This routine defines the rules that govern the delete semantics of
* then we have to mark that tuple as being deleted by adding
* it to the _del relation.
*/
+#ifdef NOT_USED
void
VersionDelete(char *vname, char *bname, char *snapshot)
{
eval_as_new_xact(rule_buf);
#endif /* OLD_REWRITE */
}
+#endif
/*
* This routine defines the rules that govern the update semantics
* adding the tuple to the _del relation.
* 2.2 A copy of the tuple is appended to the _added relation
*/
+#ifdef NOT_USED
void
VersionReplace(char *vname, char *bname, char *snapshot)
{
}
+#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.16 1997/08/12 22:52:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.17 1997/08/19 21:30:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static int AsyncExistsPendingNotify(char *);
static void ClearPendingNotify(void);
+static void Async_NotifyFrontEnd(void);
+static void Async_Unlisten(char *relname, int pid);
+static void Async_UnlistenOnExit(int code, char *relname);
/*
*--------------------------------------------------------------
*
*--------------------------------------------------------------
*/
-void
+static void
Async_Unlisten(char *relname, int pid)
{
Relation lDesc;
heap_close(lDesc);
}
-void
+static void
Async_UnlistenOnExit(int code, /* from exitpg */
char *relname)
{
*/
GlobalMemory notifyContext = NULL;
-void
+static void
Async_NotifyFrontEnd()
{
extern CommandDest whereToSendOutput;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.12 1997/08/18 20:52:07 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.13 1997/08/19 21:30:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
#endif /* !NO_SECURITY */
+static Relation copy_heap(Oid OIDOldHeap);
+static void copy_index(Oid OIDOldIndex, Oid OIDNewHeap);
+static void rebuildheap(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex);
+
/*
* cluster
*
StartTransactionCommand();
}
-Relation
+static Relation
copy_heap(Oid OIDOldHeap)
{
char NewName[NAMEDATALEN];
return NewHeap;
}
-void
+static void
copy_index(Oid OIDOldIndex, Oid OIDNewHeap)
{
Relation OldIndex, NewHeap;
}
-void
+static void
rebuildheap(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex)
{
Relation LocalNewHeap, LocalOldHeap, LocalOldIndex;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.4 1996/11/08 00:45:54 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execAmi.c,v 1.5 1997/08/19 21:30:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "catalog/heap.h"
+static Pointer ExecBeginScan(Relation relation, int nkeys, ScanKey skeys,
+ bool isindex, ScanDirection dir, TimeQual time_range);
+static Relation ExecOpenR(Oid relationOid, bool isindex);
+
/* ----------------------------------------------------------------
* ExecOpenScanR
*
* returns a relation descriptor given an object id.
* ----------------------------------------------------------------
*/
-Relation
+static Relation
ExecOpenR(Oid relationOid, bool isindex)
{
Relation relation;
* -cim 9/14/89
* ----------------------------------------------------------------
*/
-Pointer
+static Pointer
ExecBeginScan(Relation relation,
int nkeys,
ScanKey skeys,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/Attic/execFlatten.c,v 1.1.1.1 1996/07/09 06:21:24 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/Attic/execFlatten.c,v 1.2 1997/08/19 21:30:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "executor/executor.h"
#include "executor/execFlatten.h"
+#ifdef SETS_FIXED
+static bool FjoinBumpOuterNodes(TargetEntry *tlist, ExprContext *econtext,
+ DatumPtr results, char *nulls);
+#endif
+
Datum
ExecEvalIter(Iter *iterNode,
ExprContext *econtext,
return;
}
-bool
+#ifdef SETS_FIXED
+static bool
FjoinBumpOuterNodes(TargetEntry *tlist,
ExprContext *econtext,
DatumPtr results,
char *nulls)
{
-#ifdef SETS_FIXED
bool funcIsDone = true;
Fjoin *fjNode = tlist->fjoin;
char *alwaysDone = fjNode->fj_alwaysDone;
trailers = lnext(trailers);
}
return false;
-#endif
- return false;
}
+#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.16 1997/08/19 04:43:45 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.17 1997/08/19 21:31:00 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#undef ALL_TUPLES
#define ALL_TUPLES queryLimit
+#ifdef NOT_USED
int
ExecutorLimit(int limit)
{
return queryLimit = limit;
}
#endif
+#endif
/* ----------------------------------------------------------------
* ExecutorStart
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.11 1997/04/22 03:32:35 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.12 1997/08/19 21:31:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static Datum ExecEvalAggreg(Aggreg *agg, ExprContext *econtext, bool *isNull);
static Datum ExecEvalArrayRef(ArrayRef *arrayRef, ExprContext *econtext,
bool *isNull, bool *isDone);
+static Datum ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull);
+static Datum ExecEvalFunc(Expr *funcClause, ExprContext *econtext,
+ bool *isNull, bool *isDone);
+static void ExecEvalFuncArgs(FunctionCachePtr fcache, ExprContext *econtext,
+ List *argList, Datum argV[], bool *argIsDone);
+static Datum ExecEvalNot(Expr *notclause, ExprContext *econtext, bool *isNull);
+static Datum ExecEvalOper(Expr *opClause, ExprContext *econtext,
+ bool *isNull);
+static Datum ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull);
+static Datum ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull);
+static Datum ExecMakeFunctionResult(Node *node, List *arguments,
+ ExprContext *econtext, bool *isNull, bool *isDone);
+static bool ExecQualClause(Node *clause, ExprContext *econtext);
/* --------------------------------
* ExecEvalArrayRef
* We have an Assert to make sure this entry condition is met.
*
* ---------------------------------------------------------------- */
-Datum
+static Datum
ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull)
{
Datum result;
* to use this. Ex: overpaid(EMP) might call GetAttributeByNum().
* ----------------
*/
-char *
+#ifdef NOT_USED
+static char *
GetAttributeByNum(TupleTableSlot *slot,
AttrNumber attrno,
bool *isNull)
return (char *) NULL;
return (char *) retval;
}
+#endif
/* XXX char16 name for catalogs */
+#ifdef NOT_USED
char *
att_by_num(TupleTableSlot *slot,
AttrNumber attrno,
{
return(GetAttributeByNum(slot, attrno, isNull));
}
+#endif
char *
GetAttributeByName(TupleTableSlot *slot, char *attname, bool *isNull)
}
/* XXX char16 name for catalogs */
+#ifdef NOT_USED
char *
att_by_name(TupleTableSlot *slot, char *attname, bool *isNull)
{
return(GetAttributeByName(slot, attname, isNull));
}
+#endif
-void
+static void
ExecEvalFuncArgs(FunctionCachePtr fcache,
ExprContext *econtext,
List *argList,
* ExecMakeFunctionResult
* ----------------
*/
-Datum
+static Datum
ExecMakeFunctionResult(Node *node,
List *arguments,
ExprContext *econtext,
* ExecEvalOper
* ----------------------------------------------------------------
*/
-Datum
+static Datum
ExecEvalOper(Expr *opClause, ExprContext *econtext, bool *isNull)
{
Oper *op;
* ----------------------------------------------------------------
*/
-Datum
+static Datum
ExecEvalFunc(Expr *funcClause,
ExprContext *econtext,
bool *isNull,
* need to know this, mind you...
* ----------------------------------------------------------------
*/
-Datum
+static Datum
ExecEvalNot(Expr *notclause, ExprContext *econtext, bool *isNull)
{
Datum expr_value;
* ExecEvalOr
* ----------------------------------------------------------------
*/
-Datum
+static Datum
ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull)
{
List *clauses;
* ExecEvalAnd
* ----------------------------------------------------------------
*/
-Datum
+static Datum
ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull)
{
List *clauses;
* rest of the qualification)
* ----------------------------------------------------------------
*/
-bool
+static bool
ExecQualClause(Node *clause, ExprContext *econtext)
{
Datum expr_value;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execTuples.c,v 1.5 1996/12/11 00:26:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execTuples.c,v 1.6 1997/08/19 21:31:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/catalog_utils.h"
#include "catalog/pg_type.h"
+static TupleTableSlot *NodeGetResultTupleSlot(Plan *node);
+
+
/* ----------------------------------------------------------------
* tuple table create/delete functions
* ----------------------------------------------------------------
* merge joins that you need to diddle the slot policy.
* --------------------------------
*/
+#ifdef NOT_USED
bool /* return: slot policy */
ExecSlotPolicy(TupleTableSlot* slot) /* slot to inspect */
{
return slot->ttc_shouldFree;
}
+#endif
/* --------------------------------
* ExecSetSlotPolicy
* with the slot's tuple, and set the "isNew" flag at the same time.
* --------------------------------
*/
+#ifdef NOT_USED
TupleDesc /* return: old slot tuple descriptor */
ExecSetNewSlotDescriptor(TupleTableSlot *slot, /* slot to change */
TupleDesc tupdesc) /* tuple descriptor */
return old_tupdesc;
}
+#endif
/* --------------------------------
* ExecSlotBuffer
* also use ExecIncrSlotBufferRefcnt().
* --------------------------------
*/
+#ifdef NOT_USED
Buffer /* return: old slot buffer */
ExecSetSlotBuffer(TupleTableSlot *slot, /* slot to change */
Buffer b) /* tuple descriptor */
return oldb;
}
+#endif
/* --------------------------------
* ExecIncrSlotBufferRefcnt
* now storing a new type of tuple in this slot
* --------------------------------
*/
+#ifdef NOT_USED
bool /* return: descriptor "is new" */
ExecSlotDescriptorIsNew(TupleTableSlot *slot) /* slot to inspect */
{
return isNew; */
return slot->ttc_descIsNew;
}
+#endif
/* ----------------------------------------------------------------
* convenience initialization routines
* ExecInitHashTupleSlot
* ----------------
*/
+#ifdef NOT_USED
void
ExecInitHashTupleSlot(EState *estate, HashJoinState *hashstate)
{
INIT_SLOT_ALLOC;
hashstate->hj_HashTupleSlot = slot;
}
+#endif
-TupleTableSlot *
+static TupleTableSlot *
NodeGetResultTupleSlot(Plan *node)
{
TupleTableSlot *slot;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.10 1997/08/18 20:52:27 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.11 1997/08/19 21:31:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/pg_type.h"
#include "parser/parsetree.h"
+static void ExecGetIndexKeyInfo(IndexTupleForm indexTuple, int *numAttsOutP,
+ AttrNumber **attsOutP, FuncIndexInfoPtr fInfoP);
+
/* ----------------------------------------------------------------
* global counters for number of tuples processed, retrieved,
* appended, replaced, deleted.
* ResetTupleCount
* ----------------------------------------------------------------
*/
+#ifdef NOT_USED
void
ResetTupleCount(void)
{
NTupleReplaced = 0;
NIndexTupleProcessed = 0;
}
+#endif
/* ----------------------------------------------------------------
* PrintTupleCount
* ----------------------------------------------------------------
*/
+#ifdef NOT_USED
void
DisplayTupleCount(FILE *statfp)
{
(NTupleReplaced == 1) ? "" : "s");
fprintf(statfp, "\n");
}
+#endif
/* ----------------------------------------------------------------
* miscellanious init node support functions
* ExecFreeResultType
* ----------------
*/
+#ifdef NOT_USED
void
ExecFreeResultType(CommonState *commonstate)
{
/* ExecFreeTypeInfo(tupType); */
pfree(tupType);
}
-
+#endif
/* ----------------
* ExecAssignProjectionInfo
* ExecFreeScanType
* ----------------
*/
+#ifdef NOT_USED
void
ExecFreeScanType(CommonScanState *csstate)
{
/* ExecFreeTypeInfo(tupType); */
pfree(tupType);
}
+#endif
/* ----------------
* ExecAssignScanType
* parameters.
* ----------------------------------------------------------------
*/
-void
+static void
ExecGetIndexKeyInfo(IndexTupleForm indexTuple,
int *numAttsOutP,
AttrNumber **attsOutP,
* set of routines..
* ----------------------------------------------------------------
*/
+#ifdef NOT_USED
IndexTuple
ExecFormIndexTuple(HeapTuple heapTuple,
Relation heapRelation,
return indexTuple;
}
+#endif
/* ----------------------------------------------------------------
* ExecInsertIndexTuples
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeAppend.c,v 1.4 1996/11/06 06:47:39 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeAppend.c,v 1.5 1997/08/19 21:31:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/mcxt.h"
#include "parser/parsetree.h" /* for rt_store() macro */
+static bool exec_append_initialize_next(Append *node);
+
/* ----------------------------------------------------------------
* exec-append-initialize-next
*
* Returns t iff there is a "next" scan to process.
* ----------------------------------------------------------------
*/
-bool
+static bool
exec_append_initialize_next(Append *node)
{
EState *estate;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeHash.c,v 1.9 1997/07/28 00:53:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeHash.c,v 1.10 1997/08/19 21:31:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static void mk_hj_temp(char *tempname);
static int hashFunc(char *key, int len);
+static int ExecHashPartition(Hash *node);
+static RelativeAddr hashTableAlloc(int size, HashJoinTable hashtable);
+static void ExecHashOverflowInsert(HashJoinTable hashtable,
+ HashBucket bucket,
+ HeapTuple heapTuple);
/* ----------------------------------------------------------------
* ExecHash
ExecEndNode(outerPlan, (Plan*)node);
}
-RelativeAddr
+static RelativeAddr
hashTableAlloc(int size, HashJoinTable hashtable)
{
RelativeAddr p;
* insert into the overflow area of a hash bucket
* ----------------------------------------------------------------
*/
-void
+static void
ExecHashOverflowInsert(HashJoinTable hashtable,
HashBucket bucket,
HeapTuple heapTuple)
* determine the number of batches needed for a hashjoin
* ----------------------------------------------------------------
*/
-int
+static int
ExecHashPartition(Hash *node)
{
Plan *outerNode;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.4 1997/07/28 00:54:06 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeHashjoin.c,v 1.5 1997/08/19 21:31:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
ExecHashJoinGetSavedTuple(HashJoinState *hjstate, char *buffer,
File file, TupleTableSlot *tupleSlot, int *block, char **position);
+static int ExecHashJoinGetBatch(int bucketno, HashJoinTable hashtable,
+ int nbatch);
+
+static int ExecHashJoinNewBatch(HashJoinState *hjstate);
+
+
+
/* ----------------------------------------------------------------
* ExecHashJoin
*
* switch to a new hashjoin batch
* ----------------------------------------------------------------
*/
-int
+static int
ExecHashJoinNewBatch(HashJoinState *hjstate)
{
File *innerBatches;
* batch 0 1 2 ...
* ----------------------------------------------------------------
*/
-int
+static int
ExecHashJoinGetBatch(int bucketno, HashJoinTable hashtable, int nbatch)
{
int b;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.7 1997/08/12 22:52:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.8 1997/08/19 21:31:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/lsyscache.h"
#include "utils/psort.h"
+static bool MergeCompare(List *eqQual, List *compareQual, ExprContext *econtext);
+
/* ----------------------------------------------------------------
* MarkInnerTuple and RestoreInnerTuple macros
*
* if (key1i > key2i) is true and (key1j = key2j) for 0 < j < i.
* ----------------------------------------------------------------
*/
-bool
+static bool
MergeCompare(List *eqQual, List *compareQual, ExprContext *econtext)
{
List *clause;
* when EXEC_MERGEJOINDEBUG is defined
* ----------------------------------------------------------------
*/
+#ifdef EXEC_MERGEJOINDEBUG
void
ExecMergeTupleDumpInner(ExprContext *econtext)
{
debugtup(innerSlot->val,
innerSlot->ttc_tupleDescriptor);
}
-
+
void
ExecMergeTupleDumpOuter(ExprContext *econtext)
{
debugtup(outerSlot->val,
outerSlot->ttc_tupleDescriptor);
}
-
+
void
ExecMergeTupleDumpMarked(ExprContext *econtext,
MergeJoinState *mergestate)
debugtup(markedSlot->val,
markedSlot->ttc_tupleDescriptor);
}
-
+
void
ExecMergeTupleDump(ExprContext *econtext, MergeJoinState *mergestate)
{
printf("******** \n");
}
+#endif
static void
CleanUpSort(Plan *plan) {
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.3 1996/11/08 05:56:16 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeSeqscan.c,v 1.4 1997/08/19 21:31:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "parser/parsetree.h"
+static Oid InitScanRelation(SeqScan *node, EState *estate,
+ CommonScanState *scanstate, Plan *outerPlan);
+
+static TupleTableSlot *SeqNext(SeqScan *node);
+
/* ----------------------------------------------------------------
* Scan Support
* ----------------------------------------------------------------
* This is a workhorse for ExecSeqScan
* ----------------------------------------------------------------
*/
-TupleTableSlot *
+static TupleTableSlot *
SeqNext(SeqScan *node)
{
HeapTuple tuple;
* subplans of scans.
* ----------------------------------------------------------------
*/
-Oid
+static Oid
InitScanRelation(SeqScan *node, EState *estate,
CommonScanState *scanstate, Plan *outerPlan)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/lib/dllist.c,v 1.4 1996/11/10 03:00:20 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/lib/dllist.c,v 1.5 1997/08/19 21:31:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
/* get the value stored in the first element */
+#ifdef NOT_USED
void*
DLGetHeadVal(Dllist* l)
{
return (e ? e->dle_val : 0);
}
+#endif
Dlelem*
DLGetTail(Dllist* l)
}
/* get the value stored in the first element */
+#ifdef NOT_USED
void*
DLGetTailVal(Dllist* l)
{
return (e ? e->dle_val : 0);
}
-
+#endif
Dlelem*
DLGetPred(Dlelem* e) /* get predecessor */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/lib/Attic/lispsort.c,v 1.3 1996/11/06 08:27:14 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/lib/Attic/lispsort.c,v 1.4 1997/08/19 21:31:18 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
#include
+#ifdef NOT_USED
/*
** lisp_qsort: Takes a lisp list as input, copies it into an array of lisp
** nodes which it sorts via qsort() with the comparison function
return(output);
}
+#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/libpq/auth.c,v 1.13 1997/08/12 22:52:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/libpq/auth.c,v 1.14 1997/08/19 21:31:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include
#include
+static int be_getauthsvc(MsgType msgtype);
+
/*----------------------------------------------------------------
* common definitions for generic fe/be routines
*----------------------------------------------------------------
return;
}
-int
+static int
be_getauthsvc(MsgType msgtype)
{
int i;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/libpq/Attic/be-pqexec.c,v 1.3 1997/08/12 20:15:19 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/libpq/Attic/be-pqexec.c,v 1.4 1997/08/19 21:31:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
# include
#endif
+static char *strmake(char *str, int len);
+
/* ----------------------------------------------------------------
* PQ interface routines
* ----------------------------------------------------------------
* utilities for pqtest_PQfn()
* ----------------
*/
-char *
+static char *
strmake(char *str, int len)
{
char *newstr;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.5 1997/01/10 20:17:43 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.6 1997/08/19 21:31:36 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/elog.h"
#include "storage/itemptr.h"
+static bool equali(List *a, List *b);
+
/*
* Stuff from primnodes.h
*/
*
* XXX temp hack. needs something like T_IntList
*/
-bool equali(List *a, List *b)
+static bool
+equali(List *a, List *b)
{
List *la = (List*)a;
List *lb = (List*)b;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.3 1997/03/12 20:59:27 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/list.c,v 1.4 1997/08/19 21:31:39 momjian Exp $
*
* NOTES
* XXX a few of the following functions are duplicated to handle
return(list);
}
+#ifdef NOT_USED
List *
intLispRemove(int elem, List *list)
{
}
return(list);
}
+#endif
List *
set_difference(List *list1, List *list2)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/nodeFuncs.c,v 1.2 1996/10/31 10:42:56 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/nodeFuncs.c,v 1.3 1997/08/19 21:31:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/nodeFuncs.h"
#include "utils/lsyscache.h"
+static bool var_is_inner(Var *var);
+
/*
* single_node -
* Returns t if node corresponds to a single-noded expression
return((bool)(var->varno == OUTER));
}
-bool
+static bool
var_is_inner (Var *var)
{
return ( (bool) (var->varno == INNER));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.5 1997/08/12 20:15:27 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.6 1997/08/19 21:31:43 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
#include "nodes/nodes.h"
#include "nodes/plannodes.h"
#include "optimizer/clauses.h"
+
+static char *plannode_type (Plan* p);
+
/*
* print--
* print contents of Node to stdout
debugtup(slot->val, slot->ttc_tupleDescriptor);
}
-char*
+static char *
plannode_type (Plan* p)
{
switch(nodeTag(p)) {
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.15 1997/04/24 15:49:30 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.16 1997/08/19 21:31:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static int compute_attribute_width(TargetEntry *tlistentry);
static double base_log(double x, double b);
+static int compute_targetlist_width(List *targetlist);
int _disable_cost_ = 30000000;
* Returns a flonum.
*
*/
+#ifdef NOT_USED
Cost
cost_result(int tuples, int width)
{
Assert(temp >= 0);
return(temp);
}
+#endif
/*
* cost_nestloop--
*
* Returns the width of the tuple as a fixnum.
*/
-int
+static int
compute_targetlist_width(List *targetlist)
{
List *temp_tl;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.6 1997/01/22 06:30:57 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.7 1997/08/19 21:31:54 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
#include "optimizer/internal.h"
#include "optimizer/var.h"
+static bool agg_clause(Node *clause);
+
Expr *
make_clause(int type, Node *oper, List *args)
* AGG clause functions
*****************************************************************************/
-bool
+static bool
agg_clause(Node *clause)
{
return
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/keys.c,v 1.1.1.1 1996/07/09 06:21:38 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/keys.c,v 1.2 1997/08/19 21:32:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static Expr *matching2_tlvar(int var, List *tlist, bool (*test)());
+static bool equal_indexkey_var(int index_key, Var *var);
/*
* 1. index key
* fields of var node 'var'.
*
*/
-bool
+static bool
equal_indexkey_var(int index_key, Var *var)
{
if (index_key == var->varattno)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/ordering.c,v 1.2 1996/10/31 10:59:41 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/Attic/ordering.c,v 1.3 1997/08/19 21:32:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/internal.h"
#include "optimizer/ordering.h"
+static bool equal_sortops_order(Oid *ordering1, Oid *ordering2);
/*
* equal-path-path-ordering--
* equal_sort_ops_order -
* Returns true iff the sort operators are in the same order.
*/
-bool
+static bool
equal_sortops_order(Oid *ordering1, Oid *ordering2)
{
int i = 0;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/tlist.c,v 1.2 1997/04/05 06:39:58 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/tlist.c,v 1.3 1997/08/19 21:32:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* append the group attribute to the target list if it's not already
* in there.
*/
+#if 0
void
AddGroupAttrToTlist(List *tlist, List *grpCl)
{
-#if 0
List *gl;
int last_resdomno = length(tlist) + 1;
tlist = lappend(tlist, MakeTLE(r, (Node*)var));
}
}
-#endif
}
+#endif
/* was ExecTargetListLength() in execQual.c,
moved here to reduce dependencies on the executor module */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.33 1997/08/18 20:53:00 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.34 1997/08/19 21:32:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static void AddAggToParseState(ParseState *pstate, Aggreg *aggreg);
static void finalizeAggregates(ParseState *pstate, Query *qry);
static void parseCheckAggregates(ParseState *pstate, Query *qry);
+static ParseState* makeParseState(void);
/*****************************************************************************
*
*
*/
-ParseState*
+static ParseState*
makeParseState(void)
{
ParseState *pstate;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/Attic/catalog_utils.c,v 1.20 1997/08/12 20:15:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/Attic/catalog_utils.c,v 1.21 1997/08/19 21:32:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static Oid **argtype_inherit(int nargs, Oid *oid_array);
static Oid **genxprod(InhPaths *arginh, int nargs);
static int findsupers(Oid relid, Oid **supervec);
+static bool check_typeid(Oid id);
+static char *instr1(TypeTupleForm tp, char *string, int typlen);
+static void op_error(char *op, Oid arg1, Oid arg2);
/* check to see if a type id is valid,
* returns true if it is. By using this call before calling
* can be produced because the caller typically has more context of
* what's going on - jolly
*/
-bool
+static bool
check_typeid(Oid id)
{
return (SearchSysCacheTuple(TYPOID,
/* Given a typename and value, returns the ascii form of the value */
+#ifdef NOT_USED
char *
outstr(char *typename, /* Name of type of value */
char *value) /* Could be of any type */
op = tp->typoutput;
return((char *) fmgr(op, value));
}
+#endif
/* Given a Type and a string, return the internal form of that string */
char *
/* Given a type structure and a string, returns the internal form of
that string */
-char *
+static char *
instr1(TypeTupleForm tp, char *string, int typlen)
{
Oid op;
return (type->typelem);
}
+#ifdef NOT_USED
char
FindDelimiter(char *typename)
{
delim = type->typdelim;
return (delim);
}
+#endif
/*
* Give a somewhat useful error message when the operator for two types
* is not found.
*/
-void
+static void
op_error(char *op, Oid arg1, Oid arg2)
{
Type tp1 = NULL, tp2 = NULL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/Attic/dbcommands.c,v 1.5 1997/08/18 20:53:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/Attic/dbcommands.c,v 1.6 1997/08/19 21:32:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static void check_permissions(char *command, char *dbname,
Oid *dbIdP, Oid *userIdP);
static HeapTuple get_pg_dbtup(char *command, char *dbname, Relation dbrel);
+static void stop_vacuum(char *dbname);
void
createdb(char *dbname)
* stop_vacuum() -- stop the vacuum daemon on the database, if one is
* running.
*/
-void
+static void
stop_vacuum(char *dbname)
{
char filename[256];
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/Attic/parse_query.c,v 1.16 1997/05/31 07:10:25 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/Attic/parse_query.c,v 1.17 1997/08/19 21:32:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/parsenodes.h"
#include "nodes/makefuncs.h"
+static void checkTargetTypes(ParseState *pstate, char *target_colname,
+ char *refname, char *colname);
+
Oid *param_type_info;
int pfunc_num_args;
* checkTargetTypes -
* checks value and target column types
*/
-void
+static void
checkTargetTypes(ParseState *pstate, char *target_colname,
char *refname, char *colname)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.51 1997/08/12 22:53:31 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.52 1997/08/19 21:32:27 momjian Exp $
*
* NOTES
*
static int DoExec(StartupInfo *packet, int portFd);
static void ExitPostmaster(int status);
static void usage(const char *);
-int ServerLoop(void);
-int BackendStartup(StartupInfo *packet, Port *port, int *pidPtr);
+static int ServerLoop(void);
+static int BackendStartup(StartupInfo *packet, Port *port, int *pidPtr);
static void send_error_reply(Port *port, const char *errormsg);
extern char *optarg;
exit(1);
}
-int
+static int
ServerLoop(void)
{
int serverFd = ServerSock;
* otherwise.
*
*/
-int
+static int
BackendStartup(StartupInfo *packet, /* client's startup packet */
Port *port,
int *pidPtr)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_table.c,v 1.3 1996/11/03 04:56:59 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_table.c,v 1.4 1997/08/19 21:32:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
/* prints out collision stats for the buf table */
+#ifdef NOT_USED
void
DBG_LookupListCheck(int nlookup)
{
hash_stats("Shared",SharedBufHash);
}
+#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.18 1997/08/18 20:53:08 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.19 1997/08/19 21:32:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*
* WriteBuffer() -- WriteNoReleaseBuffer() + ReleaseBuffer()
*
- * DirtyBufferCopy() -- For a given dbid/relid/blockno, if the buffer is
- * in the cache and is dirty, mark it clean and copy
- * it to the requested location. This is a logical
- * write, and has been installed to support the cache
- * management code for write-once storage managers.
- *
* FlushBuffer() -- as above but never delayed write.
*
* BufferSync() -- flush all dirty buffers in the buffer pool.
*
* XXX caller must have already acquired BufMgrLock
*/
+#ifdef NOT_USED
static bool
is_userbuffer(Buffer buffer)
{
return false;
return true;
}
+#endif
+#ifdef NOT_USED
Buffer
ReadBuffer_Debug(char *file,
int line,
}
return buffer;
}
+#endif
/*
* ReadBufferWithBufferLock -- does the work of
return(TRUE);
}
+#ifdef NOT_USED
void
WriteBuffer_Debug(char *file, int line, Buffer buffer)
{
PrivateRefCount[buffer - 1], file, line);
}
}
+#endif
/*
+ * DirtyBufferCopy() -- For a given dbid/relid/blockno, if the buffer is
+ * in the cache and is dirty, mark it clean and copy
+ * it to the requested location. This is a logical
+ * write, and has been installed to support the cache
+ * management code for write-once storage managers.
+ *
* DirtyBufferCopy() -- Copy a given dirty buffer to the requested
* destination.
*
*
* NOTE: used by sony jukebox code in postgres 4.2 - ay 2/95
*/
+#ifdef NOT_USED
void
DirtyBufferCopy(Oid dbid, Oid relid, BlockNumber blkno, char *dest)
{
SpinRelease(BufMgrLock);
}
+#endif
/*
* FlushBuffer -- like WriteBuffer, but force the page to disk.
* pool and start measuring some performance with a clean empty buffer
* pool.
*/
+#ifdef NOT_USED
void
BufferPoolBlowaway()
{
BufTableDelete(&BufferDescriptors[i-1]);
}
}
+#endif
#undef IncrBufferRefCount
#undef ReleaseBuffer
return(STATUS_OK);
}
+#ifdef NOT_USED
void
IncrBufferRefCount_Debug(char *file, int line, Buffer buffer)
{
PrivateRefCount[buffer - 1], file, line);
}
}
+#endif
+#ifdef NOT_USED
void
ReleaseBuffer_Debug(char *file, int line, Buffer buffer)
{
PrivateRefCount[buffer - 1], file, line);
}
}
+#endif
+#ifdef NOT_USED
int
ReleaseAndReadBuffer_Debug(char *file,
int line,
}
return b;
}
+#endif
#ifdef BMTRACE
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/freelist.c,v 1.3 1996/11/10 03:02:16 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/freelist.c,v 1.4 1997/08/19 21:32:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
PrivateRefCount[b]++;
}
+#ifdef NOT_USED
void
PinBuffer_Debug(char *file, int line, BufferDesc *buf)
{
PrivateRefCount[buffer - 1], file, line);
}
}
+#endif
#undef UnpinBuffer
}
}
+#ifdef NOT_USED
void
UnpinBuffer_Debug(char *file, int line, BufferDesc *buf)
{
PrivateRefCount[buffer - 1], file, line);
}
}
+#endif
/*
* GetFreeBuffer() -- get the 'next' buffer from the freelist.
/*
* print out the free list and check for breaks.
*/
+#ifdef NOT_USED
void
DBG_FreeListCheck(int nfree)
{
}
}
+#endif
#ifdef NOT_USED
/*
* Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Id: fd.c,v 1.21 1997/08/18 02:14:50 momjian Exp $
+ * $Id: fd.c,v 1.22 1997/08/19 21:32:48 momjian Exp $
*
* NOTES:
*
/*
* Called when we get a shared invalidation message on some relation.
*/
+#ifdef NOT_USED
void
FileInvalidate(File file)
{
LruDelete(file);
}
}
+#endif
/* VARARGS2 */
static File
/*
* XXX not actually used but here for completeness
*/
+#ifdef NOT_USED
long
FileTell(File file)
{
file, VfdCache[file].fileName));
return VfdCache[file].seekPos;
}
+#endif
int
FileTruncate(File file, int offset)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.10 1997/01/08 08:32:01 bryanh Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.11 1997/08/19 21:32:54 momjian Exp $
*
* NOTES
*
int UsePrivateMemory = 0;
#endif
+static void IpcMemoryDetach(int status, char *shmaddr);
+
/* ----------------------------------------------------------------
* exit() handling stuff
* ----------------------------------------------------------------
/* */
/* note: the xxx_return variables are only used for debugging. */
/****************************************************************************/
+#ifdef NOT_USED
static int IpcSemaphoreSet_return;
void
IpcConfigTip();
}
}
+#endif
/****************************************************************************/
/* IpcSemaphoreKill(key) - removes a semaphore */
/* from a backend address space */
/* (only called by backends running under the postmaster) */
/****************************************************************************/
-void
+static void
IpcMemoryDetach(int status, char *shmaddr)
{
if (shmdt(shmaddr) < 0) {
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/Attic/s_lock.c,v 1.17 1997/08/17 02:39:54 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/Attic/s_lock.c,v 1.18 1997/08/19 21:33:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#if defined(HAS_TEST_AND_SET)
# if defined(__alpha__) && defined(linux)
-extern long int tas(slock_t *lock);
+static long int tas(slock_t *lock);
# else
-extern int tas(slock_t *lock);
+static int tas(slock_t *lock);
#endif
#if defined (nextstep)
#if defined(NEED_I386_TAS_ASM)
-int
+static int
tas(slock_t *m)
{
slock_t res;
#if defined(__alpha__) && defined(linux)
-long int
+static long int
tas(slock_t *m)
{
slock_t res;
#if defined(linux) && defined(sparc)
-int
+static int
tas(slock_t *m)
{
slock_t res;
#if defined(NEED_NS32K_TAS_ASM)
-int
+static int
tas(slock_t *m)
{
slock_t res = 0;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmqueue.c,v 1.2 1996/11/03 05:06:58 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmqueue.c,v 1.3 1997/08/19 21:33:06 momjian Exp $
*
* NOTES
*
* SHMQueueIsDetached -- TRUE if element is not currently
* in a queue.
*/
+#ifdef NOT_USED
bool
SHMQueueIsDetached(SHM_QUEUE *queue)
{
Assert(SHM_PTR_VALID(queue));
return ((queue)->prev == INVALID_OFFSET);
}
+#endif
/*
* SHMQueueElemInit -- clear an element's links
* SHMQueueInsertHD -- put elem in queue between the queue head
* and its "prev" element.
*/
+#ifdef NOT_USED
void
SHMQueueInsertHD(SHM_QUEUE *queue, SHM_QUEUE *elem)
{
dumpQ(queue, "in SHMQueueInsertHD: end");
#endif /* SHMQUEUE_DEBUG_HD */
}
+#endif
void
SHMQueueInsertTL(SHM_QUEUE *queue, SHM_QUEUE *elem)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/ipc/Attic/spin.c,v 1.4 1997/01/14 01:53:11 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/ipc/Attic/spin.c,v 1.5 1997/08/19 21:33:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return(TRUE);
}
-bool
-AttachSpinLocks(IPCKey key)
-{
- /* the spin lock shared memory must have been attached by now */
- return(TRUE);
-}
-
bool
InitSpinLocks(int init, IPCKey key)
{
ExclusiveUnlock(lock);
}
-bool
+#else /* HAS_TEST_AND_SET */
+/* Spinlocks are implemented using SysV semaphores */
+
+static bool AttachSpinLocks(IPCKey key);
+static bool SpinIsLocked(SPINLOCK lock);
+
+
+static bool
+AttachSpinLocks(IPCKey key)
+{
+ /* the spin lock shared memory must have been attached by now */
+ return(TRUE);
+}
+
+static bool
SpinIsLocked(SPINLOCK lock)
{
return(!LockIsFree(lock));
}
-#else /* HAS_TEST_AND_SET */
-/* Spinlocks are implemented using SysV semaphores */
-
-
/*
* SpinAcquire -- try to grab a spinlock
*
IpcSemaphoreUnlock(SpinLockId, lock, IpcExclusiveLock);
}
-bool
+static bool
SpinIsLocked(SPINLOCK lock)
{
int semval;
/*
* Attach to existing spinlock set
*/
-bool
+static bool
AttachSpinLocks(IPCKey key)
{
IpcSemaphoreId id;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.12 1997/08/12 22:54:04 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.13 1997/08/19 21:33:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* updated so frequently, and postgres only appends tuples at the
* end of relations. Once clustering works, we should fix this.
*/
+#ifdef NOT_USED
int
inv_stat(LargeObjectDesc *obj_desc, struct pgstat *stbuf)
{
return (0);
}
+#endif
int
inv_seek(LargeObjectDesc *obj_desc, int offset, int whence)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.4 1997/01/10 20:18:47 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.5 1997/08/19 21:33:15 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "storage/bufmgr.h"
#include "access/transam.h" /* for AmiTransactionId */
+static void LRelIdAssign(LRelId *lRelId, Oid dbId, Oid relId);
+
/* ----------------
*
* ----------------
* after it is created.
* ----------------
*/
+#ifdef NOT_USED
Oid
LRelIdGetDatabaseId(LRelId lRelId)
{
return (lRelId.dbId);
}
-
+#endif
/*
* LRelIdGetRelationId --
* DatabaseIdIsMyDatabaseId --
* True iff database object identifier is valid in my present database.
*/
+#ifdef NOT_USED
bool
DatabaseIdIsMyDatabaseId(Oid databaseId)
{
return (bool)
(!OidIsValid(databaseId) || databaseId == MyDatabaseId);
}
+#endif
/*
* LRelIdContainsMyDatabaseId --
* True iff "lock" relation identifier is valid in my present database.
*/
+#ifdef NOT_USED
bool
LRelIdContainsMyDatabaseId(LRelId lRelId)
{
return (bool)
(!OidIsValid(lRelId.dbId) || lRelId.dbId == MyDatabaseId);
}
+#endif
/*
* RelationInitLockInfo --
* RelationDiscardLockInfo --
* Discards the lock information in a relation descriptor.
*/
+#ifdef NOT_USED
void
RelationDiscardLockInfo(Relation relation)
{
pfree(relation->lockInfo);
relation->lockInfo = NULL;
}
+#endif
/*
* RelationSetLockForDescriptorOpen --
* RelationSetLockForTupleRead --
* Sets tuple level read lock.
*/
+#ifdef NOT_USED
void
RelationSetLockForTupleRead(Relation relation, ItemPointer itemPointer)
{
*/
MultiLockTuple(linfo, itemPointer, READ_LOCK);
}
+#endif
/* ----------------
* RelationSetLockForReadPage
* a WORM disk jukebox. Sometimes need exclusive access to extend a
* file by a block.
*/
+#ifdef NOT_USED
void
RelationSetLockForExtend(Relation relation)
{
MultiLockReln((LockInfo) relation->lockInfo, EXTEND_LOCK);
}
+#endif
+#ifdef NOT_USED
void
RelationUnsetLockForExtend(Relation relation)
{
MultiReleaseReln((LockInfo) relation->lockInfo, EXTEND_LOCK);
}
+#endif
/*
* Create an LRelid --- Why not just pass in a pointer to the storage?
*/
-void
+static void
LRelIdAssign(LRelId *lRelId, Oid dbId, Oid relId)
{
lRelId->dbId = dbId;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.10 1997/08/12 22:54:07 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.11 1997/08/19 21:33:19 momjian Exp $
*
* NOTES
* Outside modules can create a lock table and acquire/release
#include "access/xact.h"
#include "access/transam.h"
+static int WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock,
+ LOCKT lockt);
+
/*#define LOCK_MGR_DEBUG*/
#ifndef LOCK_MGR_DEBUG
* client to use different tableIds when acquiring/releasing
* short term and long term locks.
*/
+#ifdef NOT_USED
LockTableId
LockTabRename(LockTableId tableId)
{
AllTables[newTableId] = AllTables[tableId];
return(newTableId);
}
+#endif
/*
* LockAcquire -- Check for lock conflicts, sleep if conflict found,
return(STATUS_FOUND);
}
-int
+static int
WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock, LOCKT lockt)
{
PROC_QUEUE *waitQueue = &(lock->waitProcs);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/multi.c,v 1.3 1997/08/12 22:54:09 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/Attic/multi.c,v 1.4 1997/08/19 21:33:25 momjian Exp $
*
* NOTES:
* (1) The lock.c module assumes that the caller here is doing
#include "utils/rel.h"
#include "miscadmin.h" /* MyDatabaseId */
+static bool MultiAcquire(LockTableId tableId, LOCKTAG *tag, LOCKT lockt,
+ LOCK_LEVEL level);
+static bool MultiRelease(LockTableId tableId, LOCKTAG *tag, LOCKT lockt,
+ LOCK_LEVEL level);
/*
* INTENT indicates to higher level that a lower level lock has been
* Returns: TRUE if lock is set, FALSE if not
* Side Effects:
*/
-bool
+static bool
MultiAcquire(LockTableId tableId,
LOCKTAG *tag,
LOCKT lockt,
* Release a page in the multi-level lock table
* ------------------
*/
+#ifdef NOT_USED
bool
MultiReleasePage(LockInfo linfo, ItemPointer tidPtr, LOCKT lockt)
{
return (MultiRelease(MultiTableId, &tag, lockt, PAGE_LEVEL));
}
+#endif
/* ------------------
* Release a relation in the multi-level lock table
*
* Returns: TRUE if successful, FALSE otherwise.
*/
-bool
+static bool
MultiRelease(LockTableId tableId,
LOCKTAG *tag,
LOCKT lockt,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.17 1997/02/14 04:16:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.18 1997/08/19 21:33:29 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.17 1997/02/14 04:16:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.18 1997/08/19 21:33:29 momjian Exp $
*/
#include
#include
#include "storage/spin.h"
#include "storage/proc.h"
+static void HandleDeadLock(int sig);
+static PROC *ProcWakeup(PROC *proc, int errType);
+
/*
* timeout (in seconds) for resolving possible deadlock
*/
* Returns: a pointer to the queue or NULL
* Side Effects: Initializes the queue if we allocated one
*/
+#ifdef NOT_USED
PROC_QUEUE *
ProcQueueAlloc(char *name)
{
}
return(queue);
}
+#endif
/*
* ProcQueueInit -- initialize a shared memory process queue
* remove the process from the wait queue and set its links invalid.
* RETURN: the next process in the wait queue.
*/
-PROC *
+static PROC *
ProcWakeup(PROC *proc, int errType)
{
PROC *retProc;
/*
* ProcGetId --
*/
+#ifdef NOT_USED
int
ProcGetId()
{
return( MyProc->procId );
}
+#endif
/*
* ProcLockWakeup -- routine for waking up processes when a lock is
* up my semaphore.
* --------------------
*/
-void
+static void
HandleDeadLock(int sig)
{
LOCK *lock;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/page/bufpage.c,v 1.6 1997/03/12 21:07:11 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/page/bufpage.c,v 1.7 1997/08/19 21:33:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "lib/qsort.h"
+static void PageIndexTupleDeleteAdjustLinePointers(PageHeader phdr,
+ char *location, Size size);
+
static bool PageManagerShuffle = true; /* default is shuffle mode */
/* ----------------------------------------------------------------
*
* This routine should never be called on an empty page.
*/
-void
+static void
PageIndexTupleDeleteAdjustLinePointers(PageHeader phdr,
char *location,
Size size)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgr.c,v 1.7 1997/08/18 20:53:18 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgr.c,v 1.8 1997/08/19 21:33:38 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/rel.h"
#include "utils/palloc.h"
+static void smgrshutdown(int dummy);
+
typedef struct f_smgr {
int (*smgr_init)(); /* may be NULL */
int (*smgr_shutdown)(); /* may be NULL */
return (SM_SUCCESS);
}
-void
+static void
smgrshutdown(int dummy)
{
int i;
return (SM_SUCCESS);
}
+#ifdef NOT_USED
int
smgrabort()
{
return (SM_SUCCESS);
}
+#endif
bool
smgriswo(int16 smgrno)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/Attic/aclchk.c,v 1.12 1997/08/18 20:53:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/Attic/aclchk.c,v 1.13 1997/08/19 21:33:54 momjian Exp $
*
* NOTES
* See acl.h.
#include "parser/catalog_utils.h"
#include "fmgr.h"
+static int32 aclcheck(Acl *acl, AclId id, AclIdType idtype, AclMode mode);
+
/*
* Enable use of user relations in place of real system catalogs.
*/
* Returns 1 if the 'id' of type 'idtype' has ACL entries in 'acl' to satisfy
* any one of the requirements of 'mode'. Returns 0 otherwise.
*/
-int32
+static int32
aclcheck(Acl *acl, AclId id, AclIdType idtype, AclMode mode)
{
register unsigned i;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/dest.c,v 1.6 1997/08/12 22:54:19 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/dest.c,v 1.7 1997/08/19 21:34:02 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "commands/async.h"
+static Oid GetAppendOid(void);
+static void ResetAppendOid(void);
+
/* ----------------
* output functions
* ----------------
static Oid AppendOid;
-void
+static void
ResetAppendOid(void)
{
AppendOid = InvalidOid;
AppendOid = MULTI_TUPLE_APPEND;
}
-Oid
+static Oid
GetAppendOid(void)
{
if (AppendOid == MULTI_TUPLE_APPEND)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.41 1997/08/14 16:11:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.42 1997/08/19 21:34:04 momjian Exp $
*
* NOTES
* this is the "main" module of the postgres backend and
#include "libpq/pqsignal.h"
#include "rewrite/rewriteHandler.h" /* for QueryRewrite() */
+static void quickdie(SIGNAL_ARGS);
+
/* ----------------
* global variables
* ----------------
siglongjmp(Warn_restart, 1);
}
-void
+static void
quickdie(SIGNAL_ARGS)
{
elog(NOTICE, "I have been signalled by the postmaster.");
*/
if (IsUnderPostmaster == false) {
puts("\nPOSTGRES backend interactive interface");
- puts("$Revision: 1.41 $ $Date: 1997/08/14 16:11:15 $");
+ puts("$Revision: 1.42 $ $Date: 1997/08/19 21:34:04 $");
}
/* ----------------
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.5 1996/11/10 03:02:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/pquery.c,v 1.6 1997/08/19 21:34:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "commands/command.h"
static char* CreateOperationTag(int operationType);
+static void ProcessQueryDesc(QueryDesc *queryDesc);
+
/* ----------------------------------------------------------------
* CreateQueryDesc
* Read the comments for ProcessQuery() below...
* ----------------------------------------------------------------
*/
-void
+static void
ProcessQueryDesc(QueryDesc *queryDesc)
{
Query *parseTree;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.12 1997/08/12 20:15:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.13 1997/08/19 21:34:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static char *getid(char *s, char *n);
static int32 aclitemeq(AclItem *a1, AclItem *a2);
static int32 aclitemgt(AclItem *a1, AclItem *a2);
+static char *aclparse(char *s, AclItem *aip, unsigned *modechg);
#define ACL_IDTYPE_GID_KEYWORD "group"
#define ACL_IDTYPE_UID_KEYWORD "user"
* UID/GID, id type identifier and mode type values.
* - loads 'modechg' with the mode change flag.
*/
-char *
+static char *
aclparse(char *s, AclItem *aip, unsigned *modechg)
{
HeapTuple htp;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.14 1997/08/18 02:14:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.15 1997/08/19 21:34:18 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static void _ReadArray (int st[], int endp[], int bsize, int srcfd, int destfd,
ArrayType *array, int isDestLO, bool *isNull);
static ArrayCastAndSet(char *src, bool typbyval, int typlen, char *dest);
-
+static SanityCheckInput(int ndim, int n, int dim[], int lb[], int indx[]);
+static int array_read(char *destptr, int eltsize, int nitems, char *srcptr);
+static char *array_seek(char *ptr, int eltsize, int nitems);
/*---------------------------------------------------------------------
* array_in :
}
#endif
-int
+static int
SanityCheckInput(int ndim, int n, int dim[], int lb[], int indx[])
{
int i;
return count;
}
-char *
+static char *
array_seek(char *ptr, int eltsize, int nitems)
{
int i;
return(ptr);
}
-int
+static int
array_read(char *destptr, int eltsize, int nitems, char *srcptr)
{
int i, inc, tmp;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.5 1997/03/02 01:34:37 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.6 1997/08/19 21:34:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static int write_chunk(struct varlena * a_chunk, int ofile);
static int seek_and_read(int pos, int size, char buff[], int fp, int from);
#endif
+static int GetChunkSize(FILE *fd, int ndim, int dim[MAXDIM], int baseSize,
+ int d[MAXDIM]);
/*------------------------------------------------------------------------
* _ChunkArray ---
* returns the dimensions of the chunk in "d"
*-----------------------------------------------------------------------
*/
-int
+static int
GetChunkSize(FILE *fd,
int ndim,
int dim[MAXDIM],
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.12 1997/08/12 22:54:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.13 1997/08/19 21:34:30 momjian Exp $
*
* NOTES
* This code is actually (almost) unused.
* Function prototypes -- internal to this file only
*/
-void reltime2tm(int32 time, struct tm *tm);
+static void reltime2tm(int32 time, struct tm *tm);
#if FALSE
static int correct_unit(char unit[], int *unptr);
#define TMODULO(t,q,u) {q = (t / u); \
if (q != 0) t -= (q * u);}
-void
+static void
reltime2tm(int32 time, struct tm *tm)
{
TMODULO(time, tm->tm_year, 31536000);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.10 1997/07/01 00:22:40 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.11 1997/08/19 21:34:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/datetime.h"
#include "access/xact.h"
+static int date2tm(DateADT dateVal, int *tzp, struct tm *tm, double *fsec, char **tzn);
+
+
static int day_tab[2][12] = {
{31,28,31,30,31,30,31,31,30,31,30,31},
{31,29,31,30,31,30,31,31,30,31,30,31} };
return(result);
} /* date_out() */
-int date2tm(DateADT dateVal, int *tzp, struct tm *tm, double *fsec, char **tzn);
-
bool
date_eq(DateADT dateVal1, DateADT dateVal2)
{
* that everything is GMT. So, convert to GMT, rotate to local time,
* and then convert again to try to get the time zones correct.
*/
-int
+static int
date2tm(DateADT dateVal, int *tzp, struct tm *tm, double *fsec, char **tzn)
{
struct tm *tx;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/datum.c,v 1.4 1996/12/14 07:56:05 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/datum.c,v 1.5 1997/08/19 21:34:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* ONLY datums created by "datumCopy" can be freed!
*-------------------------------------------------------------------------
*/
+#ifdef NOT_USED
void
datumFree(Datum value, Oid type, bool byVal, Size len)
{
pfree(s);
}
}
+#endif
/*-------------------------------------------------------------------------
* datumIsEqual
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/dt.c,v 1.31 1997/07/29 16:09:38 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/dt.c,v 1.32 1997/08/19 21:34:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#endif
#include "utils/builtins.h"
+static int DecodeDate(char *str, int fmask, int *tmask, struct tm *tm);
+static int DecodeNumber( int flen, char *field,
+ int fmask, int *tmask, struct tm *tm, double *fsec);
+static int DecodeNumberField( int len, char *str,
+ int fmask, int *tmask, struct tm *tm, double *fsec);
+static int DecodeSpecial(int field, char *lowtoken, int *val);
+static int DecodeTime(char *str, int fmask, int *tmask,
+ struct tm *tm, double *fsec);
+static int DecodeTimezone( char *str, int *tzp);
+static int DecodeUnits(int field, char *lowtoken, int *val);
+static int EncodeSpecialDateTime(DateTime dt, char *str);
+static datetkn *datebsearch(char *key, datetkn *base, unsigned int nel);
+static DateTime dt2local( DateTime dt, int timezone);
+static void dt2time(DateTime dt, int *hour, int *min, double *sec);
+static int j2day( int jd);
+static int timespan2tm(TimeSpan span, struct tm *tm, float8 *fsec);
+static int tm2timespan(struct tm *tm, double fsec, TimeSpan *span);
+
#define USE_DATE_CACHE 1
#define ROUND_ALL 0
#define TMODULO(t,q,u) {q = ((t < 0)? ceil(t / u): floor(t / u)); \
if (q != 0) t -= rint(q * u);}
-void GetEpochTime( struct tm *tm);
+static void GetEpochTime( struct tm *tm);
#define UTIME_MINYEAR (1901)
#define UTIME_MINMONTH (12)
} /* datetime_finite() */
+#ifdef NOT_USED
bool
timespan_finite(TimeSpan *timespan)
{
return(! TIMESPAN_NOT_FINITE(*timespan));
} /* timespan_finite() */
-
+#endif
/*----------------------------------------------------------
* Relational operators for datetime.
*---------------------------------------------------------*/
-void
+static void
GetEpochTime( struct tm *tm)
{
struct tm *t0;
* Text type may not be null terminated, so copy to temporary string
* then call the standard input routine.
*/
+#ifdef NOT_USED
TimeSpan *
text_timespan(text *str)
{
return(result);
} /* text_timespan() */
-
+#endif
/* datetime_trunc()
* Extract specified field from datetime.
return;
} /* j2date() */
-int
+static int
j2day( int date)
{
int day;
/* timespan2tm()
* Convert a timespan data type to a tm structure.
*/
-int
+static int
timespan2tm(TimeSpan span, struct tm *tm, float8 *fsec)
{
double time;
return 0;
} /* timespan2tm() */
-int
+static int
tm2timespan( struct tm *tm, double fsec, TimeSpan *span)
{
span->month = ((tm->tm_year*12)+tm->tm_mon);
} /* tm2timespan() */
-DateTime
+static DateTime
dt2local(DateTime dt, int tz)
{
dt -= tz;
return((((hour*60)+min)*60)+sec);
} /* time2t() */
-void
+static void
dt2time(DateTime jd, int *hour, int *min, double *sec)
{
double time;
* Decode date string which includes delimiters.
* Insist on a complete set of fields.
*/
-int
+static int
DecodeDate(char *str, int fmask, int *tmask, struct tm *tm)
{
double fsec;
* Only check the lower limit on hours, since this same code
* can be used to represent time spans.
*/
-int
+static int
DecodeTime(char *str, int fmask, int *tmask, struct tm *tm, double *fsec)
{
char *cp;
/* DecodeNumber()
* Interpret numeric field as a date value in context.
*/
-int
+static int
DecodeNumber( int flen, char *str, int fmask, int *tmask, struct tm *tm, double *fsec)
{
int val;
/* DecodeNumberField()
* Interpret numeric string as a concatenated date field.
*/
-int
+static int
DecodeNumberField( int len, char *str, int fmask, int *tmask, struct tm *tm, double *fsec)
{
char *cp;
/* DecodeTimezone()
* Interpret string as a numeric timezone.
*/
-int DecodeTimezone( char *str, int *tzp)
+static int
+DecodeTimezone( char *str, int *tzp)
{
int tz;
int hr, min;
* Implement a cache lookup since it is likely that dates
* will be related in format.
*/
-int
+static int
DecodeSpecial(int field, char *lowtoken, int *val)
{
int type;
* Decode text string using lookup table.
* This routine supports time interval decoding.
*/
-int
+static int
DecodeUnits(int field, char *lowtoken, int *val)
{
int type;
* Binary search -- from Knuth (6.2.1) Algorithm B. Special case like this
* is WAY faster than the generic bsearch().
*/
-datetkn *
+static datetkn *
datebsearch(char *key, datetkn *base, unsigned int nel)
{
register datetkn *last = base + nel - 1, *position;
/* EncodeSpecialDateTime()
* Convert reserved datetime data type to string.
*/
-int EncodeSpecialDateTime(DateTime dt, char *str)
+static int
+EncodeSpecialDateTime(DateTime dt, char *str)
{
if (DATETIME_IS_RESERVED(dt)) {
if (DATETIME_IS_INVALID(dt)) {
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.14 1997/08/12 22:54:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.15 1997/08/19 21:34:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define PI 3.1415926536
#endif
-int point_inside( Point *p, int npts, Point plist[]);
-int lseg_crossing( double x, double y, double px, double py);
+static int point_inside( Point *p, int npts, Point plist[]);
+static int lseg_crossing( double x, double y, double px, double py);
+static BOX *box_construct(double x1, double x2, double y1, double y2);
+static BOX *box_copy(BOX *box);
+static BOX *box_fill(BOX *result, double x1, double x2, double y1, double y2);
+static double box_ht(BOX *box);
+static double box_wd(BOX *box);
+static double circle_ar(CIRCLE *circle);
+static CIRCLE *circle_copy(CIRCLE *circle);
+static LINE *line_construct_pm(Point *pt, double m);
+static bool line_horizontal(LINE *line);
+static Point *line_interpt(LINE *l1, LINE *l2);
+static bool line_intersect(LINE *l1, LINE *l2);
+static bool line_parallel(LINE *l1, LINE *l2);
+static bool line_vertical(LINE *line);
+static double lseg_dt(LSEG *l1, LSEG *l2);
+static void make_bound_box(POLYGON *poly);
+static PATH *path_copy(PATH *path);
+static bool plist_same(int npts, Point p1[], Point p2[]);
+static Point *point_construct(double x, double y);
+static Point *point_copy(Point *pt);
+static int single_decode(char *str, float8 *x, char **ss);
+static int single_encode(float8 x, char *str);
+static int pair_decode(char *str, float8 *x, float8 *y, char **s);
+static int pair_encode(float8 x, float8 y, char *str);
+static int pair_count(char *s, char delim);
+static int path_decode(int opentype, int npts, char *str, int *isopen, char **ss, Point *p);
+static char *path_encode( bool closed, int npts, Point *pt);
+static void statlseg_construct(LSEG *lseg, Point *pt1, Point *pt2);
+static double box_ar(BOX *box);
+static Point *interpt_sl(LSEG *lseg, LINE *line);
+static LINE *line_construct_pp(Point *pt1, Point *pt2);
+
/*
* Delimiters for input and output strings.
* and restore that order for text output - tgl 97/01/16
*/
-int single_decode(char *str, float8 *x, char **ss);
-int single_encode(float8 x, char *str);
-int pair_decode(char *str, float8 *x, float8 *y, char **s);
-int pair_encode(float8 x, float8 y, char *str);
-int pair_count(char *s, char delim);
-int path_decode(int opentype, int npts, char *str, int *isopen, char **ss, Point *p);
-
-char *path_encode( bool closed, int npts, Point *pt);
-
-int single_decode(char *str, float8 *x, char **s)
+static int single_decode(char *str, float8 *x, char **s)
{
char *cp;
return(TRUE);
} /* single_decode() */
-int single_encode(float8 x, char *str)
+static int single_encode(float8 x, char *str)
{
sprintf(str, "%.*g", digits8, x);
return(TRUE);
} /* single_encode() */
-int pair_decode(char *str, float8 *x, float8 *y, char **s)
+static int pair_decode(char *str, float8 *x, float8 *y, char **s)
{
int has_delim;
char *cp;
return(TRUE);
}
-int pair_encode(float8 x, float8 y, char *str)
+static int pair_encode(float8 x, float8 y, char *str)
{
sprintf(str, "%.*g,%.*g", digits8, x, digits8, y);
return(TRUE);
}
-int path_decode(int opentype, int npts, char *str, int *isopen, char **ss, Point *p)
+static int path_decode(int opentype, int npts, char *str, int *isopen, char **ss, Point *p)
{
int depth = 0;
char *s, *cp;
return(TRUE);
} /* path_decode() */
-char *path_encode( bool closed, int npts, Point *pt)
+static char *path_encode( bool closed, int npts, Point *pt)
{
char *result = PALLOC(npts*(P_MAXLEN+3)+2);
* '(1,3,2,4)'
* require an odd number of delim characters in the string
*-------------------------------------------------------------*/
-int pair_count(char *s, char delim)
+static int pair_count(char *s, char delim)
{
int ndelim = 0;
/* box_construct - fill in a new box.
*/
-BOX *box_construct(double x1, double x2, double y1, double y2)
+static BOX *box_construct(double x1, double x2, double y1, double y2)
{
BOX *result = PALLOCTYPE(BOX);
/* box_fill - fill in a static box
*/
-BOX *box_fill(BOX *result, double x1, double x2, double y1, double y2)
+static BOX *box_fill(BOX *result, double x1, double x2, double y1, double y2)
{
if (x1 > x2) {
result->high.x = x1;
/* box_copy - copy a box
*/
-BOX *box_copy(BOX *box)
+static BOX *box_copy(BOX *box)
{
BOX *result = PALLOCTYPE(BOX);
/* box_ar - returns the area of the box.
*/
-double box_ar(BOX *box)
+static double box_ar(BOX *box)
{
return( box_wd(box) * box_ht(box) );
}
/* box_wd - returns the width (length) of the box
* (horizontal magnitude).
*/
-double box_wd(BOX *box)
+static double box_wd(BOX *box)
{
return( box->high.x - box->low.x );
}
/* box_ht - returns the height of the box
* (vertical magnitude).
*/
-double box_ht(BOX *box)
+static double box_ht(BOX *box)
{
return( box->high.y - box->low.y );
}
/* box_dt - returns the distance between the
* center points of two boxes.
*/
-double box_dt(BOX *box1, BOX *box2)
+#ifdef NOT_USED
+static double box_dt(BOX *box1, BOX *box2)
{
double result;
Point *a, *b;
PFREE(b);
return(result);
}
+#endif
/*----------------------------------------------------------
* Funky operations.
* Internal form: Ax+By+C=0
*---------------------------------------------------------*/
-LINE * /* point-slope */
+static LINE * /* point-slope */
line_construct_pm(Point *pt, double m)
{
LINE *result = PALLOCTYPE(LINE);
} /* line_construct_pm() */
-LINE * /* two points */
+static LINE * /* two points */
line_construct_pp(Point *pt1, Point *pt2)
{
LINE *result = PALLOCTYPE(LINE);
* Relative position routines.
*---------------------------------------------------------*/
-bool line_intersect(LINE *l1, LINE *l2)
+static bool line_intersect(LINE *l1, LINE *l2)
{
return( ! line_parallel(l1, l2) );
}
-bool line_parallel(LINE *l1, LINE *l2)
+static bool line_parallel(LINE *l1, LINE *l2)
{
#if FALSE
return( FPeq(l1->m, l2->m) );
return(FPeq(l2->A, l1->A*(l2->B / l1->B)));
} /* line_parallel() */
+#ifdef NOT_USED
bool line_perp(LINE *l1, LINE *l2)
{
#if FALSE
return( FPeq(((l1->A * l2->B) / (l1->B * l2->A)), -1.0) );
} /* line_perp() */
+#endif
-bool line_vertical(LINE *line)
+static bool line_vertical(LINE *line)
{
#if FALSE
return( FPeq(line->A, -1.0) && FPzero(line->B) );
return( FPzero(line->B) );
} /* line_vertical() */
-bool line_horizontal(LINE *line)
+static bool line_horizontal(LINE *line)
{
#if FALSE
return( FPzero(line->m) );
return( FPzero(line->A) );
} /* line_horizontal() */
-
+#ifdef NOT_USED
bool line_eq(LINE *l1, LINE *l2)
{
double k;
FPeq(l1->B, k * l2->B) &&
FPeq(l1->C, k * l2->C) );
}
-
+#endif
/*----------------------------------------------------------
* Line arithmetic routines.
/* line_interpt()
* Point where two lines l1, l2 intersect (if any)
*/
-Point *
+static Point *
line_interpt(LINE *l1, LINE *l2)
{
Point *result;
* Conversion operators.
*---------------------------------------------------------*/
-PATH *path_copy(PATH *path);
-
bool
path_isclosed( PATH *path)
{
} /* path_length() */
-
+#ifdef NOT_USED
double path_ln(PATH *path)
{
double result;
return(result);
} /* path_ln() */
+#endif
/***********************************************************************
**
} /* point_out() */
-Point *point_construct(double x, double y)
+static Point *point_construct(double x, double y)
{
Point *result = PALLOCTYPE(Point);
}
-Point *point_copy(Point *pt)
+static Point *point_copy(Point *pt)
{
Point *result;
}
/* like lseg_construct, but assume space already allocated */
-void statlseg_construct(LSEG *lseg, Point *pt1, Point *pt2)
+static void statlseg_construct(LSEG *lseg, Point *pt1, Point *pt2)
{
lseg->p[0].x = pt1->x;
lseg->p[0].y = pt1->y;
}
/* distance between l1, l2 */
-double
+static double
lseg_dt(LSEG *l1, LSEG *l2)
{
double *d, result;
* lines and boxes, since there are typically two.
*-------------------------------------------------------------------*/
-Point *interpt_sl(LSEG *lseg, LINE *line)
+static Point *interpt_sl(LSEG *lseg, LINE *line)
{
LINE *tmp;
Point *p;
/*---------------------------------------------------------------------
* Make the smallest bounding box for the given polygon.
*---------------------------------------------------------------------*/
-void make_bound_box(POLYGON *poly)
+static void make_bound_box(POLYGON *poly)
{
int i;
double x1,y1,x2,y2;
* actual value.
*---------------------------------------------------------*/
-CIRCLE *circle_copy(CIRCLE *circle);
-
-CIRCLE *
+static CIRCLE *
circle_copy(CIRCLE *circle)
{
CIRCLE *result;
/* circle_ar - returns the area of the circle.
*/
-double circle_ar(CIRCLE *circle)
+static double circle_ar(CIRCLE *circle)
{
return(PI*(circle->radius*circle->radius));
}
/* circle_dt - returns the distance between the
* center points of two circlees.
*/
+#ifdef NOT_USED
double circle_dt(CIRCLE *circle1, CIRCLE *circle2)
{
double result;
return(result);
}
-
+#endif
/*----------------------------------------------------------
* Conversion operators.
#define HIT_IT INT_MAX
-int
+static int
point_inside( Point *p, int npts, Point plist[])
{
double x0, y0;
* It returns HIT_IT if the segment contains (0,0)
*/
-int
+static int
lseg_crossing( double x, double y, double px, double py)
{
double z;
} /* lseg_crossing() */
-bool
+static bool
plist_same(int npts, Point p1[], Point p2[])
{
int i, ii, j;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_selfuncs.c,v 1.2 1997/03/14 23:20:20 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_selfuncs.c,v 1.3 1997/08/19 21:34:40 momjian Exp $
*
* XXX These are totally bogus.
*
* below) a given box?
*/
+#ifdef NOT_USED
float64
leftsel(Oid opid,
Oid relid,
*result = 1.0 / 6.0;
return(result);
}
+#endif
+#ifdef NOT_USED
float64
leftjoinsel(Oid opid,
Oid relid,
*result = 1.0 / 6.0;
return(result);
}
+#endif
/*
* contsel -- How likely is a box to contain (be contained by) a given box?
*/
+#ifdef NOT_USED
float64
contsel(Oid opid,
Oid relid,
*result = 1.0 / 10.0;
return(result);
}
+#endif
+#ifdef NOT_USED
float64
contjoinsel(Oid opid,
Oid relid,
*result = 1.0 / 10.0;
return(result);
}
+#endif
#include "utils/palloc.h"
#include "utils/builtins.h" /* where the function declarations go */
+static int like(char *text, char *p);
+
/*
* interface routines called by the function manager
*/
}
-/* $Revision: 1.5 $
+/* $Revision: 1.6 $
** "like.c" A first attempt at a LIKE operator for Postgres95.
**
** Originally written by Rich $alz, mirror!rs, Wed Nov 26 19:03:17 EST 1986.
/*
** User-level routine. Returns TRUE or FALSE.
*/
-int
+static int
like(char *text, char *p)
{
if (p[0] == '%' && p[1] == '\0')
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/nabstime.c,v 1.30 1997/08/12 22:54:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/nabstime.c,v 1.31 1997/08/19 21:34:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/builtins.h"
#include "access/xact.h"
+static AbsoluteTime tm2abstime(struct tm *tm, int tz);
#define MIN_DAYNUM -24856 /* December 13, 1901 */
#define MAX_DAYNUM 24854 /* January 18, 2038 */
* Convert a tm structure to abstime.
* Note that tm has full year (not 1900-based) and 1-based month.
*/
-AbsoluteTime
+static AbsoluteTime
tm2abstime( struct tm *tm, int tz)
{
int day, sec;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/name.c,v 1.5 1997/08/18 20:53:41 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/name.c,v 1.6 1997/08/19 21:34:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return(0);
}
+#ifdef NOT_USED
int namecat(Name n1, Name n2)
{
return(namestrcat(n1, n2->data)); /* n2 can't be any longer than n1 */
}
+#endif
int namecmp(Name n1, Name n2)
{
return(0);
}
+#ifdef NOT_USED
int namestrcat(Name name, char *str)
{
int i;
}
return(0);
}
+#endif
int
namestrcmp(Name name, char *str)
* PRIVATE ROUTINES *
*****************************************************************************/
+#ifdef NOT_USED
uint32
NameComputeLength(Name name)
{
}
return (uint32)length;
}
+#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/not_in.c,v 1.2 1996/11/06 06:49:53 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/not_in.c,v 1.3 1997/08/19 21:34:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/relscan.h"
#include "utils/builtins.h" /* where function decls go */
+static int my_varattno(Relation rd, char *a);
+
/* ----------------------------------------------------------------
*
* ----------------------------------------------------------------
* If varattno (in parser/catalog_utils.h) ever is added to
* cinterface.a, this routine should go away
*/
-int my_varattno(Relation rd, char *a)
+static int my_varattno(Relation rd, char *a)
{
int i;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/numutils.c,v 1.12 1997/08/12 22:54:34 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/numutils.c,v 1.13 1997/08/19 21:34:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
** stars ("*****") and returns zero. Normal return is the width
** of the output field (sometimes shorter than 'width').
*/
+#ifdef NOT_USED
int
ftoa(double value, char *ascii, int width, int prec1, char format)
{
return (avail);
#endif /* !BSD44_derived */
}
+#endif
/*
** atof1 - ASCII TO FLOATING CONVERSION
** Side Effects:
** clobbers *val.
*/
+#ifdef NOT_USED
int
atof1(char *str, double *val)
{
*val = v;
return (0);
}
+#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.17 1997/07/29 16:12:07 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.18 1997/08/19 21:34:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* BUGS: Extremely unportable as things shoved can be string
* representations of structs, etc.
*/
+#ifdef NOT_USED
struct varlena *
shove_bytes(unsigned char *stuff, int len)
{
len - sizeof(int32));
return(result);
}
-
+#endif
/*
* returns the actual length of a text* (which may be less than
* the VARSIZE of the text*)
*/
-
+#ifdef NOT_USED
int textlen (text* t)
{
int i = 0;
i++;
return i;
}
+#endif
/*
* textcat -
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.6 1996/12/04 03:06:09 bryanh Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.7 1997/08/19 21:34:58 momjian Exp $
*
* Notes:
* XXX This needs to use exception.h to handle recovery when
#include "catalog/pg_type.h" /* for OID of int28 type */
#include "lib/dllist.h"
+static void CatCacheRemoveCTup(CatCache *cache, Dlelem *e);
+static Index CatalogCacheComputeHashIndex(struct catcache *cacheInP);
+static Index CatalogCacheComputeTupleHashIndex(struct catcache *cacheInOutP,
+ Relation relation, HeapTuple tuple);
+static void CatalogCacheInitializeCache(struct catcache *cache,
+ Relation relation);
+static long comphash(long l, char *v);
+
/* ----------------
* variables, macros and other stuff
*
#define CatalogCacheInitializeCache_DEBUG2
#endif
-void
+static void
CatalogCacheInitializeCache(struct catcache *cache,
Relation relation)
{
* XXX temporary function
* --------------------------------
*/
+#ifdef NOT_USED
void
CatalogCacheSetId(CatCache *cacheInOutP, int id)
{
Assert(id == InvalidCatalogCacheId || id >= 0);
cacheInOutP->id = id;
}
+#endif
/* ----------------
* comphash --
* v is the attribute value ("Datum")
* ----------------
*/
-long
+static long
comphash(long l, register char *v)
{
long i;
* CatalogCacheComputeHashIndex
* --------------------------------
*/
-Index
+static Index
CatalogCacheComputeHashIndex(struct catcache *cacheInP)
{
Index hashIndex;
* CatalogCacheComputeTupleHashIndex
* --------------------------------
*/
-Index
+static Index
CatalogCacheComputeTupleHashIndex(struct catcache *cacheInOutP,
Relation relation,
HeapTuple tuple)
* CatCacheRemoveCTup
* --------------------------------
*/
-void
+static void
CatCacheRemoveCTup(CatCache *cache, Dlelem *elt)
{
CatCTup *ct;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/inval.c,v 1.3 1996/11/08 05:59:55 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/inval.c,v 1.4 1997/08/19 21:35:06 momjian Exp $
*
* Note - this code is real crufty...
*
#include "catalog/catname.h" /* XXX to support hacks below */
#include "utils/syscache.h" /* XXX to support the hacks below */
+static InvalidationEntry InvalidationEntryAllocate(uint16 size);
+static void LocalInvalidInvalidate(LocalInvalid invalid, void (*function)());
+static LocalInvalid LocalInvalidRegister(LocalInvalid invalid,
+ InvalidationEntry entry);
+static void getmyrelids(void);
+
+
/* ----------------
* private invalidation structures
* ----------------
* Allocates an invalidation entry.
* --------------------------------
*/
-InvalidationEntry
+static InvalidationEntry
InvalidationEntryAllocate(uint16 size)
{
InvalidationEntryData *entryDataP;
* Returns a new local cache invalidation state containing a new entry.
* --------------------------------
*/
-LocalInvalid
+static LocalInvalid
LocalInvalidRegister(LocalInvalid invalid,
InvalidationEntry entry)
{
* invalidation state.
* --------------------------------
*/
-void
+static void
LocalInvalidInvalidate(LocalInvalid invalid, void (*function)())
{
InvalidationEntryData *entryDataP;
* getmyrelids
* --------------------------------
*/
-void
+static void
getmyrelids()
{
HeapTuple tuple;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.2 1996/10/31 05:55:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.3 1997/08/19 21:35:11 momjian Exp $
*
* NOTES
* Eventually, the index information should go through here, too.
* not. Returns 1 if by value, 0 if by reference.
*
*/
+#ifdef NOT_USED
char
get_typalign(Oid typid)
{
else
return ('i');
}
+#endif
/*
* get_typdefault -
* It returns the null char if the cache lookup fails...
*
*/
+#ifdef NOT_USED
char
get_typtype(Oid typid)
{
return('\0');
}
}
-
+#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.14 1997/08/19 04:44:21 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.15 1997/08/19 21:35:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/index.h"
#include "fmgr.h"
+static void RelationFlushRelation(Relation *relationPtr,
+ bool onlyFlushReferenceCountZero);
+static Relation RelationNameCacheGetRelation(char *relationName);
+static void init_irels(void);
+static void write_irels(void);
+
/* ----------------
* defines
* ----------------
* RelationNameCacheGetRelation
* --------------------------------
*/
-Relation
+static Relation
RelationNameCacheGetRelation(char *relationName)
{
Relation rd;
* old "getreldesc" interface.
* ----------------
*/
+#ifdef NOT_USED
Relation
getreldesc(char *relationName)
{
return RelationNameGetRelation(relationName);
}
+#endif
/* ----------------------------------------------------------------
* cache invalidation support routines
* anything anymore.
* --------------------------------
*/
-void
+static void
RelationFlushRelation(Relation *relationPtr,
bool onlyFlushReferenceCountZero)
{
/* pg_attnumind, pg_classnameind, pg_classoidind */
#define Num_indices_bootstrap 3
-void
+static void
init_irels(void)
{
Size len;
}
}
-void
+static void
write_irels(void)
{
int len;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/exc.c,v 1.14 1997/08/12 22:54:46 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/error/Attic/exc.c,v 1.15 1997/08/19 21:35:17 momjian Exp $
*
* NOTE
* XXX this code needs improvement--check for state violations and
#include "utils/exc.h"
#include "storage/ipc.h"
+static void ExcUnCaught(Exception *excP, ExcDetail detail, ExcData data,
+ ExcMessage message);
+static void ExcPrint(Exception *excP, ExcDetail detail, ExcData data,
+ ExcMessage message);
+
/*
* Global Variables
*/
ExceptionHandlingEnabled = on;
}
-void
+static void
ExcPrint(Exception *excP,
ExcDetail detail,
ExcData data,
fflush(stderr);
}
+#ifdef NOT_USED
ExcProc *
ExcGetUnCaught(void)
{
return (ExcUnCaughtP);
}
+#endif
+#ifdef NOT_USED
ExcProc *
ExcSetUnCaught(ExcProc *newP)
{
return (oldP);
}
+#endif
-void
+static void
ExcUnCaught(Exception *excP,
ExcDetail detail,
ExcData data,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.2 1996/11/08 06:00:14 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.3 1997/08/19 21:35:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*
* func_ptr, func_id, n_arguments, args...
*/
+#ifdef NOT_USED
char *
fmgr_ptr(func_ptr user_fn, Oid func_id, ...)
{
return(fmgr_c(user_fn, func_id, n_arguments, &values,
&isNull));
}
+#endif
/*
* This routine is not well thought out. When I get around to adding a
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/hash/hashfn.c,v 1.2 1996/11/03 06:54:16 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/hash/hashfn.c,v 1.3 1997/08/19 21:35:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* instructions. If this routine is heavily used enough, it's
* worth the ugly coding
*/
+#ifdef NOT_USED
long
disk_hash(char *key)
{
}
return(n);
}
-
+#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/init/miscinit.c,v 1.5 1997/04/27 19:20:37 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/miscinit.c,v 1.6 1997/08/19 21:35:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* Exceptions:
* none
*/
+#ifdef NOT_USED
void
AbortPostgres()
{
else
exitpg(FatalExitStatus);
}
+#endif
/* ----------------
* StatusBackendExit
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/init/postinit.c,v 1.10 1997/08/12 22:54:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/postinit.c,v 1.11 1997/08/19 21:35:50 momjian Exp $
*
* NOTES
* InitPostgres() is the function called from PostgresMain
#include "port-protos.h"
#include "libpq/libpq-be.h"
+static void InitCommunication(void);
+static void InitMyDatabaseId(void);
+static void InitStdio(void);
+static void InitUserid(void);
+
static IPCKey PostgresIpcKey;
* database directory but before we open any relations.
* --------------------------------
*/
-void
+static void
InitMyDatabaseId()
{
int dbfd;
* initializes crap associated with the user id.
* --------------------------------
*/
-void
+static void
InitUserid()
{
setuid(geteuid());
* This does not set MyBackendId. MyBackendTag is set, however.
* --------------------------------
*/
-void
+static void
InitCommunication()
{
char *postid;
* they all seem to do stuff associated with io.
* --------------------------------
*/
-void
+static void
InitStdio()
{
DebugFileOpen();
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/aset.c,v 1.4 1996/11/10 03:03:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/aset.c,v 1.5 1997/08/19 21:35:54 momjian Exp $
*
* NOTE
* XXX This is a preliminary implementation which lacks fail-fast
# include
#endif
+static void AllocPointerDump(AllocPointer pointer);
+static int AllocSetIterate(AllocSet set,
+ void (*function)(AllocPointer pointer));
+
#undef AllocSetReset
#undef malloc
#undef free
* Exceptions:
* BadArg if set is invalid.
*/
-int
+static int
AllocSetIterate(AllocSet set,
void (*function)(AllocPointer pointer))
{
return (count);
}
+#ifdef NOT_USED
int
AllocSetCount(AllocSet set)
{
}
return count;
}
+#endif
/*
* Private routines
* XXX AllocPointerDump --
* Displays allocated pointer.
*/
-void
+static void
AllocPointerDump(AllocPointer pointer)
{
printf("\t%-10ld@ %0#lx\n", ((long*)pointer)[-1], (long)pointer); /* XXX */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/mcxt.c,v 1.2 1996/11/08 06:00:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/mcxt.c,v 1.3 1997/08/19 21:35:57 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* ???
* BadArgumentsErr if firstTime is true for subsequent calls.
*/
+#ifdef NOT_USED
char*
MemoryContextGetName(MemoryContext context)
{
return (context->method->getName(context));
}
+#endif
/*
* PointerGetAllocSize --
* ???
* BadArgumentsErr if firstTime is true for subsequent calls.
*/
+#ifdef NOT_USED
Size
PointerGetAllocSize(Pointer pointer)
{
return (PSIZE(pointer));
}
+#endif
/*
* MemoryContextSwitchTo --
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/Attic/oset.c,v 1.1.1.1 1996/07/09 06:22:09 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/Attic/oset.c,v 1.2 1997/08/19 21:35:59 momjian Exp $
*
* NOTE
* XXX This is a preliminary implementation which lacks fail-fast
/*
* OrderedSetGetTail --
*/
+#ifdef NOT_USED
Pointer
OrderedSetGetTail(OrderedSet set)
{
}
return (NULL);
}
+#endif
/*
* OrderedElemGetPredecessor --
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/portalmem.c,v 1.4 1997/08/12 22:54:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/portalmem.c,v 1.5 1997/08/19 21:36:04 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/portal.h"
+static void CollectNamedPortals(Portal *portalP, int destroy);
+static Portal PortalHeapMemoryGetPortal(PortalHeapMemory context);
+static PortalVariableMemory PortalHeapMemoryGetVariableMemory(PortalHeapMemory context);
+static void PortalResetHeapMemory(Portal portal);
+static Portal PortalVariableMemoryGetPortal(PortalVariableMemory context);
+
/* ----------------
* ALLOCFREE_ERROR_ABORT
* define this if you want a core dump when you try to
* entry *before* we destroy anything (destroying updates the hashtable
* and screws up the sequential walk of the table). -mer 17 Aug 1992
*/
-void
+static void
CollectNamedPortals(Portal *portalP, int destroy)
{
static Portal *portalList = (Portal *)NULL;
* BadArg if mode is invalid.
* ----------------
*/
-void
+static void
PortalResetHeapMemory(Portal portal)
{
PortalHeapMemory context;
* BadState if called when disabled.
* BadArg if context is invalid.
*/
-Portal
+static Portal
PortalVariableMemoryGetPortal(PortalVariableMemory context)
{
return ((Portal)((char *)context - offsetof (PortalD, variable)));
* BadState if called when disabled.
* BadArg if context is invalid.
*/
-Portal
+static Portal
PortalHeapMemoryGetPortal(PortalHeapMemory context)
{
return ((Portal)((char *)context - offsetof (PortalD, heap)));
* BadState if called when disabled.
* BadArg if context is invalid.
*/
+#ifdef NOT_USED
PortalHeapMemory
PortalVariableMemoryGetHeapMemory(PortalVariableMemory context)
{
- offsetof (PortalD, variable)
+ offsetof (PortalD, heap)));
}
+#endif
/*
* PortalHeapMemoryGetVariableMemory --
* BadState if called when disabled.
* BadArg if context is invalid.
*/
-PortalVariableMemory
+static PortalVariableMemory
PortalHeapMemoryGetVariableMemory(PortalHeapMemory context)
{
return ((PortalVariableMemory)((char *)context
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/psort.c,v 1.16 1997/08/18 02:14:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/psort.c,v 1.17 1997/08/19 21:36:06 momjian Exp $
*
* NOTES
* Sorts the first relation into the second relation.
#include "miscadmin.h"
#include "storage/fd.h"
+static bool createrun(Sort *node, FILE *file, bool *empty);
+static void destroytape(FILE *file);
+static void dumptuples(FILE *file, Sort *node);
+static FILE *gettape(void);
+static void initialrun(Sort *node, bool *empty);
+static void inittapes(Sort *node);
+static void merge(Sort *node, struct tape *dest);
+static FILE *mergeruns(Sort *node);
+static HeapTuple tuplecopy(HeapTuple tup);
+
+
+
#define TEMPDIR "./"
static long shortzero = 0; /* used to delimit runs */
* Returns:
* number of allocated tapes
*/
-void
+static void
inittapes(Sort *node)
{
register int i;
PS(node)->using_tape_files = true;
}
-/*
- * resetpsort - resets (pfrees) palloc'd memory for an aborted Xaction
- *
- * Not implemented yet.
- */
-void
-resetpsort()
-{
- ;
-}
-
/*
* PUTTUP - writes the next tuple
* ENDRUN - mark end of run
* I (perhaps prematurely) combined the 2 algorithms.
* Also, perhaps allocate tapes when needed. Split into 2 funcs.
*/
-void
+static void
initialrun(Sort *node, bool *empty)
{
/* register struct tuple *tup; */
* FALSE iff process through end of relation
* Tuples contains the tuples for the following run upon exit
*/
-bool
+static bool
createrun(Sort *node, FILE *file, bool *empty)
{
register HeapTuple lasttuple;
* This should eventually go there under that name? And this will
* then use palloc directly (see version -r1.2).
*/
-HeapTuple
+static HeapTuple
tuplecopy(HeapTuple tup)
{
HeapTuple rettup;
* Returns:
* file of tuples in order
*/
-FILE *
+static FILE *
mergeruns(Sort *node)
{
register struct tape *tp;
* merge - handles a single merge of the tape
* (polyphase merge Alg.D(D5)--Knuth, Vol.3, p271)
*/
-void
+static void
merge(Sort *node, struct tape *dest)
{
register HeapTuple tup;
/*
* dumptuples - stores all the tuples in tree into file
*/
-void
+static void
dumptuples(FILE *file, Sort *node)
{
register struct leftist *tp;
* Open stream for writing/reading.
* NULL if unable to open temporary file.
*/
-FILE *
+static FILE *
gettape()
{
register struct tapelst *tp;
/*
* resettape - resets the tape to size 0
*/
-void
+#ifdef NOT_USED
+static void
resettape(FILE *file)
{
register struct tapelst *tp;
elog(FATAL, "could not freopen temporary file");
}
}
+#endif
/*
* distroytape - unlinks the tape
* Possible bugs:
* Exits instead of returning status, if given invalid tape.
*/
-void
+static void
destroytape(FILE *file)
{
register struct tapelst *tp, *tq;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.2 1997/03/28 07:05:28 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.3 1997/08/19 21:36:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/tqual.h"
+static AbsoluteTime TimeQualGetEndTime(TimeQual qual);
+static AbsoluteTime TimeQualGetSnapshotTime(TimeQual qual);
+static AbsoluteTime TimeQualGetStartTime(TimeQual qual);
+static bool TimeQualIncludesNow(TimeQual qual);
+static bool TimeQualIndicatesDisableValidityChecking(TimeQual qual);
+static bool TimeQualIsLegal(TimeQual qual);
+static bool TimeQualIsRanged(TimeQual qual);
+static bool TimeQualIsSnapshot(TimeQual qual);
+static bool TimeQualIsValid(TimeQual qual);
+
/*
* TimeQualMode --
* Mode indicator for treatment of time qualifications.
* TimeQualIsValid --
* True iff time qualification is valid.
*/
-bool
+static bool
TimeQualIsValid(TimeQual qual)
{
bool hasStartTime;
* Note:
* Assumes time qualification is valid.
*/
-bool
+static bool
TimeQualIsLegal(TimeQual qual)
{
Assert(TimeQualIsValid(qual));
* Note:
* Assumes time qualification is valid.
*/
-bool
+static bool
TimeQualIncludesNow(TimeQual qual)
{
Assert(TimeQualIsValid(qual));
* Assumes time qualification is valid.
* XXX may not be needed?
*/
+#ifdef NOT_USED
bool
TimeQualIncludesPast(TimeQual qual)
{
/* otherwise, must check archive (setting locks as appropriate) */
return (true);
}
+#endif
/*
* TimeQualIsSnapshot --
* Note:
* Assumes time qualification is valid.
*/
-bool
+static bool
TimeQualIsSnapshot(TimeQual qual)
{
Assert(TimeQualIsValid(qual));
* Note:
* Assumes time qualification is valid.
*/
-bool
+static bool
TimeQualIsRanged(TimeQual qual)
{
Assert(TimeQualIsValid(qual));
* Note:
* XXX This should not be implemented since this does not make sense.
*/
-bool
+static bool
TimeQualIndicatesDisableValidityChecking(TimeQual qual)
{
Assert (TimeQualIsValid(qual));
* Note:
* Assumes time qual is valid snapshot time qual.
*/
-AbsoluteTime
+static AbsoluteTime
TimeQualGetSnapshotTime(TimeQual qual)
{
Assert(TimeQualIsSnapshot(qual));
* Note:
* Assumes time qual is valid ranged time qual.
*/
-AbsoluteTime
+static AbsoluteTime
TimeQualGetStartTime(TimeQual qual)
{
Assert(TimeQualIsRanged(qual));
* Note:
* Assumes time qual is valid ranged time qual.
*/
-AbsoluteTime
+static AbsoluteTime
TimeQualGetEndTime(TimeQual qual)
{
Assert(TimeQualIsRanged(qual));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/pg_dump/common.c,v 1.12 1997/06/02 02:51:49 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/bin/pg_dump/common.c,v 1.13 1997/08/19 21:36:25 momjian Exp $
*
*
#include "pg_dump.h"
+static char** findParentsByOid(TableInfo* tbinfo, int numTables,
+ InhInfo* inhinfo, int numInherits,
+ const char *oid,
+ int *numParents);
+static int findTableByOid(TableInfo *tbinfo, int numTables, const char *oid);
+static void flagInhAttrs(TableInfo* tbinfo, int numTables,
+ InhInfo* inhinfo, int numInherits);
+static int strInArray(const char* pattern, char** arr, int arr_size);
+
/*
* findTypeByOid
* given an oid of a type, return its typename
* returns NULL if none
*/
-char**
+static char**
findParentsByOid(TableInfo* tblinfo, int numTables,
InhInfo* inhinfo, int numInherits, const char *oid,
int *numParentsPtr)
*
*/
-int
+static int
strInArray(const char* pattern, char** arr, int arr_size)
{
int i;
* modifies tblinfo
*
*/
-void
+static void
flagInhAttrs(TableInfo* tblinfo, int numTables,
InhInfo* inhinfo, int numInherits)
{
* NOTE: should hash this, but just do linear search for now
*/
-int
+static int
findTableByOid(TableInfo* tblinfo, int numTables, const char* oid)
{
int i;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.37 1997/08/19 04:44:38 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.38 1997/08/19 21:36:40 momjian Exp $
*
*
#include "pg_dump.h"
static void dumpSequence (FILE* fout, TableInfo tbinfo);
+static char *checkForQuote(const char* s);
+static void clearTableInfo(TableInfo*, int);
+static void dumpOneFunc(FILE* fout, FuncInfo* finfo, int i,
+ TypeInfo *tinfo, int numTypes);
+static int findLastBuiltinOid(void);
+static bool isViewRule(char *relname);
+static void setMaxOid(FILE *fout);
extern char *optarg;
extern int optind, opterr;
* Determine if the relation is a VIEW
*
*/
-bool
+static bool
isViewRule(char *relname)
{
PGresult *res;
free(fun);
}
-void
+static void
clearTableInfo(TableInfo *tblinfo, int numTables)
{
int i,j;
*
*/
-void
+static void
dumpOneFunc(FILE* fout, FuncInfo* finfo, int i,
TypeInfo *tinfo, int numTypes)
{
* the attrmap passed in tells how to map the attributes copied in to the
* attributes copied out
*/
+#ifdef NOT_USED
void
dumpTuples(PGresult *res, FILE *fout, int* attrmap)
{
free (outVals);
}
}
+#endif
/*
* setMaxOid -
* find the maximum oid and generate a COPY statement to set it
*/
-void
+static void
setMaxOid(FILE *fout)
{
PGresult *res;
* this is probably not foolproof but comes close
*/
-int
+static int
findLastBuiltinOid(void)
{
PGresult* res;
* checkForQuote:
* checks a string for quote characters and quotes them
*/
-char*
+static char*
checkForQuote(const char* s)
{
char *r;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_dump.h,v 1.18 1997/08/19 04:44:40 vadim Exp $
+ * $Id: pg_dump.h,v 1.19 1997/08/19 21:36:45 momjian Exp $
*
*
extern char* findTypeByOid(TypeInfo* tinfo, int numTypes, const char* oid);
extern char* findOprByOid(OprInfo *oprinfo, int numOprs, const char *oid);
extern int findFuncByName(FuncInfo* finfo, int numFuncs, const char* name);
-extern char** findParentsByOid(TableInfo* tbinfo, int numTables,
- InhInfo* inhinfo, int numInherits,
- const char *oid,
- int *numParents);
extern int findTableByName(TableInfo *tbinfo, int numTables, const char *relname);
-extern int findTableByOid(TableInfo *tbinfo, int numTables, const char *oid);
-extern void flagInhAttrs(TableInfo* tbinfo, int numTables,
- InhInfo* inhinfo, int numInherits);
extern void check_conn_and_db(void);
-extern int strInArray(const char* pattern, char** arr, int arr_size);
extern void parseArgTypes(char **argtypes, const char* str);
extern int isArchiveName(const char*);
-extern bool isViewRule(char *relname);
/*
* version specific routines
extern void clearIndInfo(IndInfo*, int);
extern void clearOprInfo(OprInfo*, int);
extern void clearTypeInfo(TypeInfo*, int);
-extern void clearTableInfo(TableInfo*, int);
extern OprInfo* getOperators(int *numOperators);
extern TableInfo* getTables(int *numTables);
TypeInfo *tinfo, int numTypes);
extern void dumpOprs(FILE* fout, OprInfo* agginfo, int numOperators,
TypeInfo *tinfo, int numTypes);
-extern void dumpOneFunc(FILE* fout, FuncInfo* finfo, int i,
- TypeInfo *tinfo, int numTypes);
extern void dumpTables(FILE* fout, TableInfo* tbinfo, int numTables,
InhInfo *inhinfo, int numInherits,
TypeInfo *tinfo, int numTypes, const char *tablename,
extern void dumpIndices(FILE* fout, IndInfo* indinfo, int numIndices,
TableInfo* tbinfo, int numTables, const char *tablename);
-extern void dumpTuples(PGresult *res, FILE *fout, int *attrmap);
-extern void setMaxOid(FILE *fout);
-extern char* checkForQuote(const char* s);
-extern int findLastBuiltinOid(void);
-
-
/* largest query string size */
#define MAXQUERYLEN 5000
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/psql/Attic/psql.c,v 1.83 1997/08/19 04:45:02 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/Attic/psql.c,v 1.84 1997/08/19 21:36:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static char * make_connect_string(char *host, char *port, char *dbname,
char *username, char *password);
-char *gets_noreadline(char *prompt, FILE * source);
-char *gets_readline(char *prompt, FILE * source);
-char *gets_fromFile(char *prompt, FILE * source);
-int listAllDbs(PsqlSettings * settings);
-void
+static char *gets_noreadline(char *prompt, FILE * source);
+static char *gets_readline(char *prompt, FILE * source);
+static char *gets_fromFile(char *prompt, FILE * source);
+static int listAllDbs(PsqlSettings * settings);
+static void
SendQuery(bool * success_p, PsqlSettings * settings, const char *query,
const bool copy_in, const bool copy_out, FILE * copystream);
-int
+static int
HandleSlashCmds(PsqlSettings * settings,
char *line,
char *query);
-int MainLoop(PsqlSettings * settings, FILE * source);
+static int MainLoop(PsqlSettings * settings, FILE * source);
/* probably should move this into libpq */
void
PQprint(FILE * fp,
PQprintOpt * po
);
-FILE *setFout(PsqlSettings * ps, char *fname);
+static FILE *setFout(PsqlSettings * ps, char *fname);
/*
* usage print out usage for command line arguments
*
*/
-int
+static int
listAllDbs(PsqlSettings * ps)
{
PGresult *results;
* gets_noreadline prompt source gets a line of input without calling
* readline, the source is ignored
*/
-char *
+static char *
gets_noreadline(char *prompt, FILE * source)
{
fputs(prompt, stdout);
* gets_readline prompt source the routine to get input from GNU readline(),
* the source is ignored the prompt argument is used as the prompting string
*/
-char *
+static char *
gets_readline(char *prompt, FILE * source)
{
char *s;
* the routine to read from a file, the prompt argument is ignored the source
* argument is a FILE *
*/
-char *
+static char *
gets_fromFile(char *prompt, FILE * source)
{
char *line;
* SendQuery: send the query string to the backend return *success_p = 1 if
* the query executed successfully returns *success_p = 0 otherwise
*/
-void
+static void
SendQuery(bool * success_p, PsqlSettings * settings, const char *query,
const bool copy_in, const bool copy_out, FILE * copystream)
{
* this line, continue building up query 2 - terminate processing of this
* query entirely, 3 - new query supplied by edit
*/
-int
+static int
HandleSlashCmds(PsqlSettings * settings,
char *line,
char *query)
* db_ptr must be initialized and set
*/
-int
+static int
MainLoop(PsqlSettings * settings, FILE * source)
{
char *line; /* line of input */
* try to open fname and return a FILE *, if it fails, use stdout, instead
*/
-FILE *
+static FILE *
setFout(PsqlSettings * ps, char *fname)
{
if (ps->queryFout && ps->queryFout != stdout) {
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/psql/stringutils.c,v 1.8 1997/02/13 08:31:57 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/stringutils.c,v 1.9 1997/08/19 21:36:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
and both sides of a string */
/* MODIFIES the string passed in and returns the head of it */
-
-char *leftTrim(char *s)
+#ifdef NOT_USED
+static char *leftTrim(char *s)
{
char *s2 = s;
int shift=0;
return s2;
}
+#endif
char *rightTrim(char *s)
{
return s;
}
-char *doubleTrim(char *s)
+#ifdef NOT_USED
+static char *doubleTrim(char *s)
{
strcpy(s,leftTrim(rightTrim(s)));
return s;
}
+#endif
#ifdef STRINGUTILS_TEST
void testStringUtils()
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: stringutils.h,v 1.3 1996/11/26 03:20:08 bryanh Exp $
+ * $Id: stringutils.h,v 1.4 1997/08/19 21:36:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* removes whitespaces from the left, right and both sides of a string */
/* MODIFIES the string passed in and returns the head of it */
-extern char *leftTrim(char *s);
extern char *rightTrim(char *s);
-extern char *doubleTrim(char *s);
#ifdef STRINGUTILS_TEST
extern void testStringUtils();
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: genam.h,v 1.6 1997/01/10 09:36:29 vadim Exp $
+ * $Id: genam.h,v 1.7 1997/08/19 21:37:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
uint16 numberOfKeys, ScanKey key);
extern void index_rescan(IndexScanDesc scan, bool scanFromEnd, ScanKey key);
extern void index_endscan(IndexScanDesc scan);
-extern void index_markpos(IndexScanDesc scan);
-extern void index_restrpos(IndexScanDesc scan);
extern RetrieveIndexResult index_getnext(IndexScanDesc scan,
ScanDirection direction);
extern RegProcedure index_getprocid(Relation irel, AttrNumber attnum,
/* in genam.c */
extern IndexScanDesc RelationGetIndexScan(Relation relation, bool scanFromEnd,
uint16 numberOfKeys, ScanKey key);
-extern void IndexScanRestart(IndexScanDesc scan, bool scanFromEnd,
- ScanKey key);
-extern void IndexScanEnd(IndexScanDesc scan);
extern void IndexScanMarkPosition(IndexScanDesc scan);
extern void IndexScanRestorePosition(IndexScanDesc scan);
extern InsertIndexResult gistinsert(Relation r, Datum *datum,
char *nulls,ItemPointer ht_ctid, Relation heapRel);
extern void _gistdump(Relation r);
-extern char *text_range_out(TXTRANGE *r);
-extern char *int_range_out(INTRANGE *r);
extern void gistfreestack(GISTSTACK *s);
extern void initGISTstate(GISTSTATE *giststate, Relation index);
extern void gistdentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr,
Relation r, Page pg, OffsetNumber o, int b, bool l) ;
-extern void gistcentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr,
- Relation r, Page pg, OffsetNumber o, int b, bool l) ;
extern StrategyNumber RelationGetGISTStrategy(Relation, AttrNumber, RegProcedure);
/* gistget.c */
extern RetrieveIndexResult gistgettuple(IndexScanDesc s, ScanDirection dir);
-extern bool gistindex_keytest(IndexTuple tuple, TupleDesc tupdesc,
- int scanKeySize, ScanKey key, GISTSTATE *giststate,
- Relation r, Page p, OffsetNumber offset);
-
-/* giststrat.c */
-extern bool RelationInvokeGISTStrategy(Relation r, AttrNumber attnum,
- StrategyNumber s, Datum left, Datum right);
#endif /* GIST_H */
extern StrategyNumber RelationGetGISTStrategy(Relation r,
AttrNumber attnum, RegProcedure proc);
-extern bool RelationInvokeGISTStrategy(Relation r, AttrNumber attnum,
- StrategyNumber s, Datum left, Datum right);
#endif /* GISTSTRAT_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: hash.h,v 1.6 1997/01/10 09:36:32 vadim Exp $
+ * $Id: hash.h,v 1.7 1997/08/19 21:37:27 momjian Exp $
*
* NOTES
* modeled after Margo Seltzer's hash implementation for unix.
Buffer metabuf);
-/* hashstrat.c */
-extern StrategyNumber _hash_getstrat(Relation rel, AttrNumber attno,
- RegProcedure proc);
-extern bool _hash_invokestrat(Relation rel, AttrNumber attno,
- StrategyNumber strat, Datum left, Datum right);
-
-
/* hashutil.c */
extern ScanKey _hash_mkscankey(Relation rel, IndexTuple itup,
HashMetaPage metap);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: heapam.h,v 1.6 1996/11/10 03:04:37 momjian Exp $
+ * $Id: heapam.h,v 1.7 1997/08/19 21:37:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* heapam.c */
extern void doinsert(Relation relation, HeapTuple tup);
-extern void SetHeapAccessMethodImmediateInvalidation(bool on);
extern Relation heap_open(Oid relationId);
extern Relation heap_openr(char *relationName);
extern int heap_attisnull(HeapTuple tup, int attnum);
extern int heap_sysattrlen(AttrNumber attno);
extern bool heap_sysattrbyval(AttrNumber attno);
-extern char *heap_getsysattr(HeapTuple tup, Buffer b, int attnum);
extern char *fastgetattr(HeapTuple tup, int attnum,
TupleDesc att, bool *isnull);
extern char *heap_getattr(HeapTuple tup, Buffer b, int attnum,
TupleDesc att, bool *isnull);
extern HeapTuple heap_copytuple(HeapTuple tuple);
-extern void heap_deformtuple(HeapTuple tuple, TupleDesc tdesc,
- Datum values[], char nulls[]);
extern HeapTuple heap_formtuple(TupleDesc tupleDescriptor,
Datum value[], char nulls[]);
extern HeapTuple heap_modifytuple(HeapTuple tuple, Buffer buffer,
HeapTuple heap_addheader(uint32 natts, int structlen, char *structure);
/* in common/heap/stats.c */
-extern void InitHeapAccessStatistics(void);
-extern void ResetHeapAccessStatistics(void);
-extern HeapAccessStatistics GetHeapAccessStatistics(void);
extern void PrintHeapAccessStatistics(HeapAccessStatistics stats);
-extern void PrintAndFreeHeapAccessStatistics(HeapAccessStatistics stats);
extern void initam(void);
/* hio.c */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: istrat.h,v 1.4 1996/11/05 10:37:04 scrappy Exp $
+ * $Id: istrat.h,v 1.5 1997/08/19 21:37:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
#define IndexStrategyIsValid(s) PointerIsValid(s)
-extern ScanKey StrategyMapGetScanKeyEntry(StrategyMap map,
- StrategyNumber strategyNumber);
extern StrategyMap IndexStrategyGetStrategyMap(IndexStrategy indexStrategy,
StrategyNumber maxStrategyNum, AttrNumber attrNum);
extern Size
AttributeNumberGetIndexStrategySize(AttrNumber maxAttributeNumber,
StrategyNumber maxStrategyNumber);
-extern bool StrategyOperatorIsValid(StrategyOperator operator,
- StrategyNumber maxStrategy);
-extern bool StrategyTermIsValid(StrategyTerm term,
- StrategyNumber maxStrategy);
-extern bool StrategyExpressionIsValid(StrategyExpression expression,
- StrategyNumber maxStrategy);
-extern bool StrategyEvaluationIsValid(StrategyEvaluation evaluation);
extern StrategyNumber RelationGetStrategy(Relation relation,
AttrNumber attributeNumber, StrategyEvaluation evaluation,
RegProcedure procedure);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: itup.h,v 1.4 1996/11/05 07:20:09 scrappy Exp $
+ * $Id: itup.h,v 1.5 1997/08/19 21:37:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* indextuple.h */
extern IndexTuple index_formtuple(TupleDesc tupleDescriptor,
Datum value[], char null[]);
-extern char *fastgetiattr(IndexTuple tup, int attnum,
- TupleDesc att, bool *isnull);
extern Datum index_getattr(IndexTuple tuple, AttrNumber attNum,
TupleDesc tupDesc, bool *isNullOutP);
extern RetrieveIndexResult
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nbtree.h,v 1.13 1997/05/30 18:40:02 vadim Exp $
+ * $Id: nbtree.h,v 1.14 1997/08/19 21:37:35 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* prototypes for functions in nbtpage.c
*/
extern void _bt_metapinit(Relation rel);
-extern void _bt_checkmeta(Relation rel);
extern Buffer _bt_getroot(Relation rel, int access);
extern Buffer _bt_getbuf(Relation rel, BlockNumber blkno, int access);
extern void _bt_relbuf(Relation rel, Buffer buf, int access);
extern void _bt_pageinit(Page page, Size size);
extern void _bt_metaproot(Relation rel, BlockNumber rootbknum, int level);
extern Buffer _bt_getstackbuf(Relation rel, BTStack stack, int access);
-extern void _bt_setpagelock(Relation rel, BlockNumber blkno, int access);
-extern void _bt_unsetpagelock(Relation rel, BlockNumber blkno, int access);
extern void _bt_pagedel(Relation rel, ItemPointer tid);
/*
extern RetrieveIndexResult _bt_next(IndexScanDesc scan, ScanDirection dir);
extern RetrieveIndexResult _bt_first(IndexScanDesc scan, ScanDirection dir);
extern bool _bt_step(IndexScanDesc scan, Buffer *bufP, ScanDirection dir);
-extern int _bt_compare(Relation rel, TupleDesc itupdesc, Page page, int keysz, ScanKey scankey, OffsetNumber offnum);
/*
* prototypes for functions in nbtstrat.c
extern void _bt_freeskey(ScanKey skey);
extern void _bt_freestack(BTStack stack);
extern void _bt_orderkeys(Relation relation, BTScanOpaque so);
-extern bool _bt_checkqual(IndexScanDesc scan, IndexTuple itup);
-extern bool _bt_checkforkeys(IndexScanDesc scan, IndexTuple itup, Size keysz);
extern bool _bt_checkkeys (IndexScanDesc scan, IndexTuple tuple, Size *keysok);
extern BTItem _bt_formitem(IndexTuple itup);
* prototypes for functions in nbtsort.c
*/
extern void *_bt_spoolinit(Relation index, int ntapes, bool isunique);
-extern void *_bt_pagestate(Relation index, int flags, int level, bool doupper);
-extern BTItem _bt_minitem(Page opage, BlockNumber oblkno, int atend);
-extern BTItem _bt_buildadd(Relation index, void *pstate, BTItem bti, int flags);
-extern void _bt_uppershutdown(Relation index, BTPageState *state);
extern void _bt_spooldestroy(void *spool);
extern void _bt_spool(Relation index, BTItem btitem, void *spool);
-extern void _bt_upperbuild(Relation index);
extern void _bt_leafbuild(Relation index, void *spool);
#endif /* NBTREE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: rtree.h,v 1.5 1997/01/10 09:36:34 vadim Exp $
+ * $Id: rtree.h,v 1.6 1997/08/19 21:37:36 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void rtadjscans(Relation r, int op, BlockNumber blkno,
OffsetNumber offnum);
/* rtstrat.h */
-extern StrategyNumber RelationGetRTStrategy(Relation r,
- AttrNumber attnum, RegProcedure proc);
-extern bool RelationInvokeRTStrategy(Relation r, AttrNumber attnum,
- StrategyNumber s, Datum left, Datum right);
extern RegProcedure RTMapOperator(Relation r, AttrNumber attnum,
RegProcedure proc);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: transam.h,v 1.6 1996/11/27 07:30:28 vadim Exp $
+ * $Id: transam.h,v 1.7 1997/08/19 21:37:38 momjian Exp $
*
* NOTES
* Transaction System Version 101 now support proper oid
/*
* prototypes for functions in transam/transam.c
*/
-extern int RecoveryCheckingEnabled(void);
-extern void SetRecoveryCheckingEnabled(bool state);
-extern bool TransactionLogTest(TransactionId transactionId, XidStatus status);
-extern void TransactionLogUpdate(TransactionId transactionId,
- XidStatus status);
extern AbsoluteTime TransactionIdGetCommitTime(TransactionId transactionId);
-extern void TransRecover(Relation logRelation);
extern void InitializeTransactionLog(void);
extern bool TransactionIdDidCommit(TransactionId transactionId);
extern bool TransactionIdDidAbort(TransactionId transactionId);
extern void TransactionIdCommit(TransactionId transactionId);
extern void TransactionIdAbort(TransactionId transactionId);
-extern void TransactionIdSetInProgress(TransactionId transactionId);
/* in transam/transsup.c */
extern void AmiTransactionOverride(bool flag);
extern void TransComputeBlockNumber(Relation relation,
TransactionId transactionId, BlockNumber *blockNumberOutP);
-extern XidStatus TransBlockGetLastTransactionIdStatus(Block tblock,
- TransactionId baseXid, TransactionId *returnXidP);
-extern XidStatus TransBlockGetXidStatus(Block tblock,
- TransactionId transactionId);
-extern void TransBlockSetXidStatus(Block tblock,
- TransactionId transactionId, XidStatus xstatus);
-extern AbsoluteTime TransBlockGetCommitTime(Block tblock,
- TransactionId transactionId);
-extern void TransBlockSetCommitTime(Block tblock,
- TransactionId transactionId, AbsoluteTime commitTime);
extern XidStatus TransBlockNumberGetXidStatus(Relation relation,
BlockNumber blockNumber, TransactionId xid, bool *failP);
extern void TransBlockNumberSetXidStatus(Relation relation,
extern void TransBlockNumberSetCommitTime(Relation relation,
BlockNumber blockNumber, TransactionId xid, AbsoluteTime xtime,
bool *failP);
-extern void TransGetLastRecordedTransaction(Relation relation,
- TransactionId xid, bool *failP);
/* in transam/varsup.c */
-extern void VariableRelationGetNextXid(TransactionId *xidP);
-extern void VariableRelationGetLastXid(TransactionId *xidP);
extern void VariableRelationPutNextXid(TransactionId xid);
-extern void VariableRelationPutLastXid(TransactionId xid);
-extern void VariableRelationGetNextOid(Oid *oid_return);
-extern void VariableRelationPutNextOid(Oid *oidP);
extern void GetNewTransactionId(TransactionId *xid);
extern void UpdateLastCommittedXid(TransactionId xid);
-extern void GetNewObjectIdBlock(Oid *oid_return, int oid_block_size);
extern void GetNewObjectId(Oid *oid_return);
extern void CheckMaxObjectId(Oid assigned_oid);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: xact.h,v 1.4 1996/11/10 03:04:42 momjian Exp $
+ * $Id: xact.h,v 1.5 1997/08/19 21:37:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern AbsoluteTime GetCurrentTransactionStartTime(void);
extern bool TransactionIdIsCurrentTransactionId(TransactionId xid);
extern bool CommandIdIsCurrentCommandId(CommandId cid);
-extern void ClearCommandIdCounterOverflowFlag(void);
extern void CommandCounterIncrement(void);
extern void InitializeTransactionSystem(void);
-extern void AtStart_Cache(void);
-extern void AtStart_Locks(void);
-extern void AtStart_Memory(void);
-extern void RecordTransactionCommit(void);
-extern void AtCommit_Cache(void);
-extern void AtCommit_Locks(void);
-extern void AtCommit_Memory(void);
-extern void RecordTransactionAbort(void);
-extern void AtAbort_Cache(void);
-extern void AtAbort_Locks(void);
-extern void AtAbort_Memory(void);
-extern void StartTransaction(void);
extern bool CurrentXactInProgress(void);
-extern void CommitTransaction(void);
-extern void AbortTransaction(void);
extern void StartTransactionCommand(void);
extern void CommitTransactionCommand(void);
extern void AbortCurrentTransaction(void);
extern void BeginTransactionBlock(void);
extern void EndTransactionBlock(void);
-extern void AbortTransactionBlock(void);
extern bool IsTransactionBlock(void);
extern void UserAbortTransactionBlock(void);
TransactionId *destination);
extern bool TransactionIdEquals(TransactionId id1, TransactionId id2);
extern bool TransactionIdIsLessThan(TransactionId id1, TransactionId id2);
-extern void TransactionIdIncrement(TransactionId *transactionId);
extern void TransactionIdAdd(TransactionId *xid, int value);
#endif /* XACT_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: bootstrap.h,v 1.4 1996/11/08 06:43:28 scrappy Exp $
+ * $Id: bootstrap.h,v 1.5 1997/08/19 21:37:42 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void DefineAttr(char *name, char *type, int attnum);
extern void InsertOneValue(Oid objectid, char *value, int i);
extern void InsertOneNull(int i);
-extern bool BootstrapAlreadySeen(Oid id);
-extern void cleanup(void);
-extern int gettype(char *type);
-extern AttributeTupleForm AllocateAttribute(void);
extern char* MapArrayTypeName(char *s);
extern char* CleanUpStr(char *s);
extern int EnterString (char *str);
-extern int CompHash (char *str, int len);
-extern hashnode *FindStr (char *str, int length, hashnode *mderef);
-extern hashnode *AddStr(char *str, int strlength, int mderef);
extern void build_indices(void);
#endif /* BOOTSTRAP_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: heap.h,v 1.3 1996/11/10 03:04:44 momjian Exp $
+ * $Id: heap.h,v 1.4 1997/08/19 21:37:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Relation heap_creatr(char *relname, unsigned smgr, TupleDesc att);
-extern int RelationAlreadyExists(Relation pg_class_desc, char relname[]);
-extern void addNewRelationType(char *typeName, Oid new_rel_oid);
-
-extern void AddPgRelationTuple(Relation pg_class_desc,
- Relation new_rel_desc, Oid new_rel_oid, int arch, unsigned natts);
-
extern Oid heap_create(char relname[],
char *typename,
int arch,
unsigned smgr, TupleDesc tupdesc);
-extern void RelationRemoveInheritance(Relation relation);
-extern void RelationRemoveIndexes(Relation relation);
-extern void DeletePgRelationTuple(Relation rdesc);
-extern void DeletePgAttributeTuples(Relation rdesc);
-extern void DeletePgTypeTuple(Relation rdesc);
extern void heap_destroy(char relname[]);
extern void heap_destroyr(Relation r);
extern void InitTempRelList(void);
-extern void AddToTempRelList(Relation r);
-extern void RemoveFromTempRelList(Relation r);
extern void DestroyTempRels(void);
#endif /* HEAP_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_type.h,v 1.12 1997/05/26 16:55:23 thomas Exp $
+ * $Id: pg_type.h,v 1.13 1997/08/19 21:37:54 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
* prototypes for functions in pg_type.c
*/
extern Oid TypeGet(char *typeName, bool *defined);
-extern Oid TypeShellMakeWithOpenRelation(Relation pg_type_desc,
- char *typeName);
extern Oid TypeShellMake(char *typeName);
extern Oid TypeCreate(char *typeName,
Oid relationOid,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: async.h,v 1.4 1996/11/08 06:01:49 momjian Exp $
+ * $Id: async.h,v 1.5 1997/08/19 21:38:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void Async_NotifyAtCommit(void);
extern void Async_NotifyAtAbort(void);
extern void Async_Listen(char *relname, int pid);
-extern void Async_Unlisten(char *relname, int pid);
-extern void Async_UnlistenOnExit(int code, char *relname);
extern GlobalMemory notifyContext;
-extern void Async_NotifyFrontEnd(void);
#endif /* ASYNC_H */
*
* Copyright (c) 1994-5, Regents of the University of California
*
- * $Id: cluster.h,v 1.1 1996/08/28 07:21:42 scrappy Exp $
+ * $Id: cluster.h,v 1.2 1997/08/19 21:38:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* functions
*/
extern void cluster(char oldrelname[], char oldindexname[]);
-extern Relation copy_heap(Oid OIDOldHeap);
-extern void copy_index(Oid OIDOldIndex, Oid OIDNewHeap);
-extern void rebuildheap(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex);
#endif /* CLUSTER_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: command.h,v 1.3 1996/11/06 08:05:02 scrappy Exp $
+ * $Id: command.h,v 1.4 1997/08/19 21:38:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern MemoryContext PortalExecutorHeapMemory;
-/*
- * PortalCleanup --
- * Cleans up the query state of the portal.
- *
- * Exceptions:
- * BadArg if portal invalid.
- */
-extern void PortalCleanup(Portal portal);
-
-
/*
* PerformPortalFetch --
* Performs the POSTQUEL function FETCH. Fetches count (or all if 0)
*/
extern void PerformPortalClose(char *name, CommandDest dest);
+extern void PortalCleanup(Portal portal);
+
/*
* PerformAddAttribute --
* Performs the POSTQUEL function ADD.
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: version.h,v 1.3 1996/11/06 10:29:33 scrappy Exp $
+ * $Id: version.h,v 1.4 1997/08/19 21:38:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef VERSION_H
#define VERSION_H
-
-
-extern void DefineVersion(char *name, char *fromRelname, char *date);
-extern void VersionCreate(char *vname, char *bname);
-extern void VersionAppend(char *vname, char *bname);
-extern void VersionRetrieve(char *vname, char *bname, char *snapshot);
-extern void VersionDelete(char *vname, char *bname, char *snapshot);
-extern void VersionReplace(char *vname, char *bname, char *snapshot);
#endif /* VERSION_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: execFlatten.h,v 1.1 1996/08/28 07:22:04 scrappy Exp $
+ * $Id: execFlatten.h,v 1.2 1997/08/19 21:38:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void ExecEvalFjoin(TargetEntry *tlist, ExprContext *econtext, bool *isNullVect, bool *fj_isDone);
-extern bool FjoinBumpOuterNodes(TargetEntry *tlist, ExprContext *econtext, DatumPtr results, char *nulls);
-
#endif /* EXECFLATTEN_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: executor.h,v 1.8 1997/05/31 16:52:19 momjian Exp $
+ * $Id: executor.h,v 1.9 1997/08/19 21:38:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void ExecOpenScanR(Oid relOid, int nkeys, ScanKey skeys, bool isindex,
ScanDirection dir, TimeQual timeRange,
Relation *returnRelation, Pointer *returnScanDesc);
-extern Relation ExecOpenR(Oid relationOid, bool isindex);
-extern Pointer ExecBeginScan(Relation relation, int nkeys, ScanKey skeys,
- bool isindex, ScanDirection dir, TimeQual time_range);
extern void ExecCloseR(Plan *node);
extern void ExecReScan(Plan *node, ExprContext *exprCtxt, Plan *parent);
extern HeapScanDesc ExecReScanR(Relation relDesc, HeapScanDesc scanDesc,
/*
* prototypes from functions in execMain.c
*/
-extern int ExecutorLimit(int limit);
extern TupleDesc ExecutorStart(QueryDesc *queryDesc, EState *estate);
extern TupleTableSlot* ExecutorRun(QueryDesc *queryDesc, EState *estate, int feature, int count);
extern void ExecutorEnd(QueryDesc *queryDesc, EState *estate);
extern Datum ExecExtractResult(TupleTableSlot *slot, AttrNumber attnum,
bool *isNull);
-extern Datum ExecEvalVar(Var *variable, ExprContext *econtext, bool *isNull);
extern Datum ExecEvalParam(Param *expression, ExprContext *econtext,
bool *isNull);
-extern char *GetAttributeByNum(TupleTableSlot *slot, AttrNumber attrno,
- bool *isNull);
-extern char *att_by_num(TupleTableSlot *slot, AttrNumber attrno,
- bool *isNull);
/* stop here */
extern char *GetAttributeByName(TupleTableSlot *slot, char *attname,
bool *isNull);
-extern char *att_by_name(TupleTableSlot *slot, char *attname, bool *isNull);
-extern void ExecEvalFuncArgs(FunctionCachePtr fcache, ExprContext *econtext,
- List *argList, Datum argV[], bool *argIsDone);
-extern Datum ExecMakeFunctionResult(Node *node, List *arguments,
- ExprContext *econtext, bool *isNull, bool *isDone);
-extern Datum ExecEvalOper(Expr *opClause, ExprContext *econtext,
- bool *isNull);
-extern Datum ExecEvalFunc(Expr *funcClause, ExprContext *econtext,
- bool *isNull, bool *isDone);
-extern Datum ExecEvalNot(Expr *notclause, ExprContext *econtext, bool *isNull);
-extern Datum ExecEvalOr(Expr *orExpr, ExprContext *econtext, bool *isNull);
-extern Datum ExecEvalAnd(Expr *andExpr, ExprContext *econtext, bool *isNull);
extern Datum ExecEvalExpr(Node *expression, ExprContext *econtext, bool *isNull,
bool *isDone);
-extern bool ExecQualClause(Node *clause, ExprContext *econtext);
extern bool ExecQual(List *qual, ExprContext *econtext);
extern int ExecTargetListLength(List *targetlist);
extern TupleTableSlot *ExecProject(ProjectionInfo *projInfo, bool *isDone);
Buffer buffer,
bool shouldFree);
extern TupleTableSlot* ExecClearTuple(TupleTableSlot* slot);
-extern bool ExecSlotPolicy(TupleTableSlot *slot);
extern bool ExecSetSlotPolicy(TupleTableSlot *slot, bool shouldFree);
extern TupleDesc ExecSetSlotDescriptor(TupleTableSlot *slot,
TupleDesc tupdesc);
extern void ExecSetSlotDescriptorIsNew(TupleTableSlot *slot, bool isNew);
-extern TupleDesc ExecSetNewSlotDescriptor(TupleTableSlot *slot,
- TupleDesc tupdesc);
-extern Buffer ExecSetSlotBuffer(TupleTableSlot *slot, Buffer b);
extern void ExecIncrSlotBufferRefcnt(TupleTableSlot *slot);
extern bool TupIsNull(TupleTableSlot* slot);
-extern bool ExecSlotDescriptorIsNew(TupleTableSlot *slot);
extern void ExecInitResultTupleSlot(EState *estate, CommonState *commonstate);
extern void ExecInitScanTupleSlot(EState *estate,
CommonScanState *commonscanstate);
extern void ExecInitMarkedTupleSlot(EState *estate, MergeJoinState *mergestate);
extern void ExecInitOuterTupleSlot(EState *estate, HashJoinState *hashstate);
-extern void ExecInitHashTupleSlot(EState *estate, HashJoinState *hashstate);
-extern TupleTableSlot *NodeGetResultTupleSlot(Plan *node);
extern TupleDesc ExecGetTupType(Plan *node);
extern TupleDesc ExecTypeFromTL(List *targetList);
* prototypes from functions in execTuples.c
*/
extern void ResetTupleCount(void);
-extern void DisplayTupleCount(FILE *statfp);
extern void ExecAssignNodeBaseInfo(EState *estate, CommonState *basenode,
Plan *parent);
extern void ExecAssignExprContext(EState *estate, CommonState *commonstate);
CommonState *commonstate);
extern void ExecAssignResultTypeFromTL(Plan *node, CommonState *commonstate);
extern TupleDesc ExecGetResultType(CommonState *commonstate);
-extern void ExecFreeResultType(CommonState *commonstate);
extern void ExecAssignProjectionInfo(Plan *node, CommonState *commonstate);
extern void ExecFreeProjectionInfo(CommonState *commonstate);
extern TupleDesc ExecGetScanType(CommonScanState *csstate);
-extern void ExecFreeScanType(CommonScanState *csstate);
extern void ExecAssignScanType(CommonScanState *csstate,
TupleDesc tupDesc);
extern void ExecAssignScanTypeFromOuterPlan(Plan *node,
CommonScanState *csstate);
extern AttributeTupleForm ExecGetTypeInfo(Relation relDesc);
-extern void ExecGetIndexKeyInfo(IndexTupleForm indexTuple, int *numAttsOutP,
- AttrNumber **attsOutP, FuncIndexInfoPtr fInfoP);
extern void ExecOpenIndices(Oid resultRelationOid,
RelationInfo *resultRelationInfo);
extern void ExecCloseIndices(RelationInfo *resultRelationInfo);
-extern IndexTuple ExecFormIndexTuple(HeapTuple heapTuple,
- Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo);
extern void ExecInsertIndexTuples(TupleTableSlot *slot, ItemPointer tupleid,
EState *estate, bool is_update);
extern void resetVarAttrLenForCreateTable(TupleDesc tupType);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeAppend.h,v 1.1 1996/08/28 07:22:15 scrappy Exp $
+ * $Id: nodeAppend.h,v 1.2 1997/08/19 21:38:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef NODEAPPEND_H
#define NODEAPPEND_H
-extern bool exec_append_initialize_next(Append *node);
extern bool ExecInitAppend(Append *node, EState *estate, Plan *parent);
extern int ExecCountSlotsAppend(Append *node);
extern TupleTableSlot *ExecProcAppend(Append *node);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeHash.h,v 1.1 1996/08/28 07:22:18 scrappy Exp $
+ * $Id: nodeHash.h,v 1.2 1997/08/19 21:38:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern bool ExecInitHash(Hash *node, EState *estate, Plan *parent);
extern int ExecCountSlotsHash(Hash *node);
extern void ExecEndHash(Hash *node);
-extern RelativeAddr hashTableAlloc(int size, HashJoinTable hashtable);
extern HashJoinTable ExecHashTableCreate(Hash *node);
extern void ExecHashTableInsert(HashJoinTable hashtable, ExprContext *econtext,
Var *hashkey, File *batches);
extern void ExecHashTableDestroy(HashJoinTable hashtable);
extern int ExecHashGetBucket(HashJoinTable hashtable, ExprContext *econtext,
Var *hashkey);
-extern void ExecHashOverflowInsert(HashJoinTable hashtable, HashBucket bucket,
- HeapTuple heapTuple);
extern HeapTuple ExecScanHashBucket(HashJoinState *hjstate, HashBucket bucket,
HeapTuple curtuple, List *hjclauses,
ExprContext *econtext);
-extern int ExecHashPartition(Hash *node);
extern void ExecHashTableReset(HashJoinTable hashtable, int ntuples);
#endif /* NODEHASH_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeHashjoin.h,v 1.1 1996/08/28 07:22:19 scrappy Exp $
+ * $Id: nodeHashjoin.h,v 1.2 1997/08/19 21:38:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void ExecEndHashJoin(HashJoin *node);
-extern int ExecHashJoinNewBatch(HashJoinState *hjstate);
-
extern char *ExecHashJoinSaveTuple(HeapTuple heapTuple, char *buffer,
File file, char *position);
-extern int ExecHashJoinGetBatch(int bucketno, HashJoinTable hashtable,
- int nbatch);
-
#endif /* NODEHASHJOIN_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeMergejoin.h,v 1.2 1996/11/10 03:05:09 momjian Exp $
+ * $Id: nodeMergejoin.h,v 1.3 1997/08/19 21:38:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef NODEMERGEJOIN_H
#define NODEMERGEJOIN_H
-extern bool MergeCompare(List *eqQual, List *compareQual, ExprContext *econtext);
-
-extern void ExecMergeTupleDumpInner(ExprContext *econtext);
-
-extern void ExecMergeTupleDumpOuter(ExprContext *econtext);
-
-extern void ExecMergeTupleDumpMarked(ExprContext *econtext,
- MergeJoinState *mergestate);
-
-extern void ExecMergeTupleDump(ExprContext *econtext,
- MergeJoinState *mergestate);
-
extern TupleTableSlot *ExecMergeJoin(MergeJoin *node);
extern bool ExecInitMergeJoin(MergeJoin *node, EState *estate, Plan *parent);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeSeqscan.h,v 1.1 1996/08/28 07:22:24 scrappy Exp $
+ * $Id: nodeSeqscan.h,v 1.2 1997/08/19 21:38:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef NODESEQSCAN_H
#define NODESEQSCAN_H
-extern TupleTableSlot *SeqNext(SeqScan *node);
extern TupleTableSlot *ExecSeqScan(SeqScan *node);
-extern Oid InitScanRelation(SeqScan *node, EState *estate,
- CommonScanState *scanstate, Plan *outerPlan);
extern bool ExecInitSeqScan(SeqScan *node, EState *estate, Plan *parent);
extern int ExecCountSlotsSeqScan(SeqScan *node);
extern void ExecEndSeqScan(SeqScan *node);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: dllist.h,v 1.3 1996/11/10 03:05:16 momjian Exp $
+ * $Id: dllist.h,v 1.4 1997/08/19 21:38:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void DLFreeElem(Dlelem*);
extern Dlelem* DLGetHead(Dllist*);
extern Dlelem* DLGetTail(Dllist*);
-extern void* DLGetHeadVal(Dllist*);
-extern void* DLGetTailVal(Dllist*);
+extern Dlelem* DLRemTail(Dllist* l);
extern Dlelem* DLGetPred(Dlelem*); /* get predecessor */
extern Dlelem* DLGetSucc(Dlelem*); /* get successor */
extern void DLRemove(Dlelem*); /* removes node from list*/
extern void DLAddHead(Dllist* list, Dlelem* node);
extern void DLAddTail(Dllist* list, Dlelem* node);
extern Dlelem* DLRemHead(Dllist* list); /* remove and return the head */
-extern Dlelem* DLRemTail(Dllist* list); /* remove and return the tail */
#define DLE_VAL(x) (x->dle_val)
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: lispsort.h,v 1.1 1996/08/28 07:22:39 scrappy Exp $
+ * $Id: lispsort.h,v 1.2 1997/08/19 21:38:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef LISPSORT_H
#define LISPSORT_H
-extern List *lisp_qsort(List *the_list, int (*compare)());
-
#endif /* LISPSORT_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: auth.h,v 1.3 1996/11/06 10:29:54 scrappy Exp $
+ * $Id: auth.h,v 1.4 1997/08/19 21:38:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern char *fe_getauthname(void);
extern int be_recvauth(MsgType msgtype, Port *port, char *username, StartupInfo* sp);
extern void be_setauthsvc(char *name);
-extern int be_getauthsvc(MsgType msgtype);
/* the value that matches any dbName value when doing
host based authentication*/
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: libpq-be.h,v 1.3 1996/11/10 03:05:18 momjian Exp $
+ * $Id: libpq-be.h,v 1.4 1997/08/19 21:38:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
PQArgBlock *args, int nargs);
extern char *PQexec(char *query);
extern int pqtest_PQexec(char *q);
-extern char *strmake(char *str, int len);
extern int pqtest_PQfn(char *q);
extern int32 pqtest(struct varlena *vlena);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: miscadmin.h,v 1.10 1997/08/14 16:11:41 momjian Exp $
+ * $Id: miscadmin.h,v 1.11 1997/08/19 21:37:03 momjian Exp $
*
* NOTES
* some of the information in this file will be moved to
/* XXX are there any other meaningful exit codes? */
/* in utils/init/postinit.c */
-extern void InitMyDatabaseId(void);
-extern void InitUserid(void);
-extern void InitCommunication(void);
-extern void InitStdio(void);
extern bool PostgresIsInitialized;
/* in miscinit.c */
extern void ExitPostgres(ExitStatus status);
-extern void AbortPostgres(void);
extern void StatusBackendExit(int status);
extern void StatusPostmasterExit(int status);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeFuncs.h,v 1.1 1996/08/28 01:57:35 scrappy Exp $
+ * $Id: nodeFuncs.h,v 1.2 1997/08/19 21:38:43 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern bool single_node(Node *node);
extern bool var_is_outer(Var *var);
-extern bool var_is_inner(Var *var);
extern bool var_is_rel(Var *var);
extern Oper *replace_opid(Oper *oper);
extern bool non_null(Expr *c);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_list.h,v 1.4 1997/03/12 21:11:23 scrappy Exp $
+ * $Id: pg_list.h,v 1.5 1997/08/19 21:38:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern List *lappend(List *list, void *obj);
extern List *lremove(void *elem, List *list);
extern void freeList(List *list);
+extern List *LispRemove(void *elem, List *list);
extern void *nth(int n, List *l);
extern void set_nth(List *l, int n, void *elem);
extern List *nreverse(List *);
extern List *set_difference(List *, List *);
extern List *set_differencei(List *, List *);
-extern List *LispRemove(void *, List *);
-extern List *intLispRemove(int, List *);
extern List *LispUnion(List *foo, List *bar);
extern List *LispUnioni(List *foo, List *bar);
extern bool same(List *foo, List *bar);
/* should be in nodes.h but needs List */
-extern bool equali(List *a, List *b);
/* in copyfuncs.c */
extern List *listCopy(List *);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: print.h,v 1.1 1996/11/10 03:05:23 momjian Exp $
+ * $Id: print.h,v 1.2 1997/08/19 21:38:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void print_keys(List *keys, List *rtable);
extern void print_tl(List *tlist, List *rtable);
extern void print_slot(TupleTableSlot *slot);
-extern char* plannode_type (Plan* p);
extern void print_plan_recursive (Plan* p, Query *parsetree,
int indentLevel, char* label);
extern void print_plan (Plan* p, Query* parsetree);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: clauses.h,v 1.2 1996/11/06 09:19:16 scrappy Exp $
+ * $Id: clauses.h,v 1.3 1997/08/19 21:39:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Var *get_leftop(Expr *clause);
extern Var *get_rightop(Expr *clause);
-extern bool agg_clause(Node *clause);
-
extern bool is_funcclause(Node *clause);
extern Expr *make_funcclause(Func *func, List *funcargs);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: cost.h,v 1.1 1996/08/28 07:23:12 scrappy Exp $
+ * $Id: cost.h,v 1.2 1997/08/19 21:39:18 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int relpages, int reltuples, int indexpages,
int indextuples, bool is_injoin);
extern Cost cost_sort(List *keys, int tuples, int width, bool noread);
-extern Cost cost_result(int tuples, int width);
extern Cost cost_nestloop(Cost outercost, Cost innercost, int outertuples,
int innertuples, int outerpages, bool is_indexjoin);
extern Cost cost_mergesort(Cost outercost, Cost innercost,
int outerwidth, int innerwidth);
extern int compute_rel_size(Rel *rel);
extern int compute_rel_width(Rel *rel);
-extern int compute_targetlist_width(List *targetlist);
extern int compute_joinrel_size(JoinPath *joinpath);
extern int page_size(int tuples, int width);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: keys.h,v 1.1 1996/08/28 07:23:16 scrappy Exp $
+ * $Id: keys.h,v 1.2 1997/08/19 21:39:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define KEYS_H
extern bool match_indexkey_operand(int indexkey, Var *operand, Rel *rel);
-extern bool equal_indexkey_var(int index_key, Var *var);
extern Var *extract_subkey(JoinKey *jk, int which_subkey);
extern bool samekeys(List *keys1, List *keys2);
extern List *collect_index_pathkeys(int *index_keys, List *tlist);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: ordering.h,v 1.2 1996/11/06 09:27:29 scrappy Exp $
+ * $Id: ordering.h,v 1.3 1997/08/19 21:39:29 momjian Exp $
*
*-------------------------------------------------------------------------
*/
MergeOrder *merge_ordering);
extern bool equal_merge_merge_ordering(MergeOrder *merge_ordering1,
MergeOrder *merge_ordering2);
-extern bool equal_sortops_order(Oid *ordering1, Oid *ordering2);
-
#endif /* ORDERING_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: tlist.h,v 1.1 1996/08/28 07:23:28 scrappy Exp $
+ * $Id: tlist.h,v 1.2 1997/08/19 21:39:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern List *flatten_tlist(List *tlist);
extern List *flatten_tlist_vars(List *full_tlist,
List *flat_tlist);
-extern void AddGroupAttrToTlist(List *tlist, List *grpCl);
-
#endif /* TLIST_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: catalog_utils.h,v 1.9 1997/05/22 00:16:28 scrappy Exp $
+ * $Id: catalog_utils.h,v 1.10 1997/08/19 21:39:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
typedef HeapTuple Type;
typedef HeapTuple Operator;
-extern bool check_typeid(Oid id);
extern Type get_id_type(Oid id);
extern char *get_id_typname(Oid id);
extern Type type(char *);
extern bool varisset(Relation rd, char *name);
extern int nf_varattno(Relation rd, char *a);
extern char *getAttrName(Relation rd, int attrno);
-extern char *outstr(char *typename, char *value);
extern char *instr2(Type tp, char *string, int typlen);
-extern char *instr1(TypeTupleForm tp, char *string, int typlen);
extern Oid GetArrayElementType(Oid typearray);
extern Oid funcid_get_rettype(Oid funcid);
extern bool func_get_detail(char *funcname, int nargs, Oid *oid_array,
extern Oid typeid_get_relid(Oid type_id);
extern Oid get_typrelid(Type typ);
extern Oid get_typelem(Oid type_id);
-extern char FindDelimiter(char *typename);
-extern void op_error(char *op, Oid arg1, Oid arg2);
extern void func_error(char *caller, char *funcname, int nargs, Oid *argtypes);
extern void agg_error(char *caller, char *aggname, Oid basetypeID);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: dbcommands.h,v 1.1 1996/08/28 07:23:53 scrappy Exp $
+ * $Id: dbcommands.h,v 1.2 1997/08/19 21:39:35 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void createdb(char *dbname);
extern void destroydb(char *dbname);
-void stop_vacuum(char *dbname);
#endif /* DBCOMMANDS_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_query.h,v 1.7 1996/11/30 18:07:02 momjian Exp $
+ * $Id: parse_query.h,v 1.8 1997/08/19 21:39:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Aggreg *ParseAgg(char *aggname, Oid basetype, Node *target);
extern void handleTargetColname(ParseState *pstate, char **resname,
char *refname, char *colname);
-extern void checkTargetTypes(ParseState *pstate, char *target_colname,
- char *refname, char *colname);
/*
* analyze.c
#endif
Oid exprType(Node *expr);
-ParseState* makeParseState(void);
QueryTreeList *parse_analyze(List *querytree_list);
/* define in parse_query.c, used in gram.y */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: buf_internals.h,v 1.13 1997/08/03 02:38:25 momjian Exp $
+ * $Id: buf_internals.h,v 1.14 1997/08/19 21:39:41 momjian Exp $
*
* NOTE
* If BUFFERPAGE0 is defined, then 0 will be used as a
(a)->blockNum = xx_blockNum;\
(a)->relId = RelationGetLRelId(xx_reln); \
}
-
+#ifdef NOT_USED
#define COPY_BUFFERTAG(a,b)\
{ \
(a)->blockNum = (b)->blockNum;\
#define EQUAL_BUFFERTAG(a,b) \
(((a)->blockNum == (b)->blockNum) &&\
(OID_Equal((a)->relId.relId,(b)->relId.relId)))
-
+#endif
#define BAD_BUFFER_ID(bid) ((bid<1) || (bid>(NBuffers)))
#define INVALID_DESCRIPTOR (-3)
extern void PinBuffer(BufferDesc *buf);
extern void PinBuffer_Debug(char *file, int line, BufferDesc *buf);
extern void UnpinBuffer(BufferDesc *buf);
-extern void UnpinBuffer_Debug(char *file, int line, BufferDesc *buf);
extern BufferDesc *GetFreeBuffer(void);
extern void InitFreeList(bool init);
-extern void DBG_FreeListCheck(int nfree);
/* buf_table.c */
extern void InitBufTable(void);
extern BufferDesc *BufTableLookup(BufferTag *tagPtr);
extern bool BufTableDelete(BufferDesc *buf);
extern bool BufTableInsert(BufferDesc *buf);
-extern void DBG_LookupListCheck(int nlookup);
/* bufmgr.c */
extern BufferDesc *BufferDescriptors;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: bufmgr.h,v 1.10 1997/03/28 07:06:53 scrappy Exp $
+ * $Id: bufmgr.h,v 1.11 1997/08/19 21:39:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Buffer RelationGetBufferWithBuffer(Relation relation,
BlockNumber blockNumber, Buffer buffer);
extern Buffer ReadBuffer(Relation reln, BlockNumber blockNum);
-extern Buffer ReadBuffer_Debug(char *file, int line, Relation reln,
- BlockNumber blockNum);
extern int WriteBuffer(Buffer buffer);
-extern void WriteBuffer_Debug(char *file, int line, Buffer buffer);
-extern void DirtyBufferCopy(Oid dbid, Oid relid, BlockNumber blkno,
- char *dest);
extern int WriteNoReleaseBuffer(Buffer buffer);
extern Buffer ReleaseAndReadBuffer(Buffer buffer, Relation relation,
BlockNumber blockNum);
extern void PrintBufferDescs(void);
extern void PrintPinnedBufs(void);
extern int BufferShmemSize(void);
-extern void BufferPoolBlowaway(void);
extern void IncrBufferRefCount(Buffer buffer);
extern int ReleaseBuffer(Buffer buffer);
-extern void IncrBufferRefCount_Debug(char *file, int line, Buffer buffer);
-extern void ReleaseBuffer_Debug(char *file, int line, Buffer buffer);
-extern int ReleaseAndReadBuffer_Debug(char *file,
- int line,
- Buffer buffer,
- Relation relation,
- BlockNumber blockNum);
extern void BufferRefCountReset(int *refcountsave);
extern void BufferRefCountRestore(int *refcountsave);
extern int SetBufferWriteMode (int mode);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: bufpage.h,v 1.7 1996/11/05 06:10:57 scrappy Exp $
+ * $Id: bufpage.h,v 1.8 1997/08/19 21:39:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Size PageGetFreeSpace(Page page);
extern void PageManagerModeSet(PageManagerMode mode);
extern void PageIndexTupleDelete(Page page, OffsetNumber offset);
-extern void PageIndexTupleDeleteAdjustLinePointers(PageHeader phdr,
- char *location, Size size);
#endif /* BUFPAGE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: fd.h,v 1.7 1997/08/18 02:15:04 momjian Exp $
+ * $Id: fd.h,v 1.8 1997/08/19 21:39:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes for functions in fd.c
*/
-extern void FileInvalidate(File file);
extern File FileNameOpenFile(FileName fileName, int fileFlags, int fileMode);
extern File PathNameOpenFile(FileName fileName, int fileFlags, int fileMode);
extern void FileClose(File file);
extern int FileRead(File file, char *buffer, int amount);
extern int FileWrite(File file, char *buffer, int amount);
extern long FileSeek(File file, long offset, int whence);
-extern long FileTell(File file);
extern int FileTruncate(File file, int offset);
extern int FileSync(File file);
extern int FileNameUnlink(char *filename);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: ipc.h,v 1.16 1997/03/12 21:12:27 scrappy Exp $
+ * $Id: ipc.h,v 1.17 1997/08/19 21:39:50 momjian Exp $
*
* NOTES
* This file is very architecture-specific. This stuff should actually
extern IpcSemaphoreId IpcSemaphoreCreate(IpcSemaphoreKey semKey,
int semNum, int permission, int semStartValue,
int removeOnExit, int *status);
-extern void IpcSemaphoreSet(int semId, int semno, int value);
extern void IpcSemaphoreKill(IpcSemaphoreKey key);
extern void IpcSemaphoreLock(IpcSemaphoreId semId, int sem, int lock);
extern void IpcSemaphoreUnlock(IpcSemaphoreId semId, int sem, int lock);
extern IpcMemoryId IpcMemoryCreate(IpcMemoryKey memKey, uint32 size,
int permission);
extern IpcMemoryId IpcMemoryIdGet(IpcMemoryKey memKey, uint32 size);
-extern void IpcMemoryDetach(int status, char *shmaddr);
extern char *IpcMemoryAttach(IpcMemoryId memId);
extern void IpcMemoryKill(IpcMemoryKey memKey);
extern void CreateAndInitSLockMemory(IPCKey key);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: large_object.h,v 1.3 1996/11/05 06:10:58 scrappy Exp $
+ * $Id: large_object.h,v 1.4 1997/08/19 21:39:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern LargeObjectDesc *inv_open(Oid lobjId, int flags);
extern void inv_close(LargeObjectDesc *obj_desc);
extern int inv_destroy(Oid lobjId);
-extern int inv_stat(LargeObjectDesc *obj_desc, struct pgstat *stbuf);
extern int inv_seek(LargeObjectDesc *obj_desc, int offset, int whence);
extern int inv_tell(LargeObjectDesc *obj_desc);
extern int inv_read(LargeObjectDesc *obj_desc, char *buf, int nbytes);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: lmgr.h,v 1.4 1996/11/08 06:02:18 momjian Exp $
+ * $Id: lmgr.h,v 1.5 1997/08/19 21:39:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern LRelId RelationGetLRelId(Relation relation);
-extern Oid LRelIdGetDatabaseId(LRelId lRelId);
extern Oid LRelIdGetRelationId(LRelId lRelId);
-extern bool DatabaseIdIsMyDatabaseId(Oid databaseId);
-extern bool LRelIdContainsMyDatabaseId(LRelId lRelId);
extern void RelationInitLockInfo(Relation relation);
-extern void RelationDiscardLockInfo(Relation relation);
extern void RelationSetLockForDescriptorOpen(Relation relation);
extern void RelationSetLockForRead(Relation relation);
extern void RelationUnsetLockForRead(Relation relation);
extern void RelationSetLockForWrite(Relation relation);
extern void RelationUnsetLockForWrite(Relation relation);
-extern void RelationSetLockForTupleRead(Relation relation,
- ItemPointer itemPointer);
/* used in vaccum.c */
extern void RelationSetLockForWritePage(Relation relation,
extern void RelationUnsetRIntentLock(Relation relation);
extern void RelationSetWIntentLock(Relation relation);
extern void RelationUnsetWIntentLock(Relation relation);
-extern void RelationSetLockForExtend(Relation relation);
-extern void RelationUnsetLockForExtend(Relation relation);
-extern void LRelIdAssign(LRelId *lRelId, Oid dbId, Oid relId);
/* single.c */
extern bool SingleLockReln(LockInfo linfo, LOCKT lockt, int action);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: lock.h,v 1.4 1997/02/12 05:25:13 scrappy Exp $
+ * $Id: lock.h,v 1.5 1997/08/19 21:39:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void LockDisable(int status);
extern LockTableId LockTabInit(char *tabName, MASK *conflictsP, int *prioP,
int ntypes);
-extern LockTableId LockTabRename(LockTableId tableId);
extern bool LockAcquire(LockTableId tableId, LOCKTAG *lockName, LOCKT lockt);
extern int LockResolveConflicts(LOCKTAB *ltable, LOCK *lock, LOCKT lockt,
TransactionId xid);
-extern int WaitOnLock(LOCKTAB *ltable, LockTableId tableId, LOCK *lock,
- LOCKT lockt);
extern bool LockRelease(LockTableId tableId, LOCKTAG *lockName, LOCKT lockt);
extern void GrantLock(LOCK *lock, LOCKT lockt);
extern bool LockReleaseAll(LockTableId tableId, SHM_QUEUE *lockQueue);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: multilev.h,v 1.2 1996/11/05 06:11:01 scrappy Exp $
+ * $Id: multilev.h,v 1.3 1997/08/19 21:39:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern bool MultiLockReln(LockInfo linfo, LOCKT lockt);
extern bool MultiLockTuple(LockInfo linfo, ItemPointer tidPtr, LOCKT lockt);
extern bool MultiLockPage(LockInfo linfo, ItemPointer tidPtr, LOCKT lockt);
-extern bool MultiAcquire(LockTableId tableId, LOCKTAG *tag, LOCKT lockt,
- LOCK_LEVEL level);
-extern bool MultiReleasePage(LockInfo linfo, ItemPointer tidPtr, LOCKT lockt);
extern bool MultiReleaseReln(LockInfo linfo, LOCKT lockt);
-extern bool MultiRelease(LockTableId tableId, LOCKTAG *tag, LOCKT lockt,
- LOCK_LEVEL level);
#endif /* MULTILEV_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: proc.h,v 1.4 1997/02/14 04:18:51 momjian Exp $
+ * $Id: proc.h,v 1.5 1997/08/19 21:39:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* extern bool ProcKill(int exitStatus, int pid); */
/* make static in storage/lmgr/proc.c -- jolly */
-extern PROC_QUEUE *ProcQueueAlloc(char *name);
extern void ProcQueueInit(PROC_QUEUE *queue);
extern int ProcSleep(PROC_QUEUE *queue, SPINLOCK spinlock, int token,
int prio, LOCK *lock);
-extern PROC *ProcWakeup(PROC *proc, int errType);
-extern int ProcGetId(void);
extern int ProcLockWakeup(PROC_QUEUE *queue, char * ltable, char * lock);
extern void ProcAddLock(SHM_QUEUE *elem);
-extern void HandleDeadLock(int sig);
extern void ProcReleaseSpins(PROC *proc);
extern void ProcFreeAllSemaphores(void);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: shmem.h,v 1.4 1996/11/27 07:32:10 vadim Exp $
+ * $Id: shmem.h,v 1.5 1997/08/19 21:40:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* prototypes for functions in shmqueue.c
*/
extern void SHMQueueInit(SHM_QUEUE *queue);
-extern bool SHMQueueIsDetached(SHM_QUEUE *queue);
extern void SHMQueueElemInit(SHM_QUEUE *queue);
extern void SHMQueueDelete(SHM_QUEUE *queue);
-extern void SHMQueueInsertHD(SHM_QUEUE *queue, SHM_QUEUE *elem);
extern void SHMQueueInsertTL(SHM_QUEUE *queue, SHM_QUEUE *elem);
extern void SHMQueueFirst(SHM_QUEUE *queue, Pointer *nextPtrPtr,
SHM_QUEUE *nextQueue);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: smgr.h,v 1.6 1996/11/27 07:33:42 vadim Exp $
+ * $Id: smgr.h,v 1.7 1997/08/19 21:40:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define DEFAULT_SMGR 0
extern int smgrinit(void);
-extern void smgrshutdown(int dummy);
extern int smgrcreate(int16 which, Relation reln);
extern int smgrunlink(int16 which, Relation reln);
extern int smgrextend(int16 which, Relation reln, char *buffer);
extern int smgrnblocks(int16 which, Relation reln);
extern int smgrtruncate(int16 which, Relation reln, int nblocks);
extern int smgrcommit(void);
-extern int smgrabort(void);
extern bool smgriswo(int16 smgrno);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: spin.h,v 1.2 1996/11/05 06:11:08 scrappy Exp $
+ * $Id: spin.h,v 1.3 1997/08/19 21:40:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
typedef int SPINLOCK;
extern bool CreateSpinlocks(IPCKey key);
-extern bool AttachSpinLocks(IPCKey key);
extern bool InitSpinLocks(int init, IPCKey key);
-
extern void SpinAcquire(SPINLOCK lock);
extern void SpinRelease(SPINLOCK lock);
-extern bool SpinIsLocked(SPINLOCK lock);
#endif /* SPIN_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: dest.h,v 1.5 1997/01/08 08:39:10 bryanh Exp $
+ * $Id: dest.h,v 1.6 1997/08/19 21:40:06 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void BeginCommand(char *pname, int operation, TupleDesc attinfo,
bool isIntoRel, bool isIntoPortal, char *tag,
CommandDest dest);
-extern void ResetAppendOid(void);
extern void UpdateAppendOid(Oid newoid);
-extern Oid GetAppendOid(void);
#endif /* DEST_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pquery.h,v 1.3 1996/11/10 03:06:09 momjian Exp $
+ * $Id: pquery.h,v 1.4 1997/08/19 21:40:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Plan *plan, EState *state, TupleDesc attinfo,
CommandDest dest);
-extern void ProcessQueryDesc(QueryDesc *queryDesc);
-
extern void ProcessQuery(Query *parsetree, Plan *plan, char *argv[],
Oid *typev, int nargs, CommandDest dest);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: tcopprot.h,v 1.3 1996/11/10 03:06:11 momjian Exp $
+ * $Id: tcopprot.h,v 1.4 1997/08/19 21:40:10 momjian Exp $
*
* OLD COMMENTS
* This file was created so that other c files could get the two
#endif /* BOOTSTRAP_HEADER */
extern void handle_warn(SIGNAL_ARGS);
-extern void quickdie(SIGNAL_ARGS);
extern void die(SIGNAL_ARGS);
extern int PostgresMain(int argc, char *argv[]);
extern void ResetUsage(void);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: acl.h,v 1.6 1997/05/22 00:16:41 scrappy Exp $
+ * $Id: acl.h,v 1.7 1997/08/19 21:40:18 momjian Exp $
*
* NOTES
* For backward-compatability purposes we have to allow there
/*
* routines used internally (parser, etc.)
*/
-extern char *aclparse(char *s, AclItem *aip, unsigned *modechg);
extern Acl *aclownerdefault(AclId ownerid);
extern Acl *acldefault(void);
extern Acl *aclinsert3(Acl *old_acl, AclItem *mod_aip, unsigned modechg);
extern void ChangeAcl(char *relname, AclItem *mod_aip, unsigned modechg);
extern AclId get_grosysid(char *groname);
extern char *get_groname(AclId grosysid);
-extern int32 aclcheck(Acl *acl, AclId id, AclIdType idtype, AclMode mode);
/* XXX move these elsewhere -pma */
extern int32 pg_aclcheck(char *relname, char *usename, AclMode mode);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: array.h,v 1.3 1996/11/04 07:18:39 scrappy Exp $
+ * $Id: array.h,v 1.4 1997/08/19 21:40:21 momjian Exp $
*
* NOTES
* XXX the data array should be LONGALIGN'd -- notice that the array
int lowerIndx[], ArrayType *newArr, int reftype,
int len, bool *isNull);
extern int array_eq (ArrayType *array1, ArrayType *array2);
-extern SanityCheckInput(int ndim, int n, int dim[], int lb[], int indx[]);
-extern char *array_seek(char *ptr, int eltsize, int nitems);
-extern int array_read(char *destptr, int eltsize, int nitems, char *srcptr);
extern int _LOtransfer(char **destfd, int size, int nitems, char **srcfd,
int isSrcLO, int isDestLO);
*/
extern char * _ChunkArray(int fd, FILE *afd, int ndim, int dim[], int baseSize,
int *nbytes, char *chunkfile);
-extern int GetChunkSize(FILE *fd, int ndim, int dim[MAXDIM], int baseSize,
- int d[MAXDIM]);
extern int _ReadChunkArray(int st[], int endp[], int bsize, int fp,
char *destfp, ArrayType *array, int isDestLO, bool *isNull);
extern struct varlena *_ReadChunkArray1El(int st[], int bsize, int fp,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: builtins.h,v 1.20 1997/07/29 16:16:10 thomas Exp $
+ * $Id: builtins.h,v 1.21 1997/08/19 21:40:26 momjian Exp $
*
* NOTES
* This should normally only be included by fmgr.h.
extern bool namege(NameData *arg1, NameData *arg2);
extern int namecmp(Name n1, Name n2);
extern int namecpy(Name n1, Name n2);
-extern int namecat(Name n1, Name n2);
extern int namestrcpy(Name name, char *str);
-extern int namestrcat(Name name, char *str);
extern int namestrcmp(Name name, char *str);
-extern uint32 NameComputeLength(Name name);
/* numutils.c */
/* XXX hack. HP-UX has a ltoa (with different arguments) already. */
extern int32 pg_atoi(char *s, int size, int c);
extern void itoa(int i, char *a);
extern void ltoa(int32 l, char *a);
-extern int ftoa(double value, char *ascii, int width, int prec1, char format);
-extern int atof1(char *str, double *val);
/*
* Per-opclass comparison functions for new btrees. These are
extern char *datetime_out(DateTime *datetime);
extern TimeSpan *timespan_in(char *str);
extern char *timespan_out(TimeSpan *timespan);
+extern int datetime2tm( DateTime dt, int *tzp, struct tm *tm, double *fsec, char **tzn);
/* filename.c */
extern char *filename_in(char *file);
extern bool float84ge(float64 arg1, float32 arg2);
/* geo_ops.c, geo_selfuncs.c */
+extern double *box_area(BOX *box);
/* misc.c */
extern bool nullvalue(Datum value, bool *isNull);
/* not_in.c */
extern bool int4notin(int16 not_in_arg, char *relation_and_attr);
extern bool oidnotin(Oid the_oid, char *compare);
-extern int my_varattno(Relation rd, char *a);
/* oid.c */
extern Oid *oid8in(char *oidString);
/* varlena.c */
extern struct varlena *byteain(char *inputText);
-extern struct varlena *shove_bytes(unsigned char *stuff, int len);
extern char *byteaout(struct varlena *vlena);
extern struct varlena *textin(char *inputText);
extern char *textout(struct varlena *vlena);
-extern int textlen (text* t);
extern text *textcat(text* t1, text* t2);
extern bool texteq(struct varlena *arg1, struct varlena *arg2);
extern bool textne(struct varlena *arg1, struct varlena *arg2);
extern bool namenlike(NameData *s, struct varlena *p);
extern bool textlike(struct varlena *s, struct varlena *p);
extern bool textnlike(struct varlena *s, struct varlena *p);
-extern int like(char *text, char *p);
/* oracle_compat.c */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: catcache.h,v 1.4 1996/11/04 11:51:15 scrappy Exp $
+ * $Id: catcache.h,v 1.5 1997/08/19 21:40:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern struct catcache *Caches;
extern GlobalMemory CacheCxt;
-extern void CatalogCacheInitializeCache(struct catcache *cache,
- Relation relation);
-extern void CatalogCacheSetId(CatCache *cacheInOutP, int id);
-extern long comphash(long l, char *v);
-extern Index CatalogCacheComputeHashIndex(struct catcache *cacheInP);
-extern Index CatalogCacheComputeTupleHashIndex(struct catcache *cacheInOutP,
- Relation relation, HeapTuple tuple);
-extern void CatCacheRemoveCTup(CatCache *cache, Dlelem *e);
extern void CatalogCacheIdInvalidate(int cacheId, Index hashIndex,
ItemPointer pointer);
extern void ResetSystemCache(void);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: dt.h,v 1.15 1997/07/29 16:16:12 thomas Exp $
+ * $Id: dt.h,v 1.16 1997/08/19 21:40:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern bool timespan_le(TimeSpan *span1, TimeSpan *span2);
extern bool timespan_ge(TimeSpan *span1, TimeSpan *span2);
extern bool timespan_gt(TimeSpan *span1, TimeSpan *span2);
-extern bool timespan_finite(TimeSpan *span);
extern TimeSpan *timespan_smaller(TimeSpan *span1, TimeSpan *span2);
extern TimeSpan *timespan_larger(TimeSpan *span1, TimeSpan *span2);
extern text *datetime_text(DateTime *datetime);
extern DateTime *text_datetime(text *str);
extern text *timespan_text(TimeSpan *timespan);
-extern TimeSpan *text_timespan(text *str);
extern DateTime *datetime_trunc(text *units, DateTime *datetime);
extern TimeSpan *timespan_trunc(text *units, TimeSpan *timespan);
extern float64 datetime_part(text *units, DateTime *datetime);
extern void GetCurrentTime(struct tm *tm);
extern DateTime SetDateTime(DateTime datetime);
extern int tm2datetime(struct tm *tm, double fsec, int *tzp, DateTime *dt);
-extern int datetime2tm( DateTime dt, int *tzp, struct tm *tm, double *fsec, char **tzn);
-
-extern int timespan2tm(TimeSpan span, struct tm *tm, float8 *fsec);
-extern int tm2timespan(struct tm *tm, double fsec, TimeSpan *span);
-
-extern DateTime dt2local( DateTime dt, int timezone);
extern void j2date( int jd, int *year, int *month, int *day);
extern int date2j( int year, int month, int day);
-extern int j2day( int jd);
extern double time2t(const int hour, const int min, const double sec);
-extern void dt2time(DateTime dt, int *hour, int *min, double *sec);
extern int ParseDateTime( char *timestr, char *lowstr,
char *field[], int ftype[], int maxfields, int *numfields);
extern int DecodeDateTime( char *field[], int ftype[],
int nf, int *dtype, struct tm *tm, double *fsec, int *tzp);
-extern int DecodeDate(char *str, int fmask, int *tmask, struct tm *tm);
-extern int DecodeNumber( int flen, char *field,
- int fmask, int *tmask, struct tm *tm, double *fsec);
-extern int DecodeNumberField( int len, char *str,
- int fmask, int *tmask, struct tm *tm, double *fsec);
-extern int DecodeTime(char *str,
- int fmask, int *tmask, struct tm *tm, double *fsec);
+
extern int DecodeTimeOnly( char *field[], int ftype[], int nf,
int *dtype, struct tm *tm, double *fsec);
-extern int DecodeTimezone( char *str, int *tzp);
-extern int DecodeSpecial(int field, char *lowtoken, int *val);
extern int DecodeDateDelta( char *field[], int ftype[],
int nf, int *dtype, struct tm *tm, double *fsec);
-extern int DecodeUnits(int field, char *lowtoken, int *val);
-extern int EncodeSpecialDateTime(DateTime dt, char *str);
extern int EncodeDateOnly(struct tm *tm, int style, char *str);
extern int EncodeTimeOnly(struct tm *tm, double fsec, int style, char *str);
extern int EncodeDateTime(struct tm *tm, double fsec, int *tzp, char **tzn, int style, char *str);
extern int EncodeTimeSpan(struct tm *tm, double fsec, int style, char *str);
-extern datetkn *datebsearch(char *key, datetkn *base, unsigned int nel);
-
#endif /* DT_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: exc.h,v 1.6 1996/12/10 07:04:22 bryanh Exp $
+ * $Id: exc.h,v 1.7 1997/08/19 21:40:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* prototypes for functions in exc.c
*/
extern void EnableExceptionHandling(bool on);
-extern void ExcPrint(Exception *excP, ExcDetail detail, ExcData data,
- ExcMessage message);
-extern ExcProc *ExcGetUnCaught(void);
-extern ExcProc *ExcSetUnCaught(ExcProc *newP);
-extern void ExcUnCaught(Exception *excP, ExcDetail detail, ExcData data,
- ExcMessage message);
-extern void ExcUnCaught(Exception *excP, ExcDetail detail, ExcData data,
- ExcMessage message);
extern void ExcRaise(Exception *excP,
ExcDetail detail,
ExcData data,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: geo_decls.h,v 1.6 1997/07/29 16:16:13 thomas Exp $
+ * $Id: geo_decls.h,v 1.7 1997/08/19 21:40:34 momjian Exp $
*
* NOTE
* These routines do *not* use the float types from adt/.
/* public point routines */
extern Point *point_in(char *str);
extern char *point_out(Point *pt);
-extern Point *point_construct(double x, double y);
-extern Point *point_copy(Point *pt);
extern bool point_left(Point *pt1, Point *pt2);
extern bool point_right(Point *pt1, Point *pt2);
extern bool point_above(Point *pt1, Point *pt2);
extern double *dist_sl(LSEG *lseg, LINE *line);
extern double *dist_sb(LSEG *lseg, BOX *box);
extern double *dist_lb(LINE *line, BOX *box);
-extern Point *interpt_sl(LSEG *lseg, LINE *line);
extern Point *close_pl(Point *pt, LINE *line);
extern Point *close_ps(Point *pt, LSEG *lseg);
extern Point *close_pb(Point *pt, BOX *box);
/* private routines */
extern LSEG *lseg_construct(Point *pt1, Point *pt2);
-extern void statlseg_construct(LSEG *lseg, Point *pt1, Point *pt2);
-extern double lseg_dt(LSEG *l1, LSEG *l2);
-extern void make_bound_box(POLYGON *poly);
/* public box routines */
extern BOX *box_in(char *str);
extern bool box_le(BOX *box1, BOX *box2);
extern bool box_ge(BOX *box1, BOX *box2);
extern Point *box_center(BOX *box);
-extern double *box_area(BOX *box);
extern double *box_width(BOX *box);
extern double *box_height(BOX *box);
extern double *box_distance(BOX *box1, BOX *box2);
extern LSEG *box_diagonal(BOX *box);
/* private routines */
-extern BOX *box_construct(double x1, double x2, double y1, double y2);
-extern BOX *box_fill(BOX *result, double x1, double x2, double y1, double y2);
-extern BOX *box_copy(BOX *box);
-extern double box_ar(BOX *box);
-extern double box_wd(BOX *box);
-extern double box_ht(BOX *box);
extern double box_dt(BOX *box1, BOX *box2);
extern BOX *box(Point *p1, Point *p2);
extern BOX *box_div(BOX *box, Point *p);
/* private line routines */
-extern LINE *line_construct_pm(Point *pt, double m);
-extern LINE *line_construct_pp(Point *pt1, Point *pt2);
-extern bool line_intersect(LINE *l1, LINE *l2);
-extern bool line_parallel(LINE *l1, LINE *l2);
-extern bool line_perp(LINE *l1, LINE *l2);
-extern bool line_vertical(LINE *line);
-extern bool line_horizontal(LINE *line);
-extern bool line_eq(LINE *l1, LINE *l2);
extern double *line_distance(LINE *l1, LINE *l2);
-extern Point *line_interpt(LINE *l1, LINE *l2);
/* public path routines */
extern PATH *path_in(char *str);
extern PATH *upgradepath(PATH *path);
extern bool isoldpath(PATH *path);
-/* private routines */
-extern double path_ln(PATH *path);
-extern bool plist_same(int npts, Point p1[], Point p2[]);
-
/* public polygon routines */
extern POLYGON *poly_in(char *s);
extern char *poly_out(POLYGON *poly);
extern CIRCLE *circle_sub_pt(CIRCLE *circle, Point *point);
extern CIRCLE *circle_mul_pt(CIRCLE *circle, Point *point);
extern CIRCLE *circle_div_pt(CIRCLE *circle, Point *point);
-extern double *circle_area(CIRCLE *circle);
extern double *circle_diameter(CIRCLE *circle);
extern double *circle_radius(CIRCLE *circle);
extern double *circle_distance(CIRCLE *circle1, CIRCLE *circle2);
extern POLYGON *circle_poly(int npts, CIRCLE *circle);
/* private routines */
-extern double circle_ar(CIRCLE *circle);
+extern double *circle_area(CIRCLE *circle);
extern double circle_dt(CIRCLE *circle1, CIRCLE *circle2);
/* geo_selfuncs.c */
char *value, int32 flag);
extern float64 areajoinsel(Oid opid, Oid relid, AttrNumber attno,
char *value, int32 flag);
-extern float64 leftsel(Oid opid, Oid relid, AttrNumber attno,
- char *value, int32 flag);
-extern float64 leftjoinsel(Oid opid, Oid relid, AttrNumber attno,
- char *value, int32 flag);
-extern float64 contsel(Oid opid, Oid relid, AttrNumber attno,
- char *value, int32 flag);
-extern float64 contjoinsel(Oid opid, Oid relid, AttrNumber attno,
- char *value, int32 flag);
#endif /* GEO_DECLS_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: hsearch.h,v 1.2 1996/10/31 09:51:20 scrappy Exp $
+ * $Id: hsearch.h,v 1.3 1997/08/19 21:40:35 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
extern long string_hash(char *key, int keysize);
extern long tag_hash(int *key, int keysize);
-extern long disk_hash(char *key);
#endif /* HSEARCH_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: inval.h,v 1.3 1996/11/04 11:51:18 scrappy Exp $
+ * $Id: inval.h,v 1.4 1997/08/19 21:40:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define EmptyLocalInvalid NULL
-extern InvalidationEntry InvalidationEntryAllocate(uint16 size);
-
-extern LocalInvalid LocalInvalidRegister(LocalInvalid invalid,
- InvalidationEntry entry);
-
-extern void LocalInvalidInvalidate(LocalInvalid invalid, void (*function)());
-
-extern void getmyrelids(void);
-
#endif /* INVAL_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: lsyscache.h,v 1.2 1996/11/04 11:51:20 scrappy Exp $
+ * $Id: lsyscache.h,v 1.3 1997/08/19 21:40:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Oid get_ruleid(char *rulename);
extern Oid get_eventrelid(Oid ruleid);
extern int16 get_typlen(Oid typid);
-extern char get_typalign(Oid typid);
extern bool get_typbyval(Oid typid);
extern struct varlena *get_typdefault(Oid typid);
-extern char get_typtype(Oid typid);
#endif /* LSYSCACHE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: mcxt.h,v 1.4 1996/11/04 11:51:21 scrappy Exp $
+ * $Id: mcxt.h,v 1.5 1997/08/19 21:40:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Pointer pointer,
Size size);
extern void MemoryContextFree(MemoryContext context, Pointer pointer);
-extern char *MemoryContextGetName(MemoryContext context);
-extern Size PointerGetAllocSize(Pointer pointer);
extern MemoryContext MemoryContextSwitchTo(MemoryContext context);
extern GlobalMemory CreateGlobalMemory(char *name);
extern void GlobalMemoryDestroy(GlobalMemory context);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: memutils.h,v 1.6 1997/03/12 21:13:19 scrappy Exp $
+ * $Id: memutils.h,v 1.7 1997/08/19 21:40:43 momjian Exp $
*
* NOTES
* some of the information in this file will be moved to
extern void OrderedSetInit(OrderedSet set, Offset offset);
extern bool OrderedSetContains(OrderedSet set, OrderedElem elem);
extern Pointer OrderedSetGetHead(OrderedSet set);
-extern Pointer OrderedSetGetTail(OrderedSet set);
extern Pointer OrderedElemGetPredecessor(OrderedElem elem);
extern Pointer OrderedElemGetSuccessor(OrderedElem elem);
extern void OrderedElemPop(OrderedElem elem);
extern AllocPointer AllocSetRealloc(AllocSet set, AllocPointer pointer,
Size size);
-extern int AllocSetIterate(AllocSet set,
- void (*function)(AllocPointer pointer));
-
-extern int AllocSetCount(AllocSet set);
-
-extern void AllocPointerDump(AllocPointer pointer);
extern void AllocSetDump(AllocSet set);
/*****************************************************************************
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nabstime.h,v 1.9 1997/07/29 16:16:14 thomas Exp $
+ * $Id: nabstime.h,v 1.10 1997/08/19 21:40:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern bool AbsoluteTimeIsBefore(AbsoluteTime time1, AbsoluteTime time2);
extern bool AbsoluteTimeIsAfter(AbsoluteTime time1, AbsoluteTime time2);
-extern AbsoluteTime tm2abstime(struct tm *tm, int tz);
extern void abstime2tm(AbsoluteTime time, int *tzp, struct tm *tm, char *tzn);
#endif /* NABSTIME_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: portal.h,v 1.3 1996/11/04 11:51:22 scrappy Exp $
+ * $Id: portal.h,v 1.4 1997/08/19 21:40:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define VACPNAME ""
extern bool PortalNameIsSpecial(char *pname);
-extern void CollectNamedPortals(Portal *portalP, int destroy);
extern void AtEOXact_portals(void);
extern void EnablePortalManager(bool on);
extern Portal GetPortalByName(char *name);
extern EState *PortalGetState(Portal portal);
extern Portal CreatePortal(char *name);
extern void PortalDestroy(Portal *portalP);
-extern void PortalResetHeapMemory(Portal portal);
extern void StartPortalAllocMode(AllocMode mode, Size limit);
extern void EndPortalAllocMode(void);
extern PortalVariableMemory PortalGetVariableMemory(Portal portal);
extern PortalHeapMemory PortalGetHeapMemory(Portal portal);
-extern Portal PortalVariableMemoryGetPortal(PortalVariableMemory context);
-extern Portal PortalHeapMemoryGetPortal(PortalHeapMemory context);
-extern PortalHeapMemory PortalVariableMemoryGetHeapMemory(PortalVariableMemory context);
-extern PortalVariableMemory PortalHeapMemoryGetVariableMemory(PortalHeapMemory context);
/* estimate of the maximum number of open portals a user would have,
* used in initially sizing the PortalHashTable in EnablePortalManager()
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: psort.h,v 1.6 1997/08/06 07:02:49 momjian Exp $
+ * $Id: psort.h,v 1.7 1997/08/19 21:40:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* psort.c */
extern bool psort_begin(Sort *node, int nkeys, ScanKey key);
-extern void inittapes(Sort *node);
-extern void resetpsort(void);
-extern void initialrun(Sort *node, bool *empty);
-extern bool createrun(Sort *node, FILE *file, bool *empty);
-extern HeapTuple tuplecopy(HeapTuple tup);
-extern FILE *mergeruns(Sort *node);
-extern void merge(Sort *node, struct tape *dest);
-
-extern void dumptuples(FILE *file, Sort *node);
extern HeapTuple psort_grabtuple(Sort *node);
extern void psort_markpos(Sort *node);
extern void psort_restorepos(Sort *node);
extern void psort_end(Sort *node);
-extern FILE *gettape(void);
-extern void resettape(FILE *file);
-extern void destroytape(FILE *file);
-
#endif /* PSORT_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: relcache.h,v 1.5 1997/06/04 09:01:49 vadim Exp $
+ * $Id: relcache.h,v 1.6 1997/08/19 21:40:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* relation lookup routines
*/
extern Relation RelationIdCacheGetRelation(Oid relationId);
-extern Relation RelationNameCacheGetRelation(char *relationName);
extern Relation RelationIdGetRelation(Oid relationId);
extern Relation RelationNameGetRelation(char *relationName);
-extern Relation getreldesc(char *relationName);
extern void RelationClose(Relation relation);
-extern void RelationFlushRelation(Relation *relationPtr,
- bool onlyFlushReferenceCountZero);
extern void RelationForgetRelation(Oid rid);
extern void RelationIdInvalidateRelationCacheByRelationId(Oid relationId);
extern void RelationRegisterRelation(Relation relation);
extern void RelationPurgeLocalRelation(bool xactComitted);
extern void RelationInitialize(void);
-extern void init_irels(void);
-extern void write_irels(void);
-
#endif /* RELCACHE_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: tqual.h,v 1.5 1996/11/04 07:18:46 scrappy Exp $
+ * $Id: tqual.h,v 1.6 1997/08/19 21:40:50 momjian Exp $
*
* NOTE
* It may be desirable to allow time qualifications to indicate
extern void setheapoverride(bool on);
extern bool heapisoverride(void);
-extern bool TimeQualIsValid(TimeQual qual);
-extern bool TimeQualIsLegal(TimeQual qual);
-extern bool TimeQualIncludesNow(TimeQual qual);
-extern bool TimeQualIncludesPast(TimeQual qual);
-extern bool TimeQualIsSnapshot(TimeQual qual);
-extern bool TimeQualIsRanged(TimeQual qual);
-extern bool TimeQualIndicatesDisableValidityChecking(TimeQual qual);
-extern AbsoluteTime TimeQualGetSnapshotTime(TimeQual qual);
-extern AbsoluteTime TimeQualGetStartTime(TimeQual qual);
-extern AbsoluteTime TimeQualGetEndTime(TimeQual qual);
extern TimeQual TimeFormSnapshotTimeQual(AbsoluteTime time);
extern TimeQual TimeFormRangedTimeQual(AbsoluteTime startTime,
AbsoluteTime endTime);
/*
- * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.8 1997/08/12 22:55:25 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.9 1997/08/19 21:40:56 momjian Exp $
*/
#include /* faked on sunos */
/*
** Distance from a point to a path
*/
-double *
+ double *
regress_dist_ptpath(pt, path)
Point *pt;
PATH *path;
/* this essentially does a cartesian product of the lsegs in the
two paths, and finds the min distance between any two lsegs */
-double *
+ double *
regress_path_dist(p1, p2)
PATH *p1;
PATH *p2;
return(min);
}
-PATH *
+ PATH *
poly2path(poly)
POLYGON *poly;
{
}
/* return the point where two paths intersect. Assumes that they do. */
-Point *
+ Point *
interpt_pp(p1,p2)
PATH *p1;
PATH *p2;
/* like lseg_construct, but assume space already allocated */
-void
+ void
regress_lseg_construct(lseg, pt1, pt2)
LSEG *lseg;
Point *pt1;
}
-char overpaid(tuple)
+ char overpaid(tuple)
TUPLE tuple;
{
bool isnull;
double radius;
} WIDGET;
-extern WIDGET *widget_in (char *str);
-extern char *widget_out (WIDGET *widget);
-extern int pt_in_widget (Point *point, WIDGET *widget);
+ WIDGET *widget_in (char *str);
+ char *widget_out (WIDGET *widget);
+ int pt_in_widget (Point *point, WIDGET *widget);
#define NARGS 3
-WIDGET *
+ WIDGET *
widget_in(str)
char *str;
{
return(result);
}
-char *
+ char *
widget_out(widget)
WIDGET *widget;
{
return(result);
}
-int
+ int
pt_in_widget(point, widget)
Point *point;
WIDGET *widget;
#define ABS(X) ((X) > 0 ? (X) : -(X))
-int
+ int
boxarea(box)
BOX *box;
return (width * height);
}
-char *
+ char *
reverse_c16(string)
char *string;
{
projects / postgresql.git / commitdiff