#include "utils/elog.h"
static int32
-array_iterator(Oid elemtype, Oid proc, int and, ArrayType * array, Datum value)
+array_iterator(Oid elemtype, Oid proc, int and, ArrayType *array, Datum value)
{
HeapTuple typ_tuple;
TypeTupleForm typ_struct;
*/
int32
-array_texteq(ArrayType * array, char *value)
+array_texteq(ArrayType *array, char *value)
{
return array_iterator((Oid) 25, /* text */
(Oid) 67, /* texteq */
}
int32
-array_all_texteq(ArrayType * array, char *value)
+array_all_texteq(ArrayType *array, char *value)
{
return array_iterator((Oid) 25, /* text */
(Oid) 67, /* texteq */
}
int32
-array_textregexeq(ArrayType * array, char *value)
+array_textregexeq(ArrayType *array, char *value)
{
return array_iterator((Oid) 25, /* text */
(Oid) 81, /* textregexeq */
}
int32
-array_all_textregexeq(ArrayType * array, char *value)
+array_all_textregexeq(ArrayType *array, char *value)
{
return array_iterator((Oid) 25, /* text */
(Oid) 81, /* textregexeq */
*/
int32
-array_char16eq(ArrayType * array, char *value)
+array_char16eq(ArrayType *array, char *value)
{
return array_iterator((Oid) 20, /* char16 */
(Oid) 490, /* char16eq */
}
int32
-array_all_char16eq(ArrayType * array, char *value)
+array_all_char16eq(ArrayType *array, char *value)
{
return array_iterator((Oid) 20, /* char16 */
(Oid) 490, /* char16eq */
}
int32
-array_char16regexeq(ArrayType * array, char *value)
+array_char16regexeq(ArrayType *array, char *value)
{
return array_iterator((Oid) 20, /* char16 */
(Oid) 700, /* char16regexeq */
}
int32
-array_all_char16regexeq(ArrayType * array, char *value)
+array_all_char16regexeq(ArrayType *array, char *value)
{
return array_iterator((Oid) 20, /* char16 */
(Oid) 700, /* char16regexeq */
*/
int32
-array_int4eq(ArrayType * array, int4 value)
+array_int4eq(ArrayType *array, int4 value)
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 65, /* int4eq */
}
int32
-array_all_int4eq(ArrayType * array, int4 value)
+array_all_int4eq(ArrayType *array, int4 value)
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 65, /* int4eq */
}
int32
-array_int4gt(ArrayType * array, int4 value)
+array_int4gt(ArrayType *array, int4 value)
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 147, /* int4gt */
}
int32
-array_all_int4gt(ArrayType * array, int4 value)
+array_all_int4gt(ArrayType *array, int4 value)
{
return array_iterator((Oid) 23, /* int4 */
(Oid) 147, /* int4gt */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.21 1997/09/08 02:19:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.22 1997/09/08 20:53:40 momjian Exp $
*
* NOTES
* some of the executor utility code such as "ExecTypeFromTL" should be
* ----------------------------------------------------------------
*/
TupleDesc
-CreateTupleDesc(int natts, AttributeTupleForm * attrs)
+CreateTupleDesc(int natts, AttributeTupleForm *attrs)
{
TupleDesc desc;
static BlockNumber
gistChooseSubtree(Relation r, IndexTuple itup, int level,
GISTSTATE * giststate,
- GISTSTACK ** retstack, Buffer * leafbuf);
+ GISTSTACK ** retstack, Buffer *leafbuf);
static OffsetNumber
gistchoose(Relation r, Page p, IndexTuple it,
GISTSTATE * giststate);
gistbuild(Relation heap,
Relation index,
int natts,
- AttrNumber * attnum,
+ AttrNumber *attnum,
IndexStrategy istrat,
uint16 pint,
Datum * params,
int level,
GISTSTATE * giststate,
GISTSTACK ** retstack /* out */ ,
- Buffer * leafbuf /* out */ )
+ Buffer *leafbuf /* out */ )
{
Buffer buffer;
BlockNumber blk;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.14 1997/09/08 02:20:10 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.15 1997/09/08 20:53:53 momjian Exp $
*
* NOTES
* This file contains only the public interface routines.
hashbuild(Relation heap,
Relation index,
int natts,
- AttrNumber * attnum,
+ AttrNumber *attnum,
IndexStrategy istrat,
uint16 pcount,
Datum * params,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hashovfl.c,v 1.11 1997/09/08 02:20:17 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hashovfl.c,v 1.12 1997/09/08 20:53:59 momjian Exp $
*
* NOTES
* Overflow pages look like ordinary relation pages.
#include
#endif
-static OverflowPageAddress _hash_getovfladdr(Relation rel, Buffer * metabufp);
+static OverflowPageAddress _hash_getovfladdr(Relation rel, Buffer *metabufp);
static uint32 _hash_firstfreebit(uint32 map);
/*
*
*/
Buffer
-_hash_addovflpage(Relation rel, Buffer * metabufp, Buffer buf)
+_hash_addovflpage(Relation rel, Buffer *metabufp, Buffer buf)
{
OverflowPageAddress oaddr;
*
*/
static OverflowPageAddress
-_hash_getovfladdr(Relation rel, Buffer * metabufp)
+_hash_getovfladdr(Relation rel, Buffer *metabufp)
{
HashMetaPage metap;
Buffer mapbuf = 0;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hashpage.c,v 1.11 1997/09/08 02:20:18 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hashpage.c,v 1.12 1997/09/08 20:54:03 momjian Exp $
*
* NOTES
* Postgres hash pages look like ordinary relation pages. The opaque
Page
_hash_chgbufaccess(Relation rel,
- Buffer * bufp,
+ Buffer *bufp,
int from_access,
int to_access)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/hash/hashsearch.c,v 1.12 1997/09/08 02:20:20 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/hash/hashsearch.c,v 1.13 1997/09/08 20:54:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
_hash_search(Relation rel,
int keysz,
ScanKey scankey,
- Buffer * bufP,
+ Buffer *bufP,
HashMetaPage metap)
{
BlockNumber blkno;
static void
_hash_readnext(Relation rel,
- Buffer * bufp, Page * pagep, HashPageOpaque * opaquep)
+ Buffer *bufp, Page * pagep, HashPageOpaque * opaquep)
{
BlockNumber blkno;
static void
_hash_readprev(Relation rel,
- Buffer * bufp, Page * pagep, HashPageOpaque * opaquep)
+ Buffer *bufp, Page * pagep, HashPageOpaque * opaquep)
{
BlockNumber blkno;
* 'metabuf' is released when this returns.
*/
bool
-_hash_step(IndexScanDesc scan, Buffer * bufP, ScanDirection dir, Buffer metabuf)
+_hash_step(IndexScanDesc scan, Buffer *bufP, ScanDirection dir, Buffer metabuf)
{
Relation rel;
ItemPointer current;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.17 1997/09/08 02:20:28 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.18 1997/09/08 20:54:08 momjian Exp $
*
*
* INTERFACE ROUTINES
heapgettup(Relation relation,
ItemPointer tid,
int dir,
- Buffer * b,
+ Buffer *b,
TimeQual timeQual,
int nkeys,
ScanKey key)
HeapTuple
heap_getnext(HeapScanDesc scandesc,
int backw,
- Buffer * b)
+ Buffer *b)
{
register HeapScanDesc sdesc = scandesc;
Buffer localb;
heap_fetch(Relation relation,
TimeQual timeQual,
ItemPointer tid,
- Buffer * b)
+ Buffer *b)
{
ItemId lp;
Buffer buffer;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.11 1997/09/08 02:20:49 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtpage.c,v 1.12 1997/09/08 20:54:15 momjian Exp $
*
* NOTES
* Postgres btree pages look like ordinary relation pages. The opaque
#ifdef BTREE_VERSION_1
int32 btm_level;
#endif
-} BTMetaPageData;
+} BTMetaPageData;
#define BTPageGetMeta(p) \
((BTMetaPageData *) &((PageHeader) p)->pd_linp[0])
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.21 1997/09/08 02:20:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.22 1997/09/08 20:54:21 momjian Exp $
*
* NOTES
* This file contains only the public interface routines.
btbuild(Relation heap,
Relation index,
int natts,
- AttrNumber * attnum,
+ AttrNumber *attnum,
IndexStrategy istrat,
uint16 pcount,
Datum * params,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtscan.c,v 1.9 1997/09/08 02:20:52 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/Attic/nbtscan.c,v 1.10 1997/09/08 20:54:24 momjian Exp $
*
*
* NOTES
{
IndexScanDesc btsl_scan;
struct BTScanListData *btsl_next;
-} BTScanListData;
+} BTScanListData;
typedef BTScanListData *BTScanList;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.25 1997/09/08 02:20:57 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.26 1997/09/08 20:54:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static BTStack
_bt_searchr(Relation rel, int keysz, ScanKey scankey,
- Buffer * bufP, BTStack stack_in);
+ Buffer *bufP, BTStack stack_in);
static OffsetNumber
_bt_firsteq(Relation rel, TupleDesc itupdesc, Page page,
Size keysz, ScanKey scankey, OffsetNumber offnum);
_bt_compare(Relation rel, TupleDesc itupdesc, Page page,
int keysz, ScanKey scankey, OffsetNumber offnum);
static bool
- _bt_twostep(IndexScanDesc scan, Buffer * bufP, ScanDirection dir);
+ _bt_twostep(IndexScanDesc scan, Buffer *bufP, ScanDirection dir);
static RetrieveIndexResult
_bt_endpoint(IndexScanDesc scan, ScanDirection dir);
* calls a recursive-descent search routine on the tree.
*/
BTStack
-_bt_search(Relation rel, int keysz, ScanKey scankey, Buffer * bufP)
+_bt_search(Relation rel, int keysz, ScanKey scankey, Buffer *bufP)
{
*bufP = _bt_getroot(rel, BT_READ);
return (_bt_searchr(rel, keysz, scankey, bufP, (BTStack) NULL));
_bt_searchr(Relation rel,
int keysz,
ScanKey scankey,
- Buffer * bufP,
+ Buffer *bufP,
BTStack stack_in)
{
BTStack stack;
* scan to the right thing.
*/
bool
-_bt_step(IndexScanDesc scan, Buffer * bufP, ScanDirection dir)
+_bt_step(IndexScanDesc scan, Buffer *bufP, ScanDirection dir)
{
Page page;
BTPageOpaque opaque;
* succeeded, we return true; otherwise, we return false.
*/
static bool
-_bt_twostep(IndexScanDesc scan, Buffer * bufP, ScanDirection dir)
+_bt_twostep(IndexScanDesc scan, Buffer *bufP, ScanDirection dir)
{
Page page;
BTPageOpaque opaque;
*
*
* IDENTIFICATION
- * $Id: nbtsort.c,v 1.21 1997/09/08 02:20:58 momjian Exp $
+ * $Id: nbtsort.c,v 1.22 1997/09/08 20:54:28 momjian Exp $
*
* NOTES
*
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);
+static void _bt_uppershutdown(Relation index, BTPageState *state);
/*
* turn on debugging output.
short bttb_ntup; /* number of tuples in this block */
short bttb_eor; /* End-Of-Run marker */
char bttb_data[TAPEBLCKSZ - 2 * sizeof(double)];
-} BTTapeBlock;
+} BTTapeBlock;
/*
* this structure holds the bookkeeping for a simple balanced multiway
BTTapeBlock **bts_itape; /* input tape blocks */
BTTapeBlock **bts_otape; /* output tape blocks */
bool isunique;
-} BTSpool;
+} BTSpool;
/*-------------------------------------------------------------------------
* sorting comparison routine - returns {-1,0,1} depending on whether
Datum *btsk_datum;
char *btsk_nulls;
BTItem btsk_item;
-} BTSortKey;
+} BTSortKey;
static Relation _bt_sortrel;
static int _bt_nattr;
static BTSpool *_bt_inspool;
static void
-_bt_isortcmpinit(Relation index, BTSpool * spool)
+_bt_isortcmpinit(Relation index, BTSpool *spool)
{
_bt_sortrel = index;
_bt_inspool = spool;
}
static int
-_bt_isortcmp(BTSortKey * k1, BTSortKey * k2)
+_bt_isortcmp(BTSortKey *k1, BTSortKey *k2)
{
Datum *k1_datum = k1->btsk_datum;
Datum *k2_datum = k2->btsk_datum;
}
static void
-_bt_setsortkey(Relation index, BTItem bti, BTSortKey * sk)
+_bt_setsortkey(Relation index, BTItem bti, BTSortKey *sk)
{
sk->btsk_item = (BTItem) NULL;
sk->btsk_datum = (Datum *) NULL;
{
int btpqe_tape; /* tape identifier */
BTSortKey btpqe_item; /* pointer to BTItem in tape buffer */
-} BTPriQueueElem;
+} BTPriQueueElem;
#define MAXELEM MAXTAPES
typedef struct
int btpq_nelem;
BTPriQueueElem btpq_queue[MAXELEM];
Relation btpq_rel;
-} BTPriQueue;
+} BTPriQueue;
/* be sure to call _bt_isortcmpinit first */
#define GREATER(a, b) \
(_bt_isortcmp(&((a)->btpqe_item), &((b)->btpqe_item)) > 0)
static void
-_bt_pqsift(BTPriQueue * q, int parent)
+_bt_pqsift(BTPriQueue *q, int parent)
{
int child;
BTPriQueueElem e;
}
static int
-_bt_pqnext(BTPriQueue * q, BTPriQueueElem * e)
+_bt_pqnext(BTPriQueue *q, BTPriQueueElem *e)
{
if (q->btpq_nelem < 1)
{ /* already empty */
}
static void
-_bt_pqadd(BTPriQueue * q, BTPriQueueElem * e)
+_bt_pqadd(BTPriQueue *q, BTPriQueueElem *e)
{
int child,
parent;
* empty.)
*/
static void
-_bt_tapereset(BTTapeBlock * tape)
+_bt_tapereset(BTTapeBlock *tape)
{
tape->bttb_eor = 0;
tape->bttb_top = 0;
* rewind the physical tape file.
*/
static void
-_bt_taperewind(BTTapeBlock * tape)
+_bt_taperewind(BTTapeBlock *tape)
{
FileSeek(tape->bttb_fd, 0, SEEK_SET);
}
* least you don't have to delete and reinsert the directory entries.
*/
static void
-_bt_tapeclear(BTTapeBlock * tape)
+_bt_tapeclear(BTTapeBlock *tape)
{
/* blow away the contents of the old file */
_bt_taperewind(tape);
* destroy the BTTapeBlock structure and its physical tape file.
*/
static void
-_bt_tapedestroy(BTTapeBlock * tape)
+_bt_tapedestroy(BTTapeBlock *tape)
{
FileUnlink(tape->bttb_fd);
pfree((void *) tape);
* flush the tape block to the file, marking End-Of-Run if requested.
*/
static void
-_bt_tapewrite(BTTapeBlock * tape, int eor)
+_bt_tapewrite(BTTapeBlock *tape, int eor)
{
tape->bttb_eor = eor;
FileWrite(tape->bttb_fd, (char *) tape, TAPEBLCKSZ);
* - 1 if a valid block was read
*/
static int
-_bt_taperead(BTTapeBlock * tape)
+_bt_taperead(BTTapeBlock *tape)
{
int fd;
int nread;
* - sets 'pos' to the current position within the block.
*/
static BTItem
-_bt_tapenext(BTTapeBlock * tape, char **pos)
+_bt_tapenext(BTTapeBlock *tape, char **pos)
{
Size itemsz;
BTItem bti;
{
return ((BTItem) NULL);
}
- bti = (BTItem) * pos;
+ bti = (BTItem) *pos;
itemsz = BTITEMSZ(bti);
*pos += DOUBLEALIGN(itemsz);
return (bti);
* the beginning of free space.
*/
static void
-_bt_tapeadd(BTTapeBlock * tape, BTItem item, int itemsz)
+_bt_tapeadd(BTTapeBlock *tape, BTItem item, int itemsz)
{
memcpy(tape->bttb_data + tape->bttb_top, item, itemsz);
++tape->bttb_ntup;
* flush out any dirty output tape blocks
*/
static void
-_bt_spoolflush(BTSpool * btspool)
+_bt_spoolflush(BTSpool *btspool)
{
int i;
* output tapes.
*/
static void
-_bt_spoolswap(BTSpool * btspool)
+_bt_spoolswap(BTSpool *btspool)
{
File tmpfd;
BTTapeBlock *itape;
* allocate a new, clean btree page, not linked to any siblings.
*/
static void
-_bt_blnewpage(Relation index, Buffer * buf, Page * page, int flags)
+_bt_blnewpage(Relation index, Buffer *buf, Page * page, int flags)
{
BTPageOpaque opaque;
}
static void
-_bt_uppershutdown(Relation index, BTPageState * state)
+_bt_uppershutdown(Relation index, BTPageState *state)
{
BTPageState *s;
BlockNumber blkno;
* XXX three nested loops? gross. cut me up into smaller routines.
*/
static void
-_bt_merge(Relation index, BTSpool * btspool)
+_bt_merge(Relation index, BTSpool *btspool)
{
BTPageState *state;
BTPriQueue q;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtproc.c,v 1.9 1997/09/08 02:21:05 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtproc.c,v 1.10 1997/09/08 20:54:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#endif
BOX
-* rt_box_union(BOX * a, BOX * b)
+ *
+rt_box_union(BOX *a, BOX *b)
{
BOX *n;
}
BOX *
-rt_box_inter(BOX * a, BOX * b)
+rt_box_inter(BOX *a, BOX *b)
{
BOX *n;
}
void
-rt_box_size(BOX * a, float *size)
+rt_box_size(BOX *a, float *size)
{
if (a == (BOX *) NULL || a->high.x <= a->low.x || a->high.y <= a->low.y)
*size = 0.0;
* have a special return type for big boxes.
*/
void
-rt_bigbox_size(BOX * a, float *size)
+rt_bigbox_size(BOX *a, float *size)
{
rt_box_size(a, size);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.15 1997/09/08 02:21:06 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.16 1997/09/08 20:54:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
rtbuild(Relation heap,
Relation index,
int natts,
- AttrNumber * attnum,
+ AttrNumber *attnum,
IndexStrategy istrat,
uint16 pcount,
Datum * params,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.11 1997/09/08 02:21:14 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/transam.c,v 1.12 1997/09/08 20:54:36 momjian Exp $
*
* NOTES
* This file contains the high level access-method interface to the
*/
AbsoluteTime /* commit time of transaction id */
-TransactionIdGetCommitTime(TransactionId transactionId) /* transaction id to
- * test */
+TransactionIdGetCommitTime(TransactionId transactionId) /* transaction id to
+ * test */
{
BlockNumber blockNumber;
AbsoluteTime commitTime; /* commit time */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/transsup.c,v 1.11 1997/09/08 02:21:18 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/transam/Attic/transsup.c,v 1.12 1997/09/08 20:54:37 momjian Exp $
*
* NOTES
* This file contains support functions for the high
TransComputeBlockNumber(Relation relation, /* relation to test */
TransactionId transactionId, /* transaction id to
* test */
- BlockNumber * blockNumberOutP)
+ BlockNumber *blockNumberOutP)
{
long itemsPerBlock = 0;
* Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.23 1997/09/08 02:21:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.24 1997/09/08 20:54:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
index_register(char *heap,
char *ind,
int natts,
- AttrNumber * attnos,
+ AttrNumber *attnos,
uint16 nparams,
Datum * params,
FuncIndexInfo * finfo,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.26 1997/09/08 02:21:37 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.27 1997/09/08 20:54:54 momjian Exp $
*
* INTERFACE ROUTINES
* heap_creatr() - Create an uncataloged heap relation
QueryTreeList ** queryListP, CommandDest dest);
static void
-StoreAttrDefault(Relation rel, AttrDefault * attrdef)
+StoreAttrDefault(Relation rel, AttrDefault *attrdef)
{
char str[MAX_PARSE_BUFFER];
char cast[2 * NAMEDATALEN] = {0};
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.13 1997/09/08 02:21:44 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.14 1997/09/08 20:55:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
finfoP = (FuncIndexInfo *) NULL;
FormIndexDatum(natts,
- (AttrNumber *) & pgIndexP->indkey[0],
+ (AttrNumber *) &pgIndexP->indkey[0],
heapTuple,
heapDescriptor,
InvalidBuffer,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.31 1997/09/08 02:22:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.32 1997/09/08 20:55:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#endif /* OMIT_PARTIAL_INDEX */
}
FormIndexDatum(indexNatts[i],
- (AttrNumber *) & (pgIndexP[i]->indkey[0]),
+ (AttrNumber *) &(pgIndexP[i]->indkey[0]),
tuple,
tupDesc,
InvalidBuffer,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/defind.c,v 1.14 1997/09/08 02:22:08 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/defind.c,v 1.15 1997/09/08 20:55:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static void
CheckPredClause(Expr * predicate, List * rangeTable, Oid baseRelOid);
static void
-FuncIndexArgs(IndexElem * funcIndex, AttrNumber * attNumP,
+FuncIndexArgs(IndexElem * funcIndex, AttrNumber *attNumP,
Oid * argTypes, Oid * opOidP, Oid relId);
static void
-NormIndexAttrs(List * attList, AttrNumber * attNumP,
+NormIndexAttrs(List * attList, AttrNumber *attNumP,
Oid * opOidP, Oid relId);
static char *GetDefaultOpClass(Oid atttypid);
static void
FuncIndexArgs(IndexElem * funcIndex,
- AttrNumber * attNumP,
+ AttrNumber *attNumP,
Oid * argTypes,
Oid * opOidP,
Oid relId)
static void
NormIndexAttrs(List * attList, /* list of IndexElem's */
- AttrNumber * attNumP,
+ AttrNumber *attNumP,
Oid * opOidP,
Oid relId)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.12 1997/09/08 02:22:13 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.13 1997/09/08 20:55:27 momjian Exp $
*
*-------------------------------------------------------------------------
*/
ReleaseBuffer(buffer);
bufferUsed = FALSE;
}
- tup = heap_getnext(scan, 0, (Buffer *) & buffer);
+ tup = heap_getnext(scan, 0, (Buffer *) &buffer);
if (!HeapTupleIsValid(tup))
break;
bufferUsed = TRUE;
static SeqTable seqtab = NULL;
static SeqTable init_sequence(char *caller, char *name);
-static SequenceTupleForm read_info(char *caller, SeqTable elm, Buffer * buf);
+static SequenceTupleForm read_info(char *caller, SeqTable elm, Buffer *buf);
static void init_params(CreateSeqStmt * seq, SequenceTupleForm new);
static int get_param(DefElem * def);
}
static SequenceTupleForm
-read_info(char *caller, SeqTable elm, Buffer * buf)
+read_info(char *caller, SeqTable elm, Buffer *buf)
{
ItemPointerData iptr;
PageHeader page;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.44 1997/09/08 02:22:17 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.45 1997/09/08 20:55:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
FormIndexDatum(
idcur->natts,
- (AttrNumber *) & (idcur->tform->indkey[0]),
+ (AttrNumber *) &(idcur->tform->indkey[0]),
newtup,
tupdesc,
InvalidBuffer,
if (VacAttrStatsLtGtValid(stats) && stats->initialized /* &&
* !IsSystemRelationName(
*
- pgcform->relname.data) */ )
+ pgcform->relname.data) */ )
{
func_ptr out_function;
char *out_string;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.14 1997/09/08 02:22:33 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.15 1997/09/08 20:55:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int execConstLen;
/* static functions decls */
-static Datum ExecEvalAggreg(Aggreg * agg, ExprContext * econtext, bool * isNull);
+static Datum ExecEvalAggreg(Aggreg *agg, ExprContext * econtext, bool * isNull);
static Datum
-ExecEvalArrayRef(ArrayRef * arrayRef, ExprContext * econtext,
+ExecEvalArrayRef(ArrayRef *arrayRef, ExprContext * econtext,
bool * isNull, bool * isDone);
static Datum ExecEvalAnd(Expr * andExpr, ExprContext * econtext, bool * isNull);
static Datum
* --------------------------------
*/
static Datum
-ExecEvalArrayRef(ArrayRef * arrayRef,
+ExecEvalArrayRef(ArrayRef *arrayRef,
ExprContext * econtext,
bool * isNull,
bool * isDone)
* ----------------------------------------------------------------
*/
static Datum
-ExecEvalAggreg(Aggreg * agg, ExprContext * econtext, bool * isNull)
+ExecEvalAggreg(Aggreg *agg, ExprContext * econtext, bool * isNull)
{
*isNull = econtext->ecxt_nulls[agg->aggno];
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.16 1997/09/08 02:22:36 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.17 1997/09/08 20:55:39 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static void
ExecGetIndexKeyInfo(IndexTupleForm indexTuple, int *numAttsOutP,
- AttrNumber ** attsOutP, FuncIndexInfoPtr fInfoP);
+ AttrNumber **attsOutP, FuncIndexInfoPtr fInfoP);
/* ----------------------------------------------------------------
* global counters for number of tuples processed, retrieved,
static void
ExecGetIndexKeyInfo(IndexTupleForm indexTuple,
int *numAttsOutP,
- AttrNumber ** attsOutP,
+ AttrNumber **attsOutP,
FuncIndexInfoPtr fInfoP)
{
int i;
int xfn1_nargs;
int xfn2_nargs;
int finalfn_nargs;
-} AggFuncInfo;
+} AggFuncInfo;
-static Datum aggGetAttr(TupleTableSlot * tuple, Aggreg * agg, bool * isNull);
+static Datum aggGetAttr(TupleTableSlot * tuple, Aggreg *agg, bool * isNull);
/* ---------------------------------------
* ------------------------------------------
*/
TupleTableSlot *
-ExecAgg(Agg * node)
+ExecAgg(Agg *node)
{
AggState *aggstate;
EState *estate;
* -----------------
*/
bool
-ExecInitAgg(Agg * node, EState * estate, Plan * parent)
+ExecInitAgg(Agg *node, EState * estate, Plan * parent)
{
AggState *aggstate;
Plan *outerPlan;
}
int
-ExecCountSlotsAgg(Agg * node)
+ExecCountSlotsAgg(Agg *node)
{
return ExecCountSlotsNode(outerPlan(node)) +
ExecCountSlotsNode(innerPlan(node)) +
* -----------------------
*/
void
-ExecEndAgg(Agg * node)
+ExecEndAgg(Agg *node)
{
AggState *aggstate;
Plan *outerPlan;
*/
static Datum
aggGetAttr(TupleTableSlot * slot,
- Aggreg * agg,
+ Aggreg *agg,
bool * isNull)
{
Datum result;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeAppend.c,v 1.7 1997/09/08 02:22:40 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeAppend.c,v 1.8 1997/09/08 20:55:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/mcxt.h"
#include "parser/parsetree.h" /* for rt_store() macro */
-static bool exec_append_initialize_next(Append * node);
+static bool exec_append_initialize_next(Append *node);
/* ----------------------------------------------------------------
* exec-append-initialize-next
* ----------------------------------------------------------------
*/
static bool
-exec_append_initialize_next(Append * node)
+exec_append_initialize_next(Append *node)
{
EState *estate;
AppendState *unionstate;
* ----------------------------------------------------------------
*/
bool
-ExecInitAppend(Append * node, EState * estate, Plan * parent)
+ExecInitAppend(Append *node, EState * estate, Plan * parent)
{
AppendState *unionstate;
int nplans;
}
int
-ExecCountSlotsAppend(Append * node)
+ExecCountSlotsAppend(Append *node)
{
List *plan;
List *unionplans = node->unionplans;
* ----------------------------------------------------------------
*/
TupleTableSlot *
-ExecProcAppend(Append * node)
+ExecProcAppend(Append *node)
{
EState *estate;
AppendState *unionstate;
* ----------------------------------------------------------------
*/
void
-ExecEndAppend(Append * node)
+ExecEndAppend(Append *node)
{
AppendState *unionstate;
int nplans;
* columns. (ie. tuples from the same group are consecutive)
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeGroup.c,v 1.7 1997/09/08 02:22:41 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeGroup.c,v 1.8 1997/09/08 20:55:43 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static TupleTableSlot *ExecGroupOneTuple(Group * node);
static bool
sameGroup(TupleTableSlot * oldslot, TupleTableSlot * newslot,
- int numCols, AttrNumber * grpColIdx, TupleDesc tupdesc);
+ int numCols, AttrNumber *grpColIdx, TupleDesc tupdesc);
/* ---------------------------------------
* ExecGroup -
sameGroup(TupleTableSlot * oldslot,
TupleTableSlot * newslot,
int numCols,
- AttrNumber * grpColIdx,
+ AttrNumber *grpColIdx,
TupleDesc tupdesc)
{
bool isNull1,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.10 1997/09/08 02:22:46 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.11 1997/09/08 20:55:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* This is the case when
*
* outer inner 4 5 - marked tuple outer tuple - 5 5
- * new outer tuple - 5 5 6 8 - inner tuple 7
- * 12
+ * new outer tuple - 5 5 6 8 - inner tuple 7 12
*
* new outer tuple = marked tuple
*
*
* new outer tuple > marked tuple
*
- *******************************
+ ******************************
+ *
*
*
*/
* we have to advance the outer scan until we find the outer
* 8.
*
- *******************************
+ ******************************
+ *
*
*
*/
* we have to advance the inner scan until we find the inner
* 12.
*
- *******************************
+ ******************************
+ *
*
*
*/
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeNestloop.c,v 1.5 1997/09/08 02:22:48 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeNestloop.c,v 1.6 1997/09/08 20:55:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
econtext = nlstate->jstate.cs_ExprContext;
- /* ---------------- * get the current outer tuple
+ /* ---------------- * get the current outer tuple
* ----------------
*/
outerTupleSlot = nlstate->jstate.cs_OuterTupleSlot;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.8 1997/09/08 02:23:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.9 1997/09/08 20:55:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* ----------------
*/
static Append *
-_copyAppend(Append * from)
+_copyAppend(Append *from)
{
Append *newnode = makeNode(Append);
* --------------
*/
static Agg *
-_copyAgg(Agg * from)
+_copyAgg(Agg *from)
{
Agg *newnode = makeNode(Agg);
int i;
* ----------------
*/
static Aggreg *
-_copyAggreg(Aggreg * from)
+_copyAggreg(Aggreg *from)
{
Aggreg *newnode = makeNode(Aggreg);
}
static Array *
-_copyArray(Array * from)
+_copyArray(Array *from)
{
Array *newnode = makeNode(Array);
}
static ArrayRef *
-_copyArrayRef(ArrayRef * from)
+_copyArrayRef(ArrayRef *from)
{
ArrayRef *newnode = makeNode(ArrayRef);
}
static A_Const *
-_copyAConst(A_Const * from)
+_copyAConst(A_Const *from)
{
A_Const *newnode = makeNode(A_Const);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.8 1997/09/08 02:23:36 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/equalfuncs.c,v 1.9 1997/09/08 20:55:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
static bool
-_equalArray(Array * a, Array * b)
+_equalArray(Array *a, Array *b)
{
if (a->arrayelemtype != b->arrayelemtype)
return (false);
}
static bool
-_equalArrayRef(ArrayRef * a, ArrayRef * b)
+_equalArrayRef(ArrayRef *a, ArrayRef *b)
{
if (a->refelemtype != b->refelemtype)
return (false);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.8 1997/09/08 02:23:41 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.9 1997/09/08 20:55:56 momjian Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
* Append is a subclass of Plan.
*/
static void
-_outAppend(StringInfo str, Append * node)
+_outAppend(StringInfo str, Append *node)
{
char buf[500];
}
static void
-_outAgg(StringInfo str, Agg * node)
+_outAgg(StringInfo str, Agg *node)
{
char buf[500];
* Aggreg
*/
static void
-_outAggreg(StringInfo str, Aggreg * node)
+_outAggreg(StringInfo str, Aggreg *node)
{
char buf[500];
* Array is a subclass of Expr
*/
static void
-_outArray(StringInfo str, Array * node)
+_outArray(StringInfo str, Array *node)
{
char buf[500];
int i;
* ArrayRef is a subclass of Expr
*/
static void
-_outArrayRef(StringInfo str, ArrayRef * node)
+_outArrayRef(StringInfo str, ArrayRef *node)
{
char buf[500];
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/predmig.c,v 1.4 1997/09/08 02:24:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/predmig.c,v 1.5 1997/09/08 20:56:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static bool xfunc_check_stream(Stream node);
static bool xfunc_in_stream(Stream node, Stream stream);
-/* ----------------- MAIN FUNCTIONS ------------------------ */
+/* ----------------- MAIN FUNCTIONS ------------------------ */
/*
** xfunc_do_predmig
** wrapper for Predicate Migration. It calls xfunc_predmig until no
}
-/* ------------------- UTILITY FUNCTIONS ------------------------- */
+/* ------------------- UTILITY FUNCTIONS ------------------------- */
/*
** xfunc_free_stream --
}
}
-/* ------------------ DEBUGGING ROUTINES ---------------------------- */
+/* ------------------ DEBUGGING ROUTINES ---------------------------- */
/*
** Make sure all pointers in stream make sense. Make sure no joins are
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.13 1997/09/08 02:24:31 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.14 1997/09/08 20:56:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
Agg *
-make_agg(List * tlist, int nagg, Aggreg ** aggs)
+make_agg(List * tlist, int nagg, Aggreg **aggs)
{
Agg *node = makeNode(Agg);
make_group(List * tlist,
bool tuplePerGroup,
int ngrp,
- AttrNumber * grpColIdx,
+ AttrNumber *grpColIdx,
Sort * lefttree)
{
Group *node = makeNode(Group);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.6 1997/09/08 02:24:39 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.7 1997/09/08 20:56:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*
*/
void
-set_agg_tlist_references(Agg * aggNode)
+set_agg_tlist_references(Agg *aggNode)
{
List *aggTargetList;
List *subplanTargetList;
}
void
-set_agg_agglist_references(Agg * aggNode)
+set_agg_agglist_references(Agg *aggNode)
{
List *subplanTargetList;
Aggreg **aggs;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.9 1997/09/08 02:24:52 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.10 1997/09/08 20:56:19 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
void
get_relattval(Node * clause,
int *relid,
- AttrNumber * attno,
+ AttrNumber *attno,
Datum * constval,
int *flag)
{
void
get_rels_atts(Node * clause,
int *relid1,
- AttrNumber * attno1,
+ AttrNumber *attno1,
int *relid2,
- AttrNumber * attno2)
+ AttrNumber *attno2)
{
Var *left = get_leftop((Expr *) clause);
Var *right = get_rightop((Expr *) clause);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.40 1997/09/08 02:25:11 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.41 1997/09/08 20:56:25 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static Query *transformStmt(ParseState * pstate, Node * stmt);
static Query *transformDeleteStmt(ParseState * pstate, DeleteStmt * stmt);
-static Query *transformInsertStmt(ParseState * pstate, AppendStmt * stmt);
+static Query *transformInsertStmt(ParseState * pstate, AppendStmt *stmt);
static Query *transformIndexStmt(ParseState * pstate, IndexStmt * stmt);
static Query *transformExtendStmt(ParseState * pstate, ExtendStmt * stmt);
static Query *transformRuleStmt(ParseState * query, RuleStmt * stmt);
static Query *transformSelectStmt(ParseState * pstate, RetrieveStmt * stmt);
static Query *transformUpdateStmt(ParseState * pstate, ReplaceStmt * stmt);
static Query *transformCursorStmt(ParseState * pstate, CursorStmt * stmt);
-static Node *handleNestedDots(ParseState * pstate, Attr * attr, int *curr_resno);
+static Node *handleNestedDots(ParseState * pstate, Attr *attr, int *curr_resno);
#define EXPR_COLUMN_FIRST 1
#define EXPR_RELATION_FIRST 2
static void
make_arguments(int nargs, List * fargs, Oid * input_typeids,
Oid * function_typeids);
-static void AddAggToParseState(ParseState * pstate, Aggreg * aggreg);
+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);
* transform an Insert Statement
*/
static Query *
-transformInsertStmt(ParseState * pstate, AppendStmt * stmt)
+transformInsertStmt(ParseState * pstate, AppendStmt *stmt)
{
Query *qry = makeNode(Query); /* make a new query tree */
** a tree with of Iter and Func nodes.
*/
static Node *
-handleNestedDots(ParseState * pstate, Attr * attr, int *curr_resno)
+handleNestedDots(ParseState * pstate, Attr *attr, int *curr_resno)
{
List *mutator_iter;
Node *retval = NULL;
* SIDE EFFECT: aggno in target list entry will be modified
*/
static void
-AddAggToParseState(ParseState * pstate, Aggreg * aggreg)
+AddAggToParseState(ParseState * pstate, Aggreg *aggreg)
{
List *ag;
int i;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.55 1997/09/08 02:27:53 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.56 1997/09/08 20:56:38 momjian Exp $
*
* NOTES
*
typedef struct bkend
{
int pid; /* process id of backend */
-} Backend;
+} Backend;
/* list of active backends. For garbage collection only now. */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_table.c,v 1.6 1997/09/08 02:28:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/buf_table.c,v 1.7 1997/09/08 20:56:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* BufTableDelete
*/
bool
-BufTableDelete(BufferDesc * buf)
+BufTableDelete(BufferDesc *buf)
{
LookupEnt *result;
bool found;
}
bool
-BufTableInsert(BufferDesc * buf)
+BufTableInsert(BufferDesc *buf)
{
LookupEnt *result;
bool found;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.21 1997/09/08 02:28:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/bufmgr.c,v 1.22 1997/09/08 20:56:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static int WriteMode = BUFFER_LATE_WRITE; /* Delayed write is
* default */
-static void WaitIO(BufferDesc * buf, SPINLOCK spinlock);
+static void WaitIO(BufferDesc *buf, SPINLOCK spinlock);
#ifndef HAS_TEST_AND_SET
-static void SignalIO(BufferDesc * buf);
+static void SignalIO(BufferDesc *buf);
extern long *NWaitIOBackendP; /* defined in buf_init.c */
#endif /* HAS_TEST_AND_SET */
bool * foundPtr, bool bufferLockHeld);
static int FlushBuffer(Buffer buffer, bool release);
static void BufferSync(void);
-static int BufferReplace(BufferDesc * bufHdr, bool bufferLockHeld);
+static int BufferReplace(BufferDesc *bufHdr, bool bufferLockHeld);
/* ---------------------------------------------------
* RelationGetBufferWithBuffer
*/
#ifdef HAS_TEST_AND_SET
static void
-WaitIO(BufferDesc * buf, SPINLOCK spinlock)
+WaitIO(BufferDesc *buf, SPINLOCK spinlock)
{
SpinRelease(spinlock);
S_LOCK(&(buf->io_in_progress_lock));
IpcSemaphoreId WaitIOSemId;
static void
-WaitIO(BufferDesc * buf, SPINLOCK spinlock)
+WaitIO(BufferDesc *buf, SPINLOCK spinlock)
{
bool inProgress;
* SignalIO --
*/
static void
-SignalIO(BufferDesc * buf)
+SignalIO(BufferDesc *buf)
{
/* somebody better be waiting. */
Assert(buf->refcount > 1);
*
*/
static int
-BufferReplace(BufferDesc * bufHdr, bool bufferLockHeld)
+BufferReplace(BufferDesc *bufHdr, bool bufferLockHeld)
{
Relation reln;
Oid bufdb,
RelationGetNumberOfBlocks(Relation relation)
{
return
- ((relation->rd_islocal) ? relation->rd_nblocks :
- smgrnblocks(relation->rd_rel->relsmgr, relation));
+ ((relation->rd_islocal) ? relation->rd_nblocks :
+ smgrnblocks(relation->rd_rel->relsmgr, relation));
}
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/buffer/freelist.c,v 1.6 1997/09/08 02:28:33 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/buffer/freelist.c,v 1.7 1997/09/08 20:56:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* Currently, they are added on an LRU basis.
*/
void
-AddBufferToFreelist(BufferDesc * bf)
+AddBufferToFreelist(BufferDesc *bf)
{
#ifdef BMTRACE
_bm_trace(bf->tag.relId.dbId, bf->tag.relId.relId, bf->tag.blockNum,
* PinBuffer -- make buffer unavailable for replacement.
*/
void
-PinBuffer(BufferDesc * buf)
+PinBuffer(BufferDesc *buf)
{
long b;
#ifdef NOT_USED
void
-PinBuffer_Debug(char *file, int line, BufferDesc * buf)
+PinBuffer_Debug(char *file, int line, BufferDesc *buf)
{
PinBuffer(buf);
if (ShowPinTrace)
* UnpinBuffer -- make buffer available for replacement.
*/
void
-UnpinBuffer(BufferDesc * buf)
+UnpinBuffer(BufferDesc *buf)
{
long b = BufferDescriptorGetBuffer(buf) - 1;
#ifdef NOT_USED
void
-UnpinBuffer_Debug(char *file, int line, BufferDesc * buf)
+UnpinBuffer_Debug(char *file, int line, BufferDesc *buf)
{
UnpinBuffer(buf);
if (ShowPinTrace)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.15 1997/09/08 02:29:06 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.16 1997/09/08 20:56:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static HeapTuple
inv_newtuple(LargeObjectDesc * obj_desc, Buffer buffer,
Page page, char *dbuf, int nwrite);
-static HeapTuple inv_fetchtup(LargeObjectDesc * obj_desc, Buffer * bufP);
+static HeapTuple inv_fetchtup(LargeObjectDesc * obj_desc, Buffer *bufP);
static int inv_wrnew(LargeObjectDesc * obj_desc, char *buf, int nbytes);
static int
inv_wrold(LargeObjectDesc * obj_desc, char *dbuf, int nbytes,
* such tuple exists.
*/
static HeapTuple
-inv_fetchtup(LargeObjectDesc * obj_desc, Buffer * bufP)
+inv_fetchtup(LargeObjectDesc * obj_desc, Buffer *bufP)
{
HeapTuple htup;
RetrieveIndexResult res;
* * mer fixed disk layout of varlenas to get rid of the need for
* this. *
*
- *((int32 *) attptr) = nwrite + sizeof(int32); * attptr +=
+ * ((int32 *) attptr) = nwrite + sizeof(int32); * attptr +=
* sizeof(int32);
*/
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/Attic/aclchk.c,v 1.15 1997/09/08 02:29:40 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/Attic/aclchk.c,v 1.16 1997/09/08 20:56:53 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);
+static int32 aclcheck(Acl *acl, AclId id, AclIdType idtype, AclMode mode);
/*
* Enable use of user relations in place of real system catalogs.
#ifdef ACLDEBUG_TRACE
static
-dumpacl(Acl * acl)
+dumpacl(Acl *acl)
{
register unsigned i;
AclItem *aip;
*/
void
ChangeAcl(char *relname,
- AclItem * mod_aip,
+ AclItem *mod_aip,
unsigned modechg)
{
register unsigned i;
* any one of the requirements of 'mode'. Returns 0 otherwise.
*/
static int32
-aclcheck(Acl * acl, AclId id, AclIdType idtype, AclMode mode)
+aclcheck(Acl *acl, AclId id, AclIdType idtype, AclMode mode)
{
register unsigned i;
register AclItem *aip,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: tgRecipe.h,v 1.3 1997/09/08 02:30:12 momjian Exp $
+ * $Id: tgRecipe.h,v 1.4 1997/09/08 20:57:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
y;
} Point; /* this should match whatever is in
+ *
*
* geo-decls.h */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.15 1997/09/08 02:30:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.16 1997/09/08 20:57:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "miscadmin.h"
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);
+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"
* - loads 'modechg' with the mode change flag.
*/
static char *
-aclparse(char *s, AclItem * aip, unsigned *modechg)
+aclparse(char *s, AclItem *aip, unsigned *modechg)
{
HeapTuple htp;
char name[NAMEDATALEN];
* the new string
*/
char *
-aclitemout(AclItem * aip)
+aclitemout(AclItem *aip)
{
register char *p;
char *out;
* a boolean value indicating = or >
*/
static int32
-aclitemeq(AclItem * a1, AclItem * a2)
+aclitemeq(AclItem *a1, AclItem *a2)
{
if (!a1 && !a2)
return (1);
}
static int32
-aclitemgt(AclItem * a1, AclItem * a2)
+aclitemgt(AclItem *a1, AclItem *a2)
{
if (a1 && !a2)
return (1);
}
Acl *
-aclinsert3(Acl * old_acl, AclItem * mod_aip, unsigned modechg)
+aclinsert3(Acl *old_acl, AclItem *mod_aip, unsigned modechg)
{
Acl *new_acl;
AclItem *old_aip,
*
*/
Acl *
-aclinsert(Acl * old_acl, AclItem * mod_aip)
+aclinsert(Acl *old_acl, AclItem *mod_aip)
{
return (aclinsert3(old_acl, mod_aip, ACL_MODECHG_EQL));
}
Acl *
-aclremove(Acl * old_acl, AclItem * mod_aip)
+aclremove(Acl *old_acl, AclItem *mod_aip)
{
Acl *new_acl;
AclItem *old_aip,
}
int32
-aclcontains(Acl * acl, AclItem * aip)
+aclcontains(Acl *acl, AclItem *aip)
{
unsigned i,
num;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.17 1997/09/08 02:30:19 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.18 1997/09/08 20:57:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#endif
static void
_ArrayRange(int st[], int endp[], int bsize, char *destPtr,
- ArrayType * array, int from);
-static int _ArrayClipCount(int stI[], int endpI[], ArrayType * array);
+ ArrayType *array, int from);
+static int _ArrayClipCount(int stI[], int endpI[], ArrayType *array);
static void
_LOArrayRange(int st[], int endp[], int bsize, int srcfd,
- int destfd, ArrayType * array, int isSrcLO, bool * isNull);
+ int destfd, ArrayType *array, int isSrcLO, bool * isNull);
static void
_ReadArray(int st[], int endp[], int bsize, int srcfd, int destfd,
- ArrayType * array, int isDestLO, bool * isNull);
+ 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);
*-------------------------------------------------------------------------
*/
char *
-array_out(ArrayType * v, Oid element_type)
+array_out(ArrayType *v, Oid element_type)
{
int typlen;
bool typbyval;
*----------------------------------------------------------------------------
*/
char *
-array_dims(ArrayType * v, bool * isNull)
+array_dims(ArrayType *v, bool * isNull)
{
char *p,
*save_p;
*---------------------------------------------------------------------------
*/
Datum
-array_ref(ArrayType * array,
+array_ref(ArrayType *array,
int n,
int indx[],
int reftype,
*-----------------------------------------------------------------------------
*/
Datum
-array_clip(ArrayType * array,
+array_clip(ArrayType *array,
int n,
int upperIndx[],
int lowerIndx[],
*-----------------------------------------------------------------------------
*/
char *
-array_set(ArrayType * array,
+array_set(ArrayType *array,
int n,
int indx[],
char *dataPtr,
*----------------------------------------------------------------------------
*/
char *
-array_assgn(ArrayType * array,
+array_assgn(ArrayType *array,
int n,
int upperIndx[],
int lowerIndx[],
- ArrayType * newArr,
+ ArrayType *newArr,
int reftype,
int len,
bool * isNull)
*-----------------------------------------------------------------------------
*/
int
-array_eq(ArrayType * array1, ArrayType * array2)
+array_eq(ArrayType *array1, ArrayType *array2)
{
if ((array1 == NULL) || (array2 == NULL))
return (0);
int endp[],
int bsize,
char *destPtr,
- ArrayType * array,
+ ArrayType *array,
int from)
{
int n,
}
static int
-_ArrayClipCount(int stI[], int endpI[], ArrayType * array)
+_ArrayClipCount(int stI[], int endpI[], ArrayType *array)
{
int n,
*dim,
int bsize,
int srcfd,
int destfd,
- ArrayType * array,
+ ArrayType *array,
int isSrcLO,
bool * isNull)
{
int bsize,
int srcfd,
int destfd,
- ArrayType * array,
+ ArrayType *array,
int isDestLO,
bool * isNull)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.9 1997/09/08 02:30:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.10 1997/09/08 20:57:22 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
return (arg1 == arg2);
}
+
bool
charne(int8 arg1, int8 arg2)
{
return (arg1 != arg2);
}
+
bool
charlt(int8 arg1, int8 arg2)
{
return ((uint8) arg1 < (uint8) arg2);
}
+
bool
charle(int8 arg1, int8 arg2)
{
return ((uint8) arg1 <= (uint8) arg2);
}
+
bool
chargt(int8 arg1, int8 arg2)
{
return ((uint8) arg1 > (uint8) arg2);
}
+
bool
charge(int8 arg1, int8 arg2)
{
return ((uint8) arg1 >= (uint8) arg2);
}
+
int8
charpl(int8 arg1, int8 arg2)
{
return (arg1 + arg2);
}
+
int8
charmi(int8 arg1, int8 arg2)
{
return (arg1 - arg2);
}
+
int8
charmul(int8 arg1, int8 arg2)
{
return (arg1 * arg2);
}
+
int8
chardiv(int8 arg1, int8 arg2)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.8 1997/09/08 02:30:31 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.9 1997/09/08 20:57:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int bsize,
int fp,
char *destfp,
- ArrayType * array,
+ ArrayType *array,
int isDestLO,
bool * isNull)
{
_ReadChunkArray1El(int st[],
int bsize,
int fp,
- ArrayType * array,
+ ArrayType *array,
bool * isNull)
{
int i,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.16 1997/09/08 02:30:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.17 1997/09/08 20:57:26 momjian Exp $
*
* NOTES
* This code is actually (almost) unused.
static int
istinterval(char *i_string,
- AbsoluteTime * i_start,
- AbsoluteTime * i_end);
+ AbsoluteTime *i_start,
+ AbsoluteTime *i_end);
/*****************************************************************************
* USER I/O ROUTINES *
*/
static int
istinterval(char *i_string,
- AbsoluteTime * i_start,
- AbsoluteTime * i_end)
+ AbsoluteTime *i_start,
+ AbsoluteTime *i_end)
{
register char *p,
*p1;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.21 1997/09/08 02:30:42 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.22 1997/09/08 20:57:29 momjian Exp $
*
*-------------------------------------------------------------------------
*/
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 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 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 double box_ar(BOX *box);
static Point *interpt_sl(LSEG * lseg, LINE * line);
static LINE *line_construct_pp(Point * pt1, Point * pt2);
/* box_out - convert a box to external form.
*/
char *
-box_out(BOX * box)
+box_out(BOX *box)
{
if (!PointerIsValid(box))
return (NULL);
/* box_fill - fill in a static box
*/
static BOX *
-box_fill(BOX * result, double x1, double x2, double y1, double y2)
+box_fill(BOX *result, double x1, double x2, double y1, double y2)
{
if (x1 > x2)
{
/* box_copy - copy a box
*/
static BOX *
-box_copy(BOX * box)
+box_copy(BOX *box)
{
BOX *result = PALLOCTYPE(BOX);
/* box_same - are two boxes identical?
*/
bool
-box_same(BOX * box1, BOX * box2)
+box_same(BOX *box1, BOX *box2)
{
return ((FPeq(box1->high.x, box2->high.x) && FPeq(box1->low.x, box2->low.x)) &&
(FPeq(box1->high.y, box2->high.y) && FPeq(box1->low.y, box2->low.y)));
/* box_overlap - does box1 overlap box2?
*/
bool
-box_overlap(BOX * box1, BOX * box2)
+box_overlap(BOX *box1, BOX *box2)
{
return (((FPge(box1->high.x, box2->high.x) && FPle(box1->low.x, box2->high.x)) ||
(FPge(box2->high.x, box1->high.x) && FPle(box2->low.x, box1->high.x))) &&
* when time ranges are stored as rectangles.
*/
bool
-box_overleft(BOX * box1, BOX * box2)
+box_overleft(BOX *box1, BOX *box2)
{
return (FPle(box1->high.x, box2->high.x));
}
/* box_left - is box1 strictly left of box2?
*/
bool
-box_left(BOX * box1, BOX * box2)
+box_left(BOX *box1, BOX *box2)
{
return (FPlt(box1->high.x, box2->low.x));
}
/* box_right - is box1 strictly right of box2?
*/
bool
-box_right(BOX * box1, BOX * box2)
+box_right(BOX *box1, BOX *box2)
{
return (FPgt(box1->low.x, box2->high.x));
}
* are stored as rectangles.
*/
bool
-box_overright(BOX * box1, BOX * box2)
+box_overright(BOX *box1, BOX *box2)
{
return (box1->low.x >= box2->low.x);
}
/* box_contained - is box1 contained by box2?
*/
bool
-box_contained(BOX * box1, BOX * box2)
+box_contained(BOX *box1, BOX *box2)
{
return ((FPle(box1->high.x, box2->high.x) && FPge(box1->low.x, box2->low.x)) &&
(FPle(box1->high.y, box2->high.y) && FPge(box1->low.y, box2->low.y)));
/* box_contain - does box1 contain box2?
*/
bool
-box_contain(BOX * box1, BOX * box2)
+box_contain(BOX *box1, BOX *box2)
{
return ((FPge(box1->high.x, box2->high.x) && FPle(box1->low.x, box2->low.x) &&
FPge(box1->high.y, box2->high.y) && FPle(box1->low.y, box2->low.y)));
* is box1 entirely {above,below} box2?
*/
bool
-box_below(BOX * box1, BOX * box2)
+box_below(BOX *box1, BOX *box2)
{
return (FPle(box1->high.y, box2->low.y));
}
bool
-box_above(BOX * box1, BOX * box2)
+box_above(BOX *box1, BOX *box2)
{
return (FPge(box1->low.y, box2->high.y));
}
* our accuracy constraint?
*/
bool
-box_lt(BOX * box1, BOX * box2)
+box_lt(BOX *box1, BOX *box2)
{
return (FPlt(box_ar(box1), box_ar(box2)));
}
bool
-box_gt(BOX * box1, BOX * box2)
+box_gt(BOX *box1, BOX *box2)
{
return (FPgt(box_ar(box1), box_ar(box2)));
}
bool
-box_eq(BOX * box1, BOX * box2)
+box_eq(BOX *box1, BOX *box2)
{
return (FPeq(box_ar(box1), box_ar(box2)));
}
bool
-box_le(BOX * box1, BOX * box2)
+box_le(BOX *box1, BOX *box2)
{
return (FPle(box_ar(box1), box_ar(box2)));
}
bool
-box_ge(BOX * box1, BOX * box2)
+box_ge(BOX *box1, BOX *box2)
{
return (FPge(box_ar(box1), box_ar(box2)));
}
/* box_area - returns the area of the box.
*/
double *
-box_area(BOX * box)
+box_area(BOX *box)
{
double *result = PALLOCTYPE(double);
* (horizontal magnitude).
*/
double *
-box_width(BOX * box)
+box_width(BOX *box)
{
double *result = PALLOCTYPE(double);
* (vertical magnitude).
*/
double *
-box_height(BOX * box)
+box_height(BOX *box)
{
double *result = PALLOCTYPE(double);
* center points of two boxes.
*/
double *
-box_distance(BOX * box1, BOX * box2)
+box_distance(BOX *box1, BOX *box2)
{
double *result = PALLOCTYPE(double);
Point *a,
/* box_center - returns the center point of the box.
*/
Point *
-box_center(BOX * box)
+box_center(BOX *box)
{
Point *result = PALLOCTYPE(Point);
/* box_ar - returns the area of the box.
*/
static double
-box_ar(BOX * box)
+box_ar(BOX *box)
{
return (box_wd(box) * box_ht(box));
}
* (horizontal magnitude).
*/
static double
-box_wd(BOX * box)
+box_wd(BOX *box)
{
return (box->high.x - box->low.x);
}
* (vertical magnitude).
*/
static double
-box_ht(BOX * box)
+box_ht(BOX *box)
{
return (box->high.y - box->low.y);
}
*/
#ifdef NOT_USED
static double
-box_dt(BOX * box1, BOX * box2)
+box_dt(BOX *box1, BOX *box2)
{
double result;
Point *a,
* or NULL if they do not intersect.
*/
BOX *
-box_intersect(BOX * box1, BOX * box2)
+box_intersect(BOX *box1, BOX *box2)
{
BOX *result;
* provided, of course, we have LSEGs.
*/
LSEG *
-box_diagonal(BOX * box)
+box_diagonal(BOX *box)
{
Point p1,
p2;
}
double *
-dist_pb(Point * pt, BOX * box)
+dist_pb(Point * pt, BOX *box)
{
Point *tmp;
double *result;
double *
-dist_sb(LSEG * lseg, BOX * box)
+dist_sb(LSEG * lseg, BOX *box)
{
Point *tmp;
double *result;
double *
-dist_lb(LINE * line, BOX * box)
+dist_lb(LINE * line, BOX *box)
{
Point *tmp;
double *result;
} /* close_ps() */
Point *
-close_pb(Point * pt, BOX * box)
+close_pb(Point * pt, BOX *box)
{
/* think about this one for a while */
elog(WARN, "close_pb not implemented", NULL);
}
Point *
-close_sb(LSEG * lseg, BOX * box)
+close_sb(LSEG * lseg, BOX *box)
{
/* think about this one for a while */
elog(WARN, "close_sb not implemented", NULL);
}
Point *
-close_lb(LINE * line, BOX * box)
+close_lb(LINE * line, BOX *box)
{
/* think about this one for a while */
elog(WARN, "close_lb not implemented", NULL);
}
bool
-on_pb(Point * pt, BOX * box)
+on_pb(Point * pt, BOX *box)
{
if (!PointerIsValid(pt) || !PointerIsValid(box))
return (FALSE);
} /* on_sl() */
bool
-on_sb(LSEG * lseg, BOX * box)
+on_sb(LSEG * lseg, BOX *box)
{
if (!PointerIsValid(lseg) || !PointerIsValid(box))
return (FALSE);
/* XXX segment and box should be able to intersect; tgl - 97/01/09 */
bool
-inter_sb(LSEG * lseg, BOX * box)
+inter_sb(LSEG * lseg, BOX *box)
{
return (0);
}
/* XXX line and box should be able to intersect; tgl - 97/01/09 */
bool
-inter_lb(LINE * line, BOX * box)
+inter_lb(LINE * line, BOX *box)
{
return (0);
}
} /* box() */
BOX *
-box_add(BOX * box, Point * p)
+box_add(BOX *box, Point * p)
{
BOX *result;
} /* box_add() */
BOX *
-box_sub(BOX * box, Point * p)
+box_sub(BOX *box, Point * p)
{
BOX *result;
} /* box_sub() */
BOX *
-box_mul(BOX * box, Point * p)
+box_mul(BOX *box, Point * p)
{
BOX *result;
Point *high,
} /* box_mul() */
BOX *
-box_div(BOX * box, Point * p)
+box_div(BOX *box, Point * p)
{
BOX *result;
Point *high,
* Convert a box to a polygon.
*/
POLYGON *
-box_poly(BOX * box)
+box_poly(BOX *box)
{
POLYGON *poly;
int size;
* Convert a box to a circle.
*/
CIRCLE *
-box_circle(BOX * box)
+box_circle(BOX *box)
{
CIRCLE *circle;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.6 1997/09/08 02:30:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.7 1997/09/08 20:57:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
return (arg1 == arg2);
}
+
bool
int4ne(int32 arg1, int32 arg2)
{
return (arg1 != arg2);
}
+
bool
int4lt(int32 arg1, int32 arg2)
{
return (arg1 < arg2);
}
+
bool
int4le(int32 arg1, int32 arg2)
{
return (arg1 <= arg2);
}
+
bool
int4gt(int32 arg1, int32 arg2)
{
return (arg1 > arg2);
}
+
bool
int4ge(int32 arg1, int32 arg2)
{
{
return (arg1 == arg2);
}
+
bool
int2ne(int16 arg1, int16 arg2)
{
return (arg1 != arg2);
}
+
bool
int2lt(int16 arg1, int16 arg2)
{
return (arg1 < arg2);
}
+
bool
int2le(int16 arg1, int16 arg2)
{
return (arg1 <= arg2);
}
+
bool
int2gt(int16 arg1, int16 arg2)
{
return (arg1 > arg2);
}
+
bool
int2ge(int16 arg1, int16 arg2)
{
{
return (arg1 == arg2);
}
+
bool
int24ne(int32 arg1, int32 arg2)
{
return (arg1 != arg2);
}
+
bool
int24lt(int32 arg1, int32 arg2)
{
return (arg1 < arg2);
}
+
bool
int24le(int32 arg1, int32 arg2)
{
return (arg1 <= arg2);
}
+
bool
int24gt(int32 arg1, int32 arg2)
{
return (arg1 > arg2);
}
+
bool
int24ge(int32 arg1, int32 arg2)
{
{
return (arg1 == arg2);
}
+
bool
int42ne(int32 arg1, int32 arg2)
{
return (arg1 != arg2);
}
+
bool
int42lt(int32 arg1, int32 arg2)
{
return (arg1 < arg2);
}
+
bool
int42le(int32 arg1, int32 arg2)
{
return (arg1 <= arg2);
}
+
bool
int42gt(int32 arg1, int32 arg2)
{
return (arg1 > arg2);
}
+
bool
int42ge(int32 arg1, int32 arg2)
{
{
return (-arg);
}
+
int32
int4pl(int32 arg1, int32 arg2)
{
return (arg1 + arg2);
}
+
int32
int4mi(int32 arg1, int32 arg2)
{
return (arg1 - arg2);
}
+
int32
int4mul(int32 arg1, int32 arg2)
{
return (arg1 * arg2);
}
+
int32
int4div(int32 arg1, int32 arg2)
{
return (arg1 / arg2);
}
+
int32
int4inc(int32 arg)
{
{
return (-arg);
}
+
int16
int2pl(int16 arg1, int16 arg2)
{
return (arg1 + arg2);
}
+
int16
int2mi(int16 arg1, int16 arg2)
{
return (arg1 - arg2);
}
+
int16
int2mul(int16 arg1, int16 arg2)
{
return (arg1 * arg2);
}
+
int16
int2div(int16 arg1, int16 arg2)
{
return (arg1 / arg2);
}
+
int16
int2inc(int16 arg)
{
{
return (arg1 + arg2);
}
+
int32
int24mi(int32 arg1, int32 arg2)
{
return (arg1 - arg2);
}
+
int32
int24mul(int32 arg1, int32 arg2)
{
return (arg1 * arg2);
}
+
int32
int24div(int32 arg1, int32 arg2)
{
{
return (arg1 + arg2);
}
+
int32
int42mi(int32 arg1, int32 arg2)
{
return (arg1 - arg2);
}
+
int32
int42mul(int32 arg1, int32 arg2)
{
return (arg1 * arg2);
}
+
int32
int42div(int32 arg1, int32 arg2)
{
{
return (arg1 % arg2);
}
+
int32
int2mod(int16 arg1, int16 arg2)
{
return (arg1 % arg2);
}
+
int32
int24mod(int32 arg1, int32 arg2)
{
return (arg1 % arg2);
}
+
int32
int42mod(int32 arg1, int32 arg2)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/inval.c,v 1.6 1997/09/08 02:31:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/inval.c,v 1.7 1997/09/08 20:57:39 momjian Exp $
*
* Note - this code is real crufty...
*
{
CatalogInvalidationData catalog;
RelationInvalidationData relation;
-} AnyInvalidation;
+} AnyInvalidation;
typedef struct InvalidationMessageData
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/aset.c,v 1.7 1997/09/08 02:32:05 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/mmgr/aset.c,v 1.8 1997/09/08 20:57:46 momjian Exp $
*
* NOTE
* XXX This is a preliminary implementation which lacks fail-fast
{
OrderedElemData elemData; /* elem in AllocSet */
Size size;
-} AllocElemData;
+} AllocElemData;
typedef AllocElemData *AllocElem;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.42 1997/09/08 02:32:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.43 1997/09/08 20:57:50 momjian Exp $
*
*
}
void
-clearAggInfo(AggInfo * agginfo, int numArgs)
+clearAggInfo(AggInfo *agginfo, int numArgs)
{
int i;
*
*/
void
-dumpAggs(FILE * fout, AggInfo * agginfo, int numAggs,
+dumpAggs(FILE * fout, AggInfo *agginfo, int numAggs,
TypeInfo * tinfo, int numTypes)
{
int i;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_dump.h,v 1.21 1997/09/08 02:32:50 momjian Exp $
+ * $Id: pg_dump.h,v 1.22 1997/09/08 20:57:56 momjian Exp $
*
*
char *agginitval1;
char *agginitval2;
char *usename;
-} AggInfo;
+} AggInfo;
typedef struct _oprInfo
{
dumpFuncs(FILE * fout, FuncInfo * finfo, int numFuncs,
TypeInfo * tinfo, int numTypes);
extern void
-dumpAggs(FILE * fout, AggInfo * agginfo, int numAggregates,
+dumpAggs(FILE * fout, AggInfo *agginfo, int numAggregates,
TypeInfo * tinfo, int numTypes);
extern void
dumpOprs(FILE * fout, OprInfo * agginfo, int numOperators,
extern void
gistbuild(Relation heap,
Relation index, int natts,
- AttrNumber * attnum, IndexStrategy istrat,
+ AttrNumber *attnum, IndexStrategy istrat,
uint16 pint, Datum * params,
FuncIndexInfo * finfo,
PredInfo * predInfo);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: hash.h,v 1.9 1997/09/08 02:34:08 momjian Exp $
+ * $Id: hash.h,v 1.10 1997/09/08 20:58:02 momjian Exp $
*
* NOTES
* modeled after Margo Seltzer's hash implementation for unix.
extern void
hashbuild(Relation heap, Relation index, int natts,
- AttrNumber * attnum, IndexStrategy istrat, uint16 pcount,
+ AttrNumber *attnum, IndexStrategy istrat, uint16 pcount,
Datum * params, FuncIndexInfo * finfo, PredInfo * predInfo);
extern InsertIndexResult
hashinsert(Relation rel, Datum * datum, char *nulls,
/* hashovfl.c */
-extern Buffer _hash_addovflpage(Relation rel, Buffer * metabufp, Buffer buf);
+extern Buffer _hash_addovflpage(Relation rel, Buffer *metabufp, Buffer buf);
extern Buffer _hash_freeovflpage(Relation rel, Buffer ovflbuf);
extern int32
_hash_initbitmap(Relation rel, HashMetaPage metap, int32 pnum,
extern void _hash_wrtbuf(Relation rel, Buffer buf);
extern void _hash_wrtnorelbuf(Relation rel, Buffer buf);
extern Page
-_hash_chgbufaccess(Relation rel, Buffer * bufp, int from_access,
+_hash_chgbufaccess(Relation rel, Buffer *bufp, int from_access,
int to_access);
extern void _hash_pageinit(Page page, Size size);
extern void _hash_pagedel(Relation rel, ItemPointer tid);
/* hashsearch.c */
extern void
_hash_search(Relation rel, int keysz, ScanKey scankey,
- Buffer * bufP, HashMetaPage metap);
+ Buffer *bufP, HashMetaPage metap);
extern RetrieveIndexResult _hash_next(IndexScanDesc scan, ScanDirection dir);
extern RetrieveIndexResult _hash_first(IndexScanDesc scan, ScanDirection dir);
extern bool
-_hash_step(IndexScanDesc scan, Buffer * bufP, ScanDirection dir,
+_hash_step(IndexScanDesc scan, Buffer *bufP, ScanDirection dir,
Buffer metabuf);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: heapam.h,v 1.13 1997/09/08 02:34:10 momjian Exp $
+ * $Id: heapam.h,v 1.14 1997/09/08 20:58:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
TimeQual timeQual, unsigned nkeys, ScanKey key);
extern void heap_rescan(HeapScanDesc sdesc, bool scanFromEnd, ScanKey key);
extern void heap_endscan(HeapScanDesc sdesc);
-extern HeapTuple heap_getnext(HeapScanDesc scandesc, int backw, Buffer * b);
+extern HeapTuple heap_getnext(HeapScanDesc scandesc, int backw, Buffer *b);
extern HeapTuple
heap_fetch(Relation relation, TimeQual timeQual,
- ItemPointer tid, Buffer * b);
+ ItemPointer tid, Buffer *b);
extern Oid heap_insert(Relation relation, HeapTuple tup);
extern int heap_delete(Relation relation, ItemPointer tid);
extern int
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nbtree.h,v 1.16 1997/09/08 02:34:17 momjian Exp $
+ * $Id: nbtree.h,v 1.17 1997/09/08 20:58:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#define BTP_META (1 << 3)
#define BTP_CHAIN (1 << 4)
-} BTPageOpaqueData;
+} BTPageOpaqueData;
typedef BTPageOpaqueData *BTPageOpaque;
uint16 numberOfFirstKeys; /* number of keys for 1st
* attribute */
ScanKey keyData; /* key descriptor */
-} BTScanOpaqueData;
+} BTScanOpaqueData;
typedef BTScanOpaqueData *BTScanOpaque;
* 8-byte boundary */
#endif
IndexTupleData bti_itup;
-} BTItemData;
+} BTItemData;
typedef BTItemData *BTItem;
OffsetNumber bts_offset;
BTItem bts_btitem;
struct BTStackData *bts_parent;
-} BTStackData;
+} BTStackData;
typedef BTStackData *BTStack;
int btps_level;
bool btps_doupper;
struct BTPageState *btps_next;
-} BTPageState;
+} BTPageState;
/*
* We need to be able to tell the difference between read and write
extern void
btbuild(Relation heap, Relation index, int natts,
- AttrNumber * attnum, IndexStrategy istrat, uint16 pcount,
+ AttrNumber *attnum, IndexStrategy istrat, uint16 pcount,
Datum * params, FuncIndexInfo * finfo, PredInfo * predInfo);
extern InsertIndexResult
btinsert(Relation rel, Datum * datum, char *nulls,
/*
* prototypes for functions in nbtsearch.c
*/
-extern BTStack
+extern BTStack
_bt_search(Relation rel, int keysz, ScanKey scankey,
- Buffer * bufP);
-extern Buffer
+ Buffer *bufP);
+extern Buffer
_bt_moveright(Relation rel, Buffer buf, int keysz,
ScanKey scankey, int access);
extern bool
ScanKey scankey, int srchtype);
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 bool _bt_step(IndexScanDesc scan, Buffer *bufP, ScanDirection dir);
/*
* prototypes for functions in nbtstrat.c
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: rtree.h,v 1.8 1997/09/08 02:34:23 momjian Exp $
+ * $Id: rtree.h,v 1.9 1997/09/08 20:58:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void rtrescan(IndexScanDesc s, bool fromEnd, ScanKey key);
extern void
rtbuild(Relation heap, Relation index, int natts,
- AttrNumber * attnum, IndexStrategy istrat, uint16 pcount,
+ AttrNumber *attnum, IndexStrategy istrat, uint16 pcount,
Datum * params, FuncIndexInfo * finfo, PredInfo * predInfo);
extern void _rtdump(Relation r);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: strat.h,v 1.6 1997/09/08 02:34:27 momjian Exp $
+ * $Id: strat.h,v 1.7 1997/09/08 20:58:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
StrategyNumber strategy[1]; /* VARIABLE LENGTH ARRAY */
} StrategyTransformMapData; /* VARIABLE LENGTH
+ *
*
* STRUCTURE */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: transam.h,v 1.9 1997/09/08 02:34:27 momjian Exp $
+ * $Id: transam.h,v 1.10 1997/09/08 20:58:12 momjian Exp $
*
* NOTES
* Transaction System Version 101 now support proper oid
extern void AmiTransactionOverride(bool flag);
extern void
TransComputeBlockNumber(Relation relation,
- TransactionId transactionId, BlockNumber * blockNumberOutP);
+ TransactionId transactionId, BlockNumber *blockNumberOutP);
extern XidStatus
TransBlockNumberGetXidStatus(Relation relation,
BlockNumber blockNumber, TransactionId xid, bool * failP);
TransBlockNumberSetXidStatus(Relation relation,
BlockNumber blockNumber, TransactionId xid, XidStatus xstatus,
bool * failP);
-extern AbsoluteTime
+extern AbsoluteTime
TransBlockNumberGetCommitTime(Relation relation,
BlockNumber blockNumber, TransactionId xid, bool * failP);
extern void
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: tupdesc.h,v 1.10 1997/09/08 02:34:31 momjian Exp $
+ * $Id: tupdesc.h,v 1.11 1997/09/08 20:58:13 momjian Exp $
*
*-------------------------------------------------------------------------
*/
AttrNumber adnum;
char *adbin;
char *adsrc;
-} AttrDefault;
+} AttrDefault;
typedef struct constrCheck
{
extern TupleDesc CreateTemplateTupleDesc(int natts);
-extern TupleDesc CreateTupleDesc(int natts, AttributeTupleForm * attrs);
+extern TupleDesc CreateTupleDesc(int natts, AttributeTupleForm *attrs);
extern TupleDesc CreateTupleDescCopy(TupleDesc tupdesc);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: bootstrap.h,v 1.7 1997/09/08 02:34:36 momjian Exp $
+ * $Id: bootstrap.h,v 1.8 1997/09/08 20:58:15 momjian Exp $
*
*-------------------------------------------------------------------------
*/
index_register(char *heap,
char *ind,
int natts,
- AttrNumber * attnos,
+ AttrNumber *attnos,
uint16 nparams,
Datum * params,
FuncIndexInfo * finfo,
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeAgg.h,v 1.3 1997/09/08 02:36:21 momjian Exp $
+ * $Id: nodeAgg.h,v 1.4 1997/09/08 20:58:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef NODEAGG_H
#define NODEAGG_H
-extern TupleTableSlot *ExecAgg(Agg * node);
-extern bool ExecInitAgg(Agg * node, EState * estate, Plan * parent);
-extern int ExecCountSlotsAgg(Agg * node);
-extern void ExecEndAgg(Agg * node);
+extern TupleTableSlot *ExecAgg(Agg *node);
+extern bool ExecInitAgg(Agg *node, EState * estate, Plan * parent);
+extern int ExecCountSlotsAgg(Agg *node);
+extern void ExecEndAgg(Agg *node);
#endif /* NODEAGG_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodeAppend.h,v 1.4 1997/09/08 02:36:22 momjian Exp $
+ * $Id: nodeAppend.h,v 1.5 1997/09/08 20:58:19 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef NODEAPPEND_H
#define NODEAPPEND_H
-extern bool ExecInitAppend(Append * node, EState * estate, Plan * parent);
-extern int ExecCountSlotsAppend(Append * node);
-extern TupleTableSlot *ExecProcAppend(Append * node);
-extern void ExecEndAppend(Append * node);
+extern bool ExecInitAppend(Append *node, EState * estate, Plan * parent);
+extern int ExecCountSlotsAppend(Append *node);
+extern TupleTableSlot *ExecProcAppend(Append *node);
+extern void ExecEndAppend(Append *node);
#endif /* NODEAPPEND_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pqcomm.h,v 1.12 1997/09/08 02:37:08 momjian Exp $
+ * $Id: pqcomm.h,v 1.13 1997/09/08 20:58:26 momjian Exp $
*
* NOTES
* Some of this should move to libpq.h
/*
* PacketBufId id;
- *//* id of packet buf currently in use */
+*//* id of packet buf currently in use */
PacketBuf buf; /* stream implementation (curr pack buf) */
} Port;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: execnodes.h,v 1.10 1997/09/08 02:37:12 momjian Exp $
+ * $Id: execnodes.h,v 1.11 1997/09/08 20:58:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
List *as_rtentries;
List *as_result_relation_info_list;
List *as_junkFilter_list;
-} AppendState;
+} AppendState;
/* ----------------------------------------------------------------
* Scan State Information
{
CommonScanState csstate; /* its first field is NodeTag */
bool agg_done;
-} AggState;
+} AggState;
/* ---------------------
* GroupState information
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsenodes.h,v 1.25 1997/09/08 02:37:23 momjian Exp $
+ * $Id: parsenodes.h,v 1.26 1997/09/08 20:58:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
char *relname; /* the relation to add attr */
bool inh; /* add recursively to children? */
struct ColumnDef *colDef; /* the attribute definition */
-} AddAttrStmt;
+} AddAttrStmt;
/* ----------------------
* Change ACL Statement
typedef enum ArchType
{
ARCH_NONE, ARCH_LIGHT, ARCH_HEAVY /* archive mode */
-} ArchType;
+} ArchType;
typedef struct CreateStmt
{
List *targetList; /* the target list (of ResTarget) */
List *fromClause; /* the from clause */
Node *whereClause; /* qualifications */
-} AppendStmt;
+} AppendStmt;
/* ----------------------
* Delete Statement
char *opname; /* name of operator/function */
Node *lexpr; /* left argument */
Node *rexpr; /* right argument */
-} A_Expr;
+} A_Expr;
/*
* Attr -
List *attrs; /* attributes (possibly nested); list of
* Values (strings) */
List *indirection; /* array refs (list of A_Indices') */
-} Attr;
+} Attr;
/*
* A_Const - a constant expression
NodeTag type;
Value val; /* the value (with the tag) */
TypeName *typename; /* typecast */
-} A_Const;
+} A_Const;
/*
* ColumnDef - column definition (used in various creates)
NodeTag type;
Node *lidx; /* could be NULL */
Node *uidx;
-} A_Indices;
+} A_Indices;
/*
* ResTarget -
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: plannodes.h,v 1.8 1997/09/08 02:37:26 momjian Exp $
+ * $Id: plannodes.h,v 1.9 1997/09/08 20:58:48 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Index unionrelid;
List *unionrtentries;
AppendState *unionstate;
-} Append;
+} Append;
/*
* ==========
int numAgg;
Aggreg **aggs;
AggState *aggstate;
-} Agg;
+} Agg;
/* ---------------
* group node -
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: primnodes.h,v 1.9 1997/09/08 02:37:27 momjian Exp $
+ * $Id: primnodes.h,v 1.10 1997/09/08 20:58:50 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Oid aggtype; /* type of final result */
Node *target; /* attribute to aggreg on */
int aggno; /* index to ecxt_values */
-} Aggreg;
+} Aggreg;
/* ----------------
* Array
IntArray arraylow;
IntArray arrayhigh;
int arraylen;
-} Array;
+} Array;
/* ----------------
* ArrayRef:
List *reflowerindexpr;
Node *refexpr;
Node *refassgnexpr;
-} ArrayRef;
+} ArrayRef;
#endif /* PRIMNODES_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: clauses.h,v 1.5 1997/09/08 02:37:34 momjian Exp $
+ * $Id: clauses.h,v 1.6 1997/09/08 20:58:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern List *fix_opids(List * clauses);
extern void
get_relattval(Node * clause, int *relid,
- AttrNumber * attno, Datum * constval, int *flag);
+ AttrNumber *attno, Datum * constval, int *flag);
extern void
get_rels_atts(Node * clause, int *relid1,
- AttrNumber * attno1, int *relid2, AttrNumber * attno2);
+ AttrNumber *attno1, int *relid2, AttrNumber *attno2);
extern void CommuteClause(Node * clause);
#endif /* CLAUSES_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: planmain.h,v 1.3 1997/09/08 02:37:55 momjian Exp $
+ * $Id: planmain.h,v 1.4 1997/09/08 20:58:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Sort *
make_sort(List * tlist, Oid tempid, Plan * lefttree,
int keycount);
-extern Agg *make_agg(List * tlist, int nagg, Aggreg ** aggs);
+extern Agg *make_agg(List * tlist, int nagg, Aggreg **aggs);
extern Group *
make_group(List * tlist, bool tuplePerGroup, int ngrp,
- AttrNumber * grpColIdx, Sort * lefttree);
+ AttrNumber *grpColIdx, Sort * lefttree);
extern Unique *make_unique(List * tlist, Plan * lefttree, char *uniqueAttr);
extern List *generate_fjoin(List * tlist);
index_outerjoin_references(List * inner_indxqual,
List * outer_tlist, Index inner_relid);
extern void set_result_tlist_references(Result * resultNode);
-extern void set_agg_tlist_references(Agg * aggNode);
-extern void set_agg_agglist_references(Agg * aggNode);
+extern void set_agg_tlist_references(Agg *aggNode);
+extern void set_agg_agglist_references(Agg *aggNode);
#endif /* PLANMAIN_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: block.h,v 1.4 1997/09/08 02:38:55 momjian Exp $
+ * $Id: block.h,v 1.5 1997/09/08 20:58:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
uint16 bi_hi;
uint16 bi_lo;
-} BlockIdData;
+} BlockIdData;
typedef BlockIdData *BlockId; /* block identifier */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: buf_internals.h,v 1.16 1997/09/08 02:38:57 momjian Exp $
+ * $Id: buf_internals.h,v 1.17 1997/09/08 20:59:00 momjian Exp $
*
* NOTE
* If BUFFERPAGE0 is defined, then 0 will be used as a
/* Internal routines: only called by buf.c */
/*freelist.c*/
-extern void AddBufferToFreelist(BufferDesc * bf);
-extern void PinBuffer(BufferDesc * buf);
-extern void PinBuffer_Debug(char *file, int line, BufferDesc * buf);
-extern void UnpinBuffer(BufferDesc * buf);
+extern void AddBufferToFreelist(BufferDesc *bf);
+extern void PinBuffer(BufferDesc *buf);
+extern void PinBuffer_Debug(char *file, int line, BufferDesc *buf);
+extern void UnpinBuffer(BufferDesc *buf);
extern BufferDesc *GetFreeBuffer(void);
extern void InitFreeList(bool init);
/* buf_table.c */
extern void InitBufTable(void);
extern BufferDesc *BufTableLookup(BufferTag * tagPtr);
-extern bool BufTableDelete(BufferDesc * buf);
-extern bool BufTableInsert(BufferDesc * buf);
+extern bool BufTableDelete(BufferDesc *buf);
+extern bool BufTableInsert(BufferDesc *buf);
/* bufmgr.c */
extern BufferDesc *BufferDescriptors;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: bufmgr.h,v 1.13 1997/09/08 02:38:58 momjian Exp $
+ * $Id: bufmgr.h,v 1.14 1997/09/08 20:59:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes for functions in bufmgr.c
*/
-extern Buffer
+extern Buffer
RelationGetBufferWithBuffer(Relation relation,
BlockNumber blockNumber, Buffer buffer);
extern Buffer ReadBuffer(Relation reln, BlockNumber blockNum);
extern int WriteBuffer(Buffer buffer);
extern int WriteNoReleaseBuffer(Buffer buffer);
-extern Buffer
+extern Buffer
ReleaseAndReadBuffer(Buffer buffer, Relation relation,
BlockNumber blockNum);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: shmem.h,v 1.7 1997/09/08 02:39:08 momjian Exp $
+ * $Id: shmem.h,v 1.8 1997/09/08 20:59:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
char key[BTABLE_KEYSIZE]; /* string name */
unsigned long location; /* location in shared mem */
unsigned long size; /* numbytes allocated for the structure */
-} BindingEnt;
+} BindingEnt;
/*
* prototypes for functions in shmqueue.c
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: acl.h,v 1.9 1997/09/08 02:39:24 momjian Exp $
+ * $Id: acl.h,v 1.10 1997/09/08 20:59:15 momjian Exp $
*
* NOTES
* For backward-compatability purposes we have to allow there
AclId ai_id;
AclIdType ai_idtype;
AclMode ai_mode;
-} AclItem;
+} AclItem;
/* Note: if the size of AclItem changes,
change the aclitem typlen in pg_type.h */
*/
extern Acl *aclownerdefault(AclId ownerid);
extern Acl *acldefault(void);
-extern Acl *aclinsert3(Acl * old_acl, AclItem * mod_aip, unsigned modechg);
+extern Acl *aclinsert3(Acl *old_acl, AclItem *mod_aip, unsigned modechg);
extern char *aclmakepriv(char *old_privlist, char new_priv);
extern char *aclmakeuser(char *user_type, char *user);
*/
extern Acl *makeacl(int n);
extern AclItem *aclitemin(char *s);
-extern char *aclitemout(AclItem * aip);
-extern Acl *aclinsert(Acl * old_acl, AclItem * mod_aip);
-extern Acl *aclremove(Acl * old_acl, AclItem * mod_aip);
-extern int32 aclcontains(Acl * acl, AclItem * aip);
+extern char *aclitemout(AclItem *aip);
+extern Acl *aclinsert(Acl *old_acl, AclItem *mod_aip);
+extern Acl *aclremove(Acl *old_acl, AclItem *mod_aip);
+extern int32 aclcontains(Acl *acl, AclItem *aip);
/*
* prototypes for functions in aclchk.c
*/
-extern void ChangeAcl(char *relname, 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);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: array.h,v 1.6 1997/09/08 02:39:26 momjian Exp $
+ * $Id: array.h,v 1.7 1997/09/08 20:59:18 momjian Exp $
*
* NOTES
* XXX the data array should be LONGALIGN'd -- notice that the array
int size; /* total array size (in bytes) */
int ndim; /* # of dimensions */
int flags; /* implementation flags */
-} ArrayType;
+} ArrayType;
/*
* bitmask of ArrayType flags field:
* prototypes for functions defined in arrayfuncs.c
*/
extern char *array_in(char *string, Oid element_type);
-extern char *array_out(ArrayType * v, Oid element_type);
-extern char *array_dims(ArrayType * v, bool * isNull);
+extern char *array_out(ArrayType *v, Oid element_type);
+extern char *array_dims(ArrayType *v, bool * isNull);
extern Datum
-array_ref(ArrayType * array, int n, int indx[], int reftype,
+array_ref(ArrayType *array, int n, int indx[], int reftype,
int elmlen, int arraylen, bool * isNull);
extern Datum
-array_clip(ArrayType * array, int n, int upperIndx[],
+array_clip(ArrayType *array, int n, int upperIndx[],
int lowerIndx[], int reftype, int len, bool * isNull);
extern char *
-array_set(ArrayType * array, int n, int indx[], char *dataPtr,
+array_set(ArrayType *array, int n, int indx[], char *dataPtr,
int reftype, int elmlen, int arraylen, bool * isNull);
extern char *
-array_assgn(ArrayType * array, int n, int upperIndx[],
- int lowerIndx[], ArrayType * newArr, int reftype,
+array_assgn(ArrayType *array, int n, int upperIndx[],
+ int lowerIndx[], ArrayType *newArr, int reftype,
int len, bool * isNull);
-extern int array_eq(ArrayType * array1, ArrayType * array2);
+extern int array_eq(ArrayType *array1, ArrayType *array2);
extern int
_LOtransfer(char **destfd, int size, int nitems, char **srcfd,
int isSrcLO, int isDestLO);
int *nbytes, char *chunkfile);
extern int
_ReadChunkArray(int st[], int endp[], int bsize, int fp,
- char *destfp, ArrayType * array, int isDestLO, bool * isNull);
+ char *destfp, ArrayType *array, int isDestLO, bool * isNull);
extern struct varlena *
_ReadChunkArray1El(int st[], int bsize, int fp,
- ArrayType * array, bool * isNull);
+ ArrayType *array, bool * isNull);
#endif /* ARRAY_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: builtins.h,v 1.23 1997/09/08 02:39:32 momjian Exp $
+ * $Id: builtins.h,v 1.24 1997/09/08 20:59:19 momjian Exp $
*
* NOTES
* This should normally only be included by fmgr.h.
extern int32 bttextcmp(struct varlena * a, struct varlena * b);
/* support routines for the rtree access method, by opclass */
-extern BOX *rt_box_union(BOX * a, BOX * b);
-extern BOX *rt_box_inter(BOX * a, BOX * b);
-extern void rt_box_size(BOX * a, float *size);
-extern void rt_bigbox_size(BOX * a, float *size);
+extern BOX *rt_box_union(BOX *a, BOX *b);
+extern BOX *rt_box_inter(BOX *a, BOX *b);
+extern void rt_box_size(BOX *a, float *size);
+extern void rt_bigbox_size(BOX *a, float *size);
extern void rt_poly_size(POLYGON * a, float *size);
extern POLYGON *rt_poly_union(POLYGON * a, POLYGON * b);
extern POLYGON *rt_poly_inter(POLYGON * a, POLYGON * b);
extern bool float84ge(float64 arg1, float32 arg2);
/* geo_ops.c, geo_selfuncs.c */
-extern double *box_area(BOX * box);
+extern double *box_area(BOX *box);
/* misc.c */
extern bool nullvalue(Datum value, bool * isNull);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: geo_decls.h,v 1.10 1997/09/08 02:39:46 momjian Exp $
+ * $Id: geo_decls.h,v 1.11 1997/09/08 20:59:21 momjian Exp $
*
* NOTE
* These routines do *not* use the float types from adt/.
{
Point high,
low; /* corner POINTs */
-} BOX;
+} BOX;
/*---------------------------------------------------------------------
* POLYGON - Specified by an array of doubles defining the points,
extern double *dist_pl(Point * pt, LINE * line);
extern double *dist_ps(Point * pt, LSEG * lseg);
extern double *dist_ppath(Point * pt, PATH * path);
-extern double *dist_pb(Point * pt, BOX * box);
+extern double *dist_pb(Point * pt, BOX *box);
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 double *dist_sb(LSEG * lseg, BOX *box);
+extern double *dist_lb(LINE * line, BOX *box);
extern Point *close_pl(Point * pt, LINE * line);
extern Point *close_ps(Point * pt, LSEG * lseg);
-extern Point *close_pb(Point * pt, BOX * box);
+extern Point *close_pb(Point * pt, BOX *box);
extern Point *close_sl(LSEG * lseg, LINE * line);
-extern Point *close_sb(LSEG * lseg, BOX * box);
-extern Point *close_lb(LINE * line, BOX * box);
+extern Point *close_sb(LSEG * lseg, BOX *box);
+extern Point *close_lb(LINE * line, BOX *box);
extern bool on_pl(Point * pt, LINE * line);
extern bool on_ps(Point * pt, LSEG * lseg);
-extern bool on_pb(Point * pt, BOX * box);
+extern bool on_pb(Point * pt, BOX *box);
extern bool on_ppath(Point * pt, PATH * path);
extern bool on_sl(LSEG * lseg, LINE * line);
-extern bool on_sb(LSEG * lseg, BOX * box);
+extern bool on_sb(LSEG * lseg, BOX *box);
extern bool inter_sl(LSEG * lseg, LINE * line);
-extern bool inter_sb(LSEG * lseg, BOX * box);
-extern bool inter_lb(LINE * line, BOX * box);
+extern bool inter_sb(LSEG * lseg, BOX *box);
+extern bool inter_lb(LINE * line, BOX *box);
/* private routines */
extern LSEG *lseg_construct(Point * pt1, Point * pt2);
/* public box routines */
extern BOX *box_in(char *str);
-extern char *box_out(BOX * box);
-extern bool box_same(BOX * box1, BOX * box2);
-extern bool box_overlap(BOX * box1, BOX * box2);
-extern bool box_overleft(BOX * box1, BOX * box2);
-extern bool box_left(BOX * box1, BOX * box2);
-extern bool box_right(BOX * box1, BOX * box2);
-extern bool box_overright(BOX * box1, BOX * box2);
-extern bool box_contained(BOX * box1, BOX * box2);
-extern bool box_contain(BOX * box1, BOX * box2);
-extern bool box_below(BOX * box1, BOX * box2);
-extern bool box_above(BOX * box1, BOX * box2);
-extern bool box_lt(BOX * box1, BOX * box2);
-extern bool box_gt(BOX * box1, BOX * box2);
-extern bool box_eq(BOX * box1, BOX * box2);
-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 Point *box_center(BOX * box);
-extern BOX *box_intersect(BOX * box1, BOX * box2);
-extern LSEG *box_diagonal(BOX * box);
+extern char *box_out(BOX *box);
+extern bool box_same(BOX *box1, BOX *box2);
+extern bool box_overlap(BOX *box1, BOX *box2);
+extern bool box_overleft(BOX *box1, BOX *box2);
+extern bool box_left(BOX *box1, BOX *box2);
+extern bool box_right(BOX *box1, BOX *box2);
+extern bool box_overright(BOX *box1, BOX *box2);
+extern bool box_contained(BOX *box1, BOX *box2);
+extern bool box_contain(BOX *box1, BOX *box2);
+extern bool box_below(BOX *box1, BOX *box2);
+extern bool box_above(BOX *box1, BOX *box2);
+extern bool box_lt(BOX *box1, BOX *box2);
+extern bool box_gt(BOX *box1, BOX *box2);
+extern bool box_eq(BOX *box1, BOX *box2);
+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 Point *box_center(BOX *box);
+extern BOX *box_intersect(BOX *box1, BOX *box2);
+extern LSEG *box_diagonal(BOX *box);
/* private routines */
-extern double box_dt(BOX * box1, BOX * box2);
+extern double box_dt(BOX *box1, BOX *box2);
extern BOX *box(Point * p1, Point * p2);
-extern BOX *box_add(BOX * box, Point * p);
-extern BOX *box_sub(BOX * box, Point * p);
-extern BOX *box_mul(BOX * box, Point * p);
-extern BOX *box_div(BOX * box, Point * p);
+extern BOX *box_add(BOX *box, Point * p);
+extern BOX *box_sub(BOX *box, Point * p);
+extern BOX *box_mul(BOX *box, Point * p);
+extern BOX *box_div(BOX *box, Point * p);
/* private line routines */
extern double *line_distance(LINE * l1, LINE * l2);
extern Point *poly_center(POLYGON * poly);
extern BOX *poly_box(POLYGON * poly);
extern PATH *poly_path(POLYGON * poly);
-extern POLYGON *box_poly(BOX * box);
+extern POLYGON *box_poly(BOX *box);
extern POLYGON *upgradepoly(POLYGON * poly);
extern POLYGON *revertpoly(POLYGON * poly);
extern double *dist_cpoly(CIRCLE * circle, POLYGON * poly);
extern Point *circle_center(CIRCLE * circle);
extern CIRCLE *circle(Point * center, float8 * radius);
-extern CIRCLE *box_circle(BOX * box);
+extern CIRCLE *box_circle(BOX *box);
extern BOX *circle_box(CIRCLE * circle);
extern CIRCLE *poly_circle(POLYGON * poly);
extern POLYGON *circle_poly(int npts, CIRCLE * circle);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: memutils.h,v 1.10 1997/09/08 02:39:50 momjian Exp $
+ * $Id: memutils.h,v 1.11 1997/09/08 20:59:22 momjian Exp $
*
* NOTES
* some of the information in this file will be moved to
StaticAllocMode, /* always "statically" allocate */
TunableAllocMode, /* allocations are "tuned" */
BoundedAllocMode /* allocations bounded to fixed usage */
-} AllocMode;
+} AllocMode;
#define DefaultAllocMode DynamicAllocMode
{
OrderedSetData setData;
/* Note: this will change in the future to support other modes */
-} AllocSetData;
+} AllocSetData;
typedef AllocSetData *AllocSet;
extern bool AllocSetContains(AllocSet set, AllocPointer pointer);
extern AllocPointer AllocSetAlloc(AllocSet set, Size size);
extern void AllocSetFree(AllocSet set, AllocPointer pointer);
-extern AllocPointer
+extern AllocPointer
AllocSetRealloc(AllocSet set, AllocPointer pointer,
Size size);
/*
- * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.11 1997/09/08 02:40:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.12 1997/09/08 20:59:27 momjian Exp $
*/
#include /* faked on sunos */
extern Point *interpt_pp(PATH * p1, PATH * p2);
extern void regress_lseg_construct(LSEG * lseg, Point * pt1, Point * pt2);
extern char overpaid(TUPLE tuple);
-extern int boxarea(BOX * box);
+extern int boxarea(BOX *box);
extern char *reverse_c16(char *string);
/*
projects / postgresql.git / commitdiff