#
#
# IDENTIFICATION
-# $Header: /cvsroot/pgsql/src/Makefile.global.in,v 1.31 1997/12/20 18:36:26 scrappy Exp $
+# $Header: /cvsroot/pgsql/src/Makefile.global.in,v 1.32 1998/01/15 19:41:35 pgsql Exp $
#
# NOTES
# Essentially all Postgres make files include this file and use the
YACC= @YACC@
LEX= @LEX@
AROPT= @AROPT@
-CFLAGS= -I$(SRCDIR)/include @CPPFLAGS@ @CFLAGS@
+CFLAGS= -I$(SRCDIR)/include -I$(SRCDIR)/backend @CPPFLAGS@ @CFLAGS@
CFLAGS_SL= @SHARED_LIB@
LDFLAGS= @LDFLAGS@ @LIBS@
DLSUFFIX= @DLSUFFIX@
# Makefile for access/common
#
# IDENTIFICATION
-# $Header: /cvsroot/pgsql/src/backend/access/common/Makefile,v 1.8 1997/12/20 00:22:11 scrappy Exp $
+# $Header: /cvsroot/pgsql/src/backend/access/common/Makefile,v 1.9 1998/01/15 19:41:42 pgsql Exp $
#
#-------------------------------------------------------------------------
SUBSYS.o: $(OBJS)
$(LD) -r -o SUBSYS.o $(OBJS)
-heapvalid.o tupdesc.o: ../../fmgr.h
+heaptuple.o heapvalid.o tupdesc.o: ../../fmgr.h
../../fmgr.h:
$(MAKE) -C ../.. fmgr.h
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/Attic/indexvalid.c,v 1.16 1997/09/08 02:19:55 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/Attic/indexvalid.c,v 1.17 1998/01/15 19:41:44 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
if (key[0].sk_flags & SK_COMMUTE)
{
- test = (*(key[0].sk_func))
+ test = (*(fmgr_faddr(&key[0].sk_func)))
(DatumGetPointer(key[0].sk_argument),
datum) ? 1 : 0;
}
else
{
- test = (*(key[0].sk_func))
+ test = (*(fmgr_faddr(&key[0].sk_func)))
(datum,
DatumGetPointer(key[0].sk_argument)) ? 1 : 0;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/scankey.c,v 1.10 1997/09/07 04:37:39 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/scankey.c,v 1.11 1998/01/15 19:41:46 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
entry->sk_attno = attributeNumber;
entry->sk_procedure = procedure;
entry->sk_argument = argument;
- fmgr_info(procedure, &entry->sk_func, &entry->sk_nargs);
+ fmgr_info(procedure, &entry->sk_func);
+ entry->sk_nargs = entry->sk_func.fn_nargs;
Assert(ScanKeyEntryIsLegal(entry));
}
ev1p = &((GISTENTRY *) VARDATA(evec))[1];
/* form union of decompressed entries */
- datum = (char *) (giststate->unionFn) (evec, &datumsize);
+ datum = (*fmgr_faddr(&giststate->unionFn)) (evec, &datumsize);
/* did union leave decompressed version of oldud unchanged? */
- (giststate->equalFn) (ev0p->pred, datum, &result);
+ (*fmgr_faddr(&giststate->equalFn)) (ev0p->pred, datum, &result);
if (!result)
{
TupleDesc td = RelationGetTupleDescriptor(r);
VARSIZE(entryvec) = (maxoff + 2) * sizeof(GISTENTRY) + VARHDRSZ;
/* now let the user-defined picksplit function set up the split vector */
- (giststate->picksplitFn) (entryvec, &v);
+ (*fmgr_faddr(&giststate->picksplitFn)) (entryvec, &v);
/* compress ldatum and rdatum */
gistcentryinit(giststate, &tmpentry, v.spl_ldatum, (Relation) NULL,
size = IndexTupleSize(datum) - sizeof(IndexTupleData);
datum += sizeof(IndexTupleData);
gistdentryinit(giststate, &entry, datum, r, p, i, size, FALSE);
- (giststate->penaltyFn) (&entry, &identry, &usize);
+ (*fmgr_faddr(&giststate->penaltyFn)) (&entry, &identry, &usize);
if (which_grow < 0 || usize < which_grow)
{
which = i;
RegProcedure penalty_proc,
picksplit_proc,
equal_proc;
- func_ptr user_fn;
- int pronargs;
HeapTuple htup;
IndexTupleForm itupform;
penalty_proc = index_getprocid(index, 1, GIST_PENALTY_PROC);
picksplit_proc = index_getprocid(index, 1, GIST_PICKSPLIT_PROC);
equal_proc = index_getprocid(index, 1, GIST_EQUAL_PROC);
- fmgr_info(consistent_proc, &user_fn, &pronargs);
- giststate->consistentFn = user_fn;
- fmgr_info(union_proc, &user_fn, &pronargs);
- giststate->unionFn = user_fn;
- fmgr_info(compress_proc, &user_fn, &pronargs);
- giststate->compressFn = user_fn;
- fmgr_info(decompress_proc, &user_fn, &pronargs);
- giststate->decompressFn = user_fn;
- fmgr_info(penalty_proc, &user_fn, &pronargs);
- giststate->penaltyFn = user_fn;
- fmgr_info(picksplit_proc, &user_fn, &pronargs);
- giststate->picksplitFn = user_fn;
- fmgr_info(equal_proc, &user_fn, &pronargs);
- giststate->equalFn = user_fn;
+ fmgr_info(consistent_proc, &giststate->consistentFn);
+ fmgr_info(union_proc, &giststate->unionFn);
+ fmgr_info(compress_proc, &giststate->compressFn);
+ fmgr_info(decompress_proc, &giststate->decompressFn);
+ fmgr_info(penalty_proc, &giststate->penaltyFn);
+ fmgr_info(picksplit_proc, &giststate->picksplitFn);
+ fmgr_info(equal_proc, &giststate->equalFn);
/* see if key type is different from type of attribute being indexed */
htup = SearchSysCacheTuple(INDEXRELID, ObjectIdGetDatum(index->rd_id),
gistentryinit(*e, pr, r, pg, o, b, l);
if (giststate->haskeytype)
{
- dep = (GISTENTRY *) ((giststate->decompressFn) (e));
+ dep = (GISTENTRY *) ((*fmgr_faddr(&giststate->decompressFn)) (e));
gistentryinit(*e, dep->pred, dep->rel, dep->page, dep->offset, dep->bytes,
dep->leafkey);
if (dep != e)
gistentryinit(*e, pr, r, pg, o, b, l);
if (giststate->haskeytype)
{
- cep = (GISTENTRY *) ((giststate->compressFn) (e));
+ cep = (GISTENTRY *) ((*fmgr_faddr(&giststate->compressFn)) (e));
gistentryinit(*e, cep->pred, cep->rel, cep->page, cep->offset, cep->bytes,
cep->leafkey);
if (cep != e)
if (key[0].sk_flags & SK_COMMUTE)
{
- test = (*(key[0].sk_func))
+ test = (*fmgr_faddr(&key[0].sk_func))
(DatumGetPointer(key[0].sk_argument),
&de, key[0].sk_procedure) ? 1 : 0;
}
else
{
- test = (*(key[0].sk_func))
+ test = (*fmgr_faddr(&key[0].sk_func))
(&de,
DatumGetPointer(key[0].sk_argument),
key[0].sk_procedure) ? 1 : 0;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.15 1998/01/07 21:01:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.16 1998/01/15 19:42:02 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
switch (operator->flags ^ entry->sk_flags)
{
case 0x0:
- tmpres = (long) FMGR_PTR2(entry->sk_func, entry->sk_procedure,
+ tmpres = (long) FMGR_PTR2(&entry->sk_func,
left, right);
break;
case SK_NEGATE:
- tmpres = (long) !FMGR_PTR2(entry->sk_func, entry->sk_procedure,
+ tmpres = (long) !FMGR_PTR2(&entry->sk_func,
left, right);
break;
case SK_COMMUTE:
- tmpres = (long) FMGR_PTR2(entry->sk_func, entry->sk_procedure,
+ tmpres = (long) FMGR_PTR2(&entry->sk_func,
right, left);
break;
case SK_NEGATE | SK_COMMUTE:
- tmpres = (long) !FMGR_PTR2(entry->sk_func, entry->sk_procedure,
+ tmpres = (long) !FMGR_PTR2(&entry->sk_func,
right, left);
break;
entry->sk_flags = 0;
entry->sk_procedure =
((OperatorTupleForm) GETSTRUCT(tuple))->oprcode;
- fmgr_info(entry->sk_procedure, &entry->sk_func, &entry->sk_nargs);
+ fmgr_info(entry->sk_procedure, &entry->sk_func);
+ entry->sk_nargs = entry->sk_func.fn_nargs;
if (!RegProcedureIsValid(entry->sk_procedure))
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.24 1998/01/07 21:01:52 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.25 1998/01/15 19:42:10 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
if (entry->sk_flags & SK_ISNULL || null)
return (false);
- result = (long) FMGR_PTR2(entry->sk_func, entry->sk_procedure,
- entry->sk_argument, datum);
+ result = (long) FMGR_PTR2(&entry->sk_func, entry->sk_argument, datum);
if (result != 0)
return (false);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.29 1998/01/07 21:01:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtsearch.c,v 1.30 1998/01/15 19:42:13 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
}
else
{
- tmpres = (long) FMGR_PTR2(entry->sk_func, entry->sk_procedure,
- entry->sk_argument, datum);
+ tmpres = (long) FMGR_PTR2(&entry->sk_func, entry->sk_argument, datum);
}
result = tmpres;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.17 1998/01/07 21:02:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtutils.c,v 1.18 1998/01/15 19:42:15 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
{
/* yup, use the appropriate value */
test =
- (long) FMGR_PTR2(cur->sk_func, cur->sk_procedure,
- cur->sk_argument, xform[j].sk_argument);
+ (long) FMGR_PTR2(&cur->sk_func, cur->sk_argument, xform[j].sk_argument);
if (test)
xform[j].sk_argument = cur->sk_argument;
else if (j == (BTEqualStrategyNumber - 1))
if (key[0].sk_flags & SK_COMMUTE)
{
- test = (int) (*(key[0].sk_func))
+ test = (int) (*fmgr_faddr(&key[0].sk_func))
(DatumGetPointer(key[0].sk_argument),
datum);
}
else
{
- test = (int) (*(key[0].sk_func))
+ test = (int) (*fmgr_faddr(&key[0].sk_func))
(datum,
DatumGetPointer(key[0].sk_argument));
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.21 1998/01/07 21:02:07 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.22 1998/01/15 19:42:19 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
typedef struct RTSTATE
{
- func_ptr unionFn; /* union function */
- func_ptr sizeFn; /* size function */
- func_ptr interFn; /* intersection function */
+ FmgrInfo unionFn; /* union function */
+ FmgrInfo sizeFn; /* size function */
+ FmgrInfo interFn; /* intersection function */
} RTSTATE;
/* non-export function prototypes */
oldud = (char *) PageGetItem(p, PageGetItemId(p, stk->rts_child));
oldud += sizeof(IndexTupleData);
- (*rtstate->sizeFn) (oldud, &old_size);
- datum = (char *) (*rtstate->unionFn) (oldud, datum);
+ (*fmgr_faddr(&rtstate->sizeFn)) (oldud, &old_size);
+ datum = (char *) (*fmgr_faddr(&rtstate->unionFn)) (oldud, datum);
- (*rtstate->sizeFn) (datum, &newd_size);
+ (*fmgr_faddr(&rtstate->sizeFn)) (datum, &newd_size);
if (newd_size != old_size)
{
* union proc, which is guaranteed to return a rectangle.
*/
- tdatum = (char *) (*rtstate->unionFn) (datum, datum);
+ tdatum = (char *) (*fmgr_faddr(&rtstate->unionFn)) (datum, datum);
rttighten(r, stk->rts_parent, tdatum, att_size, rtstate);
pfree(tdatum);
}
WriteBuffer(b);
ldatum = (((char *) ltup) + sizeof(IndexTupleData));
rdatum = (((char *) rtup) + sizeof(IndexTupleData));
- newdatum = (char *) (*rtstate->unionFn) (ldatum, rdatum);
+ newdatum = (char *) (*fmgr_faddr(&rtstate->unionFn)) (ldatum, rdatum);
rttighten(r, stk->rts_parent, newdatum,
(IndexTupleSize(rtup) - sizeof(IndexTupleData)), rtstate);
datum_beta = ((char *) item_2) + sizeof(IndexTupleData);
/* compute the wasted space by unioning these guys */
- union_d = (char *) (rtstate->unionFn) (datum_alpha, datum_beta);
- (rtstate->sizeFn) (union_d, &size_union);
- inter_d = (char *) (rtstate->interFn) (datum_alpha, datum_beta);
- (rtstate->sizeFn) (inter_d, &size_inter);
+ union_d = (char *) (*fmgr_faddr(&rtstate->unionFn)) (datum_alpha, datum_beta);
+ (*fmgr_faddr(&rtstate->sizeFn)) (union_d, &size_union);
+ inter_d = (char *) (*fmgr_faddr(&rtstate->interFn)) (datum_alpha, datum_beta);
+ (*fmgr_faddr(&rtstate->sizeFn)) (inter_d, &size_inter);
size_waste = size_union - size_inter;
pfree(union_d);
item_1 = (IndexTuple) PageGetItem(page, PageGetItemId(page, seed_1));
datum_alpha = ((char *) item_1) + sizeof(IndexTupleData);
- datum_l = (char *) (*rtstate->unionFn) (datum_alpha, datum_alpha);
- (*rtstate->sizeFn) (datum_l, &size_l);
+ datum_l = (char *) (*fmgr_faddr(&rtstate->unionFn)) (datum_alpha, datum_alpha);
+ (*fmgr_faddr(&rtstate->sizeFn)) (datum_l, &size_l);
item_2 = (IndexTuple) PageGetItem(page, PageGetItemId(page, seed_2));
datum_beta = ((char *) item_2) + sizeof(IndexTupleData);
- datum_r = (char *) (*rtstate->unionFn) (datum_beta, datum_beta);
- (*rtstate->sizeFn) (datum_r, &size_r);
+ datum_r = (char *) (*fmgr_faddr(&rtstate->unionFn)) (datum_beta, datum_beta);
+ (*fmgr_faddr(&rtstate->sizeFn)) (datum_r, &size_r);
/*
* Now split up the regions between the two seeds. An important
}
datum_alpha = ((char *) item_1) + sizeof(IndexTupleData);
- union_dl = (char *) (*rtstate->unionFn) (datum_l, datum_alpha);
- union_dr = (char *) (*rtstate->unionFn) (datum_r, datum_alpha);
- (*rtstate->sizeFn) (union_dl, &size_alpha);
- (*rtstate->sizeFn) (union_dr, &size_beta);
+ union_dl = (char *) (*fmgr_faddr(&rtstate->unionFn)) (datum_l, datum_alpha);
+ union_dr = (char *) (*fmgr_faddr(&rtstate->unionFn)) (datum_r, datum_alpha);
+ (*fmgr_faddr(&rtstate->sizeFn)) (union_dl, &size_alpha);
+ (*fmgr_faddr(&rtstate->sizeFn)) (union_dr, &size_beta);
/* pick which page to add it to */
if (size_alpha - size_l < size_beta - size_r)
{
datum = (char *) PageGetItem(p, PageGetItemId(p, i));
datum += sizeof(IndexTupleData);
- (*rtstate->sizeFn) (datum, &dsize);
- ud = (char *) (*rtstate->unionFn) (datum, id);
- (*rtstate->sizeFn) (ud, &usize);
+ (*fmgr_faddr(&rtstate->sizeFn)) (datum, &dsize);
+ ud = (char *) (*fmgr_faddr(&rtstate->unionFn)) (datum, id);
+ (*fmgr_faddr(&rtstate->sizeFn)) (ud, &usize);
pfree(ud);
if (which_grow < 0 || usize - dsize < which_grow)
{
RegProcedure union_proc,
size_proc,
inter_proc;
- func_ptr user_fn;
- int pronargs;
union_proc = index_getprocid(index, 1, RT_UNION_PROC);
size_proc = index_getprocid(index, 1, RT_SIZE_PROC);
inter_proc = index_getprocid(index, 1, RT_INTER_PROC);
- fmgr_info(union_proc, &user_fn, &pronargs);
- rtstate->unionFn = user_fn;
- fmgr_info(size_proc, &user_fn, &pronargs);
- rtstate->sizeFn = user_fn;
- fmgr_info(inter_proc, &user_fn, &pronargs);
- rtstate->interFn = user_fn;
+ fmgr_info(union_proc, &rtstate->unionFn);
+ fmgr_info(size_proc, &rtstate->sizeFn);
+ fmgr_info(inter_proc, &rtstate->interFn);
return;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.2 1998/01/06 18:52:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.3 1998/01/15 19:42:26 pgsql Exp $
*
* NOTES
* See acl.h.
if (!RelationIsValid(relation))
elog(ERROR, "ChangeAcl: could not open '%s'??",
RelationRelationName);
- fmgr_info(NameEqualRegProcedure, &relkey[0].sk_func, &relkey[0].sk_nargs);
+ fmgr_info(NameEqualRegProcedure, &relkey[0].sk_func);
+ relkey[0].sk_nargs = relkey[0].sk_func.fn_nargs;
relkey[0].sk_argument = NameGetDatum(relname);
hsdp = heap_beginscan(relation,
0,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.34 1998/01/13 04:03:45 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.35 1998/01/15 19:42:27 pgsql Exp $
*
*
* INTERFACE ROUTINES
char nulls[Natts_pg_class];
char replace[Natts_pg_class];
- fmgr_info(ObjectIdEqualRegProcedure, (func_ptr *) &key[0].sk_func,
- &key[0].sk_nargs);
+ fmgr_info(ObjectIdEqualRegProcedure, &key[0].sk_func);
+ key[0].sk_nargs = key[0].sk_func.fn_nargs;
/* ----------------
* This routine handles updates for both the heap and index relation
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.19 1998/01/06 19:42:31 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.20 1998/01/15 19:42:30 pgsql Exp $
*
* NOTES
* these routines moved here from commands/define.c and somewhat cleaned up.
{0, Anum_pg_operator_oprright, ObjectIdEqualRegProcedure},
};
- fmgr_info(NameEqualRegProcedure,
- &opKey[0].sk_func, &opKey[0].sk_nargs);
- fmgr_info(ObjectIdEqualRegProcedure,
- &opKey[1].sk_func, &opKey[1].sk_nargs);
- fmgr_info(ObjectIdEqualRegProcedure,
- &opKey[2].sk_func, &opKey[2].sk_nargs);
+ fmgr_info(NameEqualRegProcedure, &opKey[0].sk_func);
+ fmgr_info(ObjectIdEqualRegProcedure, &opKey[1].sk_func);
+ fmgr_info(ObjectIdEqualRegProcedure, &opKey[2].sk_func);
+ opKey[0].sk_nargs = opKey[0].sk_func.fn_nargs;
+ opKey[1].sk_nargs = opKey[1].sk_func.fn_nargs;
+ opKey[2].sk_nargs = opKey[2].sk_func.fn_nargs;
/* ----------------
* form scan key
{0, Anum_pg_operator_oprright, ObjectIdEqualRegProcedure},
};
- fmgr_info(NameEqualRegProcedure,
- &opKey[0].sk_func, &opKey[0].sk_nargs);
- fmgr_info(ObjectIdEqualRegProcedure,
- &opKey[1].sk_func, &opKey[1].sk_nargs);
- fmgr_info(ObjectIdEqualRegProcedure,
- &opKey[2].sk_func, &opKey[2].sk_nargs);
+ fmgr_info(NameEqualRegProcedure, &opKey[0].sk_func);
+ fmgr_info(ObjectIdEqualRegProcedure, &opKey[1].sk_func);
+ fmgr_info(ObjectIdEqualRegProcedure, &opKey[2].sk_func);
+ opKey[0].sk_nargs = opKey[0].sk_func.fn_nargs;
+ opKey[1].sk_nargs = opKey[1].sk_func.fn_nargs;
+ opKey[2].sk_nargs = opKey[2].sk_func.fn_nargs;
operatorObjectId = OperatorGet(operatorName,
leftTypeName,
{0, ObjectIdAttributeNumber, ObjectIdEqualRegProcedure},
};
- fmgr_info(ObjectIdEqualRegProcedure,
- &opKey[0].sk_func, &opKey[0].sk_nargs);
+ fmgr_info(ObjectIdEqualRegProcedure, &opKey[0].sk_func);
+ opKey[0].sk_nargs = opKey[0].sk_func.fn_nargs;
for (i = 0; i < Natts_pg_operator; ++i)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.17 1998/01/06 19:42:33 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.18 1998/01/15 19:42:30 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
* initialize the scan key and begin a scan of pg_type
* ----------------
*/
- fmgr_info(NameEqualRegProcedure,
- &typeKey[0].sk_func, &typeKey[0].sk_nargs);
+ fmgr_info(NameEqualRegProcedure, &typeKey[0].sk_func);
+ typeKey[0].sk_nargs = typeKey[0].sk_func.fn_nargs;
typeKey[0].sk_argument = PointerGetDatum(typeName);
scan = heap_beginscan(pg_type_desc,
{0, Anum_pg_type_typname, NameEqualRegProcedure}
};
- fmgr_info(NameEqualRegProcedure,
- &typeKey[0].sk_func, &typeKey[0].sk_nargs);
+ fmgr_info(NameEqualRegProcedure, &typeKey[0].sk_func);
+ typeKey[0].sk_nargs = typeKey[0].sk_func.fn_nargs;
/* ----------------
* check that the type is not already defined.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.37 1998/01/05 16:38:46 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.38 1998/01/15 19:42:36 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
int32 attr_count,
i;
AttributeTupleForm *attr;
- func_ptr *out_functions;
- int dummy;
+ FmgrInfo *out_functions;
Oid out_func_oid;
Oid *elements;
Datum value;
if (!binary)
{
- out_functions = (func_ptr *) palloc(attr_count * sizeof(func_ptr));
+ out_functions = (FmgrInfo *) palloc(attr_count * sizeof(FmgrInfo));
elements = (Oid *) palloc(attr_count * sizeof(Oid));
for (i = 0; i < attr_count; i++)
{
out_func_oid = (Oid) GetOutputFunction(attr[i]->atttypid);
- fmgr_info(out_func_oid, &out_functions[i], &dummy);
+ fmgr_info(out_func_oid, &out_functions[i]);
elements[i] = GetTypeElement(attr[i]->atttypid);
}
nulls = NULL; /* meaningless, but compiler doesn't know
{
if (!isnull)
{
- string = (char *) (out_functions[i]) (value, elements[i]);
+ string = (char *) (*fmgr_faddr(&out_functions[i])) (value, elements[i]);
CopyAttributeOut(fp, string, delim);
pfree(string);
}
HeapTuple tuple;
AttrNumber attr_count;
AttributeTupleForm *attr;
- func_ptr *in_functions;
- int i,
- dummy;
+ FmgrInfo *in_functions;
+ int i;
Oid in_func_oid;
Datum *values;
char *nulls,
if (!binary)
{
- in_functions = (func_ptr *) palloc(attr_count * sizeof(func_ptr));
+ in_functions = (FmgrInfo *) palloc(attr_count * sizeof(FmgrInfo));
elements = (Oid *) palloc(attr_count * sizeof(Oid));
for (i = 0; i < attr_count; i++)
{
in_func_oid = (Oid) GetInputFunction(attr[i]->atttypid);
- fmgr_info(in_func_oid, &in_functions[i], &dummy);
+ fmgr_info(in_func_oid, &in_functions[i]);
elements[i] = GetTypeElement(attr[i]->atttypid);
}
}
else
{
values[i] =
- (Datum) (in_functions[i]) (string,
+ (Datum) (*fmgr_faddr(&in_functions[i])) (string,
elements[i],
attr[i]->attlen);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.20 1998/01/05 16:38:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.21 1998/01/15 19:42:38 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
#endif
relation = heap_openr(TypeRelationName);
- fmgr_info(typeKey[0].sk_procedure, &typeKey[0].sk_func,
- &typeKey[0].sk_nargs);
+ fmgr_info(typeKey[0].sk_procedure, &typeKey[0].sk_func);
+ typeKey[0].sk_nargs = typeKey[0].sk_func.fn_nargs;
/* Delete the primary type */
key[0].sk_argument = PointerGetDatum(functionName);
- fmgr_info(key[0].sk_procedure, &key[0].sk_func, &key[0].sk_nargs);
+ fmgr_info(key[0].sk_procedure, &key[0].sk_func);
+ key[0].sk_nargs = key[0].sk_func.fn_nargs;
relation = heap_openr(ProcedureRelationName);
scan = heap_beginscan(relation, 0, false, 1, key);
GetTupleForTrigger(Relation relation, ItemPointer tid,
bool before);
-extern void fmgr_info(Oid procedureId, func_ptr * function, int *nargs);
extern GlobalMemory CacheCxt;
void
build->tgname = nameout(&(pg_trigger->tgname));
build->tgfoid = pg_trigger->tgfoid;
- build->tgfunc = NULL;
- build->tgplfunc = NULL;
+ build->tgfunc.fn_addr = NULL;
build->tgtype = pg_trigger->tgtype;
build->tgnargs = pg_trigger->tgnargs;
memcpy(build->tgattr, &(pg_trigger->tgattr), 8 * sizeof(int16));
ExecCallTriggerFunc(Trigger * trigger)
{
- if (trigger->tgfunc != NULL)
+ if (trigger->tgfunc.fn_addr == NULL)
{
- return (HeapTuple) ((*(trigger->tgfunc)) ());
+ fmgr_info(trigger->tgfoid, &trigger->tgfunc);
}
- if (trigger->tgplfunc == NULL)
- {
- HeapTuple procTuple;
- HeapTuple langTuple;
- Form_pg_proc procStruct;
- Form_pg_language langStruct;
- int nargs;
-
- procTuple = SearchSysCacheTuple(PROOID,
- ObjectIdGetDatum(trigger->tgfoid),
- 0, 0, 0);
- if (!HeapTupleIsValid(procTuple))
- {
- elog(ERROR, "ExecCallTriggerFunc(): Cache lookup for proc %ld failed",
- ObjectIdGetDatum(trigger->tgfoid));
- }
- procStruct = (Form_pg_proc) GETSTRUCT(procTuple);
-
- langTuple = SearchSysCacheTuple(LANOID,
- ObjectIdGetDatum(procStruct->prolang),
- 0, 0, 0);
- if (!HeapTupleIsValid(langTuple))
- {
- elog(ERROR, "ExecCallTriggerFunc(): Cache lookup for language %ld failed",
- ObjectIdGetDatum(procStruct->prolang));
- }
- langStruct = (Form_pg_language) GETSTRUCT(langTuple);
-
- if (langStruct->lanispl == false)
- {
- fmgr_info(trigger->tgfoid, &(trigger->tgfunc), &nargs);
- return (HeapTuple) ((*(trigger->tgfunc)) ());
- }
- fmgr_info(langStruct->lanplcallfoid, &(trigger->tgplfunc), &nargs);
+ if (trigger->tgfunc.fn_plhandler != NULL) {
+ return (HeapTuple) (*(trigger->tgfunc.fn_plhandler))
+ (&trigger->tgfunc);
}
- return (HeapTuple) ((*(trigger->tgplfunc)) (trigger->tgfoid));
+ return (HeapTuple) ((*fmgr_faddr(&trigger->tgfunc)) ());
}
HeapTuple
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.57 1998/01/05 16:39:05 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.58 1998/01/15 19:42:40 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
#define swapLong(a,b) {long tmp; tmp=a; a=b; b=tmp;}
#define swapInt(a,b) {int tmp; tmp=a; a=b; b=tmp;}
#define swapDatum(a,b) {Datum tmp; tmp=a; a=b; b=tmp;}
-#define VacAttrStatsEqValid(stats) ( stats->f_cmpeq != NULL )
-#define VacAttrStatsLtGtValid(stats) ( stats->f_cmplt != NULL && \
- stats->f_cmpgt != NULL && \
+#define VacAttrStatsEqValid(stats) ( stats->f_cmpeq.fn_addr != NULL )
+#define VacAttrStatsLtGtValid(stats) ( stats->f_cmplt.fn_addr != NULL && \
+ stats->f_cmpgt.fn_addr != NULL && \
RegProcedureIsValid(stats->outfunc) )
func_operator = oper("=", stats->attr->atttypid, stats->attr->atttypid, true);
if (func_operator != NULL)
{
- int nargs;
-
pgopform = (OperatorTupleForm) GETSTRUCT(func_operator);
- fmgr_info(pgopform->oprcode, &(stats->f_cmpeq), &nargs);
+ fmgr_info(pgopform->oprcode, &(stats->f_cmpeq));
}
else
- stats->f_cmpeq = NULL;
+ stats->f_cmpeq.fn_addr = NULL;
func_operator = oper("<", stats->attr->atttypid, stats->attr->atttypid, true);
if (func_operator != NULL)
{
- int nargs;
-
pgopform = (OperatorTupleForm) GETSTRUCT(func_operator);
- fmgr_info(pgopform->oprcode, &(stats->f_cmplt), &nargs);
+ fmgr_info(pgopform->oprcode, &(stats->f_cmplt));
}
else
- stats->f_cmplt = NULL;
+ stats->f_cmplt.fn_addr = NULL;
func_operator = oper(">", stats->attr->atttypid, stats->attr->atttypid, true);
if (func_operator != NULL)
{
- int nargs;
-
pgopform = (OperatorTupleForm) GETSTRUCT(func_operator);
- fmgr_info(pgopform->oprcode, &(stats->f_cmpgt), &nargs);
+ fmgr_info(pgopform->oprcode, &(stats->f_cmpgt));
}
else
- stats->f_cmpgt = NULL;
+ stats->f_cmpgt.fn_addr = NULL;
pgttup = SearchSysCacheTuple(TYPOID,
ObjectIdGetDatum(stats->attr->atttypid),
}
if (VacAttrStatsLtGtValid(stats))
{
- if ((*(stats->f_cmplt)) (value, stats->min))
+ if ((*fmgr_faddr(&stats->f_cmplt)) (value, stats->min))
{
vc_bucketcpy(stats->attr, value, &stats->min, &stats->min_len);
stats->min_cnt = 0;
}
- if ((*(stats->f_cmpgt)) (value, stats->max))
+ if ((*fmgr_faddr(&stats->f_cmpgt)) (value, stats->max))
{
vc_bucketcpy(stats->attr, value, &stats->max, &stats->max_len);
stats->max_cnt = 0;
}
- if ((*(stats->f_cmpeq)) (value, stats->min))
+ if ((*fmgr_faddr(&stats->f_cmpeq)) (value, stats->min))
stats->min_cnt++;
- else if ((*(stats->f_cmpeq)) (value, stats->max))
+ else if ((*fmgr_faddr(&stats->f_cmpeq)) (value, stats->max))
stats->max_cnt++;
}
- if ((*(stats->f_cmpeq)) (value, stats->best))
+ if ((*fmgr_faddr(&stats->f_cmpeq)) (value, stats->best))
stats->best_cnt++;
- else if ((*(stats->f_cmpeq)) (value, stats->guess1))
+ else if ((*fmgr_faddr(&stats->f_cmpeq)) (value, stats->guess1))
{
stats->guess1_cnt++;
stats->guess1_hits++;
}
- else if ((*(stats->f_cmpeq)) (value, stats->guess2))
+ else if ((*fmgr_faddr(&stats->f_cmpeq)) (value, stats->guess2))
stats->guess2_hits++;
else
value_hit = false;
*
pgcform->relname.data) */ )
{
- func_ptr out_function;
+ FmgrInfo out_function;
char *out_string;
- int dummy;
for (i = 0; i < Natts_pg_statistic; ++i)
nulls[i] = ' ';
values[i++] = (Datum) relid; /* 1 */
values[i++] = (Datum) attp->attnum; /* 2 */
values[i++] = (Datum) InvalidOid; /* 3 */
- fmgr_info(stats->outfunc, &out_function, &dummy);
- out_string = (*out_function) (stats->min, stats->attr->atttypid);
+ fmgr_info(stats->outfunc, &out_function);
+ out_string = (*fmgr_faddr(&out_function)) (stats->min, stats->attr->atttypid);
values[i++] = (Datum) fmgr(TextInRegProcedure, out_string);
pfree(out_string);
- out_string = (char *) (*out_function) (stats->max, stats->attr->atttypid);
+ out_string = (char *) (*fmgr_faddr(&out_function)) (stats->max, stats->attr->atttypid);
values[i++] = (Datum) fmgr(TextInRegProcedure, out_string);
pfree(out_string);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.22 1998/01/07 21:02:47 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execQual.c,v 1.23 1998/01/15 19:44:24 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
if (fcache->nullVect[i] == true)
*isNull = true;
- return ((Datum) fmgr_c(fcache->func, fcache->foid, fcache->nargs,
- (FmgrValues *) argv, isNull));
+ return ((Datum) fmgr_c(&fcache->func, (FmgrValues *) argv, isNull));
}
}
Oid xfn1_oid;
Oid xfn2_oid;
Oid finalfn_oid;
- func_ptr xfn1;
- func_ptr xfn2;
- func_ptr finalfn;
- int xfn1_nargs;
- int xfn2_nargs;
- int finalfn_nargs;
+ FmgrInfo xfn1;
+ FmgrInfo xfn2;
+ FmgrInfo finalfn;
} AggFuncInfo;
static Datum aggGetAttr(TupleTableSlot *tuple, Aggreg *agg, bool *isNull);
Oid xfn1_oid,
xfn2_oid,
finalfn_oid;
- func_ptr xfn1_ptr,
- xfn2_ptr,
- finalfn_ptr;
- int xfn1_nargs,
- xfn2_nargs,
- finalfn_nargs;
agg = aggregates[i];
if (OidIsValid(finalfn_oid))
{
- fmgr_info(finalfn_oid, &finalfn_ptr, &finalfn_nargs);
+ fmgr_info(finalfn_oid, &aggFuncInfo[i].finalfn);
aggFuncInfo[i].finalfn_oid = finalfn_oid;
- aggFuncInfo[i].finalfn = finalfn_ptr;
- aggFuncInfo[i].finalfn_nargs = finalfn_nargs;
}
if (OidIsValid(xfn2_oid))
{
- fmgr_info(xfn2_oid, &xfn2_ptr, &xfn2_nargs);
+ fmgr_info(xfn2_oid, &aggFuncInfo[i].xfn2);
aggFuncInfo[i].xfn2_oid = xfn2_oid;
- aggFuncInfo[i].xfn2 = xfn2_ptr;
- aggFuncInfo[i].xfn2_nargs = xfn2_nargs;
value2[i] = (Datum) AggNameGetInitVal((char *) aggname,
aggp->aggbasetype,
2,
if (OidIsValid(xfn1_oid))
{
- fmgr_info(xfn1_oid, &xfn1_ptr, &xfn1_nargs);
+ fmgr_info(xfn1_oid, &aggFuncInfo[i].xfn1);
aggFuncInfo[i].xfn1_oid = xfn1_oid;
- aggFuncInfo[i].xfn1 = xfn1_ptr;
- aggFuncInfo[i].xfn1_nargs = xfn1_nargs;
value1[i] = (Datum) AggNameGetInitVal((char *) aggname,
aggp->aggbasetype,
1,
if (isNull && !aggregates[i]->usenulls)
continue; /* ignore this tuple for this agg */
- if (aggfns->xfn1)
+ if (aggfns->xfn1.fn_addr != NULL)
{
if (noInitValue[i])
{
args[0] = value1[i];
args[1] = newVal;
value1[i] =
- (Datum) fmgr_c(aggfns->xfn1, aggfns->xfn1_oid,
- aggfns->xfn1_nargs, (FmgrValues *) args,
+ (Datum) fmgr_c(&aggfns->xfn1,
+ (FmgrValues *) args,
&isNull1);
Assert(!isNull1);
}
}
- if (aggfns->xfn2)
+ if (aggfns->xfn2.fn_addr != NULL)
{
Datum xfn2_val = value2[i];
value2[i] =
- (Datum) fmgr_c(aggfns->xfn2, aggfns->xfn2_oid,
- aggfns->xfn2_nargs,
+ (Datum) fmgr_c(&aggfns->xfn2,
(FmgrValues *) &xfn2_val, &isNull2);
Assert(!isNull2);
}
* seems to fix behavior for avg() aggregate. -tgl 12/96
*/
}
- else if (aggfns->finalfn && nTuplesAgged > 0)
+ else if (aggfns->finalfn.fn_addr != NULL && nTuplesAgged > 0)
{
- if (aggfns->finalfn_nargs > 1)
+ if (aggfns->finalfn.fn_nargs > 1)
{
args[0] = (char *) value1[i];
args[1] = (char *) value2[i];
}
- else if (aggfns->xfn1)
+ else if (aggfns->xfn1.fn_addr != NULL)
{
args[0] = (char *) value1[i];
}
- else if (aggfns->xfn2)
+ else if (aggfns->xfn2.fn_addr != NULL)
{
args[0] = (char *) value2[i];
}
else
- elog(ERROR, "ExecAgg: no valid transition functions??");
- value1[i] =
- (Datum) fmgr_c(aggfns->finalfn, aggfns->finalfn_oid,
- aggfns->finalfn_nargs, (FmgrValues *) args,
- &(nulls[i]));
+ elog(WARN, "ExecAgg: no valid transition functions??");
+ value1[i] = (Datum) fmgr_c(&aggfns->finalfn,
+ (FmgrValues *) args, &(nulls[i]));
}
- else if (aggfns->xfn1)
+ else if (aggfns->xfn1.fn_addr != NULL)
{
/*
* fix the else part. -ay 2/95)
*/
}
- else if (aggfns->xfn2)
+ else if (aggfns->xfn2.fn_addr != NULL)
{
value1[i] = value2[i];
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.13 1998/01/07 21:04:17 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.14 1998/01/15 19:44:41 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
List *list = NIL;
Oid inhrelid;
- fmgr_info(F_OIDEQ, &key[0].sk_func, &key[0].sk_nargs);
+ fmgr_info(F_OIDEQ, &key[0].sk_func);
+ key[0].sk_nargs = key[0].sk_func.fn_nargs;
key[0].sk_argument = ObjectIdGetDatum((Oid) inhparent);
relation = heap_openr(InheritsRelationName);
Oid verbaseid;
List *list = NIL;
- fmgr_info(F_OIDEQ, &key[0].sk_func, &key[0].sk_nargs);
+ fmgr_info(F_OIDEQ, &key[0].sk_func);
+ key[0].sk_nargs = key[0].sk_func.fn_nargs;
relation = heap_openr(VersionRelationName);
key[0].sk_argument = ObjectIdGetDatum(verrelid);
scan = heap_beginscan(relation, 0, false, 1, key);
#
#
# IDENTIFICATION
-# $Header: /cvsroot/pgsql/src/backend/utils/Attic/Gen_fmgrtab.sh.in,v 1.5 1997/10/28 15:02:24 vadim Exp $
+# $Header: /cvsroot/pgsql/src/backend/utils/Attic/Gen_fmgrtab.sh.in,v 1.6 1998/01/15 19:44:50 pgsql Exp $
#
# NOTES
# Passes any -D options on to cpp prior to generating the list
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: Gen_fmgrtab.sh.in,v 1.5 1997/10/28 15:02:24 vadim Exp $
+ * $Id: Gen_fmgrtab.sh.in,v 1.6 1998/01/15 19:44:50 pgsql Exp $
*
* NOTES
* ******************************
char *data[MAXFMGRARGS];
} FmgrValues;
+typedef struct {
+ func_ptr fn_addr;
+ func_ptr fn_plhandler;
+ Oid fn_oid;
+ int fn_nargs;
+} FmgrInfo;
+
/*
* defined in fmgr.c
*/
-extern char *fmgr_pl(Oid func_id, int n_arguments, FmgrValues *values,
- bool *isNull);
-extern char *fmgr_c(func_ptr user_fn, Oid func_id, int n_arguments,
- FmgrValues *values, bool *isNull);
-extern void fmgr_info(Oid procedureId, func_ptr *function, int *nargs);
+extern char *fmgr_c(FmgrInfo *finfo, FmgrValues *values, bool *isNull);
+extern void fmgr_info(Oid procedureId, FmgrInfo *finfo);
+extern func_ptr fmgr_faddr(FmgrInfo *finfo);
extern char *fmgr(Oid procedureId, ... );
-extern char *fmgr_ptr(func_ptr user_fn, Oid func_id, ... );
+extern char *fmgr_ptr(FmgrInfo *finfo, ... );
extern char *fmgr_array_args(Oid procedureId, int nargs,
char *args[], bool *isNull);
* we must).
*/
#ifdef TRACE_FMGR_PTR
-#define FMGR_PTR2(FP, FID, ARG1, ARG2) \
- fmgr_ptr(FP, FID, 2, ARG1, ARG2)
+#define FMGR_PTR2(FINFO, ARG1, ARG2) \
+ fmgr_ptr(FINFO, 2, ARG1, ARG2)
#else
-#define FMGR_PTR2(FP, FID, ARG1, ARG2) \
- ((FP) ? (*((func_ptr)(FP)))(ARG1, ARG2) : fmgr(FID, ARG1, ARG2))
+#define FMGR_PTR2(FINFO, ARG1, ARG2) \
+ (((FINFO)->fn_addr) ? (*(fmgr_faddr(FINFO)))(ARG1, ARG2) : fmgr((FINFO)->fn_oid, ARG1, ARG2))
#endif
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/Attic/Gen_fmgrtab.sh.in,v 1.5 1997/10/28 15:02:24 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/Attic/Gen_fmgrtab.sh.in,v 1.6 1998/01/15 19:44:50 pgsql Exp $
*
* NOTES
*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.23 1998/01/05 16:39:41 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.24 1998/01/15 19:45:01 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
static int _ArrayCount(char *str, int dim[], int typdelim);
static char *
_ReadArrayStr(char *arrayStr, int nitems, int ndim, int dim[],
- func_ptr inputproc, Oid typelem, char typdelim,
+ FmgrInfo *inputproc, Oid typelem, char typdelim,
int typlen, bool typbyval, char typalign,
int *nbytes);
*p,
*q,
*r;
- func_ptr inputproc;
+ FmgrInfo inputproc;
int i,
- nitems,
- dummy;
+ nitems;
int32 nbytes;
char *dataPtr;
ArrayType *retval = NULL;
system_cache_lookup(element_type, true, &typlen, &typbyval, &typdelim,
&typelem, &typinput, &typalign);
- fmgr_info(typinput, &inputproc, &dummy);
+ fmgr_info(typinput, &inputproc);
string_save = (char *) palloc(strlen(string) + 3);
strcpy(string_save, string);
{
/* array not a large object */
dataPtr =
- (char *) _ReadArrayStr(p, nitems, ndim, dim, inputproc, typelem,
+ (char *) _ReadArrayStr(p, nitems, ndim, dim, &inputproc, typelem,
typdelim, typlen, typbyval, typalign,
&nbytes);
nbytes += ARR_OVERHEAD(ndim);
int nitems,
int ndim,
int dim[],
- func_ptr inputproc, /* function used for the
+ FmgrInfo *inputproc, /* function used for the
* conversion */
Oid typelem,
char typdelim,
*q = '\0';
if (i >= nitems)
elog(ERROR, "array_in: illformed array constant");
- values[i] = (*inputproc) (p, typelem);
+ values[i] = (*fmgr_faddr(inputproc)) (p, typelem);
p = ++q;
if (!eoArray)
char typdelim;
Oid typoutput,
typelem;
- func_ptr outputproc;
+ FmgrInfo outputproc;
char typalign;
char *p,
k,
indx[MAXDIM];
bool dummy_bool;
- int dummy_int;
int ndim,
*dim;
system_cache_lookup(element_type, false, &typlen, &typbyval,
&typdelim, &typelem, &typoutput, &typalign);
- fmgr_info(typoutput, &outputproc, &dummy_int);
+ fmgr_info(typoutput, &outputproc);
sprintf(delim, "%c", typdelim);
ndim = ARR_NDIM(v);
dim = ARR_DIMS(v);
switch (typlen)
{
case 1:
- values[i] = (*outputproc) (*p, typelem);
+ values[i] = (*fmgr_faddr(&outputproc)) (*p, typelem);
break;
case 2:
- values[i] = (*outputproc) (*(int16 *) p, typelem);
+ values[i] = (*fmgr_faddr(&outputproc)) (*(int16 *) p, typelem);
break;
case 3:
case 4:
- values[i] = (*outputproc) (*(int32 *) p, typelem);
+ values[i] = (*fmgr_faddr(&outputproc)) (*(int32 *) p, typelem);
break;
}
p += typlen;
}
else
{
- values[i] = (*outputproc) (p, typelem);
+ values[i] = (*fmgr_faddr(&outputproc)) (p, typelem);
if (typlen > 0)
p += typlen;
else
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/sets.c,v 1.11 1998/01/05 16:40:17 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/sets.c,v 1.12 1998/01/15 19:45:09 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
procrel = heap_openr(ProcedureRelationName);
RelationSetLockForWrite(procrel);
fmgr_info(ObjectIdEqualRegProcedure,
- &oidKey[0].sk_func,
- &oidKey[0].sk_nargs);
+ &oidKey[0].sk_func);
+ oidKey[0].sk_nargs = oidKey[0].sk_func.fn_nargs;
oidKey[0].sk_argument = ObjectIdGetDatum(setoid);
pg_proc_scan = heap_beginscan(procrel,
0,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.20 1998/01/07 21:06:08 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.21 1998/01/15 19:45:28 pgsql Exp $
*
* Notes:
* XXX This needs to use exception.h to handle recovery when
EQPROC(tupdesc->attrs[cache->cc_key[i] - 1]->atttypid);
fmgr_info(cache->cc_skey[i].sk_procedure,
- (func_ptr *) &cache->cc_skey[i].sk_func,
- (int *) &cache->cc_skey[i].sk_nargs);
+ &cache->cc_skey[i].sk_func);
+ cache->cc_skey[i].sk_nargs = cache->cc_skey[i].sk_func.fn_nargs;
CACHE5_elog(DEBUG, "CatalogCacheInit %16s %d %d %x",
&relation->rd_rel->relname,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/fcache.c,v 1.9 1998/01/07 21:06:11 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/fcache.c,v 1.10 1998/01/15 19:45:29 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
* ----------------
*/
retval = (FunctionCachePtr) palloc(sizeof(FunctionCache));
+ memset(retval, 0, sizeof(FunctionCache));
if (!use_syscache)
elog(ERROR, "what the ????, init the fcache without the catalogs?");
- if (retval->language != SQLlanguageId)
- fmgr_info(foid, &(retval->func), &(retval->nargs));
- else
- retval->func = (func_ptr) NULL;
+ if (retval->language != SQLlanguageId) {
+ fmgr_info(foid, &(retval->func));
+ retval->nargs = retval->func.fn_nargs;
+ } else {
+ retval->func.fn_addr = (func_ptr) NULL;
+ }
return (retval);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.33 1998/01/14 15:48:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.34 1998/01/15 19:45:31 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
/* have to reinit the function pointers in the strategy maps */
for (i = 0; i < am->amstrategies; i++)
fmgr_info(SMD(i).sk_procedure,
- &(SMD(i).sk_func), &(SMD(i).sk_nargs));
+ &(SMD(i).sk_func));
+ SMD(i).sk_nargs = SMD(i).sk_func.fn_nargs;
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.9 1998/01/07 21:06:28 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.10 1998/01/15 19:45:58 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
#include "commands/trigger.h"
-char *
-fmgr_pl(Oid func_id,
- int n_arguments,
- FmgrValues * values,
- bool * isNull)
-{
- HeapTuple procedureTuple;
- HeapTuple languageTuple;
- Form_pg_proc procedureStruct;
- Form_pg_language languageStruct;
- func_ptr plcall_fn;
- int plcall_nargs;
-
- /* Fetch the pg_proc tuple from the syscache */
- procedureTuple = SearchSysCacheTuple(PROOID,
- ObjectIdGetDatum(func_id),
- 0, 0, 0);
- if (!HeapTupleIsValid(procedureTuple))
- {
- elog(ERROR, "fmgr_pl(): Cache lookup of procedure %ld failed.",
- ObjectIdGetDatum(func_id));
- }
- procedureStruct = (Form_pg_proc) GETSTRUCT(procedureTuple);
+static FmgrInfo *fmgr_pl_finfo;
- /* Fetch the pg_language tuple from the syscache */
- languageTuple = SearchSysCacheTuple(LANOID,
- ObjectIdGetDatum(procedureStruct->prolang),
- 0, 0, 0);
- if (!HeapTupleIsValid(languageTuple))
- {
- elog(ERROR, "fmgr_pl(): Cache lookup of language %ld for procedure %ld failed.",
- ObjectIdGetDatum(procedureStruct->prolang),
- ObjectIdGetDatum(func_id));
- }
- languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
-
- /* Get the function pointer for the PL call handler */
- fmgr_info(languageStruct->lanplcallfoid, &plcall_fn, &plcall_nargs);
- if (plcall_fn == NULL)
- {
- elog(ERROR, "fmgr_pl(): failed to load PL handler for procedure %ld.",
- ObjectIdGetDatum(func_id));
+static char *
+fmgr_pl(char *arg0, ...)
+{
+ va_list pvar;
+ FmgrValues values;
+ bool isNull = false;
+ int i;
+
+ memset(&values, 0, sizeof(values));
+
+ if (fmgr_pl_finfo->fn_nargs > 0) {
+ values.data[0] = arg0;
+ if (fmgr_pl_finfo->fn_nargs > 1) {
+ va_start(pvar, arg0);
+ for (i = 1; i < fmgr_pl_finfo->fn_nargs; i++) {
+ values.data[i] = va_arg(pvar, char *);
+ }
+ va_end(pvar);
+ }
}
/* Call the PL handler */
CurrentTriggerData = NULL;
- return (*plcall_fn) (func_id,
- n_arguments,
- values,
- isNull);
-}
-
-
-char *
-fmgr_c(func_ptr user_fn,
- Oid func_id,
- int n_arguments,
- FmgrValues * values,
- bool * isNull)
-{
- char *returnValue = (char *) NULL;
-
-
+ return (*(fmgr_pl_finfo->fn_plhandler)) (fmgr_pl_finfo,
+ &values,
+ &isNull);
+}
+
+
+char *
+fmgr_c(FmgrInfo *finfo,
+ FmgrValues * values,
+ bool * isNull)
+{
+ char *returnValue = (char *) NULL;
+ int n_arguments = finfo->fn_nargs;
+ func_ptr user_fn = fmgr_faddr(finfo);
+
+
if (user_fn == (func_ptr) NULL)
{
/*
* a NULL func_ptr denotet untrusted function (in postgres 4.2).
- * Untrusted functions have very limited use and is clumsy. We now
- * use this feature for procedural languages.
+ * Untrusted functions have very limited use and is clumsy. We
+ * just get rid of it.
*/
- return fmgr_pl(func_id, n_arguments, values, isNull);
+ elog(WARN, "internal error: untrusted function not supported.");
+ }
+
+ /*
+ * If finfo contains a PL handler for this function,
+ * call that instead.
+ */
+ if (finfo->fn_plhandler != NULL) {
+ return (*(finfo->fn_plhandler))(finfo, values, isNull);
}
switch (n_arguments)
break;
default:
elog(ERROR, "fmgr_c: function %d: too many arguments (%d > %d)",
- func_id, n_arguments, MAXFMGRARGS);
+ finfo->fn_oid, n_arguments, MAXFMGRARGS);
break;
}
return (returnValue);
}
void
-fmgr_info(Oid procedureId, func_ptr * function, int *nargs)
+fmgr_info(Oid procedureId, FmgrInfo *finfo)
{
func_ptr user_fn = NULL;
FmgrCall *fcp;
Form_pg_language languageStruct;
Oid language;
+ finfo->fn_addr = NULL;
+ finfo->fn_plhandler = NULL;
+ finfo->fn_oid = procedureId;
+
if (!(fcp = fmgr_isbuiltin(procedureId)))
{
procedureTuple = SearchSysCacheTuple(PROOID,
elog(ERROR, "fmgr_info: function %d: cache lookup failed\n",
procedureId);
}
- procedureStruct = (FormData_pg_proc *)
- GETSTRUCT(procedureTuple);
+ procedureStruct = (FormData_pg_proc *) GETSTRUCT(procedureTuple);
if (!procedureStruct->proistrusted)
{
- *function = (func_ptr) NULL;
- *nargs = procedureStruct->pronargs;
+ finfo->fn_addr = (func_ptr) NULL;
+ finfo->fn_nargs = procedureStruct->pronargs;
return;
}
language = procedureStruct->prolang;
switch (language)
{
case INTERNALlanguageId:
- user_fn = fmgr_lookupByName(procedureStruct->proname.data);
- if (!user_fn)
- elog(ERROR, "fmgr_info: function %s: not in internal table",
- procedureStruct->proname.data);
+ finfo->fn_addr =
+ fmgr_lookupByName(procedureStruct->proname.data);
+ if (!finfo->fn_addr)
+ elog(WARN, "fmgr_info: function %s: not in internal table",
+ procedureStruct->proname.data);
break;
case ClanguageId:
- user_fn = fmgr_dynamic(procedureId, nargs);
+ finfo->fn_addr = fmgr_dynamic(procedureId, &(finfo->fn_nargs));
break;
case SQLlanguageId:
- user_fn = (func_ptr) NULL;
- *nargs = procedureStruct->pronargs;
+ finfo->fn_addr = (func_ptr) NULL;
+ finfo->fn_nargs = procedureStruct->pronargs;
break;
default:
GETSTRUCT(languageTuple);
if (languageStruct->lanispl)
{
- user_fn = (func_ptr) NULL;
- *nargs = procedureStruct->pronargs;
+ FmgrInfo plfinfo;
+
+ fmgr_info(((Form_pg_language)GETSTRUCT(languageTuple))->lanplcallfoid, &plfinfo);
+ finfo->fn_addr = (func_ptr) fmgr_pl;
+ finfo->fn_plhandler = plfinfo.fn_addr;
+ finfo->fn_nargs = procedureStruct->pronargs;
}
else
{
}
else
{
- user_fn = fcp->func;
- *nargs = fcp->nargs;
+ finfo->fn_addr = fcp->func;
+ finfo->fn_nargs = fcp->nargs;
}
- *function = user_fn;
+}
+
+func_ptr
+fmgr_faddr(FmgrInfo *finfo)
+{
+ fmgr_pl_finfo = finfo;
+ return finfo->fn_addr;
}
/*
register i;
int pronargs;
FmgrValues values;
- func_ptr user_fn;
+ FmgrInfo finfo;
bool isNull = false;
va_start(pvar, procedureId);
- fmgr_info(procedureId, &user_fn, &pronargs);
+ fmgr_info(procedureId, &finfo);
+ pronargs = finfo.fn_nargs;
if (pronargs > MAXFMGRARGS)
{
va_end(pvar);
/* XXX see WAY_COOL_ORTHOGONAL_FUNCTIONS */
- return (fmgr_c(user_fn, procedureId, pronargs, &values,
- &isNull));
+ return (fmgr_c(&finfo, &values, &isNull));
}
/*
* the pointer, but it's available for use with macros in fmgr.h if you
* want this routine to do sanity-checking for you.
*
- * func_ptr, func_id, n_arguments, args...
+ * funcinfo, n_arguments, args...
*/
#ifdef NOT_USED
char *
-fmgr_ptr(func_ptr user_fn, Oid func_id,...)
+fmgr_ptr(FmgrInfo *finfo, ...)
{
va_list pvar;
register i;
int n_arguments;
+ FmgrInfo local_finfo;
FmgrValues values;
bool isNull = false;
- va_start(pvar, func_id);
+ local_finfo->fn_addr = finfo->fn_addr;
+ local_finfo->fn_plhandler = finfo->fn_plhandler;
+ local_finfo->fn_oid = finfo->fn_oid;
+
+ va_start(pvar, finfo);
n_arguments = va_arg(pvar, int);
+ local_finfo->fn_nargs = n_arguments;
if (n_arguments > MAXFMGRARGS)
{
elog(ERROR, "fmgr_ptr: function %d: too many arguments (%d > %d)",
va_end(pvar);
/* XXX see WAY_COOL_ORTHOGONAL_FUNCTIONS */
- return (fmgr_c(user_fn, func_id, n_arguments, &values,
- &isNull));
+ return (fmgr_c(&local_finfo, &values, &isNull));
}
#endif
char *
fmgr_array_args(Oid procedureId, int nargs, char *args[], bool * isNull)
{
- func_ptr user_fn;
- int true_arguments;
+ FmgrInfo finfo;
- fmgr_info(procedureId, &user_fn, &true_arguments);
+ fmgr_info(procedureId, &finfo);
+ finfo.fn_nargs = nargs;
/* XXX see WAY_COOL_ORTHOGONAL_FUNCTIONS */
return
- (fmgr_c(user_fn,
- procedureId,
- true_arguments,
+ (fmgr_c(&finfo,
(FmgrValues *) args,
isNull));
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/lselect.c,v 1.9 1997/09/18 05:37:30 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/lselect.c,v 1.10 1998/01/15 19:46:08 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
if (context->scanKeys[nkey].sk_flags & SK_COMMUTE)
{
if (!(result =
- (long) (*context->scanKeys[nkey].sk_func) (rattr, lattr)))
+ (long) (*fmgr_faddr(&context->scanKeys[nkey].sk_func)) (rattr, lattr)))
result =
- -(long) (*context->scanKeys[nkey].sk_func) (lattr, rattr);
+ -(long) (*fmgr_faddr(&context->scanKeys[nkey].sk_func)) (lattr, rattr);
}
else if (!(result =
- (long) (*context->scanKeys[nkey].sk_func) (lattr, rattr)))
+ (long) (*fmgr_faddr(&context->scanKeys[nkey].sk_func)) (lattr, rattr)))
result =
- -(long) (*context->scanKeys[nkey].sk_func) (rattr, lattr);
+ -(long) (*fmgr_faddr(&context->scanKeys[nkey].sk_func)) (rattr, lattr);
nkey++;
}
return (result == 1);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/psort.c,v 1.31 1998/01/13 04:04:57 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/sort/Attic/psort.c,v 1.32 1998/01/15 19:46:10 pgsql Exp $
*
* NOTES
* Sorts the first relation into the second relation.
if (PsortKeys[nkey].sk_flags & SK_COMMUTE)
{
- if (!(result = -(long) (*PsortKeys[nkey].sk_func) (rattr, lattr)))
- result = (long) (*PsortKeys[nkey].sk_func) (lattr, rattr);
+ if (!(result = -(long) (*fmgr_faddr(&PsortKeys[nkey].sk_func)) (rattr, lattr)))
+ result = (long) (*fmgr_faddr(&PsortKeys[nkey].sk_func)) (lattr, rattr);
}
- else if (!(result = -(long) (*PsortKeys[nkey].sk_func) (lattr, rattr)))
- result = (long) (*PsortKeys[nkey].sk_func) (rattr, lattr);
+ else if (!(result = -(long) (*fmgr_faddr(&PsortKeys[nkey].sk_func)) (lattr, rattr)))
+ result = (long) (*fmgr_faddr(&PsortKeys[nkey].sk_func)) (rattr, lattr);
nkey++;
}
return (result);
#include <utils/rel.h>
#include <storage/off.h>
+#include <fmgr.h>
+
/*
** You can have as many strategies as you please in GiSTs, as
** long as your consistent method can handle them
typedef struct GISTSTATE
{
- func_ptr consistentFn;
- func_ptr unionFn;
- func_ptr compressFn;
- func_ptr decompressFn;
- func_ptr penaltyFn;
- func_ptr picksplitFn;
- func_ptr equalFn;
+ FmgrInfo consistentFn;
+ FmgrInfo unionFn;
+ FmgrInfo compressFn;
+ FmgrInfo decompressFn;
+ FmgrInfo penaltyFn;
+ FmgrInfo picksplitFn;
+ FmgrInfo equalFn;
bool haskeytype;
bool keytypbyval;
} GISTSTATE;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: skey.h,v 1.6 1997/09/08 21:51:01 momjian Exp $
+ * $Id: skey.h,v 1.7 1998/01/15 19:46:18 pgsql Exp $
*
*
* Note:
#define SKEY_H
#include <access/attnum.h>
+#include <fmgr.h>
typedef struct ScanKeyData
{
bits16 sk_flags; /* flags */
AttrNumber sk_attno; /* domain number */
RegProcedure sk_procedure; /* procedure OID */
- func_ptr sk_func;
+ FmgrInfo sk_func;
int32 sk_nargs;
Datum sk_argument; /* data to compare */
} ScanKeyData;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: valid.h,v 1.11 1997/11/24 05:09:41 momjian Exp $
+ * $Id: valid.h,v 1.12 1998/01/15 19:46:18 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
break; \
} \
\
- if (__cur_keys->sk_func == (func_ptr) oideq) /* optimization */ \
+ if (__cur_keys->sk_func.fn_addr == (func_ptr) oideq) /* optimization */ \
__test = (__cur_keys->sk_argument == __atp); \
else if (__cur_keys->sk_flags & SK_COMMUTE) \
- __test = (long) FMGR_PTR2(__cur_keys->sk_func, __cur_keys->sk_procedure, \
+ __test = (long) FMGR_PTR2(&__cur_keys->sk_func, \
__cur_keys->sk_argument, __atp); \
else \
- __test = (long) FMGR_PTR2(__cur_keys->sk_func, __cur_keys->sk_procedure, \
+ __test = (long) FMGR_PTR2(&__cur_keys->sk_func, \
__atp, __cur_keys->sk_argument); \
\
if (!__test == !(__cur_keys->sk_flags & SK_NEGATE)) \
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: vacuum.h,v 1.11 1997/11/26 01:26:08 momjian Exp $
+ * $Id: vacuum.h,v 1.12 1998/01/15 19:46:24 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
nonnull_cnt;
int32 max_cnt,
min_cnt;
- func_ptr f_cmpeq,
+ FmgrInfo f_cmpeq,
f_cmplt,
f_cmpgt;
regproc outfunc;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: fcache.h,v 1.5 1997/09/08 21:54:57 momjian Exp $
+ * $Id: fcache.h,v 1.6 1998/01/15 19:46:36 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
#ifndef FCACHE_H
#define FCACHE_H
+#include <fmgr.h>
+
typedef struct
{
int typlen; /* length of the return type */
int typbyval; /* true if return type is pass by value */
- func_ptr func; /* address of function to call (for c
+ FmgrInfo func; /* address of function to call (for c
* funcs) */
Oid foid; /* oid of the function in pg_proc */
Oid language; /* oid of the language in pg_language */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: rel.h,v 1.14 1997/11/21 19:12:32 momjian Exp $
+ * $Id: rel.h,v 1.15 1998/01/15 19:46:37 pgsql Exp $
*
*-------------------------------------------------------------------------
*/
{
char *tgname;
Oid tgfoid;
- func_ptr tgfunc;
- func_ptr tgplfunc;
+ FmgrInfo tgfunc;
int16 tgtype;
int16 tgnargs;
int16 tgattr[8];
projects / postgresql / commitdiff