diff options
Diffstat (limited to 'src/backend')
28 files changed, 1198 insertions, 1191 deletions
diff --git a/src/backend/access/gist/gist.c b/src/backend/access/gist/gist.c index 7c3bb452cce..1d8c25104ce 100644 --- a/src/backend/access/gist/gist.c +++ b/src/backend/access/gist/gist.c @@ -6,7 +6,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.55 2000/05/30 04:24:28 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/gist/gist.c,v 1.56 2000/06/13 07:34:27 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -47,7 +47,6 @@ static BlockNumber gistChooseSubtree(Relation r, IndexTuple itup, int level, static OffsetNumber gistchoose(Relation r, Page p, IndexTuple it, GISTSTATE *giststate); static int gistnospace(Page p, IndexTuple it); -void gistdelete(Relation r, ItemPointer tid); static IndexTuple gist_tuple_replacekey(Relation r, GISTENTRY entry, IndexTuple t); static void gistcentryinit(GISTSTATE *giststate, GISTENTRY *e, char *pr, Relation r, Page pg, OffsetNumber o, int b, bool l); @@ -60,17 +59,20 @@ static char *int_range_out(INTRANGE *r); /* ** routine to build an index. Basically calls insert over and over */ -void -gistbuild(Relation heap, - Relation index, - int natts, - AttrNumber *attnum, - IndexStrategy istrat, - uint16 pint, - Datum *params, - FuncIndexInfo *finfo, - PredInfo *predInfo) +Datum +gistbuild(PG_FUNCTION_ARGS) { + Relation heap = (Relation) PG_GETARG_POINTER(0); + Relation index = (Relation) PG_GETARG_POINTER(1); + int32 natts = PG_GETARG_INT32(2); + AttrNumber *attnum = (AttrNumber *) PG_GETARG_POINTER(3); +#ifdef NOT_USED + IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(4); + uint16 pcount = PG_GETARG_UINT16(5); + Datum *params = (Datum *) PG_GETARG_POINTER(6); +#endif + FuncIndexInfo *finfo = (FuncIndexInfo *) PG_GETARG_POINTER(7); + PredInfo *predInfo = (PredInfo *) PG_GETARG_POINTER(8); HeapScanDesc scan; AttrNumber i; HeapTuple htup; @@ -83,12 +85,10 @@ gistbuild(Relation heap, int nb, nh, ni; - #ifndef OMIT_PARTIAL_INDEX ExprContext *econtext; TupleTable tupleTable; TupleTableSlot *slot; - #endif Node *pred, *oldPred; @@ -302,6 +302,8 @@ gistbuild(Relation heap, /* be tidy */ pfree(nulls); pfree(d); + + PG_RETURN_POINTER(NULL); /* no real return value */ } /* @@ -310,9 +312,16 @@ gistbuild(Relation heap, * This is the public interface routine for tuple insertion in GiSTs. * It doesn't do any work; just locks the relation and passes the buck. */ -InsertIndexResult -gistinsert(Relation r, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation heapRel) +Datum +gistinsert(PG_FUNCTION_ARGS) { + Relation r = (Relation) PG_GETARG_POINTER(0); + Datum *datum = (Datum *) PG_GETARG_POINTER(1); + char *nulls = (char *) PG_GETARG_POINTER(2); + ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3); +#ifdef NOT_USED + Relation heapRel = (Relation) PG_GETARG_POINTER(4); +#endif InsertIndexResult res; IndexTuple itup; GISTSTATE giststate; @@ -351,7 +360,7 @@ gistinsert(Relation r, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation pfree(itup); pfree(compvec); - return res; + PG_RETURN_POINTER(res); } /* @@ -596,7 +605,9 @@ gistAdjustKeys(Relation r, /* delete old tuple */ ItemPointerSet(&oldtid, stk->gs_blk, stk->gs_child); - gistdelete(r, (ItemPointer) &oldtid); + DirectFunctionCall2(gistdelete, + PointerGetDatum(r), + PointerGetDatum(&oldtid)); /* generate and insert new tuple */ tupDesc = r->rd_att; @@ -890,7 +901,9 @@ gistintinsert(Relation r, /* remove old left pointer, insert the 2 new entries */ ItemPointerSet(<id, stk->gs_blk, stk->gs_child); - gistdelete(r, (ItemPointer) <id); + DirectFunctionCall2(gistdelete, + PointerGetDatum(r), + PointerGetDatum(<id)); gistentryinserttwo(r, stk, ltup, rtup, giststate); } @@ -1105,9 +1118,11 @@ gistfreestack(GISTSTACK *s) /* ** remove an entry from a page */ -void -gistdelete(Relation r, ItemPointer tid) +Datum +gistdelete(PG_FUNCTION_ARGS) { + Relation r = (Relation) PG_GETARG_POINTER(0); + ItemPointer tid = (ItemPointer) PG_GETARG_POINTER(1); BlockNumber blkno; OffsetNumber offnum; Buffer buf; @@ -1134,6 +1149,7 @@ gistdelete(Relation r, ItemPointer tid) WriteBuffer(buf); + PG_RETURN_POINTER(NULL); /* no real return value */ } void diff --git a/src/backend/access/gist/gistget.c b/src/backend/access/gist/gistget.c index c08a5cc2fea..f7b49430d07 100644 --- a/src/backend/access/gist/gistget.c +++ b/src/backend/access/gist/gistget.c @@ -29,21 +29,23 @@ static bool gistindex_keytest(IndexTuple tuple, TupleDesc tupdesc, Relation r, Page p, OffsetNumber offset); -RetrieveIndexResult -gistgettuple(IndexScanDesc s, ScanDirection dir) +Datum +gistgettuple(PG_FUNCTION_ARGS) { + IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); + ScanDirection dir = (ScanDirection) PG_GETARG_INT32(1); RetrieveIndexResult res; /* if we have it cached in the scan desc, just return the value */ if ((res = gistscancache(s, dir)) != (RetrieveIndexResult) NULL) - return res; + PG_RETURN_POINTER(res); /* not cached, so we'll have to do some work */ if (ItemPointerIsValid(&(s->currentItemData))) res = gistnext(s, dir); else res = gistfirst(s, dir); - return res; + PG_RETURN_POINTER(res); } static RetrieveIndexResult diff --git a/src/backend/access/gist/gistscan.c b/src/backend/access/gist/gistscan.c index 2196e897e4a..729837e8008 100644 --- a/src/backend/access/gist/gistscan.c +++ b/src/backend/access/gist/gistscan.c @@ -48,12 +48,13 @@ typedef GISTScanListData *GISTScanList; /* pointer to list of local scans on GiSTs */ static GISTScanList GISTScans = (GISTScanList) NULL; -IndexScanDesc -gistbeginscan(Relation r, - bool fromEnd, - uint16 nkeys, - ScanKey key) +Datum +gistbeginscan(PG_FUNCTION_ARGS) { + Relation r = (Relation) PG_GETARG_POINTER(0); + bool fromEnd = PG_GETARG_BOOL(1); + uint16 nkeys = PG_GETARG_UINT16(2); + ScanKey key = (ScanKey) PG_GETARG_POINTER(3); IndexScanDesc s; /* @@ -65,21 +66,18 @@ gistbeginscan(Relation r, s = RelationGetIndexScan(r, fromEnd, nkeys, key); gistregscan(s); - return s; + PG_RETURN_POINTER(s); } -void -gistrescan(IndexScanDesc s, bool fromEnd, ScanKey key) +Datum +gistrescan(PG_FUNCTION_ARGS) { + IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); + bool fromEnd = PG_GETARG_BOOL(1); + ScanKey key = (ScanKey) PG_GETARG_POINTER(2); GISTScanOpaque p; int i; - if (!IndexScanIsValid(s)) - { - elog(ERROR, "gistrescan: invalid scan."); - return; - } - /* * Clear all the pointers. */ @@ -155,11 +153,14 @@ gistrescan(IndexScanDesc s, bool fromEnd, ScanKey key) s->keyData[i].sk_func = p->giststate->consistentFn; } } + + PG_RETURN_POINTER(NULL); /* no real return value */ } -void -gistmarkpos(IndexScanDesc s) +Datum +gistmarkpos(PG_FUNCTION_ARGS) { + IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); GISTScanOpaque p; GISTSTACK *o, *n, @@ -188,11 +189,14 @@ gistmarkpos(IndexScanDesc s) gistfreestack(p->s_markstk); p->s_markstk = o; + + PG_RETURN_POINTER(NULL); /* no real return value */ } -void -gistrestrpos(IndexScanDesc s) +Datum +gistrestrpos(PG_FUNCTION_ARGS) { + IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); GISTScanOpaque p; GISTSTACK *o, *n, @@ -221,12 +225,15 @@ gistrestrpos(IndexScanDesc s) gistfreestack(p->s_stack); p->s_stack = o; + + PG_RETURN_POINTER(NULL); /* no real return value */ } -void -gistendscan(IndexScanDesc s) +Datum +gistendscan(PG_FUNCTION_ARGS) { - GISTScanOpaque p; + IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); + GISTScanOpaque p; p = (GISTScanOpaque) s->opaque; @@ -239,6 +246,8 @@ gistendscan(IndexScanDesc s) gistdropscan(s); /* XXX don't unset read lock -- two-phase locking */ + + PG_RETURN_POINTER(NULL); /* no real return value */ } static void diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c index 1e5bc15bf2f..eec339f42df 100644 --- a/src/backend/access/hash/hash.c +++ b/src/backend/access/hash/hash.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.37 2000/04/12 17:14:43 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/hash/hash.c,v 1.38 2000/06/13 07:34:28 tgl Exp $ * * NOTES * This file contains only the public interface routines. @@ -36,17 +36,20 @@ bool BuildingHash = false; * since the index won't be visible until this transaction commits * and since building is guaranteed to be single-threaded. */ -void -hashbuild(Relation heap, - Relation index, - int natts, - AttrNumber *attnum, - IndexStrategy istrat, - uint16 pcount, - Datum *params, - FuncIndexInfo *finfo, - PredInfo *predInfo) +Datum +hashbuild(PG_FUNCTION_ARGS) { + Relation heap = (Relation) PG_GETARG_POINTER(0); + Relation index = (Relation) PG_GETARG_POINTER(1); + int32 natts = PG_GETARG_INT32(2); + AttrNumber *attnum = (AttrNumber *) PG_GETARG_POINTER(3); +#ifdef NOT_USED + IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(4); + uint16 pcount = PG_GETARG_UINT16(5); + Datum *params = (Datum *) PG_GETARG_POINTER(6); +#endif + FuncIndexInfo *finfo = (FuncIndexInfo *) PG_GETARG_POINTER(7); + PredInfo *predInfo = (PredInfo *) PG_GETARG_POINTER(8); HeapScanDesc hscan; HeapTuple htup; IndexTuple itup; @@ -262,6 +265,8 @@ hashbuild(Relation heap, /* all done */ BuildingHash = false; + + PG_RETURN_POINTER(NULL); /* no real return value */ } /* @@ -271,20 +276,26 @@ hashbuild(Relation heap, * for the new tuple, put it there, and return an InsertIndexResult * to the caller. */ -InsertIndexResult -hashinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation heapRel) +Datum +hashinsert(PG_FUNCTION_ARGS) { + Relation rel = (Relation) PG_GETARG_POINTER(0); + Datum *datum = (Datum *) PG_GETARG_POINTER(1); + char *nulls = (char *) PG_GETARG_POINTER(2); + ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3); +#ifdef NOT_USED + Relation heapRel = (Relation) PG_GETARG_POINTER(4); +#endif + InsertIndexResult res; HashItem hitem; IndexTuple itup; - InsertIndexResult res; - /* generate an index tuple */ itup = index_formtuple(RelationGetDescr(rel), datum, nulls); itup->t_tid = *ht_ctid; if (itup->t_info & INDEX_NULL_MASK) - return (InsertIndexResult) NULL; + PG_RETURN_POINTER((InsertIndexResult) NULL); hitem = _hash_formitem(itup); @@ -293,16 +304,18 @@ hashinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relatio pfree(hitem); pfree(itup); - return res; + PG_RETURN_POINTER(res); } /* * hashgettuple() -- Get the next tuple in the scan. */ -char * -hashgettuple(IndexScanDesc scan, ScanDirection dir) +Datum +hashgettuple(PG_FUNCTION_ARGS) { + IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); + ScanDirection dir = (ScanDirection) PG_GETARG_INT32(1); RetrieveIndexResult res; /* @@ -316,19 +329,20 @@ hashgettuple(IndexScanDesc scan, ScanDirection dir) else res = _hash_first(scan, dir); - return (char *) res; + PG_RETURN_POINTER(res); } /* * hashbeginscan() -- start a scan on a hash index */ -char * -hashbeginscan(Relation rel, - bool fromEnd, - uint16 keysz, - ScanKey scankey) +Datum +hashbeginscan(PG_FUNCTION_ARGS) { + Relation rel = (Relation) PG_GETARG_POINTER(0); + bool fromEnd = PG_GETARG_BOOL(1); + uint16 keysz = PG_GETARG_UINT16(2); + ScanKey scankey = (ScanKey) PG_GETARG_POINTER(3); IndexScanDesc scan; HashScanOpaque so; @@ -341,15 +355,20 @@ hashbeginscan(Relation rel, /* register scan in case we change pages it's using */ _hash_regscan(scan); - return (char *) scan; + PG_RETURN_POINTER(scan); } /* * hashrescan() -- rescan an index relation */ -void -hashrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey) +Datum +hashrescan(PG_FUNCTION_ARGS) { + IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); +#ifdef NOT_USED /* XXX surely it's wrong to ignore this? */ + bool fromEnd = PG_GETARG_BOOL(1); +#endif + ScanKey scankey = (ScanKey) PG_GETARG_POINTER(2); ItemPointer iptr; HashScanOpaque so; @@ -376,15 +395,17 @@ hashrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey) scankey, scan->numberOfKeys * sizeof(ScanKeyData)); } + + PG_RETURN_POINTER(NULL); /* no real return value */ } /* * hashendscan() -- close down a scan */ -void -hashendscan(IndexScanDesc scan) +Datum +hashendscan(PG_FUNCTION_ARGS) { - + IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); ItemPointer iptr; HashScanOpaque so; @@ -411,26 +432,21 @@ hashendscan(IndexScanDesc scan) /* be tidy */ pfree(scan->opaque); + + PG_RETURN_POINTER(NULL); /* no real return value */ } /* * hashmarkpos() -- save current scan position * */ -void -hashmarkpos(IndexScanDesc scan) +Datum +hashmarkpos(PG_FUNCTION_ARGS) { + IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); ItemPointer iptr; HashScanOpaque so; - /* - * see if we ever call this code. if we do, then so_mrkbuf a useful - * element in the scan->opaque structure. if this procedure is never - * called, so_mrkbuf should be removed from the scan->opaque - * structure. - */ - elog(NOTICE, "Hashmarkpos() called."); - so = (HashScanOpaque) scan->opaque; /* release lock on old marked data, if any */ @@ -449,25 +465,20 @@ hashmarkpos(IndexScanDesc scan) HASH_READ); scan->currentMarkData = scan->currentItemData; } + + PG_RETURN_POINTER(NULL); /* no real return value */ } /* * hashrestrpos() -- restore scan to last saved position */ -void -hashrestrpos(IndexScanDesc scan) +Datum +hashrestrpos(PG_FUNCTION_ARGS) { + IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); ItemPointer iptr; HashScanOpaque so; - /* - * see if we ever call this code. if we do, then so_mrkbuf a useful - * element in the scan->opaque structure. if this procedure is never - * called, so_mrkbuf should be removed from the scan->opaque - * structure. - */ - elog(NOTICE, "Hashrestrpos() called."); - so = (HashScanOpaque) scan->opaque; /* release lock on current data, if any */ @@ -487,15 +498,22 @@ hashrestrpos(IndexScanDesc scan) scan->currentItemData = scan->currentMarkData; } + + PG_RETURN_POINTER(NULL); /* no real return value */ } /* stubs */ -void -hashdelete(Relation rel, ItemPointer tid) +Datum +hashdelete(PG_FUNCTION_ARGS) { + Relation rel = (Relation) PG_GETARG_POINTER(0); + ItemPointer tid = (ItemPointer) PG_GETARG_POINTER(1); + /* adjust any active scans that will be affected by this deletion */ _hash_adjscans(rel, tid); /* delete the data from the page */ _hash_pagedel(rel, tid); + + PG_RETURN_POINTER(NULL); /* no real return value */ } diff --git a/src/backend/access/index/indexam.c b/src/backend/access/index/indexam.c index 7f402a33e37..2d1504238de 100644 --- a/src/backend/access/index/indexam.c +++ b/src/backend/access/index/indexam.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.44 2000/05/30 04:24:32 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.45 2000/06/13 07:34:35 tgl Exp $ * * INTERFACE ROUTINES * index_open - open an index relation by relationId @@ -195,13 +195,12 @@ index_insert(Relation relation, * ---------------- */ specificResult = (InsertIndexResult) - DatumGetPointer(OidFunctionCall6(procedure, + DatumGetPointer(OidFunctionCall5(procedure, PointerGetDatum(relation), PointerGetDatum(datum), PointerGetDatum(nulls), PointerGetDatum(heap_t_ctid), - PointerGetDatum(heapRel), - PointerGetDatum(NULL))); + PointerGetDatum(heapRel))); /* must be pfree'ed */ return specificResult; diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c index 58469932e99..ccd5a265d31 100644 --- a/src/backend/access/nbtree/nbtree.c +++ b/src/backend/access/nbtree/nbtree.c @@ -12,7 +12,7 @@ * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.55 2000/05/31 00:28:14 petere Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtree.c,v 1.56 2000/06/13 07:34:38 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -42,17 +42,20 @@ static void _bt_restscan(IndexScanDesc scan); * since the index won't be visible until this transaction commits * and since building is guaranteed to be single-threaded. */ -void -btbuild(Relation heap, - Relation index, - int natts, - AttrNumber *attnum, - IndexStrategy istrat, - uint16 pcount, - Datum *params, - FuncIndexInfo *finfo, - PredInfo *predInfo) +Datum +btbuild(PG_FUNCTION_ARGS) { + Relation heap = (Relation) PG_GETARG_POINTER(0); + Relation index = (Relation) PG_GETARG_POINTER(1); + int32 natts = PG_GETARG_INT32(2); + AttrNumber *attnum = (AttrNumber *) PG_GETARG_POINTER(3); +#ifdef NOT_USED + IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(4); + uint16 pcount = PG_GETARG_UINT16(5); + Datum *params = (Datum *) PG_GETARG_POINTER(6); +#endif + FuncIndexInfo *finfo = (FuncIndexInfo *) PG_GETARG_POINTER(7); + PredInfo *predInfo = (PredInfo *) PG_GETARG_POINTER(8); HeapScanDesc hscan; HeapTuple htup; IndexTuple itup; @@ -332,6 +335,8 @@ btbuild(Relation heap, /* all done */ BuildingBtree = false; + + PG_RETURN_POINTER(NULL); /* no real return value */ } /* @@ -341,12 +346,17 @@ btbuild(Relation heap, * new tuple, put it there, set its unique OID as appropriate, and * return an InsertIndexResult to the caller. */ -InsertIndexResult -btinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation heapRel) +Datum +btinsert(PG_FUNCTION_ARGS) { + Relation rel = (Relation) PG_GETARG_POINTER(0); + Datum *datum = (Datum *) PG_GETARG_POINTER(1); + char *nulls = (char *) PG_GETARG_POINTER(2); + ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3); + Relation heapRel = (Relation) PG_GETARG_POINTER(4); + InsertIndexResult res; BTItem btitem; IndexTuple itup; - InsertIndexResult res; /* generate an index tuple */ itup = index_formtuple(RelationGetDescr(rel), datum, nulls); @@ -355,7 +365,8 @@ btinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation /* * See comments in btbuild. * - * if (itup->t_info & INDEX_NULL_MASK) return (InsertIndexResult) NULL; + * if (itup->t_info & INDEX_NULL_MASK) + * PG_RETURN_POINTER((InsertIndexResult) NULL); */ btitem = _bt_formitem(itup); @@ -366,15 +377,17 @@ btinsert(Relation rel, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation pfree(btitem); pfree(itup); - return res; + PG_RETURN_POINTER(res); } /* * btgettuple() -- Get the next tuple in the scan. */ -char * -btgettuple(IndexScanDesc scan, ScanDirection dir) +Datum +btgettuple(PG_FUNCTION_ARGS) { + IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); + ScanDirection dir = (ScanDirection) PG_GETARG_INT32(1); RetrieveIndexResult res; /* @@ -403,18 +416,23 @@ btgettuple(IndexScanDesc scan, ScanDirection dir) if (res) { ((BTScanOpaque) scan->opaque)->curHeapIptr = res->heap_iptr; - LockBuffer(((BTScanOpaque) scan->opaque)->btso_curbuf, BUFFER_LOCK_UNLOCK); + LockBuffer(((BTScanOpaque) scan->opaque)->btso_curbuf, + BUFFER_LOCK_UNLOCK); } - return (char *) res; + PG_RETURN_POINTER(res); } /* * btbeginscan() -- start a scan on a btree index */ -char * -btbeginscan(Relation rel, bool fromEnd, uint16 keysz, ScanKey scankey) +Datum +btbeginscan(PG_FUNCTION_ARGS) { + Relation rel = (Relation) PG_GETARG_POINTER(0); + bool fromEnd = PG_GETARG_BOOL(1); + uint16 keysz = PG_GETARG_UINT16(2); + ScanKey scankey = (ScanKey) PG_GETARG_POINTER(3); IndexScanDesc scan; /* get the scan */ @@ -423,15 +441,20 @@ btbeginscan(Relation rel, bool fromEnd, uint16 keysz, ScanKey scankey) /* register scan in case we change pages it's using */ _bt_regscan(scan); - return (char *) scan; + PG_RETURN_POINTER(scan); } /* * btrescan() -- rescan an index relation */ -void -btrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey) +Datum +btrescan(PG_FUNCTION_ARGS) { + IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); +#ifdef NOT_USED /* XXX surely it's wrong to ignore this? */ + bool fromEnd = PG_GETARG_BOOL(1); +#endif + ScanKey scankey = (ScanKey) PG_GETARG_POINTER(2); ItemPointer iptr; BTScanOpaque so; @@ -479,6 +502,7 @@ btrescan(IndexScanDesc scan, bool fromEnd, ScanKey scankey) so->numberOfKeys * sizeof(ScanKeyData)); } + PG_RETURN_POINTER(NULL); /* no real return value */ } void @@ -504,9 +528,10 @@ btmovescan(IndexScanDesc scan, Datum v) /* * btendscan() -- close down a scan */ -void -btendscan(IndexScanDesc scan) +Datum +btendscan(PG_FUNCTION_ARGS) { + IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); ItemPointer iptr; BTScanOpaque so; @@ -534,14 +559,17 @@ btendscan(IndexScanDesc scan) pfree(so); _bt_dropscan(scan); + + PG_RETURN_POINTER(NULL); /* no real return value */ } /* * btmarkpos() -- save current scan position */ -void -btmarkpos(IndexScanDesc scan) +Datum +btmarkpos(PG_FUNCTION_ARGS) { + IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); ItemPointer iptr; BTScanOpaque so; @@ -563,14 +591,17 @@ btmarkpos(IndexScanDesc scan) scan->currentMarkData = scan->currentItemData; so->mrkHeapIptr = so->curHeapIptr; } + + PG_RETURN_POINTER(NULL); /* no real return value */ } /* * btrestrpos() -- restore scan to last saved position */ -void -btrestrpos(IndexScanDesc scan) +Datum +btrestrpos(PG_FUNCTION_ARGS) { + IndexScanDesc scan = (IndexScanDesc) PG_GETARG_POINTER(0); ItemPointer iptr; BTScanOpaque so; @@ -593,17 +624,24 @@ btrestrpos(IndexScanDesc scan) scan->currentItemData = scan->currentMarkData; so->curHeapIptr = so->mrkHeapIptr; } + + PG_RETURN_POINTER(NULL); /* no real return value */ } /* stubs */ -void -btdelete(Relation rel, ItemPointer tid) +Datum +btdelete(PG_FUNCTION_ARGS) { + Relation rel = (Relation) PG_GETARG_POINTER(0); + ItemPointer tid = (ItemPointer) PG_GETARG_POINTER(1); + /* adjust any active scans that will be affected by this deletion */ _bt_adjscans(rel, tid); /* delete the data from the page */ _bt_pagedel(rel, tid); + + PG_RETURN_POINTER(NULL); /* no real return value */ } static void diff --git a/src/backend/access/rtree/rtget.c b/src/backend/access/rtree/rtget.c index 5b99e807f6f..8854163def9 100644 --- a/src/backend/access/rtree/rtget.c +++ b/src/backend/access/rtree/rtget.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtget.c,v 1.20 2000/01/26 05:56:00 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtget.c,v 1.21 2000/06/13 07:34:48 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -28,21 +28,23 @@ static RetrieveIndexResult rtnext(IndexScanDesc s, ScanDirection dir); static ItemPointer rtheapptr(Relation r, ItemPointer itemp); -RetrieveIndexResult -rtgettuple(IndexScanDesc s, ScanDirection dir) +Datum +rtgettuple(PG_FUNCTION_ARGS) { + IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); + ScanDirection dir = (ScanDirection) PG_GETARG_INT32(1); RetrieveIndexResult res; /* if we have it cached in the scan desc, just return the value */ if ((res = rtscancache(s, dir)) != (RetrieveIndexResult) NULL) - return res; + PG_RETURN_POINTER(res); /* not cached, so we'll have to do some work */ if (ItemPointerIsValid(&(s->currentItemData))) res = rtnext(s, dir); else res = rtfirst(s, dir); - return res; + PG_RETURN_POINTER(res); } static RetrieveIndexResult diff --git a/src/backend/access/rtree/rtproc.c b/src/backend/access/rtree/rtproc.c index 6b571c7d4af..df410045c2d 100644 --- a/src/backend/access/rtree/rtproc.c +++ b/src/backend/access/rtree/rtproc.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtproc.c,v 1.25 2000/01/26 05:56:00 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtproc.c,v 1.26 2000/06/13 07:34:49 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -102,13 +102,15 @@ rt_poly_union(POLYGON *a, POLYGON *b) return p; } -void -rt_poly_size(POLYGON *a, float *size) +Datum +rt_poly_size(PG_FUNCTION_ARGS) { + POLYGON *a = PG_GETARG_POLYGON_P(0); + /* NB: size is an output argument */ + float *size = (float *) PG_GETARG_POINTER(1); double xdim, ydim; - size = (float *) palloc(sizeof(float)); if (a == (POLYGON *) NULL || a->boundbox.high.x <= a->boundbox.low.x || a->boundbox.high.y <= a->boundbox.low.y) @@ -121,7 +123,7 @@ rt_poly_size(POLYGON *a, float *size) *size = (float) (xdim * ydim); } - return; + PG_RETURN_POINTER(NULL); /* no real return value */ } POLYGON * diff --git a/src/backend/access/rtree/rtree.c b/src/backend/access/rtree/rtree.c index 020f6bdff82..358d307d0b5 100644 --- a/src/backend/access/rtree/rtree.c +++ b/src/backend/access/rtree/rtree.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.47 2000/05/30 04:24:34 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.48 2000/06/13 07:34:49 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -59,17 +59,20 @@ static int nospace(Page p, IndexTuple it); static void initRtstate(RTSTATE *rtstate, Relation index); -void -rtbuild(Relation heap, - Relation index, - int natts, - AttrNumber *attnum, - IndexStrategy istrat, - uint16 pcount, - Datum *params, - FuncIndexInfo *finfo, - PredInfo *predInfo) +Datum +rtbuild(PG_FUNCTION_ARGS) { + Relation heap = (Relation) PG_GETARG_POINTER(0); + Relation index = (Relation) PG_GETARG_POINTER(1); + int32 natts = PG_GETARG_INT32(2); + AttrNumber *attnum = (AttrNumber *) PG_GETARG_POINTER(3); +#ifdef NOT_USED + IndexStrategy istrat = (IndexStrategy) PG_GETARG_POINTER(4); + uint16 pcount = PG_GETARG_UINT16(5); + Datum *params = (Datum *) PG_GETARG_POINTER(6); +#endif + FuncIndexInfo *finfo = (FuncIndexInfo *) PG_GETARG_POINTER(7); + PredInfo *predInfo = (PredInfo *) PG_GETARG_POINTER(8); HeapScanDesc scan; AttrNumber i; HeapTuple htup; @@ -277,6 +280,8 @@ rtbuild(Relation heap, /* be tidy */ pfree(nulls); pfree(d); + + PG_RETURN_POINTER(NULL); /* no real return value */ } /* @@ -285,9 +290,16 @@ rtbuild(Relation heap, * This is the public interface routine for tuple insertion in rtrees. * It doesn't do any work; just locks the relation and passes the buck. */ -InsertIndexResult -rtinsert(Relation r, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation heapRel) +Datum +rtinsert(PG_FUNCTION_ARGS) { + Relation r = (Relation) PG_GETARG_POINTER(0); + Datum *datum = (Datum *) PG_GETARG_POINTER(1); + char *nulls = (char *) PG_GETARG_POINTER(2); + ItemPointer ht_ctid = (ItemPointer) PG_GETARG_POINTER(3); +#ifdef NOT_USED + Relation heapRel = (Relation) PG_GETARG_POINTER(4); +#endif InsertIndexResult res; IndexTuple itup; RTSTATE rtState; @@ -305,7 +317,7 @@ rtinsert(Relation r, Datum *datum, char *nulls, ItemPointer ht_ctid, Relation he res = rtdoinsert(r, itup, &rtState); - return res; + PG_RETURN_POINTER(res); } static InsertIndexResult @@ -982,9 +994,11 @@ freestack(RTSTACK *s) } } -char * -rtdelete(Relation r, ItemPointer tid) +Datum +rtdelete(PG_FUNCTION_ARGS) { + Relation r = (Relation) PG_GETARG_POINTER(0); + ItemPointer tid = (ItemPointer) PG_GETARG_POINTER(1); BlockNumber blkno; OffsetNumber offnum; Buffer buf; @@ -1011,7 +1025,7 @@ rtdelete(Relation r, ItemPointer tid) WriteBuffer(buf); - return (char *) NULL; + PG_RETURN_POINTER(NULL); /* no real return value */ } static void diff --git a/src/backend/access/rtree/rtscan.c b/src/backend/access/rtree/rtscan.c index 71e2acf5f88..97a71a00588 100644 --- a/src/backend/access/rtree/rtscan.c +++ b/src/backend/access/rtree/rtscan.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.32 2000/04/12 17:14:51 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtscan.c,v 1.33 2000/06/13 07:34:49 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -51,12 +51,13 @@ typedef RTScanListData *RTScanList; /* pointer to list of local scans on rtrees */ static RTScanList RTScans = (RTScanList) NULL; -IndexScanDesc -rtbeginscan(Relation r, - bool fromEnd, - uint16 nkeys, - ScanKey key) +Datum +rtbeginscan(PG_FUNCTION_ARGS) { + Relation r = (Relation) PG_GETARG_POINTER(0); + bool fromEnd = PG_GETARG_BOOL(1); + uint16 nkeys = PG_GETARG_UINT16(2); + ScanKey key = (ScanKey) PG_GETARG_POINTER(3); IndexScanDesc s; /* @@ -68,22 +69,19 @@ rtbeginscan(Relation r, s = RelationGetIndexScan(r, fromEnd, nkeys, key); rtregscan(s); - return s; + PG_RETURN_POINTER(s); } -void -rtrescan(IndexScanDesc s, bool fromEnd, ScanKey key) +Datum +rtrescan(PG_FUNCTION_ARGS) { + IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); + bool fromEnd = PG_GETARG_BOOL(1); + ScanKey key = (ScanKey) PG_GETARG_POINTER(2); RTreeScanOpaque p; RegProcedure internal_proc; int i; - if (!IndexScanIsValid(s)) - { - elog(ERROR, "rtrescan: invalid scan."); - return; - } - /* * Clear all the pointers. */ @@ -157,11 +155,14 @@ rtrescan(IndexScanDesc s, bool fromEnd, ScanKey key) } } } + + PG_RETURN_POINTER(NULL); /* no real return value */ } -void -rtmarkpos(IndexScanDesc s) +Datum +rtmarkpos(PG_FUNCTION_ARGS) { + IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); RTreeScanOpaque p; RTSTACK *o, *n, @@ -190,11 +191,14 @@ rtmarkpos(IndexScanDesc s) freestack(p->s_markstk); p->s_markstk = o; + + PG_RETURN_POINTER(NULL); /* no real return value */ } -void -rtrestrpos(IndexScanDesc s) +Datum +rtrestrpos(PG_FUNCTION_ARGS) { + IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); RTreeScanOpaque p; RTSTACK *o, *n, @@ -223,11 +227,14 @@ rtrestrpos(IndexScanDesc s) freestack(p->s_stack); p->s_stack = o; + + PG_RETURN_POINTER(NULL); /* no real return value */ } -void -rtendscan(IndexScanDesc s) +Datum +rtendscan(PG_FUNCTION_ARGS) { + IndexScanDesc s = (IndexScanDesc) PG_GETARG_POINTER(0); RTreeScanOpaque p; p = (RTreeScanOpaque) s->opaque; @@ -241,6 +248,8 @@ rtendscan(IndexScanDesc s) rtdropscan(s); /* XXX don't unset read lock -- two-phase locking */ + + PG_RETURN_POINTER(NULL); /* no real return value */ } static void diff --git a/src/backend/catalog/pg_type.c b/src/backend/catalog/pg_type.c index 9386079997e..bf706d5146c 100644 --- a/src/backend/catalog/pg_type.c +++ b/src/backend/catalog/pg_type.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.51 2000/05/28 17:55:54 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.52 2000/06/13 07:34:52 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -409,8 +409,8 @@ TypeCreate(char *typeName, /* * For array types, the input procedures may take 3 args (data * value, element OID, atttypmod); the pg_proc argtype - * signature is 0,0,INT4OID. The output procedures may take 2 - * args (data value, element OID). + * signature is 0,OIDOID,INT4OID. The output procedures may + * take 2 args (data value, element OID). */ if (OidIsValid(elementObjectId)) { @@ -420,11 +420,13 @@ TypeCreate(char *typeName, { /* output proc */ nargs = 2; + argList[1] = OIDOID; } else { /* input proc */ nargs = 3; + argList[1] = OIDOID; argList[2] = INT4OID; } tup = SearchSysCacheTuple(PROCNAME, diff --git a/src/backend/executor/execQual.c b/src/backend/executor/execQual.c index a53957c4f4a..06b2b49ca88 100644 --- a/src/backend/executor/execQual.c +++ b/src/backend/executor/execQual.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.70 2000/05/28 17:55:55 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.71 2000/06/13 07:34:58 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -105,6 +105,7 @@ ExecEvalArrayRef(ArrayRef *arrayRef, econtext, isNull, isDone); + /* If refexpr yields NULL, result is always NULL, for now anyway */ if (*isNull) return (Datum) NULL; } @@ -132,6 +133,7 @@ ExecEvalArrayRef(ArrayRef *arrayRef, econtext, isNull, &dummy); + /* If any index expr yields NULL, result is NULL */ if (*isNull) return (Datum) NULL; } @@ -148,6 +150,7 @@ ExecEvalArrayRef(ArrayRef *arrayRef, econtext, isNull, &dummy); + /* If any index expr yields NULL, result is NULL */ if (*isNull) return (Datum) NULL; } @@ -165,7 +168,7 @@ ExecEvalArrayRef(ArrayRef *arrayRef, econtext, isNull, &dummy); - + /* For now, can't cope with inserting NULL into an array */ if (*isNull) return (Datum) NULL; @@ -175,30 +178,43 @@ ExecEvalArrayRef(ArrayRef *arrayRef, if (array_scanner == NULL) return sourceData; /* XXX do something else? */ + /* + * XXX shouldn't we copy the array value before modifying it?? + * + * Or perhaps these array routines should deliver a modified copy + * instead of changing the source in-place. + */ if (lIndex == NULL) - return (Datum) array_set(array_scanner, i, upper.indx, - (char *) sourceData, - arrayRef->refelembyval, - arrayRef->refelemlength, - arrayRef->refattrlength, isNull); - return (Datum) array_assgn(array_scanner, i, upper.indx, - lower.indx, - (ArrayType *) sourceData, - arrayRef->refelembyval, - arrayRef->refelemlength, isNull); + return PointerGetDatum(array_set(array_scanner, i, + upper.indx, + sourceData, + arrayRef->refelembyval, + arrayRef->refelemlength, + arrayRef->refattrlength, + isNull)); + return PointerGetDatum(array_assgn(array_scanner, i, + upper.indx, lower.indx, + (ArrayType *) DatumGetPointer(sourceData), + arrayRef->refelembyval, + arrayRef->refelemlength, + isNull)); } execConstByVal = arrayRef->refelembyval; execConstLen = arrayRef->refelemlength; if (lIndex == NULL) - return (Datum) array_ref(array_scanner, i, upper.indx, - arrayRef->refelembyval, - arrayRef->refelemlength, - arrayRef->refattrlength, isNull); - return (Datum) array_clip(array_scanner, i, upper.indx, lower.indx, - arrayRef->refelembyval, - arrayRef->refelemlength, isNull); + return array_ref(array_scanner, i, + upper.indx, + arrayRef->refelembyval, + arrayRef->refelemlength, + arrayRef->refattrlength, + isNull); + return PointerGetDatum(array_clip(array_scanner, i, + upper.indx, lower.indx, + arrayRef->refelembyval, + arrayRef->refelemlength, + isNull)); } diff --git a/src/backend/parser/parse_node.c b/src/backend/parser/parse_node.c index dcec30b1589..94293859dba 100644 --- a/src/backend/parser/parse_node.c +++ b/src/backend/parser/parse_node.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.40 2000/05/28 17:56:00 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.41 2000/06/13 07:35:01 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -450,7 +450,10 @@ make_const(Value *value) } else { - val = PointerGetDatum(numeric_in(strVal(value), 0, -1)); + val = DirectFunctionCall3(numeric_in, + CStringGetDatum(strVal(value)), + ObjectIdGetDatum(InvalidOid), + Int32GetDatum(-1)); typeid = NUMERICOID; typelen = -1; /* variable len */ diff --git a/src/backend/utils/adt/arrayfuncs.c b/src/backend/utils/adt/arrayfuncs.c index b721728919b..d54a6847bd2 100644 --- a/src/backend/utils/adt/arrayfuncs.c +++ b/src/backend/utils/adt/arrayfuncs.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.56 2000/06/09 01:11:08 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.57 2000/06/13 07:35:03 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -68,7 +68,7 @@ static void _LOArrayRange(int *st, int *endp, int bsize, int srcfd, 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); -static int ArrayCastAndSet(char *src, bool typbyval, int typlen, char *dest); +static int ArrayCastAndSet(Datum src, bool typbyval, int typlen, char *dest); static int SanityCheckInput(int ndim, int n, int *dim, int *lb, int *indx); static int array_read(char *destptr, int eltsize, int nitems, char *srcptr); static char *array_seek(char *ptr, int eltsize, int nitems); @@ -76,16 +76,17 @@ static char *array_seek(char *ptr, int eltsize, int nitems); /*--------------------------------------------------------------------- * array_in : * converts an array from the external format in "string" to - * it internal format. + * its internal format. * return value : * the internal representation of the input array *-------------------------------------------------------------------- */ -char * -array_in(char *string, /* input array in external form */ - Oid element_type, /* type OID of an array element */ - int32 typmod) +Datum +array_in(PG_FUNCTION_ARGS) { + char *string = PG_GETARG_CSTRING(0); /* external form */ + Oid element_type = PG_GETARG_OID(1); /* type of an array element */ + int32 typmod = PG_GETARG_INT32(2); /* typmod for array elements */ int typlen; bool typbyval, done; @@ -101,7 +102,7 @@ array_in(char *string, /* input array in external form */ nitems; int32 nbytes; char *dataPtr; - ArrayType *retval = NULL; + ArrayType *retval; int ndim, dim[MAXDIM], lBound[MAXDIM]; @@ -183,11 +184,10 @@ array_in(char *string, /* input array in external form */ nitems = getNitems(ndim, dim); if (nitems == 0) { - char *emptyArray = palloc(sizeof(ArrayType)); - - MemSet(emptyArray, 0, sizeof(ArrayType)); - *(int32 *) emptyArray = sizeof(ArrayType); - return emptyArray; + retval = (ArrayType *) palloc(sizeof(ArrayType)); + MemSet(retval, 0, sizeof(ArrayType)); + *(int32 *) retval = sizeof(ArrayType); + return PointerGetDatum(retval); } if (*p == '{') @@ -235,9 +235,10 @@ array_in(char *string, /* input array in external form */ memmove(ARR_DATA_PTR(retval), dataPtr, bytes); #endif elog(ERROR, "large object arrays not supported"); + PG_RETURN_NULL(); } pfree(string_save); - return (char *) retval; + return PointerGetDatum(retval); } /*----------------------------------------------------------------------------- @@ -578,7 +579,7 @@ _CopyArrayEls(char **values, { int inc; - inc = ArrayCastAndSet(values[i], typbyval, typlen, p); + inc = ArrayCastAndSet((Datum) values[i], typbyval, typlen, p); p += inc; if (!typbyval) pfree(values[i]); @@ -592,9 +593,11 @@ _CopyArrayEls(char **values, * containing the array in its external format. *------------------------------------------------------------------------- */ -char * -array_out(ArrayType *v, Oid element_type) +Datum +array_out(PG_FUNCTION_ARGS) { + ArrayType *v = (ArrayType *) PG_GETARG_VARLENA_P(0); + Oid element_type = PG_GETARG_OID(1); int typlen; bool typbyval; char typdelim; @@ -602,7 +605,6 @@ array_out(ArrayType *v, Oid element_type) typelem; FmgrInfo outputproc; char typalign; - char *p, *tmp, *retval, @@ -617,30 +619,31 @@ array_out(ArrayType *v, Oid element_type) l, #endif indx[MAXDIM]; - bool dummy_bool; int ndim, *dim; if (v == (ArrayType *) NULL) - return (char *) NULL; + PG_RETURN_CSTRING((char *) NULL); if (ARR_IS_LO(v) == true) { - char *p, - *save_p; - int nbytes; + text *p; + int plen, + nbytes; - /* get a wide string to print to */ - p = array_dims(v, &dummy_bool); - nbytes = strlen(ARR_DATA_PTR(v)) + VARHDRSZ + *(int *) p; + p = (text *) DatumGetPointer(DirectFunctionCall1(array_dims, + PointerGetDatum(v))); + plen = VARSIZE(p) - VARHDRSZ; - save_p = (char *) palloc(nbytes); + /* get a wide string to print to */ + nbytes = strlen(ARR_DATA_PTR(v)) + strlen(ASSGN) + plen + 1; + retval = (char *) palloc(nbytes); - strcpy(save_p, p + sizeof(int)); - strcat(save_p, ASSGN); - strcat(save_p, ARR_DATA_PTR(v)); + memcpy(retval, VARDATA(p), plen); + strcpy(retval + plen, ASSGN); + strcat(retval, ARR_DATA_PTR(v)); pfree(p); - return save_p; + PG_RETURN_CSTRING(retval); } system_cache_lookup(element_type, false, &typlen, &typbyval, @@ -653,12 +656,11 @@ array_out(ArrayType *v, Oid element_type) if (nitems == 0) { - char *emptyArray = palloc(3); - - emptyArray[0] = '{'; - emptyArray[1] = '}'; - emptyArray[2] = '\0'; - return emptyArray; + retval = (char *) palloc(3); + retval[0] = '{'; + retval[1] = '}'; + retval[2] = '\0'; + PG_RETURN_CSTRING(retval); } p = ARR_DATA_PTR(v); @@ -776,58 +778,61 @@ array_out(ArrayType *v, Oid element_type) } while (j != -1); pfree(values); - return retval; + PG_RETURN_CSTRING(retval); } /*----------------------------------------------------------------------------- * array_dims : - * returns the dimension of the array pointed to by "v" + * returns the dimensions of the array pointed to by "v", as a "text" *---------------------------------------------------------------------------- */ -char * -array_dims(ArrayType *v, bool *isNull) +Datum +array_dims(PG_FUNCTION_ARGS) { - char *p, - *save_p; + ArrayType *v = (ArrayType *) PG_GETARG_VARLENA_P(0); + text *result; + char *p; int nbytes, i; int *dimv, *lb; - if (v == (ArrayType *) NULL) - RETURN_NULL; - nbytes = ARR_NDIM(v) * 33; - + nbytes = ARR_NDIM(v) * 33 + 1; /* * 33 since we assume 15 digits per number + ':' +'[]' + * + * +1 allows for temp trailing null */ - save_p = p = (char *) palloc(nbytes + VARHDRSZ); - MemSet(save_p, 0, nbytes + VARHDRSZ); + + result = (text *) palloc(nbytes + VARHDRSZ); + MemSet(result, 0, nbytes + VARHDRSZ); + p = VARDATA(result); + dimv = ARR_DIMS(v); lb = ARR_LBOUND(v); - p += VARHDRSZ; + for (i = 0; i < ARR_NDIM(v); i++) { sprintf(p, "[%d:%d]", lb[i], dimv[i] + lb[i] - 1); p += strlen(p); } - nbytes = strlen(save_p + VARHDRSZ) + VARHDRSZ; - memmove(save_p, &nbytes, VARHDRSZ); - return save_p; + VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ; + + PG_RETURN_TEXT_P(result); } /*--------------------------------------------------------------------------- * array_ref : - * This routing takes an array pointer and an index array and returns + * This routine takes an array pointer and an index array and returns * a pointer to the referred element if element is passed by * reference otherwise returns the value of the referred element. *--------------------------------------------------------------------------- */ Datum array_ref(ArrayType *array, - int n, + int nSubscripts, int *indx, - int reftype, + bool elmbyval, int elmlen, int arraylen, bool *isNull) @@ -839,10 +844,11 @@ array_ref(ArrayType *array, offset, nbytes; struct varlena *v = NULL; - char *retval = NULL; + Datum result; + char *retval; if (array == (ArrayType *) NULL) - RETURN_NULL; + RETURN_NULL(Datum); if (arraylen > 0) { @@ -852,17 +858,17 @@ array_ref(ArrayType *array, if (indx[0] * elmlen > arraylen) elog(ERROR, "array_ref: array bound exceeded"); retval = (char *) array + indx[0] * elmlen; - return _ArrayCast(retval, reftype, elmlen); + return _ArrayCast(retval, elmbyval, elmlen); } dim = ARR_DIMS(array); lb = ARR_LBOUND(array); ndim = ARR_NDIM(array); nbytes = (*(int32 *) array) - ARR_OVERHEAD(ndim); - if (!SanityCheckInput(ndim, n, dim, lb, indx)) - RETURN_NULL; + if (!SanityCheckInput(ndim, nSubscripts, dim, lb, indx)) + RETURN_NULL(Datum); - offset = GetOffset(n, dim, lb, indx); + offset = GetOffset(nSubscripts, dim, lb, indx); if (ARR_IS_LO(array)) { @@ -874,7 +880,7 @@ array_ref(ArrayType *array, lo_name = (char *) ARR_DATA_PTR(array); #ifdef LOARRAY if ((fd = LOopen(lo_name, ARR_IS_INV(array) ? INV_READ : O_RDONLY)) < 0) - RETURN_NULL; + RETURN_NULL(Datum); #endif if (ARR_IS_CHUNKED(array)) v = _ReadChunkArray1El(indx, elmlen, fd, array, isNull); @@ -884,7 +890,7 @@ array_ref(ArrayType *array, Int32GetDatum(fd), Int32GetDatum(offset), Int32GetDatum(SEEK_SET))) < 0) - RETURN_NULL; + RETURN_NULL(Datum); #ifdef LOARRAY v = (struct varlena *) DatumGetPointer(DirectFunctionCall2(loread, @@ -893,20 +899,20 @@ array_ref(ArrayType *array, #endif } if (*isNull) - RETURN_NULL; + RETURN_NULL(Datum); if (VARSIZE(v) - VARHDRSZ < elmlen) - RETURN_NULL; + RETURN_NULL(Datum); DirectFunctionCall1(lo_close, Int32GetDatum(fd)); - retval = (char *) _ArrayCast((char *) VARDATA(v), reftype, elmlen); - if (reftype == 0) + result = _ArrayCast((char *) VARDATA(v), elmbyval, elmlen); + if (! elmbyval) { /* not by value */ char *tempdata = palloc(elmlen); - memmove(tempdata, retval, elmlen); - retval = tempdata; + memmove(tempdata, DatumGetPointer(result), elmlen); + result = PointerGetDatum(tempdata); } pfree(v); - return (Datum) retval; + return result; } if (elmlen > 0) @@ -914,32 +920,25 @@ array_ref(ArrayType *array, offset = offset * elmlen; /* off the end of the array */ if (nbytes - offset < 1) - RETURN_NULL; + RETURN_NULL(Datum); retval = ARR_DATA_PTR(array) + offset; - return _ArrayCast(retval, reftype, elmlen); + return _ArrayCast(retval, elmbyval, elmlen); } else { - bool done = false; - char *temp; int bytes = nbytes; - temp = ARR_DATA_PTR(array); + retval = ARR_DATA_PTR(array); i = 0; - while (bytes > 0 && !done) + while (bytes > 0) { if (i == offset) - { - retval = temp; - done = true; - } - bytes -= INTALIGN(*(int32 *) temp); - temp += INTALIGN(*(int32 *) temp); + return PointerGetDatum(retval); + bytes -= INTALIGN(*(int32 *) retval); + retval += INTALIGN(*(int32 *) retval); i++; } - if (!done) - RETURN_NULL; - return (Datum) retval; + RETURN_NULL(Datum); } } @@ -950,13 +949,13 @@ array_ref(ArrayType *array, * and returns a pointer to it. *----------------------------------------------------------------------------- */ -Datum +ArrayType * array_clip(ArrayType *array, - int n, + int nSubscripts, int *upperIndx, int *lowerIndx, - int reftype, - int len, + bool elmbyval, + int elmlen, bool *isNull) { int i, @@ -970,22 +969,20 @@ array_clip(ArrayType *array, /* timer_start(); */ if (array == (ArrayType *) NULL) - RETURN_NULL; + RETURN_NULL(ArrayType *); dim = ARR_DIMS(array); lb = ARR_LBOUND(array); ndim = ARR_NDIM(array); nbytes = (*(int32 *) array) - ARR_OVERHEAD(ndim); - if (!SanityCheckInput(ndim, n, dim, lb, upperIndx)) - RETURN_NULL; + if (!SanityCheckInput(ndim, nSubscripts, dim, lb, upperIndx) || + !SanityCheckInput(ndim, nSubscripts, dim, lb, lowerIndx)) + RETURN_NULL(ArrayType *); - if (!SanityCheckInput(ndim, n, dim, lb, lowerIndx)) - RETURN_NULL; - - for (i = 0; i < n; i++) + for (i = 0; i < nSubscripts; i++) if (lowerIndx[i] > upperIndx[i]) elog(ERROR, "lowerIndex cannot be larger than upperIndx"); - mda_get_range(n, span, lowerIndx, upperIndx); + mda_get_range(nSubscripts, span, lowerIndx, upperIndx); if (ARR_IS_LO(array)) { @@ -999,23 +996,23 @@ array_clip(ArrayType *array, isDestLO = true, rsize; - if (len < 0) - elog(ERROR, "array_clip: array of variable length objects not supported"); + if (elmlen < 0) + elog(ERROR, "array_clip: array of variable length objects not implemented"); #ifdef LOARRAY lo_name = (char *) ARR_DATA_PTR(array); if ((fd = LOopen(lo_name, ARR_IS_INV(array) ? INV_READ : O_RDONLY)) < 0) - RETURN_NULL; + RETURN_NULL(ArrayType *); newname = _array_newLO(&newfd, Unix); #endif - bytes = strlen(newname) + 1 + ARR_OVERHEAD(n); + bytes = strlen(newname) + 1 + ARR_OVERHEAD(nSubscripts); newArr = (ArrayType *) palloc(bytes); memmove(newArr, array, sizeof(ArrayType)); memmove(newArr, &bytes, sizeof(int)); - memmove(ARR_DIMS(newArr), span, n * sizeof(int)); - memmove(ARR_LBOUND(newArr), lowerIndx, n * sizeof(int)); + memmove(ARR_DIMS(newArr), span, nSubscripts * sizeof(int)); + memmove(ARR_LBOUND(newArr), lowerIndx, nSubscripts * sizeof(int)); strcpy(ARR_DATA_PTR(newArr), newname); - rsize = compute_size(lowerIndx, upperIndx, n, len); + rsize = compute_size(lowerIndx, upperIndx, nSubscripts, elmlen); if (rsize < MAX_BUFF_SIZE) { char *buff; @@ -1026,12 +1023,12 @@ array_clip(ArrayType *array, isDestLO = false; if (ARR_IS_CHUNKED(array)) { - _ReadChunkArray(lowerIndx, upperIndx, len, fd, &(buff[VARHDRSZ]), + _ReadChunkArray(lowerIndx, upperIndx, elmlen, fd, &(buff[VARHDRSZ]), array, 0, isNull); } else { - _ReadArray(lowerIndx, upperIndx, len, fd, (int) &(buff[VARHDRSZ]), + _ReadArray(lowerIndx, upperIndx, elmlen, fd, (int) &(buff[VARHDRSZ]), array, 0, isNull); } @@ -1048,11 +1045,11 @@ array_clip(ArrayType *array, { if (ARR_IS_CHUNKED(array)) { - _ReadChunkArray(lowerIndx, upperIndx, len, fd, (char *) newfd, array, + _ReadChunkArray(lowerIndx, upperIndx, elmlen, fd, (char *) newfd, array, 1, isNull); } else - _ReadArray(lowerIndx, upperIndx, len, fd, newfd, array, 1, isNull); + _ReadArray(lowerIndx, upperIndx, elmlen, fd, newfd, array, 1, isNull); } #ifdef LOARRAY LOclose(fd); @@ -1064,42 +1061,42 @@ array_clip(ArrayType *array, newArr = NULL; } /* timer_end(); */ - return (Datum) newArr; + return newArr; } - if (len > 0) + if (elmlen > 0) { - bytes = getNitems(n, span); - bytes = bytes * len + ARR_OVERHEAD(n); + bytes = getNitems(nSubscripts, span); + bytes = bytes * elmlen + ARR_OVERHEAD(nSubscripts); } else { bytes = _ArrayClipCount(lowerIndx, upperIndx, array); - bytes += ARR_OVERHEAD(n); + bytes += ARR_OVERHEAD(nSubscripts); } newArr = (ArrayType *) palloc(bytes); memmove(newArr, array, sizeof(ArrayType)); memmove(newArr, &bytes, sizeof(int)); - memmove(ARR_DIMS(newArr), span, n * sizeof(int)); - memmove(ARR_LBOUND(newArr), lowerIndx, n * sizeof(int)); - _ArrayRange(lowerIndx, upperIndx, len, ARR_DATA_PTR(newArr), array, 1); - return (Datum) newArr; + memmove(ARR_DIMS(newArr), span, nSubscripts * sizeof(int)); + memmove(ARR_LBOUND(newArr), lowerIndx, nSubscripts * sizeof(int)); + _ArrayRange(lowerIndx, upperIndx, elmlen, ARR_DATA_PTR(newArr), array, 1); + return newArr; } /*----------------------------------------------------------------------------- * array_set : - * This routine sets the value of an array location (specified by an index array) - * to a new value specified by "dataPtr". + * This routine sets the value of an array location (specified by + * an index array) to a new value specified by "dataValue". * result : * returns a pointer to the modified array. *----------------------------------------------------------------------------- */ -char * +ArrayType * array_set(ArrayType *array, - int n, + int nSubscripts, int *indx, - char *dataPtr, - int reftype, + Datum dataValue, + bool elmbyval, int elmlen, int arraylen, bool *isNull) @@ -1112,7 +1109,7 @@ array_set(ArrayType *array, char *pos; if (array == (ArrayType *) NULL) - RETURN_NULL; + RETURN_NULL(ArrayType *); if (arraylen > 0) { @@ -1122,20 +1119,20 @@ array_set(ArrayType *array, if (indx[0] * elmlen > arraylen) elog(ERROR, "array_ref: array bound exceeded"); pos = (char *) array + indx[0] * elmlen; - ArrayCastAndSet(dataPtr, (bool) reftype, elmlen, pos); - return (char *) array; + ArrayCastAndSet(dataValue, elmbyval, elmlen, pos); + return array; } dim = ARR_DIMS(array); lb = ARR_LBOUND(array); ndim = ARR_NDIM(array); nbytes = (*(int32 *) array) - ARR_OVERHEAD(ndim); - if (!SanityCheckInput(ndim, n, dim, lb, indx)) + if (!SanityCheckInput(ndim, nSubscripts, dim, lb, indx)) { elog(ERROR, "array_set: array bound exceeded"); - return (char *) array; + return array; } - offset = GetOffset(n, dim, lb, indx); + offset = GetOffset(nSubscripts, dim, lb, indx); if (ARR_IS_LO(array)) { @@ -1149,35 +1146,33 @@ array_set(ArrayType *array, lo_name = ARR_DATA_PTR(array); if ((fd = LOopen(lo_name, ARR_IS_INV(array) ? INV_WRITE : O_WRONLY)) < 0) - return (char *) array; + return array; #endif if (DatumGetInt32(DirectFunctionCall3(lo_lseek, Int32GetDatum(fd), Int32GetDatum(offset), Int32GetDatum(SEEK_SET))) < 0) - return (char *) array; + return array; v = (struct varlena *) palloc(elmlen + VARHDRSZ); VARSIZE(v) = elmlen + VARHDRSZ; - ArrayCastAndSet(dataPtr, (bool) reftype, elmlen, VARDATA(v)); + ArrayCastAndSet(dataValue, elmbyval, elmlen, VARDATA(v)); #ifdef LOARRAY - n = DatumGetInt32(DirectFunctionCall2(lowrite, + if (DatumGetInt32(DirectFunctionCall2(lowrite, Int32GetDatum(fd), - PointerGetDatum(v))); + PointerGetDatum(v))) + != elmlen) + RETURN_NULL(ArrayType *); #endif - - /* - * if (n < VARSIZE(v) - VARHDRSZ) RETURN_NULL; - */ pfree(v); DirectFunctionCall1(lo_close, Int32GetDatum(fd)); - return (char *) array; + return array; } if (elmlen > 0) { offset = offset * elmlen; /* off the end of the array */ if (nbytes - offset < 1) - return (char *) array; + return array; pos = ARR_DATA_PTR(array) + offset; } else @@ -1194,18 +1189,18 @@ array_set(ArrayType *array, elt_ptr = array_seek(ARR_DATA_PTR(array), -1, offset); oldlen = INTALIGN(*(int32 *) elt_ptr); - newlen = INTALIGN(*(int32 *) dataPtr); + newlen = INTALIGN(*(int32 *) DatumGetPointer(dataValue)); if (oldlen == newlen) { /* new element with same size, overwrite old data */ - ArrayCastAndSet(dataPtr, (bool) reftype, elmlen, elt_ptr); - return (char *) array; + ArrayCastAndSet(dataValue, elmbyval, elmlen, elt_ptr); + return array; } /* new element with different size, reallocate the array */ oldsize = array->size; - lth0 = ARR_OVERHEAD(n); + lth0 = ARR_OVERHEAD(nSubscripts); lth1 = (int) (elt_ptr - ARR_DATA_PTR(array)); lth2 = (int) (oldsize - lth0 - lth1 - oldlen); newsize = lth0 + lth1 + newlen + lth2; @@ -1213,16 +1208,16 @@ array_set(ArrayType *array, newarray = (ArrayType *) palloc(newsize); memmove((char *) newarray, (char *) array, lth0 + lth1); newarray->size = newsize; - newlen = ArrayCastAndSet(dataPtr, (bool) reftype, elmlen, + newlen = ArrayCastAndSet(dataValue, elmbyval, elmlen, (char *) newarray + lth0 + lth1); memmove((char *) newarray + lth0 + lth1 + newlen, (char *) array + lth0 + lth1 + oldlen, lth2); /* ??? who should free this storage ??? */ - return (char *) newarray; + return newarray; } - ArrayCastAndSet(dataPtr, (bool) reftype, elmlen, pos); - return (char *) array; + ArrayCastAndSet(dataValue, elmbyval, elmlen, pos); + return array; } /*---------------------------------------------------------------------------- @@ -1234,14 +1229,14 @@ array_set(ArrayType *array, * returns a pointer to the modified array. *---------------------------------------------------------------------------- */ -char * +ArrayType * array_assgn(ArrayType *array, - int n, + int nSubscripts, int *upperIndx, int *lowerIndx, ArrayType *newArr, - int reftype, - int len, + bool elmbyval, + int elmlen, bool *isNull) { int i, @@ -1250,19 +1245,19 @@ array_assgn(ArrayType *array, *lb; if (array == (ArrayType *) NULL) - RETURN_NULL; - if (len < 0) - elog(ERROR, "array_assgn:updates on arrays of variable length elements not allowed"); + RETURN_NULL(ArrayType *); + if (elmlen < 0) + elog(ERROR, "array_assgn: updates on arrays of variable length elements not implemented"); dim = ARR_DIMS(array); lb = ARR_LBOUND(array); ndim = ARR_NDIM(array); - if (!SanityCheckInput(ndim, n, dim, lb, upperIndx) || - !SanityCheckInput(ndim, n, dim, lb, lowerIndx)) - return (char *) array; + if (!SanityCheckInput(ndim, nSubscripts, dim, lb, upperIndx) || + !SanityCheckInput(ndim, nSubscripts, dim, lb, lowerIndx)) + RETURN_NULL(ArrayType *); - for (i = 0; i < n; i++) + for (i = 0; i < nSubscripts; i++) if (lowerIndx[i] > upperIndx[i]) elog(ERROR, "lowerIndex larger than upperIndx"); @@ -1276,28 +1271,28 @@ array_assgn(ArrayType *array, lo_name = (char *) ARR_DATA_PTR(array); if ((fd = LOopen(lo_name, ARR_IS_INV(array) ? INV_WRITE : O_WRONLY)) < 0) - return (char *) array; + return array; #endif if (ARR_IS_LO(newArr)) { #ifdef LOARRAY lo_name = (char *) ARR_DATA_PTR(newArr); if ((newfd = LOopen(lo_name, ARR_IS_INV(newArr) ? INV_READ : O_RDONLY)) < 0) - return (char *) array; + return array; #endif - _LOArrayRange(lowerIndx, upperIndx, len, fd, newfd, array, 1, isNull); + _LOArrayRange(lowerIndx, upperIndx, elmlen, fd, newfd, array, 1, isNull); DirectFunctionCall1(lo_close, Int32GetDatum(newfd)); } else { - _LOArrayRange(lowerIndx, upperIndx, len, fd, (int) ARR_DATA_PTR(newArr), + _LOArrayRange(lowerIndx, upperIndx, elmlen, fd, (int) ARR_DATA_PTR(newArr), array, 0, isNull); } DirectFunctionCall1(lo_close, Int32GetDatum(fd)); - return (char *) array; + return array; } - _ArrayRange(lowerIndx, upperIndx, len, ARR_DATA_PTR(newArr), array, 0); - return (char *) array; + _ArrayRange(lowerIndx, upperIndx, elmlen, ARR_DATA_PTR(newArr), array, 0); + return array; } /* @@ -1353,7 +1348,7 @@ array_map(FunctionCallInfo fcinfo, Oid inpType, Oid retType) elog(ERROR, "array_map: invalid nargs: %d", fcinfo->nargs); if (PG_ARGISNULL(0)) elog(ERROR, "array_map: null input array"); - v = (ArrayType *) PG_GETARG_POINTER(0); + v = (ArrayType *) PG_GETARG_VARLENA_P(0); /* Large objects not yet supported */ if (ARR_IS_LO(v) == true) @@ -1466,19 +1461,20 @@ array_map(FunctionCallInfo fcinfo, Oid inpType, Oid retType) * array_eq : * compares two arrays for equality * result : - * returns 1 if the arrays are equal, 0 otherwise. + * returns true if the arrays are equal, false otherwise. *----------------------------------------------------------------------------- */ -int -array_eq(ArrayType *array1, ArrayType *array2) +Datum +array_eq(PG_FUNCTION_ARGS) { - if ((array1 == NULL) || (array2 == NULL)) - return 0; - if (*(int *) array1 != *(int *) array2) - return 0; - if (memcmp(array1, array2, *(int *) array1)) - return 0; - return 1; + ArrayType *array1 = (ArrayType *) PG_GETARG_VARLENA_P(0); + ArrayType *array2 = (ArrayType *) PG_GETARG_VARLENA_P(1); + + if (*(int32 *) array1 != *(int32 *) array2) + PG_RETURN_BOOL(false); + if (memcmp(array1, array2, *(int32 *) array1) != 0) + PG_RETURN_BOOL(false); + PG_RETURN_BOOL(true); } /***************************************************************************/ @@ -1545,7 +1541,7 @@ _ArrayCast(char *value, bool byval, int len) static int -ArrayCastAndSet(char *src, +ArrayCastAndSet(Datum src, bool typbyval, int typlen, char *dest) @@ -1565,18 +1561,18 @@ ArrayCastAndSet(char *src, *(int16 *) dest = DatumGetInt16(src); break; case 4: - *(int32 *) dest = (int32) src; + *(int32 *) dest = DatumGetInt32(src); break; } } else - memmove(dest, src, typlen); + memmove(dest, DatumGetPointer(src), typlen); inc = typlen; } else { - memmove(dest, src, *(int32 *) src); - inc = (INTALIGN(*(int32 *) src)); + memmove(dest, DatumGetPointer(src), *(int32 *) DatumGetPointer(src)); + inc = (INTALIGN(*(int32 *) DatumGetPointer(src))); } return inc; } diff --git a/src/backend/utils/adt/cash.c b/src/backend/utils/adt/cash.c index 9bfc46bda6c..861d5931d47 100644 --- a/src/backend/utils/adt/cash.c +++ b/src/backend/utils/adt/cash.c @@ -9,7 +9,7 @@ * workings can be found in the book "Software Solutions in C" by * Dale Schumacher, Academic Press, ISBN: 0-12-632360-7. * - * $Header: /cvsroot/pgsql/src/backend/utils/adt/cash.c,v 1.37 2000/06/05 07:28:51 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/cash.c,v 1.38 2000/06/13 07:35:03 tgl Exp $ */ #include <limits.h> @@ -535,31 +535,31 @@ cash_div_flt4(Cash *c, float4 *f) /* cash_mul_int4() * Multiply cash by int4. */ -Cash * -cash_mul_int4(Cash *c, int4 i) +Datum +cash_mul_int4(PG_FUNCTION_ARGS) { - Cash *result; - - if (!PointerIsValid(c)) - return NULL; - - if (!PointerIsValid(result = palloc(sizeof(Cash)))) - elog(ERROR, "Memory allocation failed, can't multiply cash"); - - *result = ((i) * (*c)); + Cash c = PG_GETARG_CASH(0); + int32 i = PG_GETARG_INT32(1); + Cash result; - return result; -} /* cash_mul_int4() */ + result = c * i; + PG_RETURN_CASH(result); +} /* int4_mul_cash() * Multiply int4 by cash. */ -Cash * -int4_mul_cash(int4 i, Cash *c) +Datum +int4_mul_cash(PG_FUNCTION_ARGS) { - return cash_mul_int4(c, i); -} /* int4_mul_cash() */ + int32 i = PG_GETARG_INT32(0); + Cash c = PG_GETARG_CASH(1); + Cash result; + + result = i * c; + PG_RETURN_CASH(result); +} /* cash_div_int4() @@ -568,24 +568,20 @@ int4_mul_cash(int4 i, Cash *c) * XXX Don't know if rounding or truncating is correct behavior. * Round for now. - tgl 97/04/15 */ -Cash * -cash_div_int4(Cash *c, int4 i) +Datum +cash_div_int4(PG_FUNCTION_ARGS) { - Cash *result; - - if (!PointerIsValid(c)) - return NULL; - - if (!PointerIsValid(result = palloc(sizeof(Cash)))) - elog(ERROR, "Memory allocation failed, can't divide cash"); + Cash c = PG_GETARG_CASH(0); + int32 i = PG_GETARG_INT32(1); + Cash result; if (i == 0) - elog(ERROR, "cash_idiv: divide by 0 error"); + elog(ERROR, "cash_div_int4: divide by 0 error"); - *result = rint(*c / i); + result = rint(c / i); - return result; -} /* cash_div_int4() */ + PG_RETURN_CASH(result); +} /* cash_mul_int2() diff --git a/src/backend/utils/adt/chunk.c b/src/backend/utils/adt/chunk.c index 34c8c462219..1d8ec1aec8e 100644 --- a/src/backend/utils/adt/chunk.c +++ b/src/backend/utils/adt/chunk.c @@ -7,7 +7,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.26 2000/06/09 01:11:08 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/chunk.c,v 1.27 2000/06/13 07:35:03 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -517,7 +517,7 @@ _ReadChunkArray(int *st, Int32GetDatum(fp), Int32GetDatum(srcOff), Int32GetDatum(SEEK_SET))) < 0) - RETURN_NULL; + RETURN_NULL(int); jj = n - 1; for (i = 0; i < n; chunk_off[i++] = 0) @@ -541,7 +541,7 @@ _ReadChunkArray(int *st, Int32GetDatum((int32) destfp), Int32GetDatum(bptr), Int32GetDatum(SEEK_SET))) < 0) - RETURN_NULL; + RETURN_NULL(int); } else destfp = baseDestFp + bptr; @@ -556,7 +556,7 @@ _ReadChunkArray(int *st, Int32GetDatum(fp), Int32GetDatum(srcOff), Int32GetDatum(SEEK_SET))) < 0) - RETURN_NULL; + RETURN_NULL(int); } for (i = n - 1, to_read = bsize; i >= 0; to_read *= min(C[i], array_span[i]), i--) @@ -571,7 +571,7 @@ _ReadChunkArray(int *st, Int32GetDatum(fp), Int32GetDatum(srcOff), Int32GetDatum(SEEK_SET))) < 0) - RETURN_NULL; + RETURN_NULL(int); } block_seek += cdist[j]; bptr += adist[j] * bsize; @@ -581,13 +581,13 @@ _ReadChunkArray(int *st, Int32GetDatum((int32) destfp), Int32GetDatum(bptr), Int32GetDatum(SEEK_SET))) < 0) - RETURN_NULL; + RETURN_NULL(int); } else destfp = baseDestFp + bptr; temp = _LOtransfer((char **) &destfp, to_read, 1, (char **) &fp, 1, isDestLO); if (temp < to_read) - RETURN_NULL; + RETURN_NULL(int); srcOff += to_read; words_read += to_read; bptr += to_read; @@ -702,7 +702,7 @@ _ReadChunkArray1El(int *st, Int32GetDatum(fp), Int32GetDatum(srcOff), Int32GetDatum(SEEK_SET))) < 0) - RETURN_NULL; + RETURN_NULL(struct varlena *); #ifdef LOARRAY return (struct varlena *) DatumGetPointer(DirectFunctionCall2(loread, diff --git a/src/backend/utils/adt/float.c b/src/backend/utils/adt/float.c index 93800b067d8..428fb5bf2c4 100644 --- a/src/backend/utils/adt/float.c +++ b/src/backend/utils/adt/float.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/float.c,v 1.59 2000/06/08 22:37:28 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/float.c,v 1.60 2000/06/13 07:35:04 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -48,12 +48,11 @@ */ #include <ctype.h> #include <errno.h> - #include <float.h> /* faked on sunos4 */ - #include <math.h> #include "postgres.h" + #ifdef HAVE_LIMITS_H #include <limits.h> #ifndef MAXINT @@ -64,6 +63,7 @@ #include <values.h> #endif #endif + #include "fmgr.h" #include "utils/builtins.h" @@ -844,15 +844,14 @@ dtoi2(PG_FUNCTION_ARGS) /* * i4tod - converts an int4 number to a float8 number */ -float64 -i4tod(int32 num) +Datum +i4tod(PG_FUNCTION_ARGS) { - float64 result; - - result = (float64) palloc(sizeof(float64data)); + int32 num = PG_GETARG_INT32(0); + float8 result; - *result = num; - return result; + result = num; + PG_RETURN_FLOAT8(result); } @@ -909,15 +908,14 @@ ftoi2(PG_FUNCTION_ARGS) /* * i4tof - converts an int4 number to a float8 number */ -float32 -i4tof(int32 num) +Datum +i4tof(PG_FUNCTION_ARGS) { - float32 result; - - result = (float32) palloc(sizeof(float32data)); + int32 num = PG_GETARG_INT32(0); + float4 result; - *result = num; - return result; + result = num; + PG_RETURN_FLOAT4(result); } diff --git a/src/backend/utils/adt/formatting.c b/src/backend/utils/adt/formatting.c index 19cbd8ef209..6f6e3a54c89 100644 --- a/src/backend/utils/adt/formatting.c +++ b/src/backend/utils/adt/formatting.c @@ -1,7 +1,7 @@ /* ----------------------------------------------------------------------- * formatting.c * - * $Header: /cvsroot/pgsql/src/backend/utils/adt/formatting.c,v 1.11 2000/06/09 03:18:34 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/formatting.c,v 1.12 2000/06/13 07:35:04 tgl Exp $ * * * Portions Copyright (c) 1999-2000, PostgreSQL, Inc @@ -3848,13 +3848,11 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout, char *number, * ---------- */ #define NUM_TOCHAR_prepare { \ - if (!PointerIsValid(fmt)) \ - return NULL; \ \ len = VARSIZE(fmt) - VARHDRSZ; \ \ - if (!len) \ - return textin(""); \ + if (len <= 0) \ + return PointerGetDatum(textin("")); \ \ result = (text *) palloc( (len * NUM_MAX_ITEM_SIZ) + 1 + VARHDRSZ); \ format = NUM_cache(len, &Num, VARDATA(fmt), &flag); \ @@ -3891,26 +3889,24 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout, char *number, * NUMERIC to_number() (convert string to numeric) * ------------------- */ -Numeric -numeric_to_number(text *value, text *fmt) +Datum +numeric_to_number(PG_FUNCTION_ARGS) { + text *value = PG_GETARG_TEXT_P(0); + text *fmt = PG_GETARG_TEXT_P(1); NUMDesc Num; - Numeric result; + Datum result; FormatNode *format; char *numstr; int flag = 0; int len = 0; - int scale, precision; - if ((!PointerIsValid(value)) || (!PointerIsValid(fmt))) - return NULL; - len = VARSIZE(fmt) - VARHDRSZ; - if (!len) - return numeric_in(NULL, 0, 0); + if (len <= 0) + PG_RETURN_NULL(); format = NUM_cache(len, &Num, VARDATA(fmt), &flag); @@ -3925,7 +3921,10 @@ numeric_to_number(text *value, text *fmt) if (flag) pfree(format); - result = numeric_in(numstr, 0, ((precision << 16) | scale) + VARHDRSZ); + result = DirectFunctionCall3(numeric_in, + CStringGetDatum(numstr), + ObjectIdGetDatum(InvalidOid), + Int32GetDatum(((precision << 16) | scale) + VARHDRSZ)); pfree(numstr); return result; } @@ -3934,9 +3933,11 @@ numeric_to_number(text *value, text *fmt) * NUMERIC to_char() * ------------------ */ -text * -numeric_to_char(Numeric value, text *fmt) +Datum +numeric_to_char(PG_FUNCTION_ARGS) { + Numeric value = PG_GETARG_NUMERIC(0); + text *fmt = PG_GETARG_TEXT_P(1); NUMDesc Num; FormatNode *format; text *result, @@ -3948,7 +3949,7 @@ numeric_to_char(Numeric value, text *fmt) char *numstr, *orgnum, *p; - Numeric x = NULL; + Numeric x; NUM_TOCHAR_prepare; @@ -3958,10 +3959,11 @@ numeric_to_char(Numeric value, text *fmt) */ if (IS_ROMAN(&Num)) { - x = numeric_round(value, 0); + x = DatumGetNumeric(DirectFunctionCall2(numeric_round, + NumericGetDatum(value), + Int32GetDatum(0))); numstr = orgnum = int_to_roman(numeric_int4(x)); pfree(x); - } else { @@ -3969,8 +3971,10 @@ numeric_to_char(Numeric value, text *fmt) if (IS_MULTI(&Num)) { - Numeric a = int4_numeric(10); - Numeric b = int4_numeric(Num.multi); + Numeric a = DatumGetNumeric(DirectFunctionCall1(int4_numeric, + Int32GetDatum(10))); + Numeric b = DatumGetNumeric(DirectFunctionCall1(int4_numeric, + Int32GetDatum(Num.multi))); x = numeric_power(a, b); val = numeric_mul(value, x); @@ -3980,8 +3984,11 @@ numeric_to_char(Numeric value, text *fmt) Num.pre += Num.multi; } - x = numeric_round(val, Num.post); - orgnum = numeric_out(x); + x = DatumGetNumeric(DirectFunctionCall2(numeric_round, + NumericGetDatum(val), + Int32GetDatum(Num.post))); + orgnum = DatumGetCString(DirectFunctionCall1(numeric_out, + NumericGetDatum(x))); pfree(x); if (*orgnum == '-') @@ -4014,16 +4021,18 @@ numeric_to_char(Numeric value, text *fmt) } NUM_TOCHAR_finish; - return result; + PG_RETURN_TEXT_P(result); } /* --------------- * INT4 to_char() * --------------- */ -text * -int4_to_char(int32 value, text *fmt) +Datum +int4_to_char(PG_FUNCTION_ARGS) { + int32 value = PG_GETARG_INT32(0); + text *fmt = PG_GETARG_TEXT_P(1); NUMDesc Num; FormatNode *format; text *result, @@ -4044,7 +4053,6 @@ int4_to_char(int32 value, text *fmt) if (IS_ROMAN(&Num)) { numstr = orgnum = int_to_roman(value); - } else { @@ -4097,16 +4105,18 @@ int4_to_char(int32 value, text *fmt) } NUM_TOCHAR_finish; - return result; + PG_RETURN_TEXT_P(result); } /* --------------- * INT8 to_char() * --------------- */ -text * -int8_to_char(int64 *value, text *fmt) +Datum +int8_to_char(PG_FUNCTION_ARGS) { + int64 value = PG_GETARG_INT64(0); + text *fmt = PG_GETARG_TEXT_P(1); NUMDesc Num; FormatNode *format; text *result, @@ -4126,8 +4136,9 @@ int8_to_char(int64 *value, text *fmt) */ if (IS_ROMAN(&Num)) { - numstr = orgnum = int_to_roman(int84(value)); - + /* Currently don't support int8 conversion to roman... */ + numstr = orgnum = int_to_roman(DatumGetInt32( + DirectFunctionCall1(int84, Int64GetDatum(value)))); } else { @@ -4135,11 +4146,15 @@ int8_to_char(int64 *value, text *fmt) { double multi = pow((double) 10, (double) Num.multi); - orgnum = int8out(int8mul(value, dtoi8((float64) &multi))); + value = DatumGetInt64(DirectFunctionCall2(int8mul, + Int64GetDatum(value), + DirectFunctionCall1(dtoi8, + Float8GetDatum(multi)))); Num.pre += Num.multi; } - else - orgnum = int8out(value); + + orgnum = DatumGetCString(DirectFunctionCall1(int8out, + Int64GetDatum(value))); len = strlen(orgnum); if (*orgnum == '-') @@ -4178,16 +4193,18 @@ int8_to_char(int64 *value, text *fmt) } NUM_TOCHAR_finish; - return result; + PG_RETURN_TEXT_P(result); } /* ----------------- * FLOAT4 to_char() * ----------------- */ -text * -float4_to_char(float32 value, text *fmt) +Datum +float4_to_char(PG_FUNCTION_ARGS) { + float4 value = PG_GETARG_FLOAT4(0); + text *fmt = PG_GETARG_TEXT_P(1); NUMDesc Num; FormatNode *format; text *result, @@ -4204,30 +4221,30 @@ float4_to_char(float32 value, text *fmt) if (IS_ROMAN(&Num)) { - numstr = orgnum = int_to_roman((int) rint(*value)); + numstr = orgnum = int_to_roman((int) rint(value)); } else { - float32 val = value; + float4 val = value; if (IS_MULTI(&Num)) { float multi = pow((double) 10, (double) Num.multi); - val = float4mul(value, (float32) &multi); + val = value * multi; Num.pre += Num.multi; } orgnum = (char *) palloc(MAXFLOATWIDTH + 1); - len = sprintf(orgnum, "%.0f", fabs(*val)); + len = sprintf(orgnum, "%.0f", fabs(val)); if (Num.pre > len) plen = Num.pre - len; if (len >= FLT_DIG) Num.post = 0; else if (Num.post + len > FLT_DIG) Num.post = FLT_DIG - len; - sprintf(orgnum, "%.*f", Num.post, *val); + sprintf(orgnum, "%.*f", Num.post, val); if (*orgnum == '-') { /* < 0 */ @@ -4256,16 +4273,18 @@ float4_to_char(float32 value, text *fmt) } NUM_TOCHAR_finish; - return result; + PG_RETURN_TEXT_P(result); } /* ----------------- * FLOAT8 to_char() * ----------------- */ -text * -float8_to_char(float64 value, text *fmt) +Datum +float8_to_char(PG_FUNCTION_ARGS) { + float8 value = PG_GETARG_FLOAT8(0); + text *fmt = PG_GETARG_TEXT_P(1); NUMDesc Num; FormatNode *format; text *result, @@ -4282,29 +4301,29 @@ float8_to_char(float64 value, text *fmt) if (IS_ROMAN(&Num)) { - numstr = orgnum = int_to_roman((int) rint(*value)); + numstr = orgnum = int_to_roman((int) rint(value)); } else { - float64 val = value; + float8 val = value; if (IS_MULTI(&Num)) { double multi = pow((double) 10, (double) Num.multi); - val = float8mul(value, (float64) &multi); + val = value * multi; Num.pre += Num.multi; } orgnum = (char *) palloc(MAXDOUBLEWIDTH + 1); - len = sprintf(orgnum, "%.0f", fabs(*val)); + len = sprintf(orgnum, "%.0f", fabs(val)); if (Num.pre > len) plen = Num.pre - len; if (len >= DBL_DIG) Num.post = 0; else if (Num.post + len > DBL_DIG) Num.post = DBL_DIG - len; - sprintf(orgnum, "%.*f", Num.post, *val); + sprintf(orgnum, "%.*f", Num.post, val); if (*orgnum == '-') { /* < 0 */ @@ -4333,5 +4352,5 @@ float8_to_char(float64 value, text *fmt) } NUM_TOCHAR_finish; - return result; + PG_RETURN_TEXT_P(result); } diff --git a/src/backend/utils/adt/geo_ops.c b/src/backend/utils/adt/geo_ops.c index 0e8bb4405b2..dc6e077d6bf 100644 --- a/src/backend/utils/adt/geo_ops.c +++ b/src/backend/utils/adt/geo_ops.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.50 2000/04/12 17:15:50 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.51 2000/06/13 07:35:07 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -4361,22 +4361,21 @@ box_circle(BOX *box) } /* box_circle() */ -POLYGON * -circle_poly(int npts, CIRCLE *circle) +Datum +circle_poly(PG_FUNCTION_ARGS) { + int32 npts = PG_GETARG_INT32(0); + CIRCLE *circle = PG_GETARG_CIRCLE_P(1); POLYGON *poly; int size; int i; double angle; - if (!PointerIsValid(circle)) - return NULL; - if (FPzero(circle->radius) || (npts < 2)) elog(ERROR, "Unable to convert circle to polygon"); size = offsetof(POLYGON, p[0]) +(sizeof(poly->p[0]) * npts); - poly = palloc(size); + poly = (POLYGON *) palloc(size); MemSet((char *) poly, 0, size); /* zero any holes */ poly->size = size; @@ -4391,7 +4390,7 @@ circle_poly(int npts, CIRCLE *circle) make_bound_box(poly); - return poly; + PG_RETURN_POLYGON_P(poly); } /* poly_circle - convert polygon to circle diff --git a/src/backend/utils/adt/int8.c b/src/backend/utils/adt/int8.c index a30a920b6a4..774e9aba89c 100644 --- a/src/backend/utils/adt/int8.c +++ b/src/backend/utils/adt/int8.c @@ -7,7 +7,7 @@ * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/int8.c,v 1.19 2000/05/28 17:56:05 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/int8.c,v 1.20 2000/06/13 07:35:07 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -57,17 +57,15 @@ /* int8in() */ -int64 * -int8in(char *str) +Datum +int8in(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); + char *str = PG_GETARG_CSTRING(0); + int64 result; char *ptr = str; int64 tmp = 0; int sign = 1; - if (!PointerIsValid(str)) - elog(ERROR, "Bad (null) int8 external representation"); - /* * Do our own scan, rather than relying on sscanf which might be * broken for long long. @@ -91,34 +89,28 @@ int8in(char *str) if (*ptr) /* trailing junk? */ elog(ERROR, "Bad int8 external representation \"%s\"", str); - *result = (sign < 0) ? -tmp : tmp; + result = (sign < 0) ? -tmp : tmp; - return result; -} /* int8in() */ + PG_RETURN_INT64(result); +} /* int8out() */ -char * -int8out(int64 *val) +Datum +int8out(PG_FUNCTION_ARGS) { + int64 val = PG_GETARG_INT64(0); char *result; - int len; char buf[MAXINT8LEN + 1]; - if (!PointerIsValid(val)) - return NULL; - - if ((len = snprintf(buf, MAXINT8LEN, INT64_FORMAT, *val)) < 0) + if ((len = snprintf(buf, MAXINT8LEN, INT64_FORMAT, val)) < 0) elog(ERROR, "Unable to format int8"); - result = palloc(len + 1); - - strcpy(result, buf); - - return result; -} /* int8out() */ + result = pstrdup(buf); + PG_RETURN_CSTRING(result); +} /*---------------------------------------------------------- @@ -128,511 +120,403 @@ int8out(int64 *val) /* int8relop() * Is val1 relop val2? */ -bool -int8eq(int64 *val1, int64 *val2) +Datum +int8eq(PG_FUNCTION_ARGS) { - if (!val1 || !val2) - return 0; + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); - return *val1 == *val2; -} /* int8eq() */ + PG_RETURN_BOOL(val1 == val2); +} -bool -int8ne(int64 *val1, int64 *val2) +Datum +int8ne(PG_FUNCTION_ARGS) { - if (!val1 || !val2) - return 0; + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); - return *val1 != *val2; -} /* int8ne() */ + PG_RETURN_BOOL(val1 != val2); +} -bool -int8lt(int64 *val1, int64 *val2) +Datum +int8lt(PG_FUNCTION_ARGS) { - if (!val1 || !val2) - return 0; + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); - return *val1 < *val2; -} /* int8lt() */ + PG_RETURN_BOOL(val1 < val2); +} -bool -int8gt(int64 *val1, int64 *val2) +Datum +int8gt(PG_FUNCTION_ARGS) { - if (!val1 || !val2) - return 0; + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); - return *val1 > *val2; -} /* int8gt() */ + PG_RETURN_BOOL(val1 > val2); +} -bool -int8le(int64 *val1, int64 *val2) +Datum +int8le(PG_FUNCTION_ARGS) { - if (!val1 || !val2) - return 0; + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); - return *val1 <= *val2; -} /* int8le() */ + PG_RETURN_BOOL(val1 <= val2); +} -bool -int8ge(int64 *val1, int64 *val2) +Datum +int8ge(PG_FUNCTION_ARGS) { - if (!val1 || !val2) - return 0; - - return *val1 >= *val2; -} /* int8ge() */ + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); + PG_RETURN_BOOL(val1 >= val2); +} /* int84relop() * Is 64-bit val1 relop 32-bit val2? */ -bool -int84eq(int64 *val1, int32 val2) +Datum +int84eq(PG_FUNCTION_ARGS) { - if (!val1) - return 0; + int64 val1 = PG_GETARG_INT64(0); + int32 val2 = PG_GETARG_INT32(1); - return *val1 == val2; -} /* int84eq() */ + PG_RETURN_BOOL(val1 == val2); +} -bool -int84ne(int64 *val1, int32 val2) +Datum +int84ne(PG_FUNCTION_ARGS) { - if (!val1) - return 0; + int64 val1 = PG_GETARG_INT64(0); + int32 val2 = PG_GETARG_INT32(1); - return *val1 != val2; -} /* int84ne() */ + PG_RETURN_BOOL(val1 != val2); +} -bool -int84lt(int64 *val1, int32 val2) +Datum +int84lt(PG_FUNCTION_ARGS) { - if (!val1) - return 0; + int64 val1 = PG_GETARG_INT64(0); + int32 val2 = PG_GETARG_INT32(1); - return *val1 < val2; -} /* int84lt() */ + PG_RETURN_BOOL(val1 < val2); +} -bool -int84gt(int64 *val1, int32 val2) +Datum +int84gt(PG_FUNCTION_ARGS) { - if (!val1) - return 0; + int64 val1 = PG_GETARG_INT64(0); + int32 val2 = PG_GETARG_INT32(1); - return *val1 > val2; -} /* int84gt() */ + PG_RETURN_BOOL(val1 > val2); +} -bool -int84le(int64 *val1, int32 val2) +Datum +int84le(PG_FUNCTION_ARGS) { - if (!val1) - return 0; + int64 val1 = PG_GETARG_INT64(0); + int32 val2 = PG_GETARG_INT32(1); - return *val1 <= val2; -} /* int84le() */ + PG_RETURN_BOOL(val1 <= val2); +} -bool -int84ge(int64 *val1, int32 val2) +Datum +int84ge(PG_FUNCTION_ARGS) { - if (!val1) - return 0; - - return *val1 >= val2; -} /* int84ge() */ + int64 val1 = PG_GETARG_INT64(0); + int32 val2 = PG_GETARG_INT32(1); + PG_RETURN_BOOL(val1 >= val2); +} /* int48relop() * Is 32-bit val1 relop 64-bit val2? */ -bool -int48eq(int32 val1, int64 *val2) +Datum +int48eq(PG_FUNCTION_ARGS) { - if (!val2) - return 0; + int32 val1 = PG_GETARG_INT32(0); + int64 val2 = PG_GETARG_INT64(1); - return val1 == *val2; -} /* int48eq() */ + PG_RETURN_BOOL(val1 == val2); +} -bool -int48ne(int32 val1, int64 *val2) +Datum +int48ne(PG_FUNCTION_ARGS) { - if (!val2) - return 0; + int32 val1 = PG_GETARG_INT32(0); + int64 val2 = PG_GETARG_INT64(1); - return val1 != *val2; -} /* int48ne() */ + PG_RETURN_BOOL(val1 != val2); +} -bool -int48lt(int32 val1, int64 *val2) +Datum +int48lt(PG_FUNCTION_ARGS) { - if (!val2) - return 0; + int32 val1 = PG_GETARG_INT32(0); + int64 val2 = PG_GETARG_INT64(1); - return val1 < *val2; -} /* int48lt() */ + PG_RETURN_BOOL(val1 < val2); +} -bool -int48gt(int32 val1, int64 *val2) +Datum +int48gt(PG_FUNCTION_ARGS) { - if (!val2) - return 0; + int32 val1 = PG_GETARG_INT32(0); + int64 val2 = PG_GETARG_INT64(1); - return val1 > *val2; -} /* int48gt() */ + PG_RETURN_BOOL(val1 > val2); +} -bool -int48le(int32 val1, int64 *val2) +Datum +int48le(PG_FUNCTION_ARGS) { - if (!val2) - return 0; + int32 val1 = PG_GETARG_INT32(0); + int64 val2 = PG_GETARG_INT64(1); - return val1 <= *val2; -} /* int48le() */ + PG_RETURN_BOOL(val1 <= val2); +} -bool -int48ge(int32 val1, int64 *val2) +Datum +int48ge(PG_FUNCTION_ARGS) { - if (!val2) - return 0; + int32 val1 = PG_GETARG_INT32(0); + int64 val2 = PG_GETARG_INT64(1); - return val1 >= *val2; -} /* int48ge() */ + PG_RETURN_BOOL(val1 >= val2); +} /*---------------------------------------------------------- * Arithmetic operators on 64-bit integers. *---------------------------------------------------------*/ -int64 * -int8um(int64 *val) +Datum +int8um(PG_FUNCTION_ARGS) { - int64 temp = 0; - int64 *result = palloc(sizeof(int64)); - - if (!PointerIsValid(val)) - return NULL; - - result = int8mi(&temp, val); - - return result; -} /* int8um() */ + int64 val = PG_GETARG_INT64(0); + PG_RETURN_INT64(- val); +} -int64 * -int8pl(int64 *val1, int64 *val2) +Datum +int8pl(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); - - if ((!PointerIsValid(val1)) || (!PointerIsValid(val2))) - return NULL; + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); - *result = *val1 + *val2; - - return result; -} /* int8pl() */ + PG_RETURN_INT64(val1 + val2); +} -int64 * -int8mi(int64 *val1, int64 *val2) +Datum +int8mi(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); - - if ((!PointerIsValid(val1)) || (!PointerIsValid(val2))) - return NULL; - - *result = *val1 - *val2; + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); - return result; -} /* int8mi() */ + PG_RETURN_INT64(val1 - val2); +} -int64 * -int8mul(int64 *val1, int64 *val2) +Datum +int8mul(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); - - if ((!PointerIsValid(val1)) || (!PointerIsValid(val2))) - return NULL; - - *result = *val1 * *val2; + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); - return result; -} /* int8mul() */ + PG_RETURN_INT64(val1 * val2); +} -int64 * -int8div(int64 *val1, int64 *val2) +Datum +int8div(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); - - if ((!PointerIsValid(val1)) || (!PointerIsValid(val2))) - return NULL; + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); - *result = *val1 / *val2; - - return result; -} /* int8div() */ + PG_RETURN_INT64(val1 / val2); +} /* int8abs() * Absolute value */ -int64 * -int8abs(int64 *arg1) +Datum +int8abs(PG_FUNCTION_ARGS) { - int64 *result; - - if (!PointerIsValid(arg1)) - return NULL; - - result = palloc(sizeof(*result)); - - *result = ((*arg1 < 0) ? -*arg1 : *arg1); + int64 arg1 = PG_GETARG_INT64(0); - return result; + PG_RETURN_INT64((arg1 < 0) ? -arg1 : arg1); } /* int8mod() * Modulo operation. */ -int64 * -int8mod(int64 *val1, int64 *val2) +Datum +int8mod(PG_FUNCTION_ARGS) { - int64 *result; + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); + int64 result; - /* use the divide operation to check params and allocate storage */ - result = int8div(val1, val2); - *result *= *val2; - *result = *val1 - *result; + result = val1 / val2; + result *= val2; + result = val1 - result; - return result; -} /* int8mod() */ + PG_RETURN_INT64(result); +} /* int8fac() * Factorial */ -int64 * -int8fac(int64 *arg1) +Datum +int8fac(PG_FUNCTION_ARGS) { - int64 *result; + int64 arg1 = PG_GETARG_INT64(0); + int64 result; int64 i; - if (!PointerIsValid(arg1)) - return NULL; - - result = palloc(sizeof(*result)); - - if (*arg1 < 1) - *result = 0; + if (arg1 < 1) + result = 0; else - for (i = *arg1, *result = 1; i > 0; --i) - *result *= i; + for (i = arg1, result = 1; i > 0; --i) + result *= i; - return result; + PG_RETURN_INT64(result); } -int64 * -int8larger(int64 *val1, int64 *val2) +Datum +int8larger(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); - - if ((!PointerIsValid(val1)) || (!PointerIsValid(val2))) - return NULL; + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); + int64 result; - *result = ((*val1 > *val2) ? *val1 : *val2); + result = ((val1 > val2) ? val1 : val2); - return result; -} /* int8larger() */ + PG_RETURN_INT64(result); +} -int64 * -int8smaller(int64 *val1, int64 *val2) +Datum +int8smaller(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); + int64 val1 = PG_GETARG_INT64(0); + int64 val2 = PG_GETARG_INT64(1); + int64 result; - if ((!PointerIsValid(val1)) || (!PointerIsValid(val2))) - return NULL; - - *result = ((*val1 < *val2) ? *val1 : *val2); - - return result; -} /* int8smaller() */ + result = ((val1 < val2) ? val1 : val2); + PG_RETURN_INT64(result); +} -int64 * -int84pl(int64 *val1, int32 val2) +Datum +int84pl(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); + int64 val1 = PG_GETARG_INT64(0); + int32 val2 = PG_GETARG_INT32(1); - if (!PointerIsValid(val1)) - return NULL; - - *result = *val1 + (int64) val2; - - return result; -} /* int84pl() */ + PG_RETURN_INT64(val1 + val2); +} -int64 * -int84mi(int64 *val1, int32 val2) +Datum +int84mi(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); + int64 val1 = PG_GETARG_INT64(0); + int32 val2 = PG_GETARG_INT32(1); - if (!PointerIsValid(val1)) - return NULL; - - *result = *val1 - (int64) val2; - - return result; -} /* int84mi() */ + PG_RETURN_INT64(val1 - val2); +} -int64 * -int84mul(int64 *val1, int32 val2) +Datum +int84mul(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); - - if (!PointerIsValid(val1)) - return NULL; + int64 val1 = PG_GETARG_INT64(0); + int32 val2 = PG_GETARG_INT32(1); - *result = *val1 * (int64) val2; - - return result; -} /* int84mul() */ + PG_RETURN_INT64(val1 * val2); +} -int64 * -int84div(int64 *val1, int32 val2) +Datum +int84div(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); - - if (!PointerIsValid(val1)) - return NULL; - - *result = *val1 / (int64) val2; - - return result; -} /* int84div() */ + int64 val1 = PG_GETARG_INT64(0); + int32 val2 = PG_GETARG_INT32(1); + PG_RETURN_INT64(val1 / val2); +} -int64 * -int48pl(int32 val1, int64 *val2) +Datum +int48pl(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); - - if (!PointerIsValid(val2)) - return NULL; + int32 val1 = PG_GETARG_INT32(0); + int64 val2 = PG_GETARG_INT64(1); - *result = (int64) val1 + *val2; - - return result; -} /* int48pl() */ + PG_RETURN_INT64(val1 + val2); +} -int64 * -int48mi(int32 val1, int64 *val2) +Datum +int48mi(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); - - if (!PointerIsValid(val2)) - return NULL; + int32 val1 = PG_GETARG_INT32(0); + int64 val2 = PG_GETARG_INT64(1); - *result = (int64) val1 - *val2; - - return result; -} /* int48mi() */ + PG_RETURN_INT64(val1 - val2); +} -int64 * -int48mul(int32 val1, int64 *val2) +Datum +int48mul(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); - - if (!PointerIsValid(val2)) - return NULL; - - *result = (int64) val1 **val2; + int32 val1 = PG_GETARG_INT32(0); + int64 val2 = PG_GETARG_INT64(1); - return result; -} /* int48mul() */ + PG_RETURN_INT64(val1 * val2); +} -int64 * -int48div(int32 val1, int64 *val2) +Datum +int48div(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); - - if (!PointerIsValid(val2)) - return NULL; - - *result = (int64) val1 / *val2; + int32 val1 = PG_GETARG_INT32(0); + int64 val2 = PG_GETARG_INT64(1); - return result; -} /* int48div() */ + PG_RETURN_INT64(val1 / val2); +} /*---------------------------------------------------------- * Conversion operators. *---------------------------------------------------------*/ -int64 * -int48(int32 val) +Datum +int48(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); + int32 val = PG_GETARG_INT32(0); - *result = val; - - return result; -} /* int48() */ + PG_RETURN_INT64((int64) val); +} -int32 -int84(int64 *val) +Datum +int84(PG_FUNCTION_ARGS) { + int64 val = PG_GETARG_INT64(0); int32 result; - if (!PointerIsValid(val)) - elog(ERROR, "Invalid (null) int64, can't convert int8 to int4"); - - if ((*val < INT_MIN) || (*val > INT_MAX)) + if ((val < INT_MIN) || (val > INT_MAX)) elog(ERROR, "int8 conversion to int4 is out of range"); - result = *val; - - return result; -} /* int84() */ - -#if NOT_USED -int64 * -int2vector (int16 val) -{ - int64 *result; - - result = palloc(sizeof(int64)); - - *result = val; - - return result; -} /* int2vector() */ - -int16 -int82(int64 *val) -{ - int16 result; - - if (!PointerIsValid(val)) - elog(ERROR, "Invalid (null) int8, can't convert to int2"); + result = (int32) val; - if ((*val < SHRT_MIN) || (*val > SHRT_MAX)) - elog(ERROR, "int8 conversion to int2 is out of range"); - - result = *val; - - return result; -} /* int82() */ - -#endif + PG_RETURN_INT32(result); +} -float64 -i8tod(int64 *val) +Datum +i8tod(PG_FUNCTION_ARGS) { - float64 result = palloc(sizeof(float64data)); - - if (!PointerIsValid(val)) - elog(ERROR, "Invalid (null) int8, can't convert to float8"); + int64 val = PG_GETARG_INT64(0); + float8 result; - *result = *val; + result = val; - return result; -} /* i8tod() */ + PG_RETURN_FLOAT8(result); +} /* dtoi8() * Convert double float to 8-byte integer. @@ -644,62 +528,63 @@ i8tod(int64 *val) * does the right thing on my i686/linux-rh4.2 box. * - thomas 1998-06-16 */ -int64 * -dtoi8(float64 val) +Datum +dtoi8(PG_FUNCTION_ARGS) { - int64 *result = palloc(sizeof(int64)); + float8 val = PG_GETARG_FLOAT8(0); + int64 result; - if (!PointerIsValid(val)) - elog(ERROR, "Invalid (null) float8, can't convert to int8"); - - if ((*val < (-pow(2, 63) + 1)) || (*val > (pow(2, 63) - 1))) + if ((val < (-pow(2.0, 63.0) + 1)) || (val > (pow(2.0, 63.0) - 1))) elog(ERROR, "Floating point conversion to int64 is out of range"); - *result = *val; + result = (int64) val; - return result; -} /* dtoi8() */ + PG_RETURN_INT64(result); +} /* text_int8() */ -int64 * -text_int8(text *str) +Datum +text_int8(PG_FUNCTION_ARGS) { + text *str = PG_GETARG_TEXT_P(0); int len; char *s; - - if (!PointerIsValid(str)) - elog(ERROR, "Bad (null) int8 external representation"); + Datum result; len = (VARSIZE(str) - VARHDRSZ); s = palloc(len + 1); - memmove(s, VARDATA(str), len); + memcpy(s, VARDATA(str), len); *(s + len) = '\0'; - return int8in(s); -} /* text_int8() */ + result = DirectFunctionCall1(int8in, CStringGetDatum(s)); + + pfree(s); + + return result; +} /* int8_text() */ -text * -int8_text(int64 *val) +Datum +int8_text(PG_FUNCTION_ARGS) { - text *result; - - int len; + /* val is int64, but easier to leave it as Datum */ + Datum val = PG_GETARG_DATUM(0); char *s; + int len; + text *result; - if (!PointerIsValid(val)) - return NULL; - - s = int8out(val); + s = DatumGetCString(DirectFunctionCall1(int8out, val)); len = strlen(s); - result = palloc(VARHDRSZ + len); + result = (text *) palloc(VARHDRSZ + len); VARSIZE(result) = len + VARHDRSZ; - memmove(VARDATA(result), s, len); + memcpy(VARDATA(result), s, len); - return result; -} /* int8_text() */ + pfree(s); + + PG_RETURN_TEXT_P(result); +} diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c index 500cb151ac7..a628e9c8f3a 100644 --- a/src/backend/utils/adt/numeric.c +++ b/src/backend/utils/adt/numeric.c @@ -5,7 +5,7 @@ * * 1998 Jan Wieck * - * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.28 2000/06/05 07:28:52 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.29 2000/06/13 07:35:07 tgl Exp $ * * ---------- */ @@ -33,9 +33,6 @@ * Local definitions * ---------- */ -#define PG_GETARG_NUMERIC(n) ((Numeric) DatumGetPointer(fcinfo->arg[n])) -#define PG_RETURN_NUMERIC(x) return PointerGetDatum(x) - #ifndef MIN #define MIN(a,b) (((a)<(b)) ? (a) : (b)) #endif @@ -189,28 +186,23 @@ static void sub_abs(NumericVar *var1, NumericVar *var2, NumericVar *result); * Input function for numeric data type * ---------- */ -Numeric -numeric_in(char *str, int dummy, int32 typmod) +Datum +numeric_in(PG_FUNCTION_ARGS) { + char *str = PG_GETARG_CSTRING(0); +#ifdef NOT_USED + Oid typelem = PG_GETARG_OID(1); +#endif + int32 typmod = PG_GETARG_INT32(2); NumericVar value; Numeric res; /* ---------- - * Check for NULL - * ---------- - */ - if (str == NULL) - return NULL; - - if (strcmp(str, "NULL") == 0) - return NULL; - - /* ---------- * Check for NaN * ---------- */ if (strcmp(str, "NaN") == 0) - return make_result(&const_nan); + PG_RETURN_NUMERIC(make_result(&const_nan)); /* ---------- * Use set_var_from_str() to parse the input string @@ -225,7 +217,7 @@ numeric_in(char *str, int dummy, int32 typmod) res = make_result(&value); free_var(&value); - return res; + PG_RETURN_NUMERIC(res); } @@ -235,25 +227,19 @@ numeric_in(char *str, int dummy, int32 typmod) * Output function for numeric data type * ---------- */ -char * -numeric_out(Numeric num) +Datum +numeric_out(PG_FUNCTION_ARGS) { + Numeric num = PG_GETARG_NUMERIC(0); NumericVar x; char *str; /* ---------- - * Handle NULL - * ---------- - */ - if (num == NULL) - return pstrdup("NULL"); - - /* ---------- * Handle NaN * ---------- */ if (NUMERIC_IS_NAN(num)) - return pstrdup("NaN"); + PG_RETURN_CSTRING(pstrdup("NaN")); /* ---------- * Get the number in the variable format. @@ -271,7 +257,7 @@ numeric_out(Numeric num) free_var(&x); - return str; + PG_RETURN_CSTRING(str); } @@ -283,9 +269,11 @@ numeric_out(Numeric num) * scale of the attribute have to be applied on the value. * ---------- */ -Numeric -numeric(Numeric num, int32 typmod) +Datum +numeric(PG_FUNCTION_ARGS) { + Numeric num = PG_GETARG_NUMERIC(0); + int32 typmod = PG_GETARG_INT32(1); Numeric new; int32 tmp_typmod; int precision; @@ -294,18 +282,11 @@ numeric(Numeric num, int32 typmod) NumericVar var; /* ---------- - * Handle NULL - * ---------- - */ - if (num == NULL) - return NULL; - - /* ---------- * Handle NaN * ---------- */ if (NUMERIC_IS_NAN(num)) - return make_result(&const_nan); + PG_RETURN_NUMERIC(make_result(&const_nan)); /* ---------- * If the value isn't a valid type modifier, simply return a @@ -316,7 +297,7 @@ numeric(Numeric num, int32 typmod) { new = (Numeric) palloc(num->varlen); memcpy(new, num, num->varlen); - return new; + PG_RETURN_NUMERIC(new); } /* ---------- @@ -341,7 +322,7 @@ numeric(Numeric num, int32 typmod) new->n_rscale = scale; new->n_sign_dscale = NUMERIC_SIGN(new) | ((uint16) scale & NUMERIC_DSCALE_MASK); - return new; + PG_RETURN_NUMERIC(new); } /* ---------- @@ -357,7 +338,7 @@ numeric(Numeric num, int32 typmod) free_var(&var); - return new; + PG_RETURN_NUMERIC(new); } @@ -502,26 +483,21 @@ numeric_sign(Numeric num) * point --- Oracle interprets rounding that way. * ---------- */ -Numeric -numeric_round(Numeric num, int32 scale) +Datum +numeric_round(PG_FUNCTION_ARGS) { + Numeric num = PG_GETARG_NUMERIC(0); + int32 scale = PG_GETARG_INT32(1); Numeric res; NumericVar arg; int i; /* ---------- - * Handle NULL - * ---------- - */ - if (num == NULL) - return NULL; - - /* ---------- * Handle NaN * ---------- */ if (NUMERIC_IS_NAN(num)) - return make_result(&const_nan); + PG_RETURN_NUMERIC(make_result(&const_nan)); /* ---------- * Limit the scale value to avoid possible overflow in calculations below. @@ -587,7 +563,7 @@ numeric_round(Numeric num, int32 scale) res = make_result(&arg); free_var(&arg); - return res; + PG_RETURN_NUMERIC(res); } @@ -599,25 +575,20 @@ numeric_round(Numeric num, int32 scale) * point --- Oracle interprets truncation that way. * ---------- */ -Numeric -numeric_trunc(Numeric num, int32 scale) +Datum +numeric_trunc(PG_FUNCTION_ARGS) { + Numeric num = PG_GETARG_NUMERIC(0); + int32 scale = PG_GETARG_INT32(1); Numeric res; NumericVar arg; /* ---------- - * Handle NULL - * ---------- - */ - if (num == NULL) - return NULL; - - /* ---------- * Handle NaN * ---------- */ if (NUMERIC_IS_NAN(num)) - return make_result(&const_nan); + PG_RETURN_NUMERIC(make_result(&const_nan)); /* ---------- * Limit the scale value to avoid possible overflow in calculations below. @@ -650,7 +621,7 @@ numeric_trunc(Numeric num, int32 scale) res = make_result(&arg); free_var(&arg); - return res; + PG_RETURN_NUMERIC(res); } @@ -1708,9 +1679,10 @@ numeric_power(Numeric num1, Numeric num2) */ -Numeric -int4_numeric(int32 val) +Datum +int4_numeric(PG_FUNCTION_ARGS) { + int32 val = PG_GETARG_INT32(0); Numeric res; NumericVar result; char *tmp; @@ -1725,7 +1697,7 @@ int4_numeric(int32 val) free_var(&result); pfree(tmp); - return res; + PG_RETURN_NUMERIC(res); } @@ -1769,7 +1741,8 @@ int8_numeric(int64 *val) init_var(&result); - tmp = int8out(val); + tmp = DatumGetCString(DirectFunctionCall1(int8out, + PointerGetDatum(val))); set_var_from_str(tmp, &result); res = make_result(&result); @@ -1785,7 +1758,7 @@ numeric_int8(Numeric num) { NumericVar x; char *str; - int64 *result; + Datum result; if (num == NULL) return NULL; @@ -1804,10 +1777,11 @@ numeric_int8(Numeric num) free_var(&x); - result = int8in(str); + result = DirectFunctionCall1(int8in, CStringGetDatum(str)); + pfree(str); - return result; + return (int64 *) (result); } @@ -1904,7 +1878,8 @@ numeric_float8(Numeric num) return result; } - tmp = numeric_out(num); + tmp = DatumGetCString(DirectFunctionCall1(numeric_out, + NumericGetDatum(num))); result = float8in(tmp); pfree(tmp); @@ -1954,7 +1929,8 @@ numeric_float4(Numeric num) return result; } - tmp = numeric_out(num); + tmp = DatumGetCString(DirectFunctionCall1(numeric_out, + NumericGetDatum(num))); result = float4in(tmp); pfree(tmp); diff --git a/src/backend/utils/adt/oracle_compat.c b/src/backend/utils/adt/oracle_compat.c index 522e6c7bce4..4455c04c556 100644 --- a/src/backend/utils/adt/oracle_compat.c +++ b/src/backend/utils/adt/oracle_compat.c @@ -1,7 +1,7 @@ /* * Edmund Mergl <E.Mergl@bawue.de> * - * $Id: oracle_compat.c,v 1.24 2000/04/12 17:15:51 momjian Exp $ + * $Id: oracle_compat.c,v 1.25 2000/06/13 07:35:07 tgl Exp $ * */ @@ -150,9 +150,12 @@ initcap(text *string) * ********************************************************************/ -text * -lpad(text *string1, int4 len, text *string2) +Datum +lpad(PG_FUNCTION_ARGS) { + text *string1 = PG_GETARG_TEXT_P(0); + int32 len = PG_GETARG_INT32(1); + text *string2 = PG_GETARG_TEXT_P(2); text *ret; char *ptr1, *ptr2, @@ -160,12 +163,10 @@ lpad(text *string1, int4 len, text *string2) int m, n; - if ((string1 == (text *) NULL) || - (len <= (VARSIZE(string1) - VARHDRSZ)) || - ((m = len - VARSIZE(string1) + VARHDRSZ) <= 0) || - (string2 == (text *) NULL) || + if (((VARSIZE(string1) - VARHDRSZ) < 0) || + ((m = len - (VARSIZE(string1) - VARHDRSZ)) <= 0) || ((VARSIZE(string2) - VARHDRSZ) <= 0)) - return string1; + PG_RETURN_TEXT_P(string1); ret = (text *) palloc(VARHDRSZ + len); VARSIZE(ret) = VARHDRSZ + len; @@ -176,7 +177,7 @@ lpad(text *string1, int4 len, text *string2) while (m--) { *ptr_ret++ = *ptr2; - ptr2 = ptr2 == VARDATA(string2) + VARSIZE(string2) - VARHDRSZ - 1 ? VARDATA(string2) : ++ptr2; + ptr2 = (ptr2 == VARDATA(string2) + VARSIZE(string2) - VARHDRSZ - 1) ? VARDATA(string2) : ++ptr2; } n = VARSIZE(string1) - VARHDRSZ; @@ -185,7 +186,7 @@ lpad(text *string1, int4 len, text *string2) while (n--) *ptr_ret++ = *ptr1++; - return ret; + PG_RETURN_TEXT_P(ret); } @@ -204,9 +205,12 @@ lpad(text *string1, int4 len, text *string2) * ********************************************************************/ -text * -rpad(text *string1, int4 len, text *string2) +Datum +rpad(PG_FUNCTION_ARGS) { + text *string1 = PG_GETARG_TEXT_P(0); + int32 len = PG_GETARG_INT32(1); + text *string2 = PG_GETARG_TEXT_P(2); text *ret; char *ptr1, *ptr2, @@ -214,12 +218,10 @@ rpad(text *string1, int4 len, text *string2) int m, n; - if ((string1 == (text *) NULL) || - (len <= (VARSIZE(string1) - VARHDRSZ)) || - ((m = len - VARSIZE(string1) + VARHDRSZ) <= 0) || - (string2 == (text *) NULL) || + if (((VARSIZE(string1) - VARHDRSZ) < 0) || + ((m = len - (VARSIZE(string1) - VARHDRSZ)) <= 0) || ((VARSIZE(string2) - VARHDRSZ) <= 0)) - return string1; + PG_RETURN_TEXT_P(string1); ret = (text *) palloc(VARHDRSZ + len); VARSIZE(ret) = VARHDRSZ + len; @@ -236,10 +238,10 @@ rpad(text *string1, int4 len, text *string2) while (m--) { *ptr_ret++ = *ptr2; - ptr2 = ptr2 == VARDATA(string2) + VARSIZE(string2) - VARHDRSZ - 1 ? VARDATA(string2) : ++ptr2; + ptr2 = (ptr2 == VARDATA(string2) + VARSIZE(string2) - VARHDRSZ - 1) ? VARDATA(string2) : ++ptr2; } - return ret; + PG_RETURN_TEXT_P(ret); } @@ -551,22 +553,25 @@ ascii(text *string) } /* ascii() */ -text * -ichar(int4 cvalue) +Datum +ichar(PG_FUNCTION_ARGS) { + int32 cvalue = PG_GETARG_INT32(0); text *result; result = (text *) palloc(VARHDRSZ + 1); VARSIZE(result) = VARHDRSZ + 1; *VARDATA(result) = (char) cvalue; - return result; -} /* ichar() */ + PG_RETURN_TEXT_P(result); +} -text * -repeat(text *string, int4 count) +Datum +repeat(PG_FUNCTION_ARGS) { + text *string = PG_GETARG_TEXT_P(0); + int32 count = PG_GETARG_INT32(1); text *result; int slen, tlen; @@ -589,5 +594,5 @@ repeat(text *string, int4 count) cp += slen; } - return result; -} /* repeat() */ + PG_RETURN_TEXT_P(result); +} diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index 7bee5abe282..5b2a2ea0163 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -3,7 +3,7 @@ * out of its tuple * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.53 2000/06/12 19:40:43 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.54 2000/06/13 07:35:08 tgl Exp $ * * This software is copyrighted by Jan Wieck - Hamburg. * @@ -551,18 +551,19 @@ pg_get_indexdef(PG_FUNCTION_ARGS) * fallback to 'unknown (UID=n)' * ---------- */ -NameData * -pg_get_userbyid(int32 uid) +Datum +pg_get_userbyid(PG_FUNCTION_ARGS) { + int32 uid = PG_GETARG_INT32(0); + Name result; HeapTuple usertup; Form_pg_shadow user_rec; - NameData *result; /* ---------- * Allocate space for the result * ---------- */ - result = (NameData *) palloc(NAMEDATALEN); + result = (Name) palloc(NAMEDATALEN); memset(NameStr(*result), 0, NAMEDATALEN); /* ---------- @@ -570,16 +571,17 @@ pg_get_userbyid(int32 uid) * ---------- */ usertup = SearchSysCacheTuple(SHADOWSYSID, - ObjectIdGetDatum(uid), 0, 0, 0); + ObjectIdGetDatum(uid), + 0, 0, 0); if (HeapTupleIsValid(usertup)) { user_rec = (Form_pg_shadow) GETSTRUCT(usertup); StrNCpy(NameStr(*result), NameStr(user_rec->usename), NAMEDATALEN); } else - sprintf((char *) result, "unknown (UID=%d)", uid); + sprintf(NameStr(*result), "unknown (UID=%d)", uid); - return result; + PG_RETURN_NAME(result); } /* ---------- diff --git a/src/backend/utils/adt/varchar.c b/src/backend/utils/adt/varchar.c index 781d6591b3b..80d8a6a8db6 100644 --- a/src/backend/utils/adt/varchar.c +++ b/src/backend/utils/adt/varchar.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.63 2000/06/05 07:28:52 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.64 2000/06/13 07:35:08 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -61,20 +61,21 @@ extern char *convertstr(char *, int, int); /* * bpcharin - * converts a string of char() type to the internal representation. - * len is the length specified in () plus VARHDRSZ bytes. (XXX dummy is here - * because we pass typelem as the second argument for array_in.) + * len is the length specified in () plus VARHDRSZ bytes. */ -char * -bpcharin(char *s, int dummy, int32 atttypmod) +Datum +bpcharin(PG_FUNCTION_ARGS) { - char *result, - *r; + char *s = PG_GETARG_CSTRING(0); +#ifdef NOT_USED + Oid typelem = PG_GETARG_OID(1); +#endif + int32 atttypmod = PG_GETARG_INT32(2); + BpChar *result; + char *r; int len; int i; - if (s == NULL) - return (char *) NULL; - if (atttypmod < (int32) VARHDRSZ) { /* If typmod is -1 (or invalid), use the actual string length */ @@ -84,7 +85,7 @@ bpcharin(char *s, int dummy, int32 atttypmod) else len = atttypmod - VARHDRSZ; - result = (char *) palloc(atttypmod); + result = (BpChar *) palloc(atttypmod); VARSIZE(result) = atttypmod; r = VARDATA(result); for (i = 0; i < len; i++, r++, s++) @@ -95,85 +96,78 @@ bpcharin(char *s, int dummy, int32 atttypmod) } #ifdef CYR_RECODE - convertstr(result + VARHDRSZ, len, 0); + convertstr(VARDATA(result), len, 0); #endif /* blank pad the string if necessary */ for (; i < len; i++) *r++ = ' '; - return result; + + PG_RETURN_BPCHAR_P(result); } -char * -bpcharout(char *s) +Datum +bpcharout(PG_FUNCTION_ARGS) { + BpChar *s = PG_GETARG_BPCHAR_P(0); char *result; int len; - if (s == NULL) - { - result = (char *) palloc(2); - result[0] = '-'; - result[1] = '\0'; - } - else - { - len = VARSIZE(s) - VARHDRSZ; - result = (char *) palloc(len + 1); - StrNCpy(result, VARDATA(s), len + 1); /* these are blank-padded */ - } + len = VARSIZE(s) - VARHDRSZ; + result = (char *) palloc(len + 1); + StrNCpy(result, VARDATA(s), len + 1); /* copy and add null term */ #ifdef CYR_RECODE convertstr(result, len, 1); #endif - return result; + PG_RETURN_CSTRING(result); } /* bpchar() * Converts a char() type to a specific internal length. * len is the length specified in () plus VARHDRSZ bytes. */ -char * -bpchar(char *s, int32 len) +Datum +bpchar(PG_FUNCTION_ARGS) { - char *result, - *r; + BpChar *str = PG_GETARG_BPCHAR_P(0); + int32 len = PG_GETARG_INT32(1); + BpChar *result; + char *r, + *s; int rlen, slen; int i; - if (s == NULL) - return (char *) NULL; - /* No work if typmod is invalid or supplied data matches it already */ - if (len < (int32) VARHDRSZ || len == VARSIZE(s)) - return s; + if (len < (int32) VARHDRSZ || len == VARSIZE(str)) + PG_RETURN_BPCHAR_P(str); rlen = len - VARHDRSZ; #ifdef STRINGDEBUG printf("bpchar- convert string length %d (%d) ->%d (%d)\n", - VARSIZE(s) - VARHDRSZ, VARSIZE(s), rlen, len); + VARSIZE(str) - VARHDRSZ, VARSIZE(str), rlen, len); #endif - result = (char *) palloc(len); + result = (BpChar *) palloc(len); VARSIZE(result) = len; r = VARDATA(result); -#ifdef MULTIBYTE +#ifdef MULTIBYTE /* * truncate multi-byte string in a way not to break multi-byte * boundary */ - if (VARSIZE(s) > len) - slen = pg_mbcliplen(VARDATA(s), VARSIZE(s) - VARHDRSZ, rlen); + if (VARSIZE(str) > len) + slen = pg_mbcliplen(VARDATA(str), VARSIZE(str) - VARHDRSZ, rlen); else - slen = VARSIZE(s) - VARHDRSZ; + slen = VARSIZE(str) - VARHDRSZ; #else - slen = VARSIZE(s) - VARHDRSZ; + slen = VARSIZE(str) - VARHDRSZ; #endif - s = VARDATA(s); + s = VARDATA(str); #ifdef STRINGDEBUG printf("bpchar- string is '"); @@ -181,13 +175,9 @@ bpchar(char *s, int32 len) for (i = 0; (i < rlen) && (i < slen); i++) { - if (*s == '\0') - break; - #ifdef STRINGDEBUG printf("%c", *s); #endif - *r++ = *s++; } @@ -199,19 +189,21 @@ bpchar(char *s, int32 len) for (; i < rlen; i++) *r++ = ' '; - return result; -} /* bpchar() */ + PG_RETURN_BPCHAR_P(result); +} /* _bpchar() - * Converts an array of char() type to a specific internal length. + * Converts an array of char() elements to a specific internal length. * len is the length specified in () plus VARHDRSZ bytes. */ -ArrayType * -_bpchar(ArrayType *v, int32 len) +Datum +_bpchar(PG_FUNCTION_ARGS) { + ArrayType *v = (ArrayType *) PG_GETARG_VARLENA_P(0); + int32 len = PG_GETARG_INT32(1); FunctionCallInfoData locfcinfo; - Datum result; - /* Since bpchar() is a built-in function, we should only need to + /* + * Since bpchar() is a built-in function, we should only need to * look it up once per run. */ static FmgrInfo bpchar_finfo; @@ -226,9 +218,7 @@ _bpchar(ArrayType *v, int32 len) locfcinfo.arg[0] = PointerGetDatum(v); locfcinfo.arg[1] = Int32GetDatum(len); - result = array_map(&locfcinfo, BPCHAROID, BPCHAROID); - - return (ArrayType *) DatumGetPointer(result); + return array_map(&locfcinfo, BPCHAROID, BPCHAROID); } @@ -240,7 +230,7 @@ _bpchar(ArrayType *v, int32 len) Datum bpchar_char(PG_FUNCTION_ARGS) { - struct varlena *s = PG_GETARG_BPCHAR_P(0); + BpChar *s = PG_GETARG_BPCHAR_P(0); PG_RETURN_CHAR(*VARDATA(s)); } @@ -252,9 +242,9 @@ Datum char_bpchar(PG_FUNCTION_ARGS) { char c = PG_GETARG_CHAR(0); - struct varlena *result; + BpChar *result; - result = (struct varlena *) palloc(VARHDRSZ + 1); + result = (BpChar *) palloc(VARHDRSZ + 1); VARSIZE(result) = VARHDRSZ + 1; *(VARDATA(result)) = c; @@ -338,75 +328,67 @@ name_bpchar(NameData *s) /* * varcharin - * converts a string of varchar() type to the internal representation. - * len is the length specified in () plus VARHDRSZ bytes. (XXX dummy is here - * because we pass typelem as the second argument for array_in.) + * len is the length specified in () plus VARHDRSZ bytes. */ -char * -varcharin(char *s, int dummy, int32 atttypmod) +Datum +varcharin(PG_FUNCTION_ARGS) { - char *result; + char *s = PG_GETARG_CSTRING(0); +#ifdef NOT_USED + Oid typelem = PG_GETARG_OID(1); +#endif + int32 atttypmod = PG_GETARG_INT32(2); + VarChar *result; int len; - if (s == NULL) - return (char *) NULL; - len = strlen(s) + VARHDRSZ; if (atttypmod >= (int32) VARHDRSZ && len > atttypmod) len = atttypmod; /* clip the string at max length */ - result = (char *) palloc(len); + result = (VarChar *) palloc(len); VARSIZE(result) = len; - strncpy(VARDATA(result), s, len - VARHDRSZ); + memcpy(VARDATA(result), s, len - VARHDRSZ); #ifdef CYR_RECODE - convertstr(result + VARHDRSZ, len, 0); + convertstr(VARDATA(result), len, 0); #endif - return result; + PG_RETURN_VARCHAR_P(result); } -char * -varcharout(char *s) +Datum +varcharout(PG_FUNCTION_ARGS) { + VarChar *s = PG_GETARG_VARCHAR_P(0); char *result; int len; - if (s == NULL) - { - result = (char *) palloc(2); - result[0] = '-'; - result[1] = '\0'; - } - else - { - len = VARSIZE(s) - VARHDRSZ; - result = (char *) palloc(len + 1); - StrNCpy(result, VARDATA(s), len + 1); - } + len = VARSIZE(s) - VARHDRSZ; + result = (char *) palloc(len + 1); + StrNCpy(result, VARDATA(s), len + 1); /* copy and add null term */ #ifdef CYR_RECODE convertstr(result, len, 1); #endif - return result; + PG_RETURN_CSTRING(result); } /* varchar() * Converts a varchar() type to the specified size. * slen is the length specified in () plus VARHDRSZ bytes. */ -char * -varchar(char *s, int32 slen) +Datum +varchar(PG_FUNCTION_ARGS) { - char *result; + VarChar *s = PG_GETARG_VARCHAR_P(0); + int32 slen = PG_GETARG_INT32(1); + VarChar *result; int len; - if (s == NULL) - return (char *) NULL; - len = VARSIZE(s); if (slen < (int32) VARHDRSZ || len <= slen) - return (char *) s; + PG_RETURN_VARCHAR_P(s); /* only reach here if we need to truncate string... */ @@ -422,23 +404,25 @@ varchar(char *s, int32 slen) len = slen - VARHDRSZ; #endif - result = (char *) palloc(slen); + result = (VarChar *) palloc(slen); VARSIZE(result) = slen; - strncpy(VARDATA(result), VARDATA(s), len); + memcpy(VARDATA(result), VARDATA(s), len); - return result; -} /* varchar() */ + PG_RETURN_VARCHAR_P(result); +} /* _varchar() - * Converts an array of varchar() type to the specified size. + * Converts an array of varchar() elements to the specified size. * len is the length specified in () plus VARHDRSZ bytes. */ -ArrayType * -_varchar(ArrayType *v, int32 len) +Datum +_varchar(PG_FUNCTION_ARGS) { + ArrayType *v = (ArrayType *) PG_GETARG_VARLENA_P(0); + int32 len = PG_GETARG_INT32(1); FunctionCallInfoData locfcinfo; - Datum result; - /* Since varchar() is a built-in function, we should only need to + /* + * Since varchar() is a built-in function, we should only need to * look it up once per run. */ static FmgrInfo varchar_finfo; @@ -453,9 +437,7 @@ _varchar(ArrayType *v, int32 len) locfcinfo.arg[0] = PointerGetDatum(v); locfcinfo.arg[1] = Int32GetDatum(len); - result = array_map(&locfcinfo, VARCHAROID, VARCHAROID); - - return (ArrayType *) DatumGetPointer(result); + return array_map(&locfcinfo, VARCHAROID, VARCHAROID); } diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c index 154d8beb270..34a3c13e1aa 100644 --- a/src/backend/utils/adt/varlena.c +++ b/src/backend/utils/adt/varlena.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.58 2000/04/12 17:15:52 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.59 2000/06/13 07:35:08 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -323,21 +323,19 @@ textcat(text *t1, text *t2) * Formerly returned the entire string; now returns a portion. * - Thomas Lockhart 1998-12-10 */ -text * -text_substr(text *string, int32 m, int32 n) +Datum +text_substr(PG_FUNCTION_ARGS) { + text *string = PG_GETARG_TEXT_P(0); + int32 m = PG_GETARG_INT32(1); + int32 n = PG_GETARG_INT32(2); text *ret; int len; - #ifdef MULTIBYTE int i; char *p; - #endif - if (string == (text *) NULL) - return string; - len = VARSIZE(string) - VARHDRSZ; #ifdef MULTIBYTE len = pg_mbstrlen_with_len(VARDATA(string), len); @@ -374,13 +372,14 @@ text_substr(text *string, int32 m, int32 n) p += pg_mblen(p); n = p - (VARDATA(string) + m); #endif + ret = (text *) palloc(VARHDRSZ + n); VARSIZE(ret) = VARHDRSZ + n; memcpy(VARDATA(ret), VARDATA(string) + m, n); - return ret; -} /* text_substr() */ + PG_RETURN_TEXT_P(ret); +} /* * textpos - @@ -636,19 +635,17 @@ byteaoctetlen(bytea *v) * byteaGetByte * * this routine treats "bytea" as an array of bytes. - * It returns the Nth byte (a number between 0 and 255) or - * it dies if the length of this array is less than n. + * It returns the Nth byte (a number between 0 and 255). *------------------------------------------------------------- */ -int32 -byteaGetByte(bytea *v, int32 n) +Datum +byteaGetByte(PG_FUNCTION_ARGS) { + bytea *v = PG_GETARG_BYTEA_P(0); + int32 n = PG_GETARG_INT32(1); int len; int byte; - if (!PointerIsValid(v)) - return 0; - len = VARSIZE(v) - VARHDRSZ; if (n < 0 || n >= len) @@ -657,7 +654,7 @@ byteaGetByte(bytea *v, int32 n) byte = ((unsigned char *) VARDATA(v))[n]; - return (int32) byte; + PG_RETURN_INT32(byte); } /*------------------------------------------------------------- @@ -665,21 +662,19 @@ byteaGetByte(bytea *v, int32 n) * * This routine treats a "bytea" type like an array of bits. * It returns the value of the Nth bit (0 or 1). - * If 'n' is out of range, it dies! * *------------------------------------------------------------- */ -int32 -byteaGetBit(bytea *v, int32 n) +Datum +byteaGetBit(PG_FUNCTION_ARGS) { + bytea *v = PG_GETARG_BYTEA_P(0); + int32 n = PG_GETARG_INT32(1); int byteNo, bitNo; int len; int byte; - if (!PointerIsValid(v)) - return 0; - len = VARSIZE(v) - VARHDRSZ; if (n < 0 || n >= len * 8) @@ -692,9 +687,9 @@ byteaGetBit(bytea *v, int32 n) byte = ((unsigned char *) VARDATA(v))[byteNo]; if (byte & (1 << bitNo)) - return (int32) 1; + PG_RETURN_INT32(1); else - return (int32) 0; + PG_RETURN_INT32(0); } /*------------------------------------------------------------- @@ -705,15 +700,15 @@ byteaGetBit(bytea *v, int32 n) * *------------------------------------------------------------- */ -bytea * -byteaSetByte(bytea *v, int32 n, int32 newByte) +Datum +byteaSetByte(PG_FUNCTION_ARGS) { + bytea *v = PG_GETARG_BYTEA_P(0); + int32 n = PG_GETARG_INT32(1); + int32 newByte = PG_GETARG_INT32(2); int len; bytea *res; - if (!PointerIsValid(v)) - return 0; - len = VARSIZE(v) - VARHDRSZ; if (n < 0 || n >= len) @@ -731,7 +726,7 @@ byteaSetByte(bytea *v, int32 n, int32 newByte) */ ((unsigned char *) VARDATA(res))[n] = newByte; - return res; + PG_RETURN_BYTEA_P(res); } /*------------------------------------------------------------- @@ -742,9 +737,12 @@ byteaSetByte(bytea *v, int32 n, int32 newByte) * *------------------------------------------------------------- */ -bytea * -byteaSetBit(bytea *v, int32 n, int32 newBit) +Datum +byteaSetBit(PG_FUNCTION_ARGS) { + bytea *v = PG_GETARG_BYTEA_P(0); + int32 n = PG_GETARG_INT32(1); + int32 newBit = PG_GETARG_INT32(2); bytea *res; int len; int oldByte, @@ -752,9 +750,6 @@ byteaSetBit(bytea *v, int32 n, int32 newBit) int byteNo, bitNo; - if (!PointerIsValid(v)) - return NULL; - len = VARSIZE(v) - VARHDRSZ; if (n < 0 || n >= len * 8) @@ -771,24 +766,24 @@ byteaSetBit(bytea *v, int32 n, int32 newBit) elog(ERROR, "byteaSetBit: new bit must be 0 or 1"); /* - * get the byte where the bit we want is stored. + * Make a copy of the original varlena. */ - oldByte = byteaGetByte(v, byteNo); + res = (bytea *) palloc(VARSIZE(v)); + memcpy((char *) res, (char *) v, VARSIZE(v)); /* - * calculate the new value for that byte + * Update the byte. */ + oldByte = ((unsigned char *) VARDATA(res))[byteNo]; + if (newBit == 0) newByte = oldByte & (~(1 << bitNo)); else newByte = oldByte | (1 << bitNo); - /* - * NOTE: 'byteaSetByte' creates a copy of 'v' & sets the byte. - */ - res = byteaSetByte(v, byteNo, newByte); + ((unsigned char *) VARDATA(res))[byteNo] = newByte; - return res; + PG_RETURN_BYTEA_P(res); } diff --git a/src/backend/utils/init/miscinit.c b/src/backend/utils/init/miscinit.c index 12facde811e..3dee08ec51b 100644 --- a/src/backend/utils/init/miscinit.c +++ b/src/backend/utils/init/miscinit.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/init/miscinit.c,v 1.48 2000/06/08 22:37:33 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/init/miscinit.c,v 1.49 2000/06/13 07:35:09 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -28,6 +28,7 @@ #include "catalog/catname.h" #include "catalog/pg_shadow.h" #include "miscadmin.h" +#include "utils/builtins.h" #include "utils/syscache.h" static char *GetPidFname(void); @@ -98,25 +99,26 @@ SetDatabaseName(const char *name) } #ifndef MULTIBYTE -/* even if MULTIBYTE is not enabled, this function is neccesary - * since pg_proc.h has entries for them. +/* even if MULTIBYTE is not enabled, these functions are necessary + * since pg_proc.h has references to them. */ -const char * -getdatabaseencoding() + +Datum +getdatabaseencoding(PG_FUNCTION_ARGS) { - return ("SQL_ASCII"); + PG_RETURN_NAME("SQL_ASCII"); } -const char * -pg_encoding_to_char(int encoding) +Datum +PG_encoding_to_char(PG_FUNCTION_ARGS) { - return ("SQL_ASCII"); + PG_RETURN_NAME("SQL_ASCII"); } -int -pg_char_to_encoding(const char *encoding_string) +Datum +PG_char_to_encoding(PG_FUNCTION_ARGS) { - return (0); + PG_RETURN_INT32(0); } #endif diff --git a/src/backend/utils/mb/common.c b/src/backend/utils/mb/common.c index 2927bc5e946..89f63ad2ec0 100644 --- a/src/backend/utils/mb/common.c +++ b/src/backend/utils/mb/common.c @@ -2,7 +2,7 @@ * This file contains some public functions * usable for both the backend and the frontend. * Tatsuo Ishii - * $Id: common.c,v 1.8 2000/01/18 05:14:24 ishii Exp $ */ + * $Id: common.c,v 1.9 2000/06/13 07:35:15 tgl Exp $ */ #include <stdlib.h> #include <string.h> @@ -14,8 +14,10 @@ #endif #include "postgres.h" + #include "miscadmin.h" #include "mb/pg_wchar.h" +#include "utils/builtins.h" /* * convert encoding char to encoding symbol value. @@ -38,6 +40,15 @@ pg_char_to_encoding(const char *s) return (p->encoding); } +/* Same, as an fmgr-callable function */ +Datum +PG_char_to_encoding(PG_FUNCTION_ARGS) +{ + Name s = PG_GETARG_NAME(0); + + PG_RETURN_INT32(pg_char_to_encoding(NameStr(*s))); +} + /* * check to see if encoding name is valid */ @@ -77,6 +88,15 @@ pg_encoding_to_char(int encoding) return (p->name); } +/* Same, as an fmgr-callable function */ +Datum +PG_encoding_to_char(PG_FUNCTION_ARGS) +{ + int32 encoding = PG_GETARG_INT32(0); + + PG_RETURN_NAME(pg_encoding_to_char(encoding)); +} + /* returns the byte length of a multi-byte word for an encoding */ int pg_encoding_mblen(int encoding, const unsigned char *mbstr) diff --git a/src/backend/utils/mb/mbutils.c b/src/backend/utils/mb/mbutils.c index ba22ec347ff..2e21f4f37ae 100644 --- a/src/backend/utils/mb/mbutils.c +++ b/src/backend/utils/mb/mbutils.c @@ -3,12 +3,14 @@ * client encoding and server internal encoding. * (currently mule internal code (mic) is used) * Tatsuo Ishii - * $Id: mbutils.c,v 1.9 1999/09/11 22:28:00 tgl Exp $ */ + * $Id: mbutils.c,v 1.10 2000/06/13 07:35:12 tgl Exp $ */ #include "postgres.h" + #include "miscadmin.h" #include "mb/pg_wchar.h" +#include "utils/builtins.h" static int client_encoding = -1; static void (*client_to_mic) ();/* something to MIC */ @@ -266,10 +268,10 @@ GetDatabaseEncoding() } /* for builtin-function */ -const char * -getdatabaseencoding() +Datum +getdatabaseencoding(PG_FUNCTION_ARGS) { - return (pg_encoding_to_char(DatabaseEncoding)); + PG_RETURN_NAME(pg_encoding_to_char(DatabaseEncoding)); } /* set and get template1 database encoding */ |