From 48165ec2262b73c5b81a6caabab66d883d013a83 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 5 Jun 2000 07:29:25 +0000 Subject: [PATCH] Latest round of fmgr updates. All functions with bool,char, or int2 inputs have been converted to newstyle. This should go a long way towards fixing our portability problems with platforms where char and short parameters are passed differently from int-width parameters. Still more to do for the Alpha port however. --- src/backend/access/hash/hashfunc.c | 209 +++-- src/backend/access/nbtree/nbtcompare.c | 240 +++--- src/backend/access/transam/xid.c | 43 +- src/backend/bootstrap/bootstrap.c | 6 +- src/backend/commands/comment.c | 2 +- src/backend/commands/copy.c | 9 +- src/backend/parser/parse_expr.c | 5 +- src/backend/storage/large_object/inv_api.c | 5 +- src/backend/storage/smgr/smgr.c | 18 +- src/backend/storage/smgr/smgrtype.c | 47 +- src/backend/tcop/fastpath.c | 4 +- src/backend/utils/adt/acl.c | 21 +- src/backend/utils/adt/bool.c | 159 +++- src/backend/utils/adt/cash.c | 76 +- src/backend/utils/adt/char.c | 232 +++--- src/backend/utils/adt/float.c | 79 +- src/backend/utils/adt/formatting.c | 10 +- src/backend/utils/adt/geo_selfuncs.c | 86 +- src/backend/utils/adt/int.c | 769 ++++++++++-------- src/backend/utils/adt/misc.c | 73 +- src/backend/utils/adt/numeric.c | 34 +- src/backend/utils/adt/oid.c | 193 +++-- src/backend/utils/adt/regproc.c | 64 +- src/backend/utils/adt/selfuncs.c | 441 ++++------ src/backend/utils/adt/varchar.c | 44 +- src/backend/utils/cache/catcache.c | 48 +- src/backend/utils/fmgr/fmgr.c | 170 ++-- src/include/access/hash.h | 34 +- src/include/access/xact.h | 8 +- src/include/catalog/catversion.h | 4 +- src/include/catalog/pg_operator.h | 26 +- src/include/catalog/pg_proc.h | 424 +++++----- src/include/catalog/pg_type.h | 28 +- src/include/fmgr.h | 65 +- src/include/storage/smgr.h | 10 +- src/include/utils/builtins.h | 390 ++++----- src/include/utils/cash.h | 6 +- src/include/utils/catcache.h | 6 +- src/include/utils/geo_decls.h | 21 +- src/pl/plperl/plperl.c | 5 +- src/pl/plpgsql/src/gram.y | 4 +- src/pl/tcl/pltcl.c | 5 +- src/test/regress/expected/opr_sanity.out | 42 +- .../regress/input/create_function_2.source | 2 +- .../regress/output/create_function_2.source | 2 +- src/test/regress/regress.c | 24 +- src/test/regress/sql/opr_sanity.sql | 42 +- 47 files changed, 2201 insertions(+), 2034 deletions(-) diff --git a/src/backend/access/hash/hashfunc.c b/src/backend/access/hash/hashfunc.c index 80d9ac3741..9a6d36f205 100644 --- a/src/backend/access/hash/hashfunc.c +++ b/src/backend/access/hash/hashfunc.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/hash/hashfunc.c,v 1.25 2000/04/12 17:14:44 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/hash/hashfunc.c,v 1.26 2000/06/05 07:28:35 tgl Exp $ * * NOTES * These functions are stored in pg_amproc. For each operator class @@ -21,134 +21,132 @@ #include "access/hash.h" -uint32 -hashint2(int16 key) +Datum +hashint2(PG_FUNCTION_ARGS) { - return (uint32) ~key; + PG_RETURN_UINT32((uint32) ~ PG_GETARG_INT16(0)); } -uint32 -hashint4(uint32 key) +Datum +hashint4(PG_FUNCTION_ARGS) { - return ~key; + PG_RETURN_UINT32(~ PG_GETARG_UINT32(0)); } -uint32 -hashint8(int64 *key) +Datum +hashint8(PG_FUNCTION_ARGS) { - return ~((uint32) *key); + /* we just use the low 32 bits... */ + PG_RETURN_UINT32(~((uint32) PG_GETARG_INT64(0))); } /* Hash function from Chris Torek. */ -uint32 -hashfloat4(float32 keyp) +Datum +hashfloat4(PG_FUNCTION_ARGS) { - int len; + float4 key = PG_GETARG_FLOAT4(0); + char *kp = (char *) &key; + int len = sizeof(key); int loop; uint32 h; - char *kp = (char *) keyp; - - len = sizeof(float32data); #define HASH4a h = (h << 5) - h + *kp++; #define HASH4b h = (h << 5) + h + *kp++; #define HASH4 HASH4b - h = 0; - if (len > 0) - { - loop = (len + 8 - 1) >> 3; + /* + * This is a tad silly, given that we expect len = 4, but a smart + * compiler should be able to eliminate the redundant code... + */ + loop = (len + 8 - 1) >> 3; - switch (len & (8 - 1)) - { - case 0: - do - { /* All fall throughs */ - HASH4; - case 7: - HASH4; - case 6: - HASH4; - case 5: - HASH4; - case 4: - HASH4; - case 3: - HASH4; - case 2: - HASH4; - case 1: - HASH4; - } while (--loop); - } + switch (len & (8 - 1)) + { + case 0: + do + { /* All fall throughs */ + HASH4; + case 7: + HASH4; + case 6: + HASH4; + case 5: + HASH4; + case 4: + HASH4; + case 3: + HASH4; + case 2: + HASH4; + case 1: + HASH4; + } while (--loop); } - return h; + PG_RETURN_UINT32(h); } - -uint32 -hashfloat8(float64 keyp) +Datum +hashfloat8(PG_FUNCTION_ARGS) { - int len; + float8 key = PG_GETARG_FLOAT8(0); + char *kp = (char *) &key; + int len = sizeof(key); int loop; uint32 h; - char *kp = (char *) keyp; - - len = sizeof(float64data); #define HASH4a h = (h << 5) - h + *kp++; #define HASH4b h = (h << 5) + h + *kp++; #define HASH4 HASH4b - h = 0; - if (len > 0) + /* + * This is a tad silly, given that we expect len = 8, but a smart + * compiler should be able to eliminate the redundant code... + */ + loop = (len + 8 - 1) >> 3; + + switch (len & (8 - 1)) { - loop = (len + 8 - 1) >> 3; - - switch (len & (8 - 1)) - { - case 0: - do - { /* All fall throughs */ - HASH4; - case 7: - HASH4; - case 6: - HASH4; - case 5: - HASH4; - case 4: - HASH4; - case 3: - HASH4; - case 2: - HASH4; - case 1: - HASH4; - } while (--loop); - } + case 0: + do + { /* All fall throughs */ + HASH4; + case 7: + HASH4; + case 6: + HASH4; + case 5: + HASH4; + case 4: + HASH4; + case 3: + HASH4; + case 2: + HASH4; + case 1: + HASH4; + } while (--loop); } - return h; + PG_RETURN_UINT32(h); } - -uint32 -hashoid(Oid key) +Datum +hashoid(PG_FUNCTION_ARGS) { - return (uint32) ~key; + PG_RETURN_UINT32(~(uint32) PG_GETARG_OID(0)); } -uint32 -hashoidvector(Oid *key) +Datum +hashoidvector(PG_FUNCTION_ARGS) { + Oid *key = (Oid *) PG_GETARG_POINTER(0); int i; uint32 result = 0; for (i = INDEX_MAX_KEYS; --i >= 0;) result = (result << 1) ^ (~(uint32) key[i]); - return result; + PG_RETURN_UINT32(result); } /* @@ -156,55 +154,50 @@ hashoidvector(Oid *key) * hash function, because it has no pg_proc entry. We only need it * for catcache indexing. */ -uint32 -hashint2vector(int16 *key) +Datum +hashint2vector(PG_FUNCTION_ARGS) { + int16 *key = (int16 *) PG_GETARG_POINTER(0); int i; uint32 result = 0; for (i = INDEX_MAX_KEYS; --i >= 0;) result = (result << 1) ^ (~(uint32) key[i]); - return result; + PG_RETURN_UINT32(result); } #define PRIME1 37 #define PRIME2 1048583 -uint32 -hashchar(char key) +Datum +hashchar(PG_FUNCTION_ARGS) { uint32 h; /* Convert char to integer */ - h = (key - ' '); + h = (PG_GETARG_CHAR(0) - ' '); h %= PRIME2; - return h; + PG_RETURN_UINT32(h); } - -uint32 -hashname(NameData *n) +Datum +hashname(PG_FUNCTION_ARGS) { + char *key = NameStr(* PG_GETARG_NAME(0)); + int len = NAMEDATALEN; uint32 h; - int len; - char *key; - - key = NameStr(*n); h = 0; - len = NAMEDATALEN; /* Convert string to integer */ while (len--) h = h * PRIME1 ^ (*key++ - ' '); h %= PRIME2; - return h; + PG_RETURN_UINT32(h); } - - /* * (Comment from the original db3 hashing code: ) * @@ -216,19 +209,17 @@ hashname(NameData *n) * * "OZ's original sdbm hash" */ -uint32 -hashtext(struct varlena * key) +Datum +hashtext(PG_FUNCTION_ARGS) { + text *key = PG_GETARG_TEXT_P(0); int keylen; char *keydata; uint32 n; int loop; keydata = VARDATA(key); - keylen = VARSIZE(key); - - /* keylen includes the four bytes in which string keylength is stored */ - keylen -= sizeof(VARSIZE(key)); + keylen = VARSIZE(key) - VARHDRSZ; #define HASHC n = *keydata++ + 65599 * n @@ -260,5 +251,5 @@ hashtext(struct varlena * key) } while (--loop); } } - return n; + PG_RETURN_UINT32(n); } diff --git a/src/backend/access/nbtree/nbtcompare.c b/src/backend/access/nbtree/nbtcompare.c index 3e58c677a0..aba0151c83 100644 --- a/src/backend/access/nbtree/nbtcompare.c +++ b/src/backend/access/nbtree/nbtcompare.c @@ -8,141 +8,203 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.34 2000/04/12 17:14:49 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtcompare.c,v 1.35 2000/06/05 07:28:36 tgl Exp $ * - * NOTES - * These functions are stored in pg_amproc. For each operator class - * defined on btrees, they compute + * NOTES + * + * These functions are stored in pg_amproc. For each operator class + * defined on btrees, they compute * * compare(a, b): * < 0 if a < b, * = 0 if a == b, * > 0 if a > b. + * + * The result is always an int32 regardless of the input datatype. + * + * NOTE: although any negative int32 is acceptable for reporting "<", + * and any positive int32 is acceptable for reporting ">", routines + * that work on 32-bit or wider datatypes can't just return "a - b". + * That could overflow and give the wrong answer. + * *------------------------------------------------------------------------- */ - #include "postgres.h" #include "utils/builtins.h" -int32 -btint2cmp(int16 a, int16 b) +Datum +btboolcmp(PG_FUNCTION_ARGS) { - return (int32) (a - b); + bool a = PG_GETARG_BOOL(0); + bool b = PG_GETARG_BOOL(1); + + PG_RETURN_INT32((int32) a - (int32) b); } -int32 -btint4cmp(int32 a, int32 b) +Datum +btint2cmp(PG_FUNCTION_ARGS) { + int16 a = PG_GETARG_INT16(0); + int16 b = PG_GETARG_INT16(1); + + PG_RETURN_INT32((int32) a - (int32) b); +} + +Datum +btint4cmp(PG_FUNCTION_ARGS) +{ + int32 a = PG_GETARG_INT32(0); + int32 b = PG_GETARG_INT32(1); + if (a > b) - return 1; + PG_RETURN_INT32(1); else if (a == b) - return 0; + PG_RETURN_INT32(0); else - return -1; + PG_RETURN_INT32(-1); } -int32 -btint8cmp(int64 *a, int64 *b) +Datum +btint8cmp(PG_FUNCTION_ARGS) { - if (*a > *b) - return 1; - else if (*a == *b) - return 0; - else - return -1; -} + int64 a = PG_GETARG_INT64(0); + int64 b = PG_GETARG_INT64(1); -int32 -btint24cmp(int16 a, int32 b) -{ - return ((int32) a) - b; -} - -int32 -btint42cmp(int32 a, int16 b) -{ - return a - ((int32) b); -} - -int32 -btfloat4cmp(float32 a, float32 b) -{ - if (*a > *b) - return 1; - else if (*a == *b) - return 0; - else - return -1; -} - -int32 -btfloat8cmp(float64 a, float64 b) -{ - if (*a > *b) - return 1; - else if (*a == *b) - return 0; - else - return -1; -} - -int32 -btoidcmp(Oid a, Oid b) -{ if (a > b) - return 1; + PG_RETURN_INT32(1); else if (a == b) - return 0; + PG_RETURN_INT32(0); else - return -1; + PG_RETURN_INT32(-1); } -int32 -btoidvectorcmp(Oid *a, Oid *b) +Datum +btint24cmp(PG_FUNCTION_ARGS) { + int16 a = PG_GETARG_INT16(0); + int32 b = PG_GETARG_INT32(1); + + if (a > b) + PG_RETURN_INT32(1); + else if (a == b) + PG_RETURN_INT32(0); + else + PG_RETURN_INT32(-1); +} + +Datum +btint42cmp(PG_FUNCTION_ARGS) +{ + int32 a = PG_GETARG_INT32(0); + int16 b = PG_GETARG_INT16(1); + + if (a > b) + PG_RETURN_INT32(1); + else if (a == b) + PG_RETURN_INT32(0); + else + PG_RETURN_INT32(-1); +} + +Datum +btfloat4cmp(PG_FUNCTION_ARGS) +{ + float4 a = PG_GETARG_FLOAT4(0); + float4 b = PG_GETARG_FLOAT4(1); + + if (a > b) + PG_RETURN_INT32(1); + else if (a == b) + PG_RETURN_INT32(0); + else + PG_RETURN_INT32(-1); +} + +Datum +btfloat8cmp(PG_FUNCTION_ARGS) +{ + float8 a = PG_GETARG_FLOAT8(0); + float8 b = PG_GETARG_FLOAT8(1); + + if (a > b) + PG_RETURN_INT32(1); + else if (a == b) + PG_RETURN_INT32(0); + else + PG_RETURN_INT32(-1); +} + +Datum +btoidcmp(PG_FUNCTION_ARGS) +{ + Oid a = PG_GETARG_OID(0); + Oid b = PG_GETARG_OID(1); + + if (a > b) + PG_RETURN_INT32(1); + else if (a == b) + PG_RETURN_INT32(0); + else + PG_RETURN_INT32(-1); +} + +Datum +btoidvectorcmp(PG_FUNCTION_ARGS) +{ + Oid *a = (Oid *) PG_GETARG_POINTER(0); + Oid *b = (Oid *) PG_GETARG_POINTER(1); int i; for (i = 0; i < INDEX_MAX_KEYS; i++) - /* we use this because we need the int4gt, etc */ - if (!int4eq(a[i], b[i])) + { + if (a[i] != b[i]) { - if (int4gt(a[i], b[i])) - return 1; + if (a[i] > b[i]) + PG_RETURN_INT32(1); else - return -1; + PG_RETURN_INT32(-1); } - return 0; + } + PG_RETURN_INT32(0); } - int32 btabstimecmp(AbsoluteTime a, AbsoluteTime b) { if (AbsoluteTimeIsBefore(a, b)) - return -1; + PG_RETURN_INT32(-1); else if (AbsoluteTimeIsBefore(b, a)) - return 1; + PG_RETURN_INT32(1); else - return 0; + PG_RETURN_INT32(0); } -int32 -btcharcmp(char a, char b) +Datum +btcharcmp(PG_FUNCTION_ARGS) { - return (int32) ((uint8) a - (uint8) b); + char a = PG_GETARG_CHAR(0); + char b = PG_GETARG_CHAR(1); + + /* Be careful to compare chars as unsigned */ + PG_RETURN_INT32((int32) ((uint8) a) - (int32) ((uint8) b)); } -int32 -btnamecmp(NameData *a, NameData *b) +Datum +btnamecmp(PG_FUNCTION_ARGS) { - return strncmp(NameStr(*a), NameStr(*b), NAMEDATALEN); + Name a = PG_GETARG_NAME(0); + Name b = PG_GETARG_NAME(1); + + PG_RETURN_INT32(strncmp(NameStr(*a), NameStr(*b), NAMEDATALEN)); } -int32 -bttextcmp(struct varlena * a, struct varlena * b) +Datum +bttextcmp(PG_FUNCTION_ARGS) { + text *a = PG_GETARG_TEXT_P(0); + text *b = PG_GETARG_TEXT_P(1); int res; unsigned char *ap, *bp; @@ -187,7 +249,7 @@ bttextcmp(struct varlena * a, struct varlena * b) { do { - res = (int) (*ap++ - *bp++); + res = (int) *ap++ - (int) *bp++; len--; } while (res == 0 && len != 0); } @@ -195,7 +257,7 @@ bttextcmp(struct varlena * a, struct varlena * b) #endif if (res != 0 || VARSIZE(a) == VARSIZE(b)) - return res; + PG_RETURN_INT32(res); /* * The two strings are the same in the first len bytes, and they are @@ -203,13 +265,7 @@ bttextcmp(struct varlena * a, struct varlena * b) */ if (VARSIZE(a) < VARSIZE(b)) - return -1; + PG_RETURN_INT32(-1); else - return 1; -} - -int32 -btboolcmp(bool a, bool b) -{ - return (int32) ((uint8) a - (uint8) b); + PG_RETURN_INT32(1); } diff --git a/src/backend/access/transam/xid.c b/src/backend/access/transam/xid.c index df5c59543c..28171a7f33 100644 --- a/src/backend/access/transam/xid.c +++ b/src/backend/access/transam/xid.c @@ -1,12 +1,12 @@ /*------------------------------------------------------------------------- * * xid.c - * POSTGRES transaction identifier code. + * POSTGRES transaction identifier type. * * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: xid.c,v 1.27 2000/01/26 05:56:04 momjian Exp $ + * $Id: xid.c,v 1.28 2000/06/05 07:28:38 tgl Exp $ * * OLD COMMENTS * XXX WARNING @@ -19,33 +19,42 @@ *------------------------------------------------------------------------- */ - #include "postgres.h" + #include "access/xact.h" +/* + * TransactionId is typedef'd as uint32, so... + */ +#define PG_GETARG_TRANSACTIONID(n) PG_GETARG_UINT32(n) +#define PG_RETURN_TRANSACTIONID(x) PG_RETURN_UINT32(x) + + extern TransactionId NullTransactionId; extern TransactionId DisabledTransactionId; extern TransactionId AmiTransactionId; extern TransactionId FirstTransactionId; /* XXX name for catalogs */ -TransactionId -xidin(char *representation) +Datum +xidin(PG_FUNCTION_ARGS) { - return atol(representation); + char *representation = PG_GETARG_CSTRING(0); + + PG_RETURN_TRANSACTIONID((TransactionId) atol(representation)); } /* XXX name for catalogs */ -char * -xidout(TransactionId transactionId) +Datum +xidout(PG_FUNCTION_ARGS) { + TransactionId transactionId = PG_GETARG_TRANSACTIONID(0); /* maximum 32 bit unsigned integer representation takes 10 chars */ char *representation = palloc(11); - snprintf(representation, 11, "%u", transactionId); - - return representation; + snprintf(representation, 11, "%lu", (unsigned long) transactionId); + PG_RETURN_CSTRING(representation); } /* ---------------------------------------------------------------- @@ -57,14 +66,15 @@ xidout(TransactionId transactionId) * xideq - returns 1, iff xid1 == xid2 * 0 else; */ -bool -xideq(TransactionId xid1, TransactionId xid2) +Datum +xideq(PG_FUNCTION_ARGS) { - return (bool) (xid1 == xid2); + TransactionId xid1 = PG_GETARG_TRANSACTIONID(0); + TransactionId xid2 = PG_GETARG_TRANSACTIONID(1); + + PG_RETURN_BOOL(xid1 == xid2); } - - /* ---------------------------------------------------------------- * TransactionIdAdd * ---------------------------------------------------------------- @@ -73,5 +83,4 @@ void TransactionIdAdd(TransactionId *xid, int value) { *xid += value; - return; } diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c index 9c0f58e159..e8aa2a7402 100644 --- a/src/backend/bootstrap/bootstrap.c +++ b/src/backend/bootstrap/bootstrap.c @@ -8,7 +8,7 @@ * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.84 2000/05/31 00:28:14 petere Exp $ + * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.85 2000/06/05 07:28:40 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -38,7 +38,7 @@ #include "utils/lsyscache.h" #include "utils/portal.h" -#define ALLOC(t, c) (t *)calloc((unsigned)(c), sizeof(t)) +#define ALLOC(t, c) ((t *) calloc((unsigned)(c), sizeof(t))) extern void BaseInit(void); extern void StartupXLOG(void); @@ -112,7 +112,7 @@ static struct typinfo Procid[] = { {"int4", INT4OID, 0, 4, F_INT4IN, F_INT4OUT}, {"regproc", REGPROCOID, 0, 4, F_REGPROCIN, F_REGPROCOUT}, {"text", TEXTOID, 0, -1, F_TEXTIN, F_TEXTOUT}, - {"oid", OIDOID, 0, 4, F_INT4IN, F_INT4OUT}, + {"oid", OIDOID, 0, 4, F_OIDIN, F_OIDOUT}, {"tid", TIDOID, 0, 6, F_TIDIN, F_TIDOUT}, {"xid", XIDOID, 0, 4, F_XIDIN, F_XIDOUT}, {"cid", CIDOID, 0, 4, F_CIDIN, F_CIDOUT}, diff --git a/src/backend/commands/comment.c b/src/backend/commands/comment.c index cd2c71359f..9739c68ffd 100644 --- a/src/backend/commands/comment.c +++ b/src/backend/commands/comment.c @@ -772,7 +772,7 @@ CommentOperator(char *opername, List *arguments, char *comment) /*** Get the procedure associated with the operator ***/ data = (Form_pg_operator) GETSTRUCT(optuple); - oid = regproctooid(data->oprcode); + oid = RegprocToOid(data->oprcode); if (oid == InvalidOid) elog(ERROR, "operator '%s' does not have an underlying function", opername); diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c index adba62242a..68773ba14e 100644 --- a/src/backend/commands/copy.c +++ b/src/backend/commands/copy.c @@ -7,7 +7,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.110 2000/06/02 15:57:18 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.111 2000/06/05 07:28:42 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -473,7 +473,9 @@ CopyTo(Relation rel, bool binary, bool oids, FILE *fp, char *delim, char *null_p if (oids && !binary) { - CopySendString(oidout(tuple->t_data->t_oid), fp); + CopySendString(DatumGetCString(DirectFunctionCall1(oidout, + ObjectIdGetDatum(tuple->t_data->t_oid))), + fp); CopySendChar(delim[0], fp); } @@ -782,7 +784,8 @@ CopyFrom(Relation rel, bool binary, bool oids, FILE *fp, char *delim, char *null done = 1; else { - loaded_oid = oidin(string); + loaded_oid = DatumGetObjectId(DirectFunctionCall1(oidin, + CStringGetDatum(string))); if (loaded_oid == InvalidOid) elog(ERROR, "COPY TEXT: Invalid Oid"); } diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c index ed8ee41e45..b2785f820a 100644 --- a/src/backend/parser/parse_expr.c +++ b/src/backend/parser/parse_expr.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.79 2000/05/30 00:49:50 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.80 2000/06/05 07:28:43 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -892,7 +892,8 @@ parser_typecast_constant(Value *expr, TypeName *typename) { case T_Integer: string_palloced = true; - const_string = int4out(expr->val.ival); + const_string = DatumGetCString(DirectFunctionCall1(int4out, + Int32GetDatum(expr->val.ival))); break; case T_Float: case T_String: diff --git a/src/backend/storage/large_object/inv_api.c b/src/backend/storage/large_object/inv_api.c index 6f60e902ca..506a12a0a9 100644 --- a/src/backend/storage/large_object/inv_api.c +++ b/src/backend/storage/large_object/inv_api.c @@ -9,7 +9,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.68 2000/05/28 17:56:03 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/storage/large_object/inv_api.c,v 1.69 2000/06/05 07:28:45 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -174,7 +174,8 @@ inv_create(int flags) if (!RelationIsValid(indr)) { elog(ERROR, "cannot create index for large obj on %s under inversion", - smgrout(DEFAULT_SMGR)); + DatumGetCString(DirectFunctionCall1(smgrout, + Int16GetDatum(DEFAULT_SMGR)))); } retval = (LargeObjectDesc *) palloc(sizeof(LargeObjectDesc)); diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c index 3b857cd319..419cc8610f 100644 --- a/src/backend/storage/smgr/smgr.c +++ b/src/backend/storage/smgr/smgr.c @@ -11,7 +11,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgr.c,v 1.35 2000/04/12 17:15:42 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgr.c,v 1.36 2000/06/05 07:28:47 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -105,7 +105,9 @@ smgrinit() if (smgrsw[i].smgr_init) { if ((*(smgrsw[i].smgr_init)) () == SM_FAIL) - elog(FATAL, "initialization failed on %s", smgrout(i)); + elog(FATAL, "initialization failed on %s", + DatumGetCString(DirectFunctionCall1(smgrout, + Int16GetDatum(i)))); } } @@ -125,7 +127,9 @@ smgrshutdown(int dummy) if (smgrsw[i].smgr_shutdown) { if ((*(smgrsw[i].smgr_shutdown)) () == SM_FAIL) - elog(FATAL, "shutdown failed on %s", smgrout(i)); + elog(FATAL, "shutdown failed on %s", + DatumGetCString(DirectFunctionCall1(smgrout, + Int16GetDatum(i)))); } } } @@ -445,7 +449,9 @@ smgrcommit() if (smgrsw[i].smgr_commit) { if ((*(smgrsw[i].smgr_commit)) () == SM_FAIL) - elog(FATAL, "transaction commit failed on %s", smgrout(i)); + elog(FATAL, "transaction commit failed on %s", + DatumGetCString(DirectFunctionCall1(smgrout, + Int16GetDatum(i)))); } } @@ -462,7 +468,9 @@ smgrabort() if (smgrsw[i].smgr_abort) { if ((*(smgrsw[i].smgr_abort)) () == SM_FAIL) - elog(FATAL, "transaction abort failed on %s", smgrout(i)); + elog(FATAL, "transaction abort failed on %s", + DatumGetCString(DirectFunctionCall1(smgrout, + Int16GetDatum(i)))); } } diff --git a/src/backend/storage/smgr/smgrtype.c b/src/backend/storage/smgr/smgrtype.c index e6cd6c3bf4..49d08e1a7a 100644 --- a/src/backend/storage/smgr/smgrtype.c +++ b/src/backend/storage/smgr/smgrtype.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgrtype.c,v 1.16 2000/01/26 05:57:05 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/storage/smgr/smgrtype.c,v 1.17 2000/06/05 07:28:47 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -37,45 +37,48 @@ static smgrid StorageManager[] = { static int NStorageManagers = lengthof(StorageManager); -int2 -smgrin(char *s) +Datum +smgrin(PG_FUNCTION_ARGS) { - int i; + char *s = PG_GETARG_CSTRING(0); + int16 i; for (i = 0; i < NStorageManagers; i++) { if (strcmp(s, StorageManager[i].smgr_name) == 0) - return (int2) i; + PG_RETURN_INT16(i); } - elog(ERROR, "smgrin: illegal storage manager name %s", s); - return 0; + elog(ERROR, "smgrin: unknown storage manager name '%s'", s); + PG_RETURN_INT16(0); } -char * -smgrout(int2 i) +Datum +smgrout(PG_FUNCTION_ARGS) { + int16 i = PG_GETARG_INT16(0); char *s; if (i >= NStorageManagers || i < 0) elog(ERROR, "Illegal storage manager id %d", i); - s = (char *) palloc(strlen(StorageManager[i].smgr_name) + 1); - strcpy(s, StorageManager[i].smgr_name); - return s; + s = pstrdup(StorageManager[i].smgr_name); + PG_RETURN_CSTRING(s); } -bool -smgreq(int2 a, int2 b) +Datum +smgreq(PG_FUNCTION_ARGS) { - if (a == b) - return true; - return false; + int16 a = PG_GETARG_INT16(0); + int16 b = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(a == b); } -bool -smgrne(int2 a, int2 b) +Datum +smgrne(PG_FUNCTION_ARGS) { - if (a == b) - return false; - return true; + int16 a = PG_GETARG_INT16(0); + int16 b = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(a != b); } diff --git a/src/backend/tcop/fastpath.c b/src/backend/tcop/fastpath.c index 45c62f365e..10ff95b962 100644 --- a/src/backend/tcop/fastpath.c +++ b/src/backend/tcop/fastpath.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.40 2000/05/30 07:09:23 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.41 2000/06/05 07:28:49 tgl Exp $ * * NOTES * This cruft is the server side of PQfn. @@ -164,7 +164,7 @@ valid_fp_info(Oid func_id, struct fp_info * fip) Assert(fip != (struct fp_info *) NULL); return (OidIsValid(fip->funcid) && - oideq(func_id, fip->funcid) && + func_id == fip->funcid && TransactionIdIsCurrentTransactionId(fip->xid) && CommandIdIsCurrentCommandId(fip->cid)); } diff --git a/src/backend/utils/adt/acl.c b/src/backend/utils/adt/acl.c index 6c27fbe03f..0a6c664e7d 100644 --- a/src/backend/utils/adt/acl.c +++ b/src/backend/utils/adt/acl.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.45 2000/04/12 17:15:47 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.46 2000/06/05 07:28:51 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -21,6 +21,7 @@ #include "catalog/pg_type.h" #include "lib/stringinfo.h" #include "utils/acl.h" +#include "utils/builtins.h" #include "utils/memutils.h" #include "utils/syscache.h" @@ -268,7 +269,6 @@ aclitemout(AclItem *aip) static AclItem default_aclitem = {ACL_ID_WORLD, ACL_IDTYPE_WORLD, ACL_WORLD_DEFAULT}; - extern char *int2out(); char *tmpname; if (!aip) @@ -287,20 +287,11 @@ aclitemout(AclItem *aip) 0, 0, 0); if (!HeapTupleIsValid(htup)) { - char *tmp = int2out(aip->ai_id); - -#ifdef NOT_USED - - When this elog(NOTICE) goes to the libpq client, - it crashes the - client because the NOTICE protocol is coming right in the middle - of a request for a field value.We skip the NOTICE for now. - - elog(NOTICE, "aclitemout: usesysid %d not found", - aip->ai_id); - -#endif + /* Generate numeric UID if we don't find an entry */ + char *tmp; + tmp = DatumGetCString(DirectFunctionCall1(int4out, + Int32GetDatum((int32) aip->ai_id))); strcat(p, tmp); pfree(tmp); } diff --git a/src/backend/utils/adt/bool.c b/src/backend/utils/adt/bool.c index c5657babcf..bdf695aa52 100644 --- a/src/backend/utils/adt/bool.c +++ b/src/backend/utils/adt/bool.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/bool.c,v 1.22 2000/02/10 19:51:39 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/bool.c,v 1.23 2000/06/05 07:28:51 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -29,43 +29,45 @@ * * In the switch statement, check the most-used possibilities first. */ -bool -boolin(char *b) +Datum +boolin(PG_FUNCTION_ARGS) { + char *b = PG_GETARG_CSTRING(0); + switch (*b) { case 't': case 'T': if (strncasecmp(b, "true", strlen(b)) == 0) - return TRUE; + PG_RETURN_BOOL(true); break; case 'f': case 'F': if (strncasecmp(b, "false", strlen(b)) == 0) - return FALSE; + PG_RETURN_BOOL(false); break; case 'y': case 'Y': if (strncasecmp(b, "yes", strlen(b)) == 0) - return TRUE; + PG_RETURN_BOOL(true); break; case '1': if (strncasecmp(b, "1", strlen(b)) == 0) - return TRUE; + PG_RETURN_BOOL(true); break; case 'n': case 'N': if (strncasecmp(b, "no", strlen(b)) == 0) - return FALSE; + PG_RETURN_BOOL(false); break; case '0': if (strncasecmp(b, "0", strlen(b)) == 0) - return FALSE; + PG_RETURN_BOOL(false); break; default: @@ -73,72 +75,143 @@ boolin(char *b) } elog(ERROR, "Bad boolean external representation '%s'", b); + /* not reached */ - return FALSE; -} /* boolin() */ + PG_RETURN_BOOL(false); +} /* * boolout - converts 1 or 0 to "t" or "f" */ -char * -boolout(bool b) +Datum +boolout(PG_FUNCTION_ARGS) { + bool b = PG_GETARG_BOOL(0); char *result = (char *) palloc(2); - *result = (b) ? 't' : 'f'; + result[0] = (b) ? 't' : 'f'; result[1] = '\0'; - return result; -} /* boolout() */ + PG_RETURN_CSTRING(result); +} /***************************************************************************** * PUBLIC ROUTINES * *****************************************************************************/ -bool -booleq(bool arg1, bool arg2) +Datum +booleq(PG_FUNCTION_ARGS) { - return arg1 == arg2; + bool arg1 = PG_GETARG_BOOL(0); + bool arg2 = PG_GETARG_BOOL(1); + + PG_RETURN_BOOL(arg1 == arg2); } -bool -boolne(bool arg1, bool arg2) +Datum +boolne(PG_FUNCTION_ARGS) { - return arg1 != arg2; + bool arg1 = PG_GETARG_BOOL(0); + bool arg2 = PG_GETARG_BOOL(1); + + PG_RETURN_BOOL(arg1 != arg2); } -bool -boollt(bool arg1, bool arg2) +Datum +boollt(PG_FUNCTION_ARGS) { - return arg1 < arg2; + bool arg1 = PG_GETARG_BOOL(0); + bool arg2 = PG_GETARG_BOOL(1); + + PG_RETURN_BOOL(arg1 < arg2); } -bool -boolgt(bool arg1, bool arg2) +Datum +boolgt(PG_FUNCTION_ARGS) { - return arg1 > arg2; + bool arg1 = PG_GETARG_BOOL(0); + bool arg2 = PG_GETARG_BOOL(1); + + PG_RETURN_BOOL(arg1 > arg2); } -bool -boolle(bool arg1, bool arg2) +Datum +boolle(PG_FUNCTION_ARGS) { - return arg1 <= arg2; + bool arg1 = PG_GETARG_BOOL(0); + bool arg2 = PG_GETARG_BOOL(1); + + PG_RETURN_BOOL(arg1 <= arg2); } -bool -boolge(bool arg1, bool arg2) +Datum +boolge(PG_FUNCTION_ARGS) { - return arg1 >= arg2; + bool arg1 = PG_GETARG_BOOL(0); + bool arg2 = PG_GETARG_BOOL(1); + + PG_RETURN_BOOL(arg1 >= arg2); } -bool -istrue(bool arg1) -{ - return arg1 == TRUE; -} /* istrue() */ +/* + * Per SQL92, istrue() and isfalse() should return false, not NULL, + * when presented a NULL input (since NULL is our implementation of + * UNKNOWN). Conversely isnottrue() and isnotfalse() should return true. + * Therefore, these routines are all declared not-strict in pg_proc + * and must do their own checking for null inputs. + * + * Note we don't need isunknown() and isnotunknown() functions, since + * nullvalue() and nonnullvalue() will serve. + */ -bool -isfalse(bool arg1) +Datum +istrue(PG_FUNCTION_ARGS) { - return arg1 != TRUE; -} /* isfalse() */ + bool b; + + if (PG_ARGISNULL(0)) + PG_RETURN_BOOL(false); + + b = PG_GETARG_BOOL(0); + + PG_RETURN_BOOL(b); +} + +Datum +isfalse(PG_FUNCTION_ARGS) +{ + bool b; + + if (PG_ARGISNULL(0)) + PG_RETURN_BOOL(false); + + b = PG_GETARG_BOOL(0); + + PG_RETURN_BOOL(! b); +} + +Datum +isnottrue(PG_FUNCTION_ARGS) +{ + bool b; + + if (PG_ARGISNULL(0)) + PG_RETURN_BOOL(true); + + b = PG_GETARG_BOOL(0); + + PG_RETURN_BOOL(! b); +} + +Datum +isnotfalse(PG_FUNCTION_ARGS) +{ + bool b; + + if (PG_ARGISNULL(0)) + PG_RETURN_BOOL(true); + + b = PG_GETARG_BOOL(0); + + PG_RETURN_BOOL(b); +} diff --git a/src/backend/utils/adt/cash.c b/src/backend/utils/adt/cash.c index 9a06bc3895..9bfc46bda6 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.36 2000/05/16 20:48:49 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/cash.c,v 1.37 2000/06/05 07:28:51 tgl Exp $ */ #include @@ -35,6 +35,24 @@ static struct lconv *lconvert = NULL; #endif + +/* + * Cash is a pass-by-ref SQL type, so we must pass and return pointers. + * These macros and support routine hide the pass-by-refness. + */ +#define PG_GETARG_CASH(n) (* ((Cash *) DatumGetPointer(fcinfo->arg[n]))) +#define PG_RETURN_CASH(x) return CashGetDatum(x) + +static Datum +CashGetDatum(Cash value) +{ + Cash *result = (Cash *) palloc(sizeof(Cash)); + + *result = value; + return PointerGetDatum(result); +} + + /* cash_in() * Convert a string to a cash data type. * Format is [$]###[,]###[.##] @@ -573,32 +591,30 @@ cash_div_int4(Cash *c, int4 i) /* cash_mul_int2() * Multiply cash by int2. */ -Cash * -cash_mul_int2(Cash *c, int2 s) +Datum +cash_mul_int2(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 = ((s) * (*c)); - - return result; -} /* cash_mul_int2() */ + Cash c = PG_GETARG_CASH(0); + int16 s = PG_GETARG_INT16(1); + Cash result; + result = c * s; + PG_RETURN_CASH(result); +} /* int2_mul_cash() * Multiply int2 by cash. */ -Cash * -int2_mul_cash(int2 s, Cash *c) +Datum +int2_mul_cash(PG_FUNCTION_ARGS) { - return cash_mul_int2(c, s); -} /* int2_mul_cash() */ + int16 s = PG_GETARG_INT16(0); + Cash c = PG_GETARG_CASH(1); + Cash result; + result = s * c; + PG_RETURN_CASH(result); +} /* cash_div_int2() * Divide cash by int2. @@ -606,25 +622,19 @@ int2_mul_cash(int2 s, Cash *c) * XXX Don't know if rounding or truncating is correct behavior. * Round for now. - tgl 97/04/15 */ -Cash * -cash_div_int2(Cash *c, int2 s) +Datum +cash_div_int2(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); + int16 s = PG_GETARG_INT16(1); + Cash result; if (s == 0) elog(ERROR, "cash_div: divide by 0 error"); - *result = rint(*c / s); - - return result; -} /* cash_div_int2() */ - + result = rint(c / s); + PG_RETURN_CASH(result); +} /* cashlarger() * Return larger of two cash values. diff --git a/src/backend/utils/adt/char.c b/src/backend/utils/adt/char.c index 6675e4cb99..04e40406f8 100644 --- a/src/backend/utils/adt/char.c +++ b/src/backend/utils/adt/char.c @@ -2,18 +2,19 @@ * * char.c * Functions for the built-in type "char". - * Functions for the built-in type "cid". + * Functions for the built-in type "cid" (what's that doing here?) * * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.27 2000/01/26 05:57:13 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.28 2000/06/05 07:28:51 tgl Exp $ * *------------------------------------------------------------------------- */ #include "postgres.h" + #include "utils/builtins.h" /***************************************************************************** @@ -23,149 +24,194 @@ /* * charin - converts "x" to 'x' */ -int32 -charin(char *ch) +Datum +charin(PG_FUNCTION_ARGS) { - if (ch == NULL) - return (int32) '\0'; - return (int32) *ch; + char *ch = PG_GETARG_CSTRING(0); + + PG_RETURN_CHAR(ch[0]); } /* * charout - converts 'x' to "x" */ -char * -charout(int32 ch) +Datum +charout(PG_FUNCTION_ARGS) { + char ch = PG_GETARG_CHAR(0); char *result = (char *) palloc(2); - result[0] = (char) ch; + result[0] = ch; result[1] = '\0'; - return result; + PG_RETURN_CSTRING(result); } -/* - * cidin - converts "..." to internal representation. - * - * NOTE: we must not use 'charin' because cid might be a non - * printable character... - */ -int32 -cidin(char *s) -{ - CommandId c; - - if (s == NULL) - c = 0; - else - c = atoi(s); - - return (int32) c; -} - -/* - * cidout - converts a cid to "..." - * - * NOTE: we must no use 'charout' because cid might be a non - * printable character... - */ -char * -cidout(int32 c) -{ - char *result; - CommandId c2; - - result = palloc(12); - c2 = (CommandId) c; - sprintf(result, "%u", (unsigned) (c2)); - return result; -} - - /***************************************************************************** * PUBLIC ROUTINES * *****************************************************************************/ -bool -chareq(int8 arg1, int8 arg2) +/* + * NOTE: comparisons are done as though char is unsigned (uint8). + * Arithmetic is done as though char is signed (int8). + * + * You wanted consistency? + */ + +Datum +chareq(PG_FUNCTION_ARGS) { - return arg1 == arg2; + char arg1 = PG_GETARG_CHAR(0); + char arg2 = PG_GETARG_CHAR(1); + + PG_RETURN_BOOL(arg1 == arg2); } -bool -charne(int8 arg1, int8 arg2) +Datum +charne(PG_FUNCTION_ARGS) { - return arg1 != arg2; + char arg1 = PG_GETARG_CHAR(0); + char arg2 = PG_GETARG_CHAR(1); + + PG_RETURN_BOOL(arg1 != arg2); } -bool -charlt(int8 arg1, int8 arg2) +Datum +charlt(PG_FUNCTION_ARGS) { - return (uint8) arg1 < (uint8) arg2; + char arg1 = PG_GETARG_CHAR(0); + char arg2 = PG_GETARG_CHAR(1); + + PG_RETURN_BOOL((uint8) arg1 < (uint8) arg2); } -bool -charle(int8 arg1, int8 arg2) +Datum +charle(PG_FUNCTION_ARGS) { - return (uint8) arg1 <= (uint8) arg2; + char arg1 = PG_GETARG_CHAR(0); + char arg2 = PG_GETARG_CHAR(1); + + PG_RETURN_BOOL((uint8) arg1 <= (uint8) arg2); } -bool -chargt(int8 arg1, int8 arg2) +Datum +chargt(PG_FUNCTION_ARGS) { - return (uint8) arg1 > (uint8) arg2; + char arg1 = PG_GETARG_CHAR(0); + char arg2 = PG_GETARG_CHAR(1); + + PG_RETURN_BOOL((uint8) arg1 > (uint8) arg2); } -bool -charge(int8 arg1, int8 arg2) +Datum +charge(PG_FUNCTION_ARGS) { - return (uint8) arg1 >= (uint8) arg2; + char arg1 = PG_GETARG_CHAR(0); + char arg2 = PG_GETARG_CHAR(1); + + PG_RETURN_BOOL((uint8) arg1 >= (uint8) arg2); } -int8 -charpl(int8 arg1, int8 arg2) +Datum +charpl(PG_FUNCTION_ARGS) { - return arg1 + arg2; + char arg1 = PG_GETARG_CHAR(0); + char arg2 = PG_GETARG_CHAR(1); + + PG_RETURN_CHAR((int8) arg1 + (int8) arg2); } -int8 -charmi(int8 arg1, int8 arg2) +Datum +charmi(PG_FUNCTION_ARGS) { - return arg1 - arg2; + char arg1 = PG_GETARG_CHAR(0); + char arg2 = PG_GETARG_CHAR(1); + + PG_RETURN_CHAR((int8) arg1 - (int8) arg2); } -int8 -charmul(int8 arg1, int8 arg2) +Datum +charmul(PG_FUNCTION_ARGS) { - return arg1 * arg2; + char arg1 = PG_GETARG_CHAR(0); + char arg2 = PG_GETARG_CHAR(1); + + PG_RETURN_CHAR((int8) arg1 * (int8) arg2); } -int8 -chardiv(int8 arg1, int8 arg2) +Datum +chardiv(PG_FUNCTION_ARGS) { - return arg1 / arg2; + char arg1 = PG_GETARG_CHAR(0); + char arg2 = PG_GETARG_CHAR(1); + + PG_RETURN_CHAR((int8) arg1 / (int8) arg2); } -bool -cideq(int8 arg1, int8 arg2) +Datum +text_char(PG_FUNCTION_ARGS) { - return arg1 == arg2; + text *arg1 = PG_GETARG_TEXT_P(0); + + /* XXX what if arg1 has length zero? */ + PG_RETURN_CHAR(*(VARDATA(arg1))); } -int8 -text_char(text *arg1) +Datum +char_text(PG_FUNCTION_ARGS) { - return ((int8) *(VARDATA(arg1))); -} + char arg1 = PG_GETARG_CHAR(0); + text *result = palloc(VARHDRSZ + 1); -text * -char_text(int8 arg1) -{ - text *result; - - result = palloc(VARHDRSZ + 1); VARSIZE(result) = VARHDRSZ + 1; *(VARDATA(result)) = arg1; - return result; + PG_RETURN_TEXT_P(result); +} + + +/***************************************************************************** + * USER I/O ROUTINES * + *****************************************************************************/ + +/* + * cidin - converts CommandId to internal representation. + */ +Datum +cidin(PG_FUNCTION_ARGS) +{ + char *s = PG_GETARG_CSTRING(0); + CommandId c; + + c = atoi(s); + + /* XXX assume that CommandId is 32 bits... */ + PG_RETURN_INT32((int32) c); +} + +/* + * cidout - converts a cid to external representation. + */ +Datum +cidout(PG_FUNCTION_ARGS) +{ + /* XXX assume that CommandId is 32 bits... */ + CommandId c = PG_GETARG_INT32(0); + char *result = (char *) palloc(16); + + sprintf(result, "%u", (unsigned int) c); + PG_RETURN_CSTRING(result); +} + +/***************************************************************************** + * PUBLIC ROUTINES * + *****************************************************************************/ + +Datum +cideq(PG_FUNCTION_ARGS) +{ + /* XXX assume that CommandId is 32 bits... */ + CommandId arg1 = PG_GETARG_INT32(0); + CommandId arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 == arg2); } diff --git a/src/backend/utils/adt/float.c b/src/backend/utils/adt/float.c index 354ee0110b..b7b654cc32 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.57 2000/04/12 17:15:49 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/float.c,v 1.58 2000/06/05 07:28:51 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -122,25 +122,6 @@ extern double rint(double x); #define FLOAT8_MAX DBL_MAX #define FLOAT8_MIN DBL_MIN -/* - * if FLOAT8_MIN and FLOAT8_MAX are the limits of the range a - * double can store, then how are we ever going to wind up - * with something stored in a double that is outside those - * limits? (and similarly for FLOAT4_{MIN,MAX}/float.) - * doesn't make sense to me, and it causes a - * floating point exception on linuxalpha, so UNSAFE_FLOATS - * it is. - * (maybe someone wanted to allow for values other than DBL_MIN/ - * DBL_MAX for FLOAT8_MIN/FLOAT8_MAX?) - * --djm 12/12/96 - * according to Richard Henderson this is a known bug in gcc on - * the Alpha. might as well leave the workaround in - * until the distributions are updated. - * --djm 12/16/96 - */ -#if ( defined(linux) && defined(__alpha__) ) && !defined(UNSAFE_FLOATS) -#define UNSAFE_FLOATS -#endif /* check to see if a float4 val is outside of @@ -844,19 +825,17 @@ dtoi4(float64 num) /* * dtoi2 - converts a float8 number to an int2 number */ -int16 -dtoi2(float64 num) +Datum +dtoi2(PG_FUNCTION_ARGS) { + float8 num = PG_GETARG_FLOAT8(0); int16 result; - if (!num) - return 0; /* fmgr will return NULL anyway */ - - if ((*num < SHRT_MIN) || (*num > SHRT_MAX)) + if ((num < SHRT_MIN) || (num > SHRT_MAX)) elog(ERROR, "dtoi2: integer out of range"); - result = rint(*num); - return result; + result = (int16) rint(num); + PG_RETURN_INT16(result); } @@ -878,15 +857,14 @@ i4tod(int32 num) /* * i2tod - converts an int2 number to a float8 number */ -float64 -i2tod(int16 num) +Datum +i2tod(PG_FUNCTION_ARGS) { - float64 result; + int16 num = PG_GETARG_INT16(0); + float8 result; - result = (float64) palloc(sizeof(float64data)); - - *result = num; - return result; + result = num; + PG_RETURN_FLOAT8(result); } @@ -910,21 +888,19 @@ ftoi4(float32 num) /* - * ftoi2 - converts a float8 number to an int2 number + * ftoi2 - converts a float4 number to an int2 number */ -int16 -ftoi2(float32 num) +Datum +ftoi2(PG_FUNCTION_ARGS) { + float4 num = PG_GETARG_FLOAT4(0); int16 result; - if (!num) - return 0; /* fmgr will return NULL anyway */ - - if ((*num < SHRT_MIN) || (*num > SHRT_MAX)) + if ((num < SHRT_MIN) || (num > SHRT_MAX)) elog(ERROR, "ftoi2: integer out of range"); - result = rint(*num); - return result; + result = (int16) rint(num); + PG_RETURN_INT16(result); } @@ -944,17 +920,16 @@ i4tof(int32 num) /* - * i2tof - converts an int2 number to a float8 number + * i2tof - converts an int2 number to a float4 number */ -float32 -i2tof(int16 num) +Datum +i2tof(PG_FUNCTION_ARGS) { - float32 result; + int16 num = PG_GETARG_INT16(0); + float4 result; - result = (float32) palloc(sizeof(float32data)); - - *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 8d204a1595..674bbefea5 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.8 2000/04/12 17:15:49 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/formatting.c,v 1.9 2000/06/05 07:28:51 tgl Exp $ * * * Portions Copyright (c) 1999-2000, PostgreSQL, Inc @@ -4048,11 +4048,15 @@ int4_to_char(int32 value, text *fmt) { if (IS_MULTI(&Num)) { - orgnum = int4out(int4mul(value, (int32) pow((double) 10, (double) Num.multi))); + orgnum = DatumGetCString(DirectFunctionCall1(int4out, + Int32GetDatum(value * ((int32) pow((double) 10, (double) Num.multi))))); Num.pre += Num.multi; } else - orgnum = int4out(value); + { + orgnum = DatumGetCString(DirectFunctionCall1(int4out, + Int32GetDatum(value))); + } len = strlen(orgnum); if (*orgnum == '-') diff --git a/src/backend/utils/adt/geo_selfuncs.c b/src/backend/utils/adt/geo_selfuncs.c index 5b77e1c330..e5f239612e 100644 --- a/src/backend/utils/adt/geo_selfuncs.c +++ b/src/backend/utils/adt/geo_selfuncs.c @@ -9,7 +9,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_selfuncs.c,v 1.15 2000/05/13 06:04:46 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_selfuncs.c,v 1.16 2000/06/05 07:28:52 tgl Exp $ * * XXX These are totally bogus. Perhaps someone will make them do * something reasonable, someday. @@ -44,32 +44,16 @@ * Selectivity for operators that depend on area, such as "overlap". */ -float64 -areasel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +areasel(PG_FUNCTION_ARGS) { - float64 result; - - result = (float64) palloc(sizeof(float64data)); - *result = 0.02; - return result; + PG_RETURN_FLOAT8(0.02); } -float64 -areajoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +areajoinsel(PG_FUNCTION_ARGS) { - float64 result; - - result = (float64) palloc(sizeof(float64data)); - *result = 0.02; - return result; + PG_RETURN_FLOAT8(0.02); } /* @@ -79,32 +63,16 @@ areajoinsel(Oid opid, * a given box? */ -float64 -positionsel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +positionsel(PG_FUNCTION_ARGS) { - float64 result; - - result = (float64) palloc(sizeof(float64data)); - *result = 0.1; - return result; + PG_RETURN_FLOAT8(0.1); } -float64 -positionjoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +positionjoinsel(PG_FUNCTION_ARGS) { - float64 result; - - result = (float64) palloc(sizeof(float64data)); - *result = 0.1; - return result; + PG_RETURN_FLOAT8(0.1); } /* @@ -114,30 +82,14 @@ positionjoinsel(Oid opid, * estimate than areasel does. */ -float64 -contsel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +contsel(PG_FUNCTION_ARGS) { - float64 result; - - result = (float64) palloc(sizeof(float64data)); - *result = 0.01; - return result; + PG_RETURN_FLOAT8(0.01); } -float64 -contjoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +contjoinsel(PG_FUNCTION_ARGS) { - float64 result; - - result = (float64) palloc(sizeof(float64data)); - *result = 0.01; - return result; + PG_RETURN_FLOAT8(0.01); } diff --git a/src/backend/utils/adt/int.c b/src/backend/utils/adt/int.c index 242e9c5401..6e236a01c7 100644 --- a/src/backend/utils/adt/int.c +++ b/src/backend/utils/adt/int.c @@ -1,14 +1,14 @@ /*------------------------------------------------------------------------- * * int.c - * Functions for the built-in integer types. + * Functions for the built-in integer types (except int8). * * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.36 2000/04/12 17:15:50 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.37 2000/06/05 07:28:52 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -25,13 +25,12 @@ * * Arithmetic operators: * intmod, int4fac - * - * XXX makes massive and possibly unwarranted type promotion assumptions. - * fix me when we figure out what we want to do about ANSIfication... */ #include + #include "postgres.h" + #ifdef HAVE_LIMITS_H #include #endif @@ -52,42 +51,39 @@ /* * int2in - converts "num" to short */ -int32 -int2in(char *num) +Datum +int2in(PG_FUNCTION_ARGS) { - return (int32) pg_atoi(num, sizeof(int16), '\0'); + char *num = PG_GETARG_CSTRING(0); + + PG_RETURN_INT16(pg_atoi(num, sizeof(int16), '\0')); } /* * int2out - converts short to "num" */ -char * -int2out(int16 sh) +Datum +int2out(PG_FUNCTION_ARGS) { - char *result; + int16 arg1 = PG_GETARG_INT16(0); + char *result = (char *) palloc(7); /* sign, 5 digits, '\0' */ - result = (char *) palloc(7);/* assumes sign, 5 digits, '\0' */ - itoa((int) sh, result); - return result; + itoa((int) arg1, result); + PG_RETURN_CSTRING(result); } /* * int2vectorin - converts "num num ..." to internal form * - * Note: - * Fills any nonexistent digits with NULLs. + * Note: Fills any missing slots with zeroes. */ -int16 * -int2vectorin(char *intString) +Datum +int2vectorin(PG_FUNCTION_ARGS) { - int16 *result; + char *intString = PG_GETARG_CSTRING(0); + int16 *result = (int16 *) palloc(sizeof(int16[INDEX_MAX_KEYS])); int slot; - if (intString == NULL) - return NULL; - - result = (int16 *) palloc(sizeof(int16[INDEX_MAX_KEYS])); - for (slot = 0; *intString && slot < INDEX_MAX_KEYS; slot++) { if (sscanf(intString, "%hd", &result[slot]) != 1) @@ -104,28 +100,21 @@ int2vectorin(char *intString) while (slot < INDEX_MAX_KEYS) result[slot++] = 0; - return result; + PG_RETURN_POINTER(result); } /* * int2vectorout - converts internal form to "num num ..." */ -char * -int2vectorout(int16 *int2Array) +Datum +int2vectorout(PG_FUNCTION_ARGS) { + int16 *int2Array = (int16 *) PG_GETARG_POINTER(0); int num, maxnum; char *rp; char *result; - if (int2Array == NULL) - { - result = (char *) palloc(2); - result[0] = '-'; - result[1] = '\0'; - return result; - } - /* find last non-zero value in vector */ for (maxnum = INDEX_MAX_KEYS - 1; maxnum >= 0; maxnum--) if (int2Array[maxnum] != 0) @@ -142,71 +131,72 @@ int2vectorout(int16 *int2Array) ; } *rp = '\0'; - return result; + PG_RETURN_CSTRING(result); } /* * We don't have a complete set of int2vector support routines, * but we need int2vectoreq for catcache indexing. */ -bool -int2vectoreq(int16 *arg1, int16 *arg2) +Datum +int2vectoreq(PG_FUNCTION_ARGS) { - return (bool) (memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(int16)) == 0); + int16 *arg1 = (int16 *) PG_GETARG_POINTER(0); + int16 *arg2 = (int16 *) PG_GETARG_POINTER(1); + + PG_RETURN_BOOL(memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(int16)) == 0); } +/* + * Type int44 has no real-world use, but the regression tests use it. + * It's a four-element vector of int4's. + */ /* * int44in - converts "num num ..." to internal form * - * Note: - * Fills any nonexistent digits with NULLs. + * Note: Fills any missing positions with zeroes. */ -int32 * -int44in(char *input_string) +Datum +int44in(PG_FUNCTION_ARGS) { - int32 *foo = (int32 *) palloc(4 * sizeof(int32)); - int i = 0; + char *input_string = PG_GETARG_CSTRING(0); + int32 *result = (int32 *) palloc(4 * sizeof(int32)); + int i; i = sscanf(input_string, "%d, %d, %d, %d", - &foo[0], - &foo[1], - &foo[2], - &foo[3]); + &result[0], + &result[1], + &result[2], + &result[3]); while (i < 4) - foo[i++] = 0; + result[i++] = 0; - return foo; + PG_RETURN_POINTER(result); } /* * int44out - converts internal form to "num num ..." */ -char * -int44out(int32 *an_array) +Datum +int44out(PG_FUNCTION_ARGS) { - int temp = 4; - char *output_string = NULL; + int32 *an_array = (int32 *) PG_GETARG_POINTER(0); + char *result = (char *) palloc(16 * 4); /* Allow 14 digits + sign */ int i; + char *walk; - if (temp > 0) + walk = result; + for (i = 0; i < 4; i++) { - char *walk; - - output_string = (char *) palloc(16 * temp); /* assume 15 digits + - * sign */ - walk = output_string; - for (i = 0; i < temp; i++) - { - itoa(an_array[i], walk); - while (*++walk != '\0') - ; - *walk++ = ' '; - } - *--walk = '\0'; + itoa(an_array[i], walk); + while (*++walk != '\0') + ; + *walk++ = ' '; } - return output_string; + *--walk = '\0'; + PG_RETURN_CSTRING(result); } @@ -217,23 +207,25 @@ int44out(int32 *an_array) /* * int4in - converts "num" to int4 */ -int32 -int4in(char *num) +Datum +int4in(PG_FUNCTION_ARGS) { - return pg_atoi(num, sizeof(int32), '\0'); + char *num = PG_GETARG_CSTRING(0); + + PG_RETURN_INT32(pg_atoi(num, sizeof(int32), '\0')); } /* * int4out - converts int4 to "num" */ -char * -int4out(int32 l) +Datum +int4out(PG_FUNCTION_ARGS) { - char *result; + int32 arg1 = PG_GETARG_INT32(0); + char *result = (char *) palloc(12); /* sign, 10 digits, '\0' */ - result = (char *) palloc(12); /* assumes sign, 10 digits, '\0' */ - ltoa(l, result); - return result; + ltoa(arg1, result); + PG_RETURN_CSTRING(result); } @@ -243,116 +235,94 @@ int4out(int32 l) * =================== */ -int32 -i2toi4(int16 arg1) +Datum +i2toi4(PG_FUNCTION_ARGS) { - return (int32) arg1; + int16 arg1 = PG_GETARG_INT16(0); + + PG_RETURN_INT32((int32) arg1); } -int16 -i4toi2(int32 arg1) +Datum +i4toi2(PG_FUNCTION_ARGS) { + int32 arg1 = PG_GETARG_INT32(0); + if (arg1 < SHRT_MIN) elog(ERROR, "i4toi2: '%d' causes int2 underflow", arg1); if (arg1 > SHRT_MAX) elog(ERROR, "i4toi2: '%d' causes int2 overflow", arg1); - return (int16) arg1; + PG_RETURN_INT16((int16) arg1); } -text * -int2_text(int16 arg1) +Datum +int2_text(PG_FUNCTION_ARGS) { - text *result; + int16 arg1 = PG_GETARG_INT16(0); + text *result = (text *) palloc(7+VARHDRSZ); /* sign,5 digits, '\0' */ + itoa((int) arg1, VARDATA(result)); + VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ; + PG_RETURN_TEXT_P(result); +} + +Datum +text_int2(PG_FUNCTION_ARGS) +{ + text *string = PG_GETARG_TEXT_P(0); + Datum result; int len; char *str; - str = int2out(arg1); - len = (strlen(str) + VARHDRSZ); - - result = palloc(len); - - VARSIZE(result) = len; - memmove(VARDATA(result), str, (len - VARHDRSZ)); - - pfree(str); - - return result; -} /* int2_text() */ - -int16 -text_int2(text *string) -{ - int16 result; - - int len; - char *str; - - if (!string) - return 0; - - len = (VARSIZE(string) - VARHDRSZ); + len = VARSIZE(string) - VARHDRSZ; str = palloc(len + 1); - memmove(str, VARDATA(string), len); + memcpy(str, VARDATA(string), len); *(str + len) = '\0'; - result = int2in(str); + result = DirectFunctionCall1(int2in, CStringGetDatum(str)); pfree(str); return result; -} /* text_int2() */ +} -text * -int4_text(int32 arg1) +Datum +int4_text(PG_FUNCTION_ARGS) { - text *result; + int32 arg1 = PG_GETARG_INT32(0); + text *result = (text *) palloc(12+VARHDRSZ); /* sign,10 digits,'\0' */ + ltoa(arg1, VARDATA(result)); + VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ; + PG_RETURN_TEXT_P(result); +} + +Datum +text_int4(PG_FUNCTION_ARGS) +{ + text *string = PG_GETARG_TEXT_P(0); + Datum result; int len; char *str; - str = int4out(arg1); - len = (strlen(str) + VARHDRSZ); - - result = palloc(len); - - VARSIZE(result) = len; - memmove(VARDATA(result), str, (len - VARHDRSZ)); - - pfree(str); - - return result; -} /* int4_text() */ - -int32 -text_int4(text *string) -{ - int32 result; - - int len; - char *str; - - if (!string) - return 0; - - len = (VARSIZE(string) - VARHDRSZ); + len = VARSIZE(string) - VARHDRSZ; str = palloc(len + 1); - memmove(str, VARDATA(string), len); + memcpy(str, VARDATA(string), len); *(str + len) = '\0'; - result = int4in(str); + result = DirectFunctionCall1(int4in, CStringGetDatum(str)); pfree(str); return result; -} /* text_int4() */ +} /* - * ========================= - * BOOLEAN OPERATOR ROUTINES - * ========================= + * ============================ + * COMPARISON OPERATOR ROUTINES + * ============================ */ /* @@ -363,148 +333,221 @@ text_int4(text *string) * intgt - returns 1 iff arg1 > arg2 * intge - returns 1 iff arg1 >= arg2 */ -bool -int4eq(int32 arg1, int32 arg2) + +Datum +int4eq(PG_FUNCTION_ARGS) { - return arg1 == arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 == arg2); } -bool -int4ne(int32 arg1, int32 arg2) +Datum +int4ne(PG_FUNCTION_ARGS) { - return arg1 != arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 != arg2); } -bool -int4lt(int32 arg1, int32 arg2) +Datum +int4lt(PG_FUNCTION_ARGS) { - return arg1 < arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 < arg2); } -bool -int4le(int32 arg1, int32 arg2) +Datum +int4le(PG_FUNCTION_ARGS) { - return arg1 <= arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 <= arg2); } -bool -int4gt(int32 arg1, int32 arg2) +Datum +int4gt(PG_FUNCTION_ARGS) { - return arg1 > arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 > arg2); } -bool -int4ge(int32 arg1, int32 arg2) +Datum +int4ge(PG_FUNCTION_ARGS) { - return arg1 >= arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 >= arg2); } -bool -int2eq(int16 arg1, int16 arg2) +Datum +int2eq(PG_FUNCTION_ARGS) { - return arg1 == arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 == arg2); } -bool -int2ne(int16 arg1, int16 arg2) +Datum +int2ne(PG_FUNCTION_ARGS) { - return arg1 != arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 != arg2); } -bool -int2lt(int16 arg1, int16 arg2) +Datum +int2lt(PG_FUNCTION_ARGS) { - return arg1 < arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 < arg2); } -bool -int2le(int16 arg1, int16 arg2) +Datum +int2le(PG_FUNCTION_ARGS) { - return arg1 <= arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 <= arg2); } -bool -int2gt(int16 arg1, int16 arg2) +Datum +int2gt(PG_FUNCTION_ARGS) { - return arg1 > arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 > arg2); } -bool -int2ge(int16 arg1, int16 arg2) +Datum +int2ge(PG_FUNCTION_ARGS) { - return arg1 >= arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 >= arg2); } -bool -int24eq(int32 arg1, int32 arg2) +Datum +int24eq(PG_FUNCTION_ARGS) { - return arg1 == arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 == arg2); } -bool -int24ne(int32 arg1, int32 arg2) +Datum +int24ne(PG_FUNCTION_ARGS) { - return arg1 != arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 != arg2); } -bool -int24lt(int32 arg1, int32 arg2) +Datum +int24lt(PG_FUNCTION_ARGS) { - return arg1 < arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 < arg2); } -bool -int24le(int32 arg1, int32 arg2) +Datum +int24le(PG_FUNCTION_ARGS) { - return arg1 <= arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 <= arg2); } -bool -int24gt(int32 arg1, int32 arg2) +Datum +int24gt(PG_FUNCTION_ARGS) { - return arg1 > arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 > arg2); } -bool -int24ge(int32 arg1, int32 arg2) +Datum +int24ge(PG_FUNCTION_ARGS) { - return arg1 >= arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_BOOL(arg1 >= arg2); } -bool -int42eq(int32 arg1, int32 arg2) +Datum +int42eq(PG_FUNCTION_ARGS) { - return arg1 == arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 == arg2); } -bool -int42ne(int32 arg1, int32 arg2) +Datum +int42ne(PG_FUNCTION_ARGS) { - return arg1 != arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 != arg2); } -bool -int42lt(int32 arg1, int32 arg2) +Datum +int42lt(PG_FUNCTION_ARGS) { - return arg1 < arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 < arg2); } -bool -int42le(int32 arg1, int32 arg2) +Datum +int42le(PG_FUNCTION_ARGS) { - return arg1 <= arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 <= arg2); } -bool -int42gt(int32 arg1, int32 arg2) +Datum +int42gt(PG_FUNCTION_ARGS) { - return arg1 > arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 > arg2); } -bool -int42ge(int32 arg1, int32 arg2) +Datum +int42ge(PG_FUNCTION_ARGS) { - return arg1 >= arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_BOOL(arg1 >= arg2); } /* @@ -513,159 +556,226 @@ int42ge(int32 arg1, int32 arg2) * int[24]mul - returns arg1 * arg2 * int[24]div - returns arg1 / arg2 */ -int32 -int4um(int32 arg) + +Datum +int4um(PG_FUNCTION_ARGS) { - return -arg; + int32 arg = PG_GETARG_INT32(0); + + PG_RETURN_INT32(-arg); } -int32 -int4pl(int32 arg1, int32 arg2) +Datum +int4pl(PG_FUNCTION_ARGS) { - return arg1 + arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 + arg2); } -int32 -int4mi(int32 arg1, int32 arg2) +Datum +int4mi(PG_FUNCTION_ARGS) { - return arg1 - arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 - arg2); } -int32 -int4mul(int32 arg1, int32 arg2) +Datum +int4mul(PG_FUNCTION_ARGS) { - return arg1 * arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 * arg2); } -int32 -int4div(int32 arg1, int32 arg2) +Datum +int4div(PG_FUNCTION_ARGS) { - return arg1 / arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 / arg2); } -int32 -int4inc(int32 arg) +Datum +int4inc(PG_FUNCTION_ARGS) { - return arg + (int32) 1; + int32 arg = PG_GETARG_INT32(0); + + PG_RETURN_INT32(arg + 1); } -int16 -int2um(int16 arg) +Datum +int2um(PG_FUNCTION_ARGS) { - return -arg; + int16 arg = PG_GETARG_INT16(0); + + PG_RETURN_INT16(-arg); } -int16 -int2pl(int16 arg1, int16 arg2) +Datum +int2pl(PG_FUNCTION_ARGS) { - return arg1 + arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16(arg1 + arg2); } -int16 -int2mi(int16 arg1, int16 arg2) +Datum +int2mi(PG_FUNCTION_ARGS) { - return arg1 - arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16(arg1 - arg2); } -int16 -int2mul(int16 arg1, int16 arg2) +Datum +int2mul(PG_FUNCTION_ARGS) { - return arg1 * arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16(arg1 * arg2); } -int16 -int2div(int16 arg1, int16 arg2) +Datum +int2div(PG_FUNCTION_ARGS) { - return arg1 / arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16(arg1 / arg2); } -int16 -int2inc(int16 arg) +Datum +int2inc(PG_FUNCTION_ARGS) { - return arg + (int16) 1; + int16 arg = PG_GETARG_INT16(0); + + PG_RETURN_INT16(arg + 1); } -int32 -int24pl(int32 arg1, int32 arg2) +Datum +int24pl(PG_FUNCTION_ARGS) { - return arg1 + arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 + arg2); } -int32 -int24mi(int32 arg1, int32 arg2) +Datum +int24mi(PG_FUNCTION_ARGS) { - return arg1 - arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 - arg2); } -int32 -int24mul(int32 arg1, int32 arg2) +Datum +int24mul(PG_FUNCTION_ARGS) { - return arg1 * arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 * arg2); } -int32 -int24div(int32 arg1, int32 arg2) +Datum +int24div(PG_FUNCTION_ARGS) { - return arg1 / arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 / arg2); } -int32 -int42pl(int32 arg1, int32 arg2) +Datum +int42pl(PG_FUNCTION_ARGS) { - return arg1 + arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT32(arg1 + arg2); } -int32 -int42mi(int32 arg1, int32 arg2) +Datum +int42mi(PG_FUNCTION_ARGS) { - return arg1 - arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT32(arg1 - arg2); } -int32 -int42mul(int32 arg1, int32 arg2) +Datum +int42mul(PG_FUNCTION_ARGS) { - return arg1 * arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT32(arg1 * arg2); } -int32 -int42div(int32 arg1, int32 arg2) +Datum +int42div(PG_FUNCTION_ARGS) { - return arg1 / arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT32(arg1 / arg2); } -/* - * int[24]mod - returns arg1 mod arg2 - */ -int32 -int4mod(int32 arg1, int32 arg2) +Datum +int4mod(PG_FUNCTION_ARGS) { - return arg1 % arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 % arg2); } -int32 -int2mod(int16 arg1, int16 arg2) +Datum +int2mod(PG_FUNCTION_ARGS) { - return arg1 % arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16(arg1 % arg2); } -int32 -int24mod(int32 arg1, int32 arg2) +Datum +int24mod(PG_FUNCTION_ARGS) { - return arg1 % arg2; + int16 arg1 = PG_GETARG_INT16(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32(arg1 % arg2); } -int32 -int42mod(int32 arg1, int32 arg2) +Datum +int42mod(PG_FUNCTION_ARGS) { - return arg1 % arg2; + int32 arg1 = PG_GETARG_INT32(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT32(arg1 % arg2); } /* int[24]fac() * Factorial */ -int32 -int4fac(int32 arg1) +Datum +int4fac(PG_FUNCTION_ARGS) { + int32 arg1 = PG_GETARG_INT32(0); int32 result; if (arg1 < 1) @@ -673,12 +783,13 @@ int4fac(int32 arg1) else for (result = 1; arg1 > 0; --arg1) result *= arg1; - return result; + PG_RETURN_INT32(result); } -int32 -int2fac(int16 arg1) +Datum +int2fac(PG_FUNCTION_ARGS) { + int16 arg1 = PG_GETARG_INT16(0); int32 result; if (arg1 < 1) @@ -686,44 +797,60 @@ int2fac(int16 arg1) else for (result = 1; arg1 > 0; --arg1) result *= arg1; - return result; + PG_RETURN_INT32(result); } /* int[24]abs() * Absolute value */ -int32 -int4abs(int32 arg1) +Datum +int4abs(PG_FUNCTION_ARGS) { - return ((arg1 < 0) ? -arg1 : arg1); + int32 arg1 = PG_GETARG_INT32(0); + + PG_RETURN_INT32((arg1 < 0) ? -arg1 : arg1); } -int16 -int2abs(int16 arg1) +Datum +int2abs(PG_FUNCTION_ARGS) { - return ((arg1 < 0) ? -arg1 : arg1); + int16 arg1 = PG_GETARG_INT16(0); + + PG_RETURN_INT16((arg1 < 0) ? -arg1 : arg1); } -int16 -int2larger(int16 arg1, int16 arg2) +Datum +int2larger(PG_FUNCTION_ARGS) { - return (arg1 > arg2) ? arg1 : arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16((arg1 > arg2) ? arg1 : arg2); } -int16 -int2smaller(int16 arg1, int16 arg2) +Datum +int2smaller(PG_FUNCTION_ARGS) { - return (arg1 < arg2) ? arg1 : arg2; + int16 arg1 = PG_GETARG_INT16(0); + int16 arg2 = PG_GETARG_INT16(1); + + PG_RETURN_INT16((arg1 < arg2) ? arg1 : arg2); } -int32 -int4larger(int32 arg1, int32 arg2) +Datum +int4larger(PG_FUNCTION_ARGS) { - return (arg1 > arg2) ? arg1 : arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32((arg1 > arg2) ? arg1 : arg2); } -int32 -int4smaller(int32 arg1, int32 arg2) +Datum +int4smaller(PG_FUNCTION_ARGS) { - return (arg1 < arg2) ? arg1 : arg2; + int32 arg1 = PG_GETARG_INT32(0); + int32 arg2 = PG_GETARG_INT32(1); + + PG_RETURN_INT32((arg1 < arg2) ? arg1 : arg2); } diff --git a/src/backend/utils/adt/misc.c b/src/backend/utils/adt/misc.c index 00af6350de..7e3b8b167b 100644 --- a/src/backend/utils/adt/misc.c +++ b/src/backend/utils/adt/misc.c @@ -8,44 +8,39 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/misc.c,v 1.18 2000/01/26 05:57:14 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/misc.c,v 1.19 2000/06/05 07:28:52 tgl Exp $ * *------------------------------------------------------------------------- */ #include #include #include + #include "postgres.h" + #include "utils/builtins.h" -/*------------------------------------------------------------------------- + +/* * Check if data is Null */ -bool -nullvalue(Datum value, bool *isNull) +Datum +nullvalue(PG_FUNCTION_ARGS) { - if (*isNull) - { - *isNull = false; - return true; - } - return false; - + if (PG_ARGISNULL(0)) + PG_RETURN_BOOL(true); + PG_RETURN_BOOL(false); } -/*----------------------------------------------------------------------* - * check if data is not Null * - *--------------------------------------------------------------------- */ -bool -nonnullvalue(Datum value, bool *isNull) +/* + * Check if data is not Null + */ +Datum +nonnullvalue(PG_FUNCTION_ARGS) { - if (*isNull) - { - *isNull = false; - return false; - } - return true; - + if (PG_ARGISNULL(0)) + PG_RETURN_BOOL(false); + PG_RETURN_BOOL(true); } /* @@ -63,13 +58,18 @@ nonnullvalue(Datum value, bool *isNull) static bool random_initialized = false; -bool -oidrand(Oid o, int32 X) +Datum +oidrand(PG_FUNCTION_ARGS) { + /* XXX seems like we ought to be using the oid for something? */ +#ifdef NOT_USED + Oid o = PG_GETARG_OID(0); +#endif + int32 X = PG_GETARG_INT32(1); bool result; if (X == 0) - return true; + PG_RETURN_BOOL(true); /* * We do this because the cancel key is actually a random, so we don't @@ -83,26 +83,29 @@ oidrand(Oid o, int32 X) } result = (random() % X == 0); - return result; + PG_RETURN_BOOL(result); } /* oidsrand(int32 X) - seeds the random number generator - always return true + always returns true */ -bool -oidsrand(int32 X) +Datum +oidsrand(PG_FUNCTION_ARGS) { + int32 X = PG_GETARG_INT32(0); + srand(X); random_initialized = true; - return true; + PG_RETURN_BOOL(true); } - -int32 -userfntest(int i) +Datum +userfntest(PG_FUNCTION_ARGS) { - return i; + int32 i = PG_GETARG_INT32(0); + + PG_RETURN_INT32(i); } diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c index 36e333e121..500cb151ac 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.27 2000/04/12 17:15:50 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.28 2000/06/05 07:28:52 tgl Exp $ * * ---------- */ @@ -33,6 +33,9 @@ * 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 @@ -1714,7 +1717,8 @@ int4_numeric(int32 val) init_var(&result); - tmp = int4out(val); + tmp = DatumGetCString(DirectFunctionCall1(int4out, + Int32GetDatum(val))); set_var_from_str(tmp, &result); res = make_result(&result); @@ -1730,7 +1734,7 @@ numeric_int4(Numeric num) { NumericVar x; char *str; - int32 result; + Datum result; if (num == NULL) return 0; @@ -1749,7 +1753,7 @@ numeric_int4(Numeric num) free_var(&x); - result = int4in(str); + result = DirectFunctionCall1(int4in, CStringGetDatum(str)); pfree(str); return result; @@ -1807,35 +1811,35 @@ numeric_int8(Numeric num) } -Numeric -int2_numeric(int16 val) +Datum +int2_numeric(PG_FUNCTION_ARGS) { + int16 val = PG_GETARG_INT16(0); Numeric res; NumericVar result; char *tmp; init_var(&result); - tmp = int2out(val); + tmp = DatumGetCString(DirectFunctionCall1(int2out, + Int16GetDatum(val))); set_var_from_str(tmp, &result); res = make_result(&result); free_var(&result); pfree(tmp); - return res; + PG_RETURN_NUMERIC(res); } -int16 -numeric_int2(Numeric num) +Datum +numeric_int2(PG_FUNCTION_ARGS) { + Numeric num = PG_GETARG_NUMERIC(0); NumericVar x; char *str; - int16 result; - - if (num == NULL) - return 0; + Datum result; if (NUMERIC_IS_NAN(num)) elog(ERROR, "Cannot convert NaN to int2"); @@ -1851,7 +1855,7 @@ numeric_int2(Numeric num) free_var(&x); - result = int2in(str); + result = DirectFunctionCall1(int2in, CStringGetDatum(str)); pfree(str); return result; diff --git a/src/backend/utils/adt/oid.c b/src/backend/utils/adt/oid.c index 96640af91e..2f1651378c 100644 --- a/src/backend/utils/adt/oid.c +++ b/src/backend/utils/adt/oid.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.34 2000/04/12 17:15:51 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.35 2000/06/05 07:28:52 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -26,17 +26,15 @@ * oidvectorin - converts "num num ..." to internal form * * Note: - * Fills any nonexistent digits with NULL oids. + * Fills any unsupplied positions with InvalidOid. */ -Oid * -oidvectorin(char *oidString) +Datum +oidvectorin(PG_FUNCTION_ARGS) { + char *oidString = PG_GETARG_CSTRING(0); Oid *result; int slot; - if (oidString == NULL) - return NULL; - result = (Oid *) palloc(sizeof(Oid[INDEX_MAX_KEYS])); for (slot = 0; *oidString && slot < INDEX_MAX_KEYS; slot++) @@ -53,30 +51,23 @@ oidvectorin(char *oidString) if (*oidString) elog(ERROR, "oidvector value has too many values"); while (slot < INDEX_MAX_KEYS) - result[slot++] = 0; + result[slot++] = InvalidOid; - return result; + PG_RETURN_POINTER(result); } /* * oidvectorout - converts internal form to "num num ..." */ -char * -oidvectorout(Oid *oidArray) +Datum +oidvectorout(PG_FUNCTION_ARGS) { + Oid *oidArray = (Oid *) PG_GETARG_POINTER(0); int num, maxnum; char *rp; char *result; - if (oidArray == NULL) - { - result = (char *) palloc(2); - result[0] = '-'; - result[1] = '\0'; - return result; - } - /* find last non-zero value in vector */ for (maxnum = INDEX_MAX_KEYS - 1; maxnum >= 0; maxnum--) if (oidArray[maxnum] != 0) @@ -93,147 +84,177 @@ oidvectorout(Oid *oidArray) ; } *rp = '\0'; - return result; + PG_RETURN_CSTRING(result); } -Oid -oidin(char *s) +Datum +oidin(PG_FUNCTION_ARGS) { - return int4in(s); + char *s = PG_GETARG_CSTRING(0); + + /* XXX should use an unsigned-int conversion here */ + return DirectFunctionCall1(int4in, CStringGetDatum(s)); } -char * -oidout(Oid o) +Datum +oidout(PG_FUNCTION_ARGS) { - return int4out(o); + Oid o = PG_GETARG_OID(0); + + /* XXX should use an unsigned-int conversion here */ + return DirectFunctionCall1(int4out, ObjectIdGetDatum(o)); } /***************************************************************************** * PUBLIC ROUTINES * *****************************************************************************/ -/* - * If you change this function, change heap_keytest() - * because we have hardcoded this in there as an optimization - */ -bool -oideq(Oid arg1, Oid arg2) +Datum +oideq(PG_FUNCTION_ARGS) { - return arg1 == arg2; + Oid arg1 = PG_GETARG_OID(0); + Oid arg2 = PG_GETARG_OID(1); + + PG_RETURN_BOOL(arg1 == arg2); } -bool -oidne(Oid arg1, Oid arg2) +Datum +oidne(PG_FUNCTION_ARGS) { - return arg1 != arg2; + Oid arg1 = PG_GETARG_OID(0); + Oid arg2 = PG_GETARG_OID(1); + + PG_RETURN_BOOL(arg1 != arg2); } -bool -oidvectoreq(Oid *arg1, Oid *arg2) +Datum +oidvectoreq(PG_FUNCTION_ARGS) { - return (bool) (memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(Oid)) == 0); + Oid *arg1 = (Oid *) PG_GETARG_POINTER(0); + Oid *arg2 = (Oid *) PG_GETARG_POINTER(1); + + PG_RETURN_BOOL(memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(Oid)) == 0); } -bool -oidvectorne(Oid *arg1, Oid *arg2) +Datum +oidvectorne(PG_FUNCTION_ARGS) { - return (bool) (memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(Oid)) != 0); + Oid *arg1 = (Oid *) PG_GETARG_POINTER(0); + Oid *arg2 = (Oid *) PG_GETARG_POINTER(1); + + PG_RETURN_BOOL(memcmp(arg1, arg2, INDEX_MAX_KEYS * sizeof(Oid)) != 0); } -bool -oidvectorlt(Oid *arg1, Oid *arg2) +Datum +oidvectorlt(PG_FUNCTION_ARGS) { + Oid *arg1 = (Oid *) PG_GETARG_POINTER(0); + Oid *arg2 = (Oid *) PG_GETARG_POINTER(1); int i; for (i = 0; i < INDEX_MAX_KEYS; i++) - if (!int4eq(arg1[i], arg2[i])) - return int4lt(arg1[i], arg2[i]); - return false; + if (arg1[i] != arg2[i]) + PG_RETURN_BOOL(arg1[i] < arg2[i]); + PG_RETURN_BOOL(false); } -bool -oidvectorle(Oid *arg1, Oid *arg2) +Datum +oidvectorle(PG_FUNCTION_ARGS) { + Oid *arg1 = (Oid *) PG_GETARG_POINTER(0); + Oid *arg2 = (Oid *) PG_GETARG_POINTER(1); int i; for (i = 0; i < INDEX_MAX_KEYS; i++) - if (!int4eq(arg1[i], arg2[i])) - return int4le(arg1[i], arg2[i]); - return true; + if (arg1[i] != arg2[i]) + PG_RETURN_BOOL(arg1[i] <= arg2[i]); + PG_RETURN_BOOL(true); } -bool -oidvectorge(Oid *arg1, Oid *arg2) +Datum +oidvectorge(PG_FUNCTION_ARGS) { + Oid *arg1 = (Oid *) PG_GETARG_POINTER(0); + Oid *arg2 = (Oid *) PG_GETARG_POINTER(1); int i; for (i = 0; i < INDEX_MAX_KEYS; i++) - if (!int4eq(arg1[i], arg2[i])) - return int4ge(arg1[i], arg2[i]); - return true; + if (arg1[i] != arg2[i]) + PG_RETURN_BOOL(arg1[i] >= arg2[i]); + PG_RETURN_BOOL(true); } -bool -oidvectorgt(Oid *arg1, Oid *arg2) +Datum +oidvectorgt(PG_FUNCTION_ARGS) { + Oid *arg1 = (Oid *) PG_GETARG_POINTER(0); + Oid *arg2 = (Oid *) PG_GETARG_POINTER(1); int i; for (i = 0; i < INDEX_MAX_KEYS; i++) - if (!int4eq(arg1[i], arg2[i])) - return int4gt(arg1[i], arg2[i]); - return false; + if (arg1[i] != arg2[i]) + PG_RETURN_BOOL(arg1[i] > arg2[i]); + PG_RETURN_BOOL(false); } -bool -oideqint4(Oid arg1, int32 arg2) +Datum +oideqint4(PG_FUNCTION_ARGS) { -/* oid is unsigned, but int4 is signed */ - return arg2 >= 0 && arg1 == arg2; + Oid arg1 = PG_GETARG_OID(0); + int32 arg2 = PG_GETARG_INT32(1); + + /* oid is unsigned, but int4 is signed */ + PG_RETURN_BOOL(arg2 >= 0 && arg1 == arg2); } -bool -int4eqoid(int32 arg1, Oid arg2) +Datum +int4eqoid(PG_FUNCTION_ARGS) { -/* oid is unsigned, but int4 is signed */ - return arg1 >= 0 && arg1 == arg2; + int32 arg1 = PG_GETARG_INT32(0); + Oid arg2 = PG_GETARG_OID(1); + + /* oid is unsigned, but int4 is signed */ + PG_RETURN_BOOL(arg1 >= 0 && arg1 == arg2); } -text * -oid_text(Oid oid) +Datum +oid_text(PG_FUNCTION_ARGS) { + Oid oid = PG_GETARG_OID(0); text *result; - int len; char *str; - str = oidout(oid); - len = (strlen(str) + VARHDRSZ); + str = DatumGetCString(DirectFunctionCall1(oidout, + ObjectIdGetDatum(oid))); + len = strlen(str) + VARHDRSZ; - result = palloc(len); + result = (text *) palloc(len); VARSIZE(result) = len; - memmove(VARDATA(result), str, (len - VARHDRSZ)); + memcpy(VARDATA(result), str, (len - VARHDRSZ)); pfree(str); - return result; -} /* oid_text() */ + PG_RETURN_TEXT_P(result); +} -Oid -text_oid(text *string) +Datum +text_oid(PG_FUNCTION_ARGS) { + text *string = PG_GETARG_TEXT_P(0); Oid result; - int len; char *str; len = (VARSIZE(string) - VARHDRSZ); str = palloc(len + 1); - memmove(str, VARDATA(string), len); + memcpy(str, VARDATA(string), len); *(str + len) = '\0'; - result = oidin(str); + result = DatumGetObjectId(DirectFunctionCall1(oidin, + CStringGetDatum(str))); pfree(str); - return result; -} /* oid_text() */ + PG_RETURN_OID(result); +} diff --git a/src/backend/utils/adt/regproc.c b/src/backend/utils/adt/regproc.c index 6db76ac8c5..c5fbeadff6 100644 --- a/src/backend/utils/adt/regproc.c +++ b/src/backend/utils/adt/regproc.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.55 2000/05/28 17:56:05 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.56 2000/06/05 07:28:52 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -34,17 +34,16 @@ * * proid of '-' signifies unknown, for consistency with regprocout */ -int32 -regprocin(char *pro_name_or_oid) +Datum +regprocin(PG_FUNCTION_ARGS) { - HeapTuple proctup = NULL; + char *pro_name_or_oid = PG_GETARG_CSTRING(0); + HeapTuple proctup; HeapTupleData tuple; RegProcedure result = InvalidOid; - if (pro_name_or_oid == NULL) - return InvalidOid; if (pro_name_or_oid[0] == '-' && pro_name_or_oid[1] == '\0') - return InvalidOid; + PG_RETURN_OID(InvalidOid); if (!IsIgnoringSystemIndexes()) { @@ -57,7 +56,8 @@ regprocin(char *pro_name_or_oid) pro_name_or_oid[0] <= '9') { proctup = SearchSysCacheTuple(PROCOID, - ObjectIdGetDatum(oidin(pro_name_or_oid)), + DirectFunctionCall1(oidin, + CStringGetDatum(pro_name_or_oid)), 0, 0, 0); if (HeapTupleIsValid(proctup)) result = (RegProcedure) proctup->t_data->t_oid; @@ -78,7 +78,7 @@ regprocin(char *pro_name_or_oid) (bits16) 0x0, (AttrNumber) 1, (RegProcedure) F_NAMEEQ, - PointerGetDatum(pro_name_or_oid)); + CStringGetDatum(pro_name_or_oid)); hdesc = heap_openr(ProcedureRelationName, AccessShareLock); idesc = index_openr(ProcedureNameIndex); @@ -125,7 +125,7 @@ regprocin(char *pro_name_or_oid) (bits16) 0, (AttrNumber) 1, (RegProcedure) F_NAMEEQ, - (Datum) pro_name_or_oid); + CStringGetDatum(pro_name_or_oid)); procscan = heap_beginscan(proc, 0, SnapshotNow, 1, &key); if (!HeapScanIsValid(procscan)) @@ -133,7 +133,7 @@ regprocin(char *pro_name_or_oid) heap_close(proc, AccessShareLock); elog(ERROR, "regprocin: could not begin scan of %s", ProcedureRelationName); - return 0; + PG_RETURN_OID(InvalidOid); } proctup = heap_getnext(procscan, 0); if (HeapTupleIsValid(proctup)) @@ -143,24 +143,25 @@ regprocin(char *pro_name_or_oid) RelationGetDescr(proc), &isnull); if (isnull) - elog(FATAL, "regprocin: null procedure %s", pro_name_or_oid); + elog(ERROR, "regprocin: null procedure %s", pro_name_or_oid); } else - result = (RegProcedure) 0; + elog(ERROR, "No procedure with name %s", pro_name_or_oid); heap_endscan(procscan); heap_close(proc, AccessShareLock); } - return (int32) result; + PG_RETURN_OID(result); } /* * regprocout - converts proid to "pro_name" */ -char * -regprocout(RegProcedure proid) +Datum +regprocout(PG_FUNCTION_ARGS) { + RegProcedure proid = PG_GETARG_OID(0); HeapTuple proctup; char *result; @@ -170,7 +171,7 @@ regprocout(RegProcedure proid) { result[0] = '-'; result[1] = '\0'; - return result; + PG_RETURN_CSTRING(result); } if (!IsBootstrapProcessingMode()) @@ -203,7 +204,7 @@ regprocout(RegProcedure proid) (bits16) 0, (AttrNumber) ObjectIdAttributeNumber, (RegProcedure) F_INT4EQ, - (Datum) proid); + ObjectIdGetDatum(proid)); procscan = heap_beginscan(proc, 0, SnapshotNow, 1, &key); if (!HeapScanIsValid(procscan)) @@ -211,7 +212,6 @@ regprocout(RegProcedure proid) heap_close(proc, AccessShareLock); elog(ERROR, "regprocout: could not begin scan of %s", ProcedureRelationName); - return 0; } proctup = heap_getnext(procscan, 0); if (HeapTupleIsValid(proctup)) @@ -224,7 +224,7 @@ regprocout(RegProcedure proid) if (!isnull) StrNCpy(result, s, NAMEDATALEN); else - elog(FATAL, "regprocout: null procedure %u", proid); + elog(ERROR, "regprocout: null procedure %u", proid); } else { @@ -235,7 +235,7 @@ regprocout(RegProcedure proid) heap_close(proc, AccessShareLock); } - return result; + PG_RETURN_CSTRING(result); } /* @@ -245,21 +245,15 @@ regprocout(RegProcedure proid) * OIDs are significant in the input vector, so that trailing InvalidOid * argument types can be recognized. */ -text * -oidvectortypes(Oid *oidArray) +Datum +oidvectortypes(PG_FUNCTION_ARGS) { + Oid *oidArray = (Oid *) PG_GETARG_POINTER(0); HeapTuple typetup; text *result; int numargs, num; - if (oidArray == NULL) - { - result = (text *) palloc(VARHDRSZ); - VARSIZE(result) = 0; - return result; - } - /* Try to guess how many args there are :-( */ numargs = 0; for (num = 0; num < FUNC_MAX_ARGS; num++) @@ -289,7 +283,7 @@ oidvectortypes(Oid *oidArray) strcat(VARDATA(result), "- "); } VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ; - return result; + PG_RETURN_TEXT_P(result); } @@ -302,10 +296,12 @@ oidvectortypes(Oid *oidArray) * Define RegprocToOid() as a macro in builtins.h. * Referenced in pg_proc.h. - tgl 97/04/26 */ -Oid -regproctooid(RegProcedure rp) +Datum +regproctooid(PG_FUNCTION_ARGS) { - return (Oid) rp; + RegProcedure rp = PG_GETARG_OID(0); + + PG_RETURN_OID((Oid) rp); } /* (see int.c for comparison/operation routines) */ diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c index 611f57f9ac..fb1a77cfbd 100644 --- a/src/backend/utils/adt/selfuncs.c +++ b/src/backend/utils/adt/selfuncs.c @@ -15,7 +15,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.68 2000/05/30 04:24:51 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.69 2000/06/05 07:28:52 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -44,9 +44,6 @@ /* N is not a valid var/constant or relation id */ #define NONVALUE(N) ((N) == 0) -/* are we looking at a functional index selectivity request? */ -#define FunctionalSelectivity(nIndKeys,attNum) ((attNum)==InvalidAttrNumber) - /* default selectivity estimate for equalities such as "A = b" */ #define DEFAULT_EQ_SEL 0.01 @@ -106,18 +103,18 @@ static Datum string_to_datum(const char *str, Oid datatype); * of the given constant "value" may be different from the type of the * attribute. */ -float64 -eqsel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +eqsel(PG_FUNCTION_ARGS) { - float64 result; + Oid opid = PG_GETARG_OID(0); + Oid relid = PG_GETARG_OID(1); + AttrNumber attno = PG_GETARG_INT16(2); + Datum value = PG_GETARG_DATUM(3); + int32 flag = PG_GETARG_INT32(4); + float8 result; - result = (float64) palloc(sizeof(float64data)); if (NONVALUE(attno) || NONVALUE(relid)) - *result = DEFAULT_EQ_SEL; + result = DEFAULT_EQ_SEL; else { Oid typid; @@ -239,9 +236,9 @@ eqsel(Oid opid, selec = get_attdisbursion(relid, attno, 0.01); } - *result = (float64data) selec; + result = (float8) selec; } - return result; + PG_RETURN_FLOAT8(result); } /* @@ -251,18 +248,14 @@ eqsel(Oid opid, * but have comparable selectivity behavior. See above comments * for eqsel(). */ -float64 -neqsel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +neqsel(PG_FUNCTION_ARGS) { - float64 result; + float8 result; - result = eqsel(opid, relid, attno, value, flag); - *result = 1.0 - *result; - return result; + result = DatumGetFloat8(eqsel(fcinfo)); + result = 1.0 - result; + PG_RETURN_FLOAT8(result); } /* @@ -272,18 +265,18 @@ neqsel(Oid opid, * convert_to_scalar(). If it is applied to some other datatype, * it will return a default estimate. */ -float64 -scalarltsel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +scalarltsel(PG_FUNCTION_ARGS) { - float64 result; + Oid opid = PG_GETARG_OID(0); + Oid relid = PG_GETARG_OID(1); + AttrNumber attno = PG_GETARG_INT16(2); + Datum value = PG_GETARG_DATUM(3); + int32 flag = PG_GETARG_INT32(4); + float8 result; - result = (float64) palloc(sizeof(float64data)); if (!(flag & SEL_CONSTANT) || NONVALUE(attno) || NONVALUE(relid)) - *result = DEFAULT_INEQ_SEL; + result = DEFAULT_INEQ_SEL; else { HeapTuple oprtuple; @@ -322,8 +315,7 @@ scalarltsel(Oid opid, &loval, &hival)) { /* no stats available, so default result */ - *result = DEFAULT_INEQ_SEL; - return result; + PG_RETURN_FLOAT8(DEFAULT_INEQ_SEL); } /* Convert the values to a uniform comparison scale. */ @@ -344,8 +336,7 @@ scalarltsel(Oid opid, pfree(DatumGetPointer(hival)); pfree(DatumGetPointer(loval)); } - *result = DEFAULT_INEQ_SEL; - return result; + PG_RETURN_FLOAT8(DEFAULT_INEQ_SEL); } /* release temp storage if needed */ @@ -364,7 +355,7 @@ scalarltsel(Oid opid, * point the constant is on. But it seems better to assume * that the stats are wrong and return a default... */ - *result = DEFAULT_INEQ_SEL; + result = DEFAULT_INEQ_SEL; } else if (val < low || val > high) { @@ -375,9 +366,9 @@ scalarltsel(Oid opid, * chance the stats are out of date. */ if (flag & SEL_RIGHT) - *result = (val < low) ? 0.001 : 0.999; + result = (val < low) ? 0.001 : 0.999; else - *result = (val < low) ? 0.999 : 0.001; + result = (val < low) ? 0.999 : 0.001; } else { @@ -386,10 +377,10 @@ scalarltsel(Oid opid, numerator = val - low; else numerator = high - val; - *result = numerator / denominator; + result = numerator / denominator; } } - return result; + PG_RETURN_FLOAT8(result); } /* @@ -397,42 +388,37 @@ scalarltsel(Oid opid, * * See above comments for scalarltsel. */ -float64 -scalargtsel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +scalargtsel(PG_FUNCTION_ARGS) { - float64 result; + float8 result; /* * Compute selectivity of "<", then invert --- but only if we were * able to produce a non-default estimate. */ - result = scalarltsel(opid, relid, attno, value, flag); - if (*result != DEFAULT_INEQ_SEL) - *result = 1.0 - *result; - return result; + result = DatumGetFloat8(scalarltsel(fcinfo)); + if (result != DEFAULT_INEQ_SEL) + result = 1.0 - result; + PG_RETURN_FLOAT8(result); } /* * patternsel - Generic code for pattern-match selectivity. */ -static float64 -patternsel(Oid opid, - Pattern_Type ptype, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +static Datum +patternsel(PG_FUNCTION_ARGS, Pattern_Type ptype) { - float64 result; + Oid opid = PG_GETARG_OID(0); + Oid relid = PG_GETARG_OID(1); + AttrNumber attno = PG_GETARG_INT16(2); + Datum value = PG_GETARG_DATUM(3); + int32 flag = PG_GETARG_INT32(4); + float8 result; - result = (float64) palloc(sizeof(float64data)); /* Must have a constant for the pattern, or cannot learn anything */ if ((flag & (SEL_CONSTANT | SEL_RIGHT)) != (SEL_CONSTANT | SEL_RIGHT)) - *result = DEFAULT_MATCH_SEL; + result = DEFAULT_MATCH_SEL; else { HeapTuple oprtuple; @@ -469,7 +455,12 @@ patternsel(Oid opid, if (eqopr == InvalidOid) elog(ERROR, "patternsel: no = operator for type %u", ltype); eqcon = string_to_datum(prefix, ltype); - result = eqsel(eqopr, relid, attno, eqcon, SEL_CONSTANT|SEL_RIGHT); + result = DatumGetFloat8(DirectFunctionCall5(eqsel, + ObjectIdGetDatum(eqopr), + ObjectIdGetDatum(relid), + Int16GetDatum(attno), + eqcon, + Int32GetDatum(SEL_CONSTANT|SEL_RIGHT))); pfree(DatumGetPointer(eqcon)); } else @@ -494,125 +485,103 @@ patternsel(Oid opid, selec = 0.0; else if (selec > 1.0) selec = 1.0; - *result = (float64data) selec; + result = (float8) selec; } if (prefix) pfree(prefix); pfree(patt); } - return result; + PG_RETURN_FLOAT8(result); } /* * regexeqsel - Selectivity of regular-expression pattern match. */ -float64 -regexeqsel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +regexeqsel(PG_FUNCTION_ARGS) { - return patternsel(opid, Pattern_Type_Regex, relid, attno, value, flag); + return patternsel(fcinfo, Pattern_Type_Regex); } /* * icregexeqsel - Selectivity of case-insensitive regex match. */ -float64 -icregexeqsel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +icregexeqsel(PG_FUNCTION_ARGS) { - return patternsel(opid, Pattern_Type_Regex_IC, relid, attno, value, flag); + return patternsel(fcinfo, Pattern_Type_Regex_IC); } /* * likesel - Selectivity of LIKE pattern match. */ -float64 -likesel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +likesel(PG_FUNCTION_ARGS) { - return patternsel(opid, Pattern_Type_Like, relid, attno, value, flag); + return patternsel(fcinfo, Pattern_Type_Like); } /* * regexnesel - Selectivity of regular-expression pattern non-match. */ -float64 -regexnesel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +regexnesel(PG_FUNCTION_ARGS) { - float64 result; + float8 result; - result = patternsel(opid, Pattern_Type_Regex, relid, attno, value, flag); - *result = 1.0 - *result; - return result; + result = DatumGetFloat8(patternsel(fcinfo, Pattern_Type_Regex)); + result = 1.0 - result; + PG_RETURN_FLOAT8(result); } /* * icregexnesel - Selectivity of case-insensitive regex non-match. */ -float64 -icregexnesel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +icregexnesel(PG_FUNCTION_ARGS) { - float64 result; + float8 result; - result = patternsel(opid, Pattern_Type_Regex_IC, relid, attno, value, flag); - *result = 1.0 - *result; - return result; + result = DatumGetFloat8(patternsel(fcinfo, Pattern_Type_Regex_IC)); + result = 1.0 - result; + PG_RETURN_FLOAT8(result); } /* * nlikesel - Selectivity of LIKE pattern non-match. */ -float64 -nlikesel(Oid opid, - Oid relid, - AttrNumber attno, - Datum value, - int32 flag) +Datum +nlikesel(PG_FUNCTION_ARGS) { - float64 result; + float8 result; - result = patternsel(opid, Pattern_Type_Like, relid, attno, value, flag); - *result = 1.0 - *result; - return result; + result = DatumGetFloat8(patternsel(fcinfo, Pattern_Type_Like)); + result = 1.0 - result; + PG_RETURN_FLOAT8(result); } /* * eqjoinsel - Join selectivity of "=" */ -float64 -eqjoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +eqjoinsel(PG_FUNCTION_ARGS) { - float64 result; - float64data num1, +#ifdef NOT_USED + Oid opid = PG_GETARG_OID(0); +#endif + Oid relid1 = PG_GETARG_OID(1); + AttrNumber attno1 = PG_GETARG_INT16(2); + Oid relid2 = PG_GETARG_OID(3); + AttrNumber attno2 = PG_GETARG_INT16(4); + float8 result; + float8 num1, num2, min; bool unknown1 = NONVALUE(relid1) || NONVALUE(attno1); bool unknown2 = NONVALUE(relid2) || NONVALUE(attno2); - result = (float64) palloc(sizeof(float64data)); if (unknown1 && unknown2) - *result = DEFAULT_EQ_SEL; + result = DEFAULT_EQ_SEL; else { num1 = unknown1 ? 1.0 : get_attdisbursion(relid1, attno1, 0.01); @@ -637,162 +606,106 @@ eqjoinsel(Oid opid, * about applying the operator to the most common values? */ min = (num1 < num2) ? num1 : num2; - *result = min; + result = min; } - return result; + PG_RETURN_FLOAT8(result); } /* * neqjoinsel - Join selectivity of "!=" */ -float64 -neqjoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +neqjoinsel(PG_FUNCTION_ARGS) { - float64 result; + float8 result; - result = eqjoinsel(opid, relid1, attno1, relid2, attno2); - *result = 1.0 - *result; - return result; + result = DatumGetFloat8(eqjoinsel(fcinfo)); + result = 1.0 - result; + PG_RETURN_FLOAT8(result); } /* * scalarltjoinsel - Join selectivity of "<" and "<=" for scalars */ -float64 -scalarltjoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +scalarltjoinsel(PG_FUNCTION_ARGS) { - float64 result; - - result = (float64) palloc(sizeof(float64data)); - *result = DEFAULT_INEQ_SEL; - return result; + PG_RETURN_FLOAT8(DEFAULT_INEQ_SEL); } /* * scalargtjoinsel - Join selectivity of ">" and ">=" for scalars */ -float64 -scalargtjoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +scalargtjoinsel(PG_FUNCTION_ARGS) { - float64 result; - - result = (float64) palloc(sizeof(float64data)); - *result = DEFAULT_INEQ_SEL; - return result; + PG_RETURN_FLOAT8(DEFAULT_INEQ_SEL); } /* * regexeqjoinsel - Join selectivity of regular-expression pattern match. */ -float64 -regexeqjoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +regexeqjoinsel(PG_FUNCTION_ARGS) { - float64 result; - - result = (float64) palloc(sizeof(float64data)); - *result = DEFAULT_MATCH_SEL; - return result; + PG_RETURN_FLOAT8(DEFAULT_MATCH_SEL); } /* * icregexeqjoinsel - Join selectivity of case-insensitive regex match. */ -float64 -icregexeqjoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +icregexeqjoinsel(PG_FUNCTION_ARGS) { - float64 result; - - result = (float64) palloc(sizeof(float64data)); - *result = DEFAULT_MATCH_SEL; - return result; + PG_RETURN_FLOAT8(DEFAULT_MATCH_SEL); } /* * likejoinsel - Join selectivity of LIKE pattern match. */ -float64 -likejoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +likejoinsel(PG_FUNCTION_ARGS) { - float64 result; - - result = (float64) palloc(sizeof(float64data)); - *result = DEFAULT_MATCH_SEL; - return result; + PG_RETURN_FLOAT8(DEFAULT_MATCH_SEL); } /* * regexnejoinsel - Join selectivity of regex non-match. */ -float64 -regexnejoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +regexnejoinsel(PG_FUNCTION_ARGS) { - float64 result; + float8 result; - result = regexeqjoinsel(opid, relid1, attno1, relid2, attno2); - *result = 1.0 - *result; - return result; + result = DatumGetFloat8(regexeqjoinsel(fcinfo)); + result = 1.0 - result; + PG_RETURN_FLOAT8(result); } /* * icregexnejoinsel - Join selectivity of case-insensitive regex non-match. */ -float64 -icregexnejoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +icregexnejoinsel(PG_FUNCTION_ARGS) { - float64 result; + float8 result; - result = icregexeqjoinsel(opid, relid1, attno1, relid2, attno2); - *result = 1.0 - *result; - return result; + result = DatumGetFloat8(icregexeqjoinsel(fcinfo)); + result = 1.0 - result; + PG_RETURN_FLOAT8(result); } /* * nlikejoinsel - Join selectivity of LIKE pattern non-match. */ -float64 -nlikejoinsel(Oid opid, - Oid relid1, - AttrNumber attno1, - Oid relid2, - AttrNumber attno2) +Datum +nlikejoinsel(PG_FUNCTION_ARGS) { - float64 result; + float8 result; - result = likejoinsel(opid, relid1, attno1, relid2, attno2); - *result = 1.0 - *result; - return result; + result = DatumGetFloat8(likejoinsel(fcinfo)); + result = 1.0 - result; + PG_RETURN_FLOAT8(result); } @@ -1563,8 +1476,12 @@ prefix_selectivity(char *prefix, datatype); prefixcon = string_to_datum(prefix, datatype); /* Assume scalargtsel is appropriate for all supported types */ - prefixsel = * scalargtsel(cmpopr, relid, attno, - prefixcon, SEL_CONSTANT|SEL_RIGHT); + prefixsel = DatumGetFloat8(DirectFunctionCall5(scalargtsel, + ObjectIdGetDatum(cmpopr), + ObjectIdGetDatum(relid), + Int16GetDatum(attno), + prefixcon, + Int32GetDatum(SEL_CONSTANT|SEL_RIGHT))); pfree(DatumGetPointer(prefixcon)); /* @@ -1582,8 +1499,12 @@ prefix_selectivity(char *prefix, datatype); prefixcon = string_to_datum(greaterstr, datatype); /* Assume scalarltsel is appropriate for all supported types */ - topsel = * scalarltsel(cmpopr, relid, attno, - prefixcon, SEL_CONSTANT|SEL_RIGHT); + topsel = DatumGetFloat8(DirectFunctionCall5(scalarltsel, + ObjectIdGetDatum(cmpopr), + ObjectIdGetDatum(relid), + Int16GetDatum(attno), + prefixcon, + Int32GetDatum(SEL_CONSTANT|SEL_RIGHT))); pfree(DatumGetPointer(prefixcon)); pfree(greaterstr); @@ -1966,13 +1887,16 @@ string_to_datum(const char *str, Oid datatype) *------------------------------------------------------------------------- */ -static void -genericcostestimate(Query *root, RelOptInfo *rel, - IndexOptInfo *index, List *indexQuals, - Cost *indexStartupCost, - Cost *indexTotalCost, - Selectivity *indexSelectivity) +static Datum +genericcostestimate(PG_FUNCTION_ARGS) { + Query *root = (Query *) PG_GETARG_POINTER(0); + RelOptInfo *rel = (RelOptInfo *) PG_GETARG_POINTER(1); + IndexOptInfo *index = (IndexOptInfo *) PG_GETARG_POINTER(2); + List *indexQuals = (List *) PG_GETARG_POINTER(3); + Cost *indexStartupCost = (Cost *) PG_GETARG_POINTER(4); + Cost *indexTotalCost = (Cost *) PG_GETARG_POINTER(5); + Selectivity *indexSelectivity = (Selectivity *) PG_GETARG_POINTER(6); double numIndexTuples; double numIndexPages; @@ -2007,52 +1931,35 @@ genericcostestimate(Query *root, RelOptInfo *rel, *indexStartupCost = 0; *indexTotalCost = numIndexPages + (cpu_index_tuple_cost + cost_qual_eval(indexQuals)) * numIndexTuples; + + /* No real return value ... */ + PG_RETURN_POINTER(NULL); } /* * For first cut, just use generic function for all index types. */ -void -btcostestimate(Query *root, RelOptInfo *rel, - IndexOptInfo *index, List *indexQuals, - Cost *indexStartupCost, - Cost *indexTotalCost, - Selectivity *indexSelectivity) +Datum +btcostestimate(PG_FUNCTION_ARGS) { - genericcostestimate(root, rel, index, indexQuals, - indexStartupCost, indexTotalCost, indexSelectivity); + return genericcostestimate(fcinfo); } -void -rtcostestimate(Query *root, RelOptInfo *rel, - IndexOptInfo *index, List *indexQuals, - Cost *indexStartupCost, - Cost *indexTotalCost, - Selectivity *indexSelectivity) +Datum +rtcostestimate(PG_FUNCTION_ARGS) { - genericcostestimate(root, rel, index, indexQuals, - indexStartupCost, indexTotalCost, indexSelectivity); + return genericcostestimate(fcinfo); } -void -hashcostestimate(Query *root, RelOptInfo *rel, - IndexOptInfo *index, List *indexQuals, - Cost *indexStartupCost, - Cost *indexTotalCost, - Selectivity *indexSelectivity) +Datum +hashcostestimate(PG_FUNCTION_ARGS) { - genericcostestimate(root, rel, index, indexQuals, - indexStartupCost, indexTotalCost, indexSelectivity); + return genericcostestimate(fcinfo); } -void -gistcostestimate(Query *root, RelOptInfo *rel, - IndexOptInfo *index, List *indexQuals, - Cost *indexStartupCost, - Cost *indexTotalCost, - Selectivity *indexSelectivity) +Datum +gistcostestimate(PG_FUNCTION_ARGS) { - genericcostestimate(root, rel, index, indexQuals, - indexStartupCost, indexTotalCost, indexSelectivity); + return genericcostestimate(fcinfo); } diff --git a/src/backend/utils/adt/varchar.c b/src/backend/utils/adt/varchar.c index f98de78878..781d6591b3 100644 --- a/src/backend/utils/adt/varchar.c +++ b/src/backend/utils/adt/varchar.c @@ -1,19 +1,20 @@ /*------------------------------------------------------------------------- * * varchar.c - * Functions for the built-in type char() and varchar(). + * Functions for the built-in types char(n) and varchar(n). * * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.62 2000/05/30 00:49:53 momjian Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.63 2000/06/05 07:28:52 tgl Exp $ * *------------------------------------------------------------------------- */ #include "postgres.h" + #include "catalog/pg_type.h" #include "utils/builtins.h" #include "utils/fmgroids.h" @@ -22,9 +23,10 @@ #include "mb/pg_wchar.h" #endif -#ifdef CYR_RECODE -char *convertstr(char *, int, int); +#ifdef CYR_RECODE +/* XXX no points for style --- this is actually in utils/init/miscinit.c */ +extern char *convertstr(char *, int, int); #endif @@ -34,7 +36,7 @@ char *convertstr(char *, int, int); * VARCHAR is for storing string whose length is at most the length specified * at CREATE TABLE time. * - * It's hard to implement these types because we cannot figure out what + * It's hard to implement these types because we cannot figure out * the length of the type from the type itself. I change (hopefully all) the * fmgr calls that invoke input functions of a data type to supply the * length also. (eg. in INSERTs, we have the tupleDescriptor which contains @@ -44,8 +46,9 @@ char *convertstr(char *, int, int); * must be null-terminated. * * We actually implement this as a varlena so that we don't have to pass in - * the length for the comparison functions. (The difference between "text" - * is that we truncate and possibly blank-pad the string at insertion time.) + * the length for the comparison functions. (The difference between these + * types and "text" is that we truncate and possibly blank-pad the string + * at insertion time.) * * - ay 6/95 */ @@ -231,28 +234,33 @@ _bpchar(ArrayType *v, int32 len) /* bpchar_char() * Convert bpchar(1) to char. + * + * If input is multiple chars, only the first is returned. */ -int32 -bpchar_char(char *s) +Datum +bpchar_char(PG_FUNCTION_ARGS) { - return (int32) *VARDATA(s); -} /* bpchar_char() */ + struct varlena *s = PG_GETARG_BPCHAR_P(0); + + PG_RETURN_CHAR(*VARDATA(s)); +} /* char_bpchar() * Convert char to bpchar(1). */ -char * -char_bpchar(int32 c) +Datum +char_bpchar(PG_FUNCTION_ARGS) { - char *result; + char c = PG_GETARG_CHAR(0); + struct varlena *result; - result = palloc(VARHDRSZ + 1); + result = (struct varlena *) palloc(VARHDRSZ + 1); VARSIZE(result) = VARHDRSZ + 1; - *(VARDATA(result)) = (char) c; + *(VARDATA(result)) = c; - return result; -} /* char_bpchar() */ + PG_RETURN_BPCHAR_P(result); +} /* bpchar_name() diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c index e5fb546ca7..428110aa36 100644 --- a/src/backend/utils/cache/catcache.c +++ b/src/backend/utils/cache/catcache.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.64 2000/05/28 17:56:06 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.65 2000/06/05 07:28:53 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -35,7 +35,7 @@ static Index CatalogCacheComputeTupleHashIndex(struct catcache * cacheInOutP, HeapTuple tuple); static void CatalogCacheInitializeCache(struct catcache * cache, Relation relation); -static uint32 cc_hashname(NameData *n); +static Datum cc_hashname(PG_FUNCTION_ARGS); /* ---------------- * variables, macros and other stuff @@ -87,38 +87,38 @@ static const Oid eqproc[] = { * ---------------------------------------------------------------- */ -static CCHashFunc +static PGFunction GetCCHashFunc(Oid keytype) { switch (keytype) { - case BOOLOID: - case CHAROID: - return (CCHashFunc) hashchar; + case BOOLOID: + case CHAROID: + return hashchar; case NAMEOID: - return (CCHashFunc) cc_hashname; + return cc_hashname; case INT2OID: - return (CCHashFunc) hashint2; + return hashint2; case INT2VECTOROID: - return (CCHashFunc) hashint2vector; + return hashint2vector; case INT4OID: - return (CCHashFunc) hashint4; + return hashint4; case TEXTOID: - return (CCHashFunc) hashtext; + return hashtext; case REGPROCOID: case OIDOID: - return (CCHashFunc) hashoid; + return hashoid; case OIDVECTOROID: - return (CCHashFunc) hashoidvector; + return hashoidvector; default: elog(FATAL, "GetCCHashFunc: type %u unsupported as catcache key", keytype); - return NULL; + return (PGFunction) NULL; } } -static uint32 -cc_hashname(NameData *n) +static Datum +cc_hashname(PG_FUNCTION_ARGS) { /* @@ -129,9 +129,9 @@ cc_hashname(NameData *n) */ NameData my_n; - namestrcpy(&my_n, NameStr(*n)); + namestrcpy(&my_n, NameStr(* PG_GETARG_NAME(0))); - return hashname(&my_n); + return DirectFunctionCall1(hashname, NameGetDatum(&my_n)); } @@ -320,19 +320,23 @@ CatalogCacheComputeHashIndex(struct catcache * cacheInP) { case 4: hashIndex ^= - (*cacheInP->cc_hashfunc[3]) (cacheInP->cc_skey[3].sk_argument) << 9; + DatumGetUInt32(DirectFunctionCall1(cacheInP->cc_hashfunc[3], + cacheInP->cc_skey[3].sk_argument)) << 9; /* FALLTHROUGH */ case 3: hashIndex ^= - (*cacheInP->cc_hashfunc[2]) (cacheInP->cc_skey[2].sk_argument) << 6; + DatumGetUInt32(DirectFunctionCall1(cacheInP->cc_hashfunc[2], + cacheInP->cc_skey[2].sk_argument)) << 6; /* FALLTHROUGH */ case 2: hashIndex ^= - (*cacheInP->cc_hashfunc[1]) (cacheInP->cc_skey[1].sk_argument) << 3; + DatumGetUInt32(DirectFunctionCall1(cacheInP->cc_hashfunc[1], + cacheInP->cc_skey[1].sk_argument)) << 3; /* FALLTHROUGH */ case 1: hashIndex ^= - (*cacheInP->cc_hashfunc[0]) (cacheInP->cc_skey[0].sk_argument); + DatumGetUInt32(DirectFunctionCall1(cacheInP->cc_hashfunc[0], + cacheInP->cc_skey[0].sk_argument)); break; default: elog(FATAL, "CCComputeHashIndex: %d cc_nkeys", cacheInP->cc_nkeys); diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c index 713d714bb7..489d8c260f 100644 --- a/src/backend/utils/fmgr/fmgr.c +++ b/src/backend/utils/fmgr/fmgr.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.42 2000/05/30 04:24:53 tgl Exp $ + * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.43 2000/06/05 07:28:55 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -21,6 +21,27 @@ #include "utils/fmgrtab.h" #include "utils/syscache.h" +/* + * Declaration for old-style function pointer type. This is now used only + * in fmgr_oldstyle() and is no longer exported. + * + * The m68k SVR4 ABI defines that pointers are returned in %a0 instead of + * %d0. So if a function pointer is declared to return a pointer, the + * compiler may look only into %a0, but if the called function was declared + * to return an integer type, it puts its value only into %d0. So the + * caller doesn't pink up the correct return value. The solution is to + * declare the function pointer to return int, so the compiler picks up the + * return value from %d0. (Functions returning pointers put their value + * *additionally* into %d0 for compatibility.) The price is that there are + * some warnings about int->pointer conversions... + */ +#if defined(__mc68000__) && defined(__ELF__) +typedef int32 ((*func_ptr) ()); +#else +typedef char *((*func_ptr) ()); +#endif + + static Datum fmgr_oldstyle(PG_FUNCTION_ARGS); static Datum fmgr_untrusted(PG_FUNCTION_ARGS); static Datum fmgr_sql(PG_FUNCTION_ARGS); @@ -377,7 +398,7 @@ fmgr_oldstyle(PG_FUNCTION_ARGS) default: /* * Increasing FUNC_MAX_ARGS doesn't automatically add cases - * to the above code, so give the actual value in this error + * to the above code, so mention the actual value in this error * not FUNC_MAX_ARGS. You could add cases to the above if you * needed to support old-style functions with many arguments, * but making 'em be new-style is probably a better idea. @@ -420,100 +441,6 @@ fmgr_sql(PG_FUNCTION_ARGS) return 0; /* keep compiler happy */ } -#if 0 - -/* - * Interface routine for functions using fmgr_faddr - */ -FmgrInfo *fmgr_pl_finfo; /* should GO AWAY */ - -char * -fmgr_faddr_link(char *arg0, ...) -{ - FunctionCallInfoData fcinfo; - int n_arguments; - Datum result; - - MemSet(&fcinfo, 0, sizeof(fcinfo)); - /* We rely on fmgr_faddr macro to have set back-link to FmgrInfo (ugh) */ - fcinfo.flinfo = fmgr_pl_finfo; - fcinfo.nargs = fcinfo.flinfo->fn_nargs; - n_arguments = fcinfo.nargs; - - if (n_arguments > 0) - { - fcinfo.arg[0] = (Datum) arg0; - if (n_arguments > 1) - { - va_list pvar; - int i; - - if (n_arguments > FUNC_MAX_ARGS) - elog(ERROR, "fmgr_faddr_link: function %u: too many arguments (%d > %d)", - fcinfo.flinfo->fn_oid, n_arguments, FUNC_MAX_ARGS); - va_start(pvar, arg0); - for (i = 1; i < n_arguments; i++) - fcinfo.arg[i] = (Datum) va_arg(pvar, char *); - va_end(pvar); - } - } - - result = FunctionCallInvoke(&fcinfo); - - /* Check for null result, since caller is clearly not expecting one */ - if (fcinfo.isnull) - elog(ERROR, "fmgr_faddr_link: function %u returned NULL", - fcinfo.flinfo->fn_oid); - - return (char *) result; -} - -/* - * fmgr - return the value of a function call - * - * This is essentially fmgr_info plus call the function. - */ -char * -fmgr(Oid procedureId,...) -{ - FmgrInfo flinfo; - FunctionCallInfoData fcinfo; - int n_arguments; - Datum result; - - fmgr_info(procedureId, &flinfo); - - MemSet(&fcinfo, 0, sizeof(fcinfo)); - fcinfo.flinfo = &flinfo; - fcinfo.nargs = flinfo.fn_nargs; - n_arguments = fcinfo.nargs; - - if (n_arguments > 0) - { - va_list pvar; - int i; - - if (n_arguments > FUNC_MAX_ARGS) - elog(ERROR, "fmgr: function %u: too many arguments (%d > %d)", - flinfo.fn_oid, n_arguments, FUNC_MAX_ARGS); - va_start(pvar, procedureId); - for (i = 0; i < n_arguments; i++) - fcinfo.arg[i] = (Datum) va_arg(pvar, char *); - va_end(pvar); - } - - result = FunctionCallInvoke(&fcinfo); - - /* Check for null result, since caller is clearly not expecting one */ - if (fcinfo.isnull) - elog(ERROR, "fmgr: function %u returned NULL", - flinfo.fn_oid); - - return (char *) result; -} - -#endif - /*------------------------------------------------------------------------- * Support routines for callers of fmgr-compatible functions @@ -1267,6 +1194,57 @@ OidFunctionCall9(Oid functionId, Datum arg1, Datum arg2, } +/* + * !!! OLD INTERFACE !!! + * + * fmgr() is the only remaining vestige of the old-style caller support + * functions. It's no longer used anywhere in the Postgres distribution, + * but we should leave it around for a release or two to ease the transition + * for user-supplied C functions. OidFunctionCallN() replaces it for new + * code. + * + * DEPRECATED, DO NOT USE IN NEW CODE + */ +char * +fmgr(Oid procedureId,...) +{ + FmgrInfo flinfo; + FunctionCallInfoData fcinfo; + int n_arguments; + Datum result; + + fmgr_info(procedureId, &flinfo); + + MemSet(&fcinfo, 0, sizeof(fcinfo)); + fcinfo.flinfo = &flinfo; + fcinfo.nargs = flinfo.fn_nargs; + n_arguments = fcinfo.nargs; + + if (n_arguments > 0) + { + va_list pvar; + int i; + + if (n_arguments > FUNC_MAX_ARGS) + elog(ERROR, "fmgr: function %u: too many arguments (%d > %d)", + flinfo.fn_oid, n_arguments, FUNC_MAX_ARGS); + va_start(pvar, procedureId); + for (i = 0; i < n_arguments; i++) + fcinfo.arg[i] = (Datum) va_arg(pvar, char *); + va_end(pvar); + } + + result = FunctionCallInvoke(&fcinfo); + + /* Check for null result, since caller is clearly not expecting one */ + if (fcinfo.isnull) + elog(ERROR, "fmgr: function %u returned NULL", + flinfo.fn_oid); + + return (char *) result; +} + + /*------------------------------------------------------------------------- * Support routines for standard pass-by-reference datatypes * diff --git a/src/include/access/hash.h b/src/include/access/hash.h index 7b9445ec69..06c0fda959 100644 --- a/src/include/access/hash.h +++ b/src/include/access/hash.h @@ -7,7 +7,7 @@ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: hash.h,v 1.31 2000/02/21 03:36:51 tgl Exp $ + * $Id: hash.h,v 1.32 2000/06/05 07:28:57 tgl Exp $ * * NOTES * modeled after Margo Seltzer's hash implementation for unix. @@ -21,7 +21,7 @@ #include "access/itup.h" #include "access/relscan.h" #include "access/sdir.h" -#include "utils/int8.h" +#include "fmgr.h" /* * An overflow page is a spare page allocated for storing data whose @@ -262,18 +262,24 @@ extern void hashmarkpos(IndexScanDesc scan); extern void hashrestrpos(IndexScanDesc scan); extern void hashdelete(Relation rel, ItemPointer tid); -/* hashfunc.c */ -extern uint32 hashint2(int16 key); -extern uint32 hashint4(uint32 key); -extern uint32 hashint8(int64 *key); -extern uint32 hashfloat4(float32 keyp); -extern uint32 hashfloat8(float64 keyp); -extern uint32 hashoid(Oid key); -extern uint32 hashoidvector(Oid *key); -extern uint32 hashint2vector(int16 *key); -extern uint32 hashchar(char key); -extern uint32 hashtext(struct varlena * key); -extern uint32 hashname(NameData *n); +/* + * Datatype-specific hash functions in hashfunc.c. + * + * NOTE: some of these are also used by catcache operations, without + * any direct connection to hash indexes. + */ +extern Datum hashint2(PG_FUNCTION_ARGS); +extern Datum hashint4(PG_FUNCTION_ARGS); +extern Datum hashint8(PG_FUNCTION_ARGS); +extern Datum hashfloat4(PG_FUNCTION_ARGS); +extern Datum hashfloat8(PG_FUNCTION_ARGS); +extern Datum hashoid(PG_FUNCTION_ARGS); +extern Datum hashoidvector(PG_FUNCTION_ARGS); +extern Datum hashint2vector(PG_FUNCTION_ARGS); +extern Datum hashchar(PG_FUNCTION_ARGS); +extern Datum hashtext(PG_FUNCTION_ARGS); +extern Datum hashname(PG_FUNCTION_ARGS); + /* private routines */ diff --git a/src/include/access/xact.h b/src/include/access/xact.h index 89a478ea0e..787b4402d2 100644 --- a/src/include/access/xact.h +++ b/src/include/access/xact.h @@ -7,7 +7,7 @@ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: xact.h,v 1.24 2000/01/26 05:57:51 momjian Exp $ + * $Id: xact.h,v 1.25 2000/06/05 07:28:57 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -115,9 +115,9 @@ extern void AbortOutOfAnyTransaction(void); extern TransactionId DisabledTransactionId; /* defined in xid.c */ -extern TransactionId xidin(char *representation); -extern char *xidout(TransactionId transactionId); -extern bool xideq(TransactionId xid1, TransactionId xid2); +extern Datum xidin(PG_FUNCTION_ARGS); +extern Datum xidout(PG_FUNCTION_ARGS); +extern Datum xideq(PG_FUNCTION_ARGS); extern void TransactionIdAdd(TransactionId *xid, int value); #endif /* XACT_H */ diff --git a/src/include/catalog/catversion.h b/src/include/catalog/catversion.h index 74b712dca9..c1d6747467 100644 --- a/src/include/catalog/catversion.h +++ b/src/include/catalog/catversion.h @@ -37,7 +37,7 @@ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: catversion.h,v 1.23 2000/05/29 01:59:10 tgl Exp $ + * $Id: catversion.h,v 1.24 2000/06/05 07:28:58 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -53,6 +53,6 @@ */ /* yyyymmddN */ -#define CATALOG_VERSION_NO 200005282 +#define CATALOG_VERSION_NO 200006021 #endif diff --git a/src/include/catalog/pg_operator.h b/src/include/catalog/pg_operator.h index 538d009525..06bb7546cd 100644 --- a/src/include/catalog/pg_operator.h +++ b/src/include/catalog/pg_operator.h @@ -8,7 +8,7 @@ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: pg_operator.h,v 1.75 2000/04/12 17:16:29 momjian Exp $ + * $Id: pg_operator.h,v 1.76 2000/06/05 07:28:59 tgl Exp $ * * NOTES * the genbki.sh script reads this file and generates .bki @@ -711,17 +711,17 @@ DATA(insert OID = 1763 ( "@" PGUID 0 l t f 0 1700 1700 0 0 0 0 numeric_ab /* LZTEXT type */ DATA(insert OID = 1657 ( "=" PGUID 0 b t f 1625 1625 16 1657 1658 1659 1659 lztext_eq eqsel eqjoinsel )); DATA(insert OID = 1658 ( "<>" PGUID 0 b t f 1625 1625 16 1658 1657 0 0 lztext_ne neqsel neqjoinsel )); -DATA(insert OID = 1659 ( "<" PGUID 0 b t f 1625 1625 16 1661 1662 0 0 lztext_lt intltsel intltjoinsel )); -DATA(insert OID = 1660 ( "<=" PGUID 0 b t f 1625 1625 16 1662 1661 0 0 lztext_le intltsel intltjoinsel )); -DATA(insert OID = 1661 ( ">" PGUID 0 b t f 1625 1625 16 1659 1660 0 0 lztext_gt intgtsel intgtjoinsel )); -DATA(insert OID = 1662 ( ">=" PGUID 0 b t f 1625 1625 16 1660 1659 0 0 lztext_ge intgtsel intgtjoinsel )); +DATA(insert OID = 1659 ( "<" PGUID 0 b t f 1625 1625 16 1661 1662 0 0 lztext_lt scalarltsel scalarltjoinsel )); +DATA(insert OID = 1660 ( "<=" PGUID 0 b t f 1625 1625 16 1662 1661 0 0 lztext_le scalarltsel scalarltjoinsel )); +DATA(insert OID = 1661 ( ">" PGUID 0 b t f 1625 1625 16 1659 1660 0 0 lztext_gt scalargtsel scalargtjoinsel )); +DATA(insert OID = 1662 ( ">=" PGUID 0 b t f 1625 1625 16 1660 1659 0 0 lztext_ge scalargtsel scalargtjoinsel )); DATA(insert OID = 1784 ( "=" PGUID 0 b t f 1560 1560 16 1784 1785 1786 1786 biteq eqsel eqjoinsel )); DATA(insert OID = 1785 ( "<>" PGUID 0 b t f 1560 1560 16 1785 1784 0 0 bitne neqsel neqjoinsel )); -DATA(insert OID = 1786 ( "<" PGUID 0 b t f 1560 1560 16 1787 1789 0 0 bitlt intltsel intltjoinsel )); -DATA(insert OID = 1787 ( ">" PGUID 0 b t f 1560 1560 16 1786 1788 0 0 bitgt intgtsel intgtjoinsel )); -DATA(insert OID = 1788 ( "<=" PGUID 0 b t f 1560 1560 16 1789 1787 0 0 bitle intltsel intltjoinsel )); -DATA(insert OID = 1789 ( ">=" PGUID 0 b t f 1560 1560 16 1788 1786 0 0 bitge intgtsel intgtjoinsel )); +DATA(insert OID = 1786 ( "<" PGUID 0 b t f 1560 1560 16 1787 1789 0 0 bitlt scalarltsel scalarltjoinsel )); +DATA(insert OID = 1787 ( ">" PGUID 0 b t f 1560 1560 16 1786 1788 0 0 bitgt scalargtsel scalargtjoinsel )); +DATA(insert OID = 1788 ( "<=" PGUID 0 b t f 1560 1560 16 1789 1787 0 0 bitle scalarltsel scalarltjoinsel )); +DATA(insert OID = 1789 ( ">=" PGUID 0 b t f 1560 1560 16 1788 1786 0 0 bitge scalargtsel scalargtjoinsel )); DATA(insert OID = 1790 ( "<=>" PGUID 0 b t f 1560 1560 23 0 0 0 0 bitcmp - - )); DATA(insert OID = 1791 ( "&" PGUID 0 b t f 1560 1560 1560 0 0 0 0 bitand - - )); DATA(insert OID = 1792 ( "|" PGUID 0 b t f 1560 1560 1560 0 0 0 0 bitor - - )); @@ -733,10 +733,10 @@ DATA(insert OID = 1797 ( "||" PGUID 0 b t f 1560 1560 1560 0 0 0 0 bitc DATA(insert OID = 1804 ( "=" PGUID 0 b t f 1562 1562 16 1804 1805 1806 1806 varbiteq eqsel eqjoinsel )); DATA(insert OID = 1805 ( "<>" PGUID 0 b t f 1562 1562 16 1805 1804 0 0 varbitne neqsel neqjoinsel )); -DATA(insert OID = 1806 ( "<" PGUID 0 b t f 1562 1562 16 1807 1809 0 0 varbitlt intltsel intltjoinsel )); -DATA(insert OID = 1807 ( ">" PGUID 0 b t f 1562 1562 16 1806 1808 0 0 varbitgt intgtsel intgtjoinsel )); -DATA(insert OID = 1808 ( "<=" PGUID 0 b t f 1562 1562 16 1809 1807 0 0 varbitle intltsel intltjoinsel )); -DATA(insert OID = 1809 ( ">=" PGUID 0 b t f 1562 1562 16 1808 1806 0 0 varbitge intgtsel intgtjoinsel )); +DATA(insert OID = 1806 ( "<" PGUID 0 b t f 1562 1562 16 1807 1809 0 0 varbitlt scalarltsel scalarltjoinsel )); +DATA(insert OID = 1807 ( ">" PGUID 0 b t f 1562 1562 16 1806 1808 0 0 varbitgt scalargtsel scalargtjoinsel )); +DATA(insert OID = 1808 ( "<=" PGUID 0 b t f 1562 1562 16 1809 1807 0 0 varbitle scalarltsel scalarltjoinsel )); +DATA(insert OID = 1809 ( ">=" PGUID 0 b t f 1562 1562 16 1808 1806 0 0 varbitge scalargtsel scalargtjoinsel )); DATA(insert OID = 1810 ( "<=>" PGUID 0 b t f 1562 1562 23 0 0 0 0 varbitcmp - - )); DATA(insert OID = 1811 ( "&" PGUID 0 b t f 1562 1562 1562 0 0 0 0 varbitand - - )); DATA(insert OID = 1812 ( "|" PGUID 0 b t f 1562 1562 1562 0 0 0 0 varbitor - - )); diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h index 76f52eef69..9d09aa8b7a 100644 --- a/src/include/catalog/pg_proc.h +++ b/src/include/catalog/pg_proc.h @@ -7,7 +7,7 @@ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: pg_proc.h,v 1.135 2000/05/29 01:59:10 tgl Exp $ + * $Id: pg_proc.h,v 1.136 2000/06/05 07:28:59 tgl Exp $ * * NOTES * The script catalog/genbki.sh reads this file and generates .bki @@ -97,37 +97,37 @@ typedef FormData_pg_proc *Form_pg_proc; /* OIDS 1 - 99 */ -DATA(insert OID = 1242 ( boolin PGUID 11 f t t t 1 f 16 "0" 100 0 0 100 boolin - )); +DATA(insert OID = 1242 ( boolin PGUID 12 f t t t 1 f 16 "0" 100 0 0 100 boolin - )); DESCR("(internal)"); -DATA(insert OID = 1243 ( boolout PGUID 11 f t t t 1 f 23 "0" 100 0 0 100 boolout - )); +DATA(insert OID = 1243 ( boolout PGUID 12 f t t t 1 f 23 "0" 100 0 0 100 boolout - )); DESCR("(internal)"); DATA(insert OID = 1244 ( byteain PGUID 11 f t t t 1 f 17 "0" 100 0 0 100 byteain - )); DESCR("(internal)"); DATA(insert OID = 31 ( byteaout PGUID 11 f t t t 1 f 23 "0" 100 0 0 100 byteaout - )); DESCR("(internal)"); -DATA(insert OID = 1245 ( charin PGUID 11 f t t t 1 f 18 "0" 100 0 0 100 charin - )); +DATA(insert OID = 1245 ( charin PGUID 12 f t t t 1 f 18 "0" 100 0 0 100 charin - )); DESCR("(internal)"); -DATA(insert OID = 33 ( charout PGUID 11 f t t t 1 f 23 "0" 100 0 0 100 charout - )); +DATA(insert OID = 33 ( charout PGUID 12 f t t t 1 f 23 "0" 100 0 0 100 charout - )); DESCR("(internal)"); DATA(insert OID = 34 ( namein PGUID 11 f t t t 1 f 19 "0" 100 0 0 100 namein - )); DESCR("(internal)"); DATA(insert OID = 35 ( nameout PGUID 11 f t t t 1 f 23 "0" 100 0 0 100 nameout - )); DESCR("(internal)"); -DATA(insert OID = 38 ( int2in PGUID 11 f t t t 1 f 21 "0" 100 0 0 100 int2in - )); +DATA(insert OID = 38 ( int2in PGUID 12 f t t t 1 f 21 "0" 100 0 0 100 int2in - )); DESCR("(internal)"); -DATA(insert OID = 39 ( int2out PGUID 11 f t t t 1 f 23 "0" 100 0 0 100 int2out - )); +DATA(insert OID = 39 ( int2out PGUID 12 f t t t 1 f 23 "0" 100 0 0 100 int2out - )); DESCR("(internal)"); -DATA(insert OID = 40 ( int2vectorin PGUID 11 f t t t 1 f 22 "0" 100 0 0 100 int2vectorin - )); +DATA(insert OID = 40 ( int2vectorin PGUID 12 f t t t 1 f 22 "0" 100 0 0 100 int2vectorin - )); DESCR("(internal)"); -DATA(insert OID = 41 ( int2vectorout PGUID 11 f t t t 1 f 23 "0" 100 0 0 100 int2vectorout - )); +DATA(insert OID = 41 ( int2vectorout PGUID 12 f t t t 1 f 23 "0" 100 0 0 100 int2vectorout - )); DESCR("(internal)"); -DATA(insert OID = 42 ( int4in PGUID 11 f t t t 1 f 23 "0" 100 0 0 100 int4in - )); +DATA(insert OID = 42 ( int4in PGUID 12 f t t t 1 f 23 "0" 100 0 0 100 int4in - )); DESCR("(internal)"); -DATA(insert OID = 43 ( int4out PGUID 11 f t t t 1 f 19 "0" 100 0 0 100 int4out - )); +DATA(insert OID = 43 ( int4out PGUID 12 f t t t 1 f 23 "0" 100 0 0 100 int4out - )); DESCR("(internal)"); -DATA(insert OID = 44 ( regprocin PGUID 11 f t f t 1 f 24 "0" 100 0 0 100 regprocin - )); +DATA(insert OID = 44 ( regprocin PGUID 12 f t f t 1 f 24 "0" 100 0 0 100 regprocin - )); DESCR("(internal)"); -DATA(insert OID = 45 ( regprocout PGUID 11 f t f t 1 f 23 "0" 100 0 0 100 regprocout - )); +DATA(insert OID = 45 ( regprocout PGUID 12 f t f t 1 f 23 "0" 100 0 0 100 regprocout - )); DESCR("(internal)"); DATA(insert OID = 46 ( textin PGUID 11 f t t t 1 f 25 "0" 100 0 0 100 textin - )); DESCR("(internal)"); @@ -137,59 +137,59 @@ DATA(insert OID = 48 ( tidin PGUID 11 f t t t 1 f 27 "0" 100 0 0 100 tid DESCR("(internal)"); DATA(insert OID = 49 ( tidout PGUID 11 f t t t 1 f 23 "0" 100 0 0 100 tidout - )); DESCR("(internal)"); -DATA(insert OID = 50 ( xidin PGUID 11 f t t t 1 f 28 "0" 100 0 0 100 xidin - )); +DATA(insert OID = 50 ( xidin PGUID 12 f t t t 1 f 28 "0" 100 0 0 100 xidin - )); DESCR("(internal)"); -DATA(insert OID = 51 ( xidout PGUID 11 f t t t 1 f 23 "0" 100 0 0 100 xidout - )); +DATA(insert OID = 51 ( xidout PGUID 12 f t t t 1 f 23 "0" 100 0 0 100 xidout - )); DESCR("(internal)"); -DATA(insert OID = 52 ( cidin PGUID 11 f t t t 1 f 29 "0" 100 0 0 100 cidin - )); +DATA(insert OID = 52 ( cidin PGUID 12 f t t t 1 f 29 "0" 100 0 0 100 cidin - )); DESCR("(internal)"); -DATA(insert OID = 53 ( cidout PGUID 11 f t t t 1 f 23 "0" 100 0 0 100 cidout - )); +DATA(insert OID = 53 ( cidout PGUID 12 f t t t 1 f 23 "0" 100 0 0 100 cidout - )); DESCR("(internal)"); -DATA(insert OID = 54 ( oidvectorin PGUID 11 f t t t 1 f 30 "0" 100 0 0 100 oidvectorin - )); +DATA(insert OID = 54 ( oidvectorin PGUID 12 f t t t 1 f 30 "0" 100 0 0 100 oidvectorin - )); DESCR("(internal)"); -DATA(insert OID = 55 ( oidvectorout PGUID 11 f t t t 1 f 23 "0" 100 0 0 100 oidvectorout - )); +DATA(insert OID = 55 ( oidvectorout PGUID 12 f t t t 1 f 23 "0" 100 0 0 100 oidvectorout - )); DESCR("(internal)"); -DATA(insert OID = 56 ( boollt PGUID 11 f t t t 2 f 16 "16 16" 100 0 0 100 boollt - )); +DATA(insert OID = 56 ( boollt PGUID 12 f t t t 2 f 16 "16 16" 100 0 0 100 boollt - )); DESCR("less-than"); -DATA(insert OID = 57 ( boolgt PGUID 11 f t t t 2 f 16 "16 16" 100 0 0 100 boolgt - )); +DATA(insert OID = 57 ( boolgt PGUID 12 f t t t 2 f 16 "16 16" 100 0 0 100 boolgt - )); DESCR("greater-than"); -DATA(insert OID = 60 ( booleq PGUID 11 f t t t 2 f 16 "16 16" 100 0 0 100 booleq - )); +DATA(insert OID = 60 ( booleq PGUID 12 f t t t 2 f 16 "16 16" 100 0 0 100 booleq - )); DESCR("equal"); -DATA(insert OID = 61 ( chareq PGUID 11 f t t t 2 f 16 "18 18" 100 0 0 100 chareq - )); +DATA(insert OID = 61 ( chareq PGUID 12 f t t t 2 f 16 "18 18" 100 0 0 100 chareq - )); DESCR("equal"); DATA(insert OID = 62 ( nameeq PGUID 11 f t t t 2 f 16 "19 19" 100 0 0 100 nameeq - )); DESCR("equal"); -DATA(insert OID = 63 ( int2eq PGUID 11 f t t t 2 f 16 "21 21" 100 0 0 100 int2eq - )); +DATA(insert OID = 63 ( int2eq PGUID 12 f t t t 2 f 16 "21 21" 100 0 0 100 int2eq - )); DESCR("equal"); -DATA(insert OID = 64 ( int2lt PGUID 11 f t t t 2 f 16 "21 21" 100 0 0 100 int2lt - )); +DATA(insert OID = 64 ( int2lt PGUID 12 f t t t 2 f 16 "21 21" 100 0 0 100 int2lt - )); DESCR("less-than"); -DATA(insert OID = 65 ( int4eq PGUID 11 f t t t 2 f 16 "23 23" 100 0 0 100 int4eq - )); +DATA(insert OID = 65 ( int4eq PGUID 12 f t t t 2 f 16 "23 23" 100 0 0 100 int4eq - )); DESCR("equal"); -DATA(insert OID = 66 ( int4lt PGUID 11 f t t t 2 f 16 "23 23" 100 0 0 100 int4lt - )); +DATA(insert OID = 66 ( int4lt PGUID 12 f t t t 2 f 16 "23 23" 100 0 0 100 int4lt - )); DESCR("less-than"); DATA(insert OID = 67 ( texteq PGUID 11 f t t t 2 f 16 "25 25" 100 0 0 0 texteq - )); DESCR("equal"); -DATA(insert OID = 68 ( xideq PGUID 11 f t t t 2 f 16 "28 28" 100 0 0 100 xideq - )); +DATA(insert OID = 68 ( xideq PGUID 12 f t t t 2 f 16 "28 28" 100 0 0 100 xideq - )); DESCR("equal"); -DATA(insert OID = 69 ( cideq PGUID 11 f t t t 2 f 16 "29 29" 100 0 0 100 cideq - )); +DATA(insert OID = 69 ( cideq PGUID 12 f t t t 2 f 16 "29 29" 100 0 0 100 cideq - )); DESCR("equal"); -DATA(insert OID = 70 ( charne PGUID 11 f t t t 2 f 16 "18 18" 100 0 0 100 charne - )); +DATA(insert OID = 70 ( charne PGUID 12 f t t t 2 f 16 "18 18" 100 0 0 100 charne - )); DESCR("not equal"); -DATA(insert OID = 1246 ( charlt PGUID 11 f t t t 2 f 16 "18 18" 100 0 0 100 charlt - )); +DATA(insert OID = 1246 ( charlt PGUID 12 f t t t 2 f 16 "18 18" 100 0 0 100 charlt - )); DESCR("less-than"); -DATA(insert OID = 72 ( charle PGUID 11 f t t t 2 f 16 "18 18" 100 0 0 100 charle - )); +DATA(insert OID = 72 ( charle PGUID 12 f t t t 2 f 16 "18 18" 100 0 0 100 charle - )); DESCR("less-than-or-equal"); -DATA(insert OID = 73 ( chargt PGUID 11 f t t t 2 f 16 "18 18" 100 0 0 100 chargt - )); +DATA(insert OID = 73 ( chargt PGUID 12 f t t t 2 f 16 "18 18" 100 0 0 100 chargt - )); DESCR("greater-than"); -DATA(insert OID = 74 ( charge PGUID 11 f t t t 2 f 16 "18 18" 100 0 0 100 charge - )); +DATA(insert OID = 74 ( charge PGUID 12 f t t t 2 f 16 "18 18" 100 0 0 100 charge - )); DESCR("greater-than-or-equal"); -DATA(insert OID = 1248 ( charpl PGUID 11 f t t t 2 f 18 "18 18" 100 0 0 100 charpl - )); -DESCR("addition"); -DATA(insert OID = 1250 ( charmi PGUID 11 f t t t 2 f 18 "18 18" 100 0 0 100 charmi - )); +DATA(insert OID = 1248 ( charpl PGUID 12 f t t t 2 f 18 "18 18" 100 0 0 100 charpl - )); +DESCR("add"); +DATA(insert OID = 1250 ( charmi PGUID 12 f t t t 2 f 18 "18 18" 100 0 0 100 charmi - )); DESCR("subtract"); -DATA(insert OID = 77 ( charmul PGUID 11 f t t t 2 f 18 "18 18" 100 0 0 100 charmul - )); +DATA(insert OID = 77 ( charmul PGUID 12 f t t t 2 f 18 "18 18" 100 0 0 100 charmul - )); DESCR("multiply"); -DATA(insert OID = 78 ( chardiv PGUID 11 f t t t 2 f 18 "18 18" 100 0 0 100 chardiv - )); +DATA(insert OID = 78 ( chardiv PGUID 12 f t t t 2 f 18 "18 18" 100 0 0 100 chardiv - )); DESCR("divide"); DATA(insert OID = 79 ( nameregexeq PGUID 11 f t t t 2 f 16 "19 25" 100 0 0 100 nameregexeq - )); @@ -205,42 +205,42 @@ DESCR("length"); DATA(insert OID = 1258 ( textcat PGUID 11 f t t t 2 f 25 "25 25" 100 0 1 0 textcat - )); DESCR("concatenate"); -DATA(insert OID = 84 ( boolne PGUID 11 f t t t 2 f 16 "16 16" 100 0 0 100 boolne - )); +DATA(insert OID = 84 ( boolne PGUID 12 f t t t 2 f 16 "16 16" 100 0 0 100 boolne - )); DESCR("not equal"); DATA(insert OID = 89 ( version PGUID 11 f t f t 0 f 25 "" 100 0 0 100 version - )); DESCR("PostgreSQL version string"); -DATA(insert OID = 1265 ( rtcostestimate PGUID 11 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100 rtcostestimate - )); +DATA(insert OID = 1265 ( rtcostestimate PGUID 12 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100 rtcostestimate - )); DESCR("r-tree cost estimator"); -DATA(insert OID = 1268 ( btcostestimate PGUID 11 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100 btcostestimate - )); +DATA(insert OID = 1268 ( btcostestimate PGUID 12 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100 btcostestimate - )); DESCR("btree cost estimator"); /* OIDS 100 - 199 */ DATA(insert OID = 100 ( int8fac PGUID 11 f t t t 1 f 20 "20" 100 0 0 100 int8fac - )); DESCR("factorial"); -DATA(insert OID = 101 ( eqsel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 eqsel - )); +DATA(insert OID = 101 ( eqsel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 eqsel - )); DESCR("restriction selectivity of = and related operators"); -DATA(insert OID = 102 ( neqsel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 neqsel - )); +DATA(insert OID = 102 ( neqsel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 neqsel - )); DESCR("restriction selectivity of <> and related operators"); -DATA(insert OID = 103 ( scalarltsel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 scalarltsel - )); +DATA(insert OID = 103 ( scalarltsel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 scalarltsel - )); DESCR("restriction selectivity of < and related operators on scalar datatypes"); -DATA(insert OID = 104 ( scalargtsel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 scalargtsel - )); +DATA(insert OID = 104 ( scalargtsel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 scalargtsel - )); DESCR("restriction selectivity of > and related operators on scalar datatypes"); -DATA(insert OID = 105 ( eqjoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 eqjoinsel - )); +DATA(insert OID = 105 ( eqjoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 eqjoinsel - )); DESCR("join selectivity of = and related operators"); -DATA(insert OID = 106 ( neqjoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 neqjoinsel - )); +DATA(insert OID = 106 ( neqjoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 neqjoinsel - )); DESCR("join selectivity of <> and related operators"); -DATA(insert OID = 107 ( scalarltjoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 scalarltjoinsel - )); +DATA(insert OID = 107 ( scalarltjoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 scalarltjoinsel - )); DESCR("join selectivity of < and related operators on scalar datatypes"); -DATA(insert OID = 108 ( scalargtjoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 scalargtjoinsel - )); +DATA(insert OID = 108 ( scalargtjoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 scalargtjoinsel - )); DESCR("join selectivity of > and related operators on scalar datatypes"); -DATA(insert OID = 112 ( text PGUID 11 f t t t 1 f 25 "23" 100 0 0 100 int4_text - )); +DATA(insert OID = 112 ( text PGUID 12 f t t t 1 f 25 "23" 100 0 0 100 int4_text - )); DESCR("convert int4 to text"); -DATA(insert OID = 113 ( text PGUID 11 f t t t 1 f 25 "21" 100 0 0 100 int2_text - )); +DATA(insert OID = 113 ( text PGUID 12 f t t t 1 f 25 "21" 100 0 0 100 int2_text - )); DESCR("convert int2 to text"); -DATA(insert OID = 114 ( text PGUID 11 f t t t 1 f 25 "26" 100 0 0 100 oid_text - )); +DATA(insert OID = 114 ( text PGUID 12 f t t t 1 f 25 "26" 100 0 0 100 oid_text - )); DESCR("convert oid to text"); DATA(insert OID = 115 ( box_above PGUID 11 f t t t 2 f 16 "603 603" 100 1 0 100 box_above - )); @@ -292,99 +292,99 @@ DATA(insert OID = 137 ( on_ppath PGUID 11 f t t t 2 f 16 "600 602" 100 0 1 DESCR("contained in"); DATA(insert OID = 138 ( box_center PGUID 11 f t t t 1 f 600 "603" 100 1 0 100 box_center - )); DESCR("center of"); -DATA(insert OID = 139 ( areasel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 areasel - )); +DATA(insert OID = 139 ( areasel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 areasel - )); DESCR("restriction selectivity for area-comparison operators"); -DATA(insert OID = 140 ( areajoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 areajoinsel - )); +DATA(insert OID = 140 ( areajoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 areajoinsel - )); DESCR("join selectivity for area-comparison operators"); -DATA(insert OID = 141 ( int4mul PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100 int4mul - )); +DATA(insert OID = 141 ( int4mul PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100 int4mul - )); DESCR("multiply"); -DATA(insert OID = 142 ( int4fac PGUID 11 f t t t 1 f 23 "23" 100 0 0 100 int4fac - )); +DATA(insert OID = 142 ( int4fac PGUID 12 f t t t 1 f 23 "23" 100 0 0 100 int4fac - )); DESCR("factorial"); DATA(insert OID = 143 ( pointdist PGUID 11 f t t t 2 f 23 "600 600" 100 0 0 100 pointdist - )); DESCR(""); -DATA(insert OID = 144 ( int4ne PGUID 11 f t t t 2 f 16 "23 23" 100 0 0 100 int4ne - )); +DATA(insert OID = 144 ( int4ne PGUID 12 f t t t 2 f 16 "23 23" 100 0 0 100 int4ne - )); DESCR("not equal"); -DATA(insert OID = 145 ( int2ne PGUID 11 f t t t 2 f 16 "21 21" 100 0 0 100 int2ne - )); +DATA(insert OID = 145 ( int2ne PGUID 12 f t t t 2 f 16 "21 21" 100 0 0 100 int2ne - )); DESCR("not equal"); -DATA(insert OID = 146 ( int2gt PGUID 11 f t t t 2 f 16 "21 21" 100 0 0 100 int2gt - )); +DATA(insert OID = 146 ( int2gt PGUID 12 f t t t 2 f 16 "21 21" 100 0 0 100 int2gt - )); DESCR("greater-than"); -DATA(insert OID = 147 ( int4gt PGUID 11 f t t t 2 f 16 "23 23" 100 0 0 100 int4gt - )); +DATA(insert OID = 147 ( int4gt PGUID 12 f t t t 2 f 16 "23 23" 100 0 0 100 int4gt - )); DESCR("greater-than"); -DATA(insert OID = 148 ( int2le PGUID 11 f t t t 2 f 16 "21 21" 100 0 0 100 int2le - )); +DATA(insert OID = 148 ( int2le PGUID 12 f t t t 2 f 16 "21 21" 100 0 0 100 int2le - )); DESCR("less-than-or-equal"); -DATA(insert OID = 149 ( int4le PGUID 11 f t t t 2 f 16 "23 23" 100 0 0 100 int4le - )); +DATA(insert OID = 149 ( int4le PGUID 12 f t t t 2 f 16 "23 23" 100 0 0 100 int4le - )); DESCR("less-than-or-equal"); -DATA(insert OID = 150 ( int4ge PGUID 11 f t t t 2 f 16 "23 23" 100 0 0 100 int4ge - )); +DATA(insert OID = 150 ( int4ge PGUID 12 f t t t 2 f 16 "23 23" 100 0 0 100 int4ge - )); DESCR("greater-than-or-equal"); -DATA(insert OID = 151 ( int2ge PGUID 11 f t t t 2 f 16 "21 21" 100 0 0 100 int2ge - )); +DATA(insert OID = 151 ( int2ge PGUID 12 f t t t 2 f 16 "21 21" 100 0 0 100 int2ge - )); DESCR("greater-than-or-equal"); -DATA(insert OID = 152 ( int2mul PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100 int2mul - )); +DATA(insert OID = 152 ( int2mul PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100 int2mul - )); DESCR("multiply"); -DATA(insert OID = 153 ( int2div PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100 int2div - )); +DATA(insert OID = 153 ( int2div PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100 int2div - )); DESCR("divide"); -DATA(insert OID = 154 ( int4div PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100 int4div - )); +DATA(insert OID = 154 ( int4div PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100 int4div - )); DESCR("divide"); -DATA(insert OID = 155 ( int2mod PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100 int2mod - )); +DATA(insert OID = 155 ( int2mod PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100 int2mod - )); DESCR("modulus"); -DATA(insert OID = 156 ( int4mod PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100 int4mod - )); +DATA(insert OID = 156 ( int4mod PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100 int4mod - )); DESCR("modulus"); DATA(insert OID = 157 ( textne PGUID 11 f t t t 2 f 16 "25 25" 100 0 0 0 textne - )); DESCR("not equal"); -DATA(insert OID = 158 ( int24eq PGUID 11 f t t t 2 f 16 "21 23" 100 0 0 100 int24eq - )); +DATA(insert OID = 158 ( int24eq PGUID 12 f t t t 2 f 16 "21 23" 100 0 0 100 int24eq - )); DESCR("equal"); -DATA(insert OID = 159 ( int42eq PGUID 11 f t t t 2 f 16 "23 21" 100 0 0 100 int42eq - )); +DATA(insert OID = 159 ( int42eq PGUID 12 f t t t 2 f 16 "23 21" 100 0 0 100 int42eq - )); DESCR("equal"); -DATA(insert OID = 160 ( int24lt PGUID 11 f t t t 2 f 16 "21 23" 100 0 0 100 int24lt - )); +DATA(insert OID = 160 ( int24lt PGUID 12 f t t t 2 f 16 "21 23" 100 0 0 100 int24lt - )); DESCR("less-than"); -DATA(insert OID = 161 ( int42lt PGUID 11 f t t t 2 f 16 "23 21" 100 0 0 100 int42lt - )); +DATA(insert OID = 161 ( int42lt PGUID 12 f t t t 2 f 16 "23 21" 100 0 0 100 int42lt - )); DESCR("less-than"); -DATA(insert OID = 162 ( int24gt PGUID 11 f t t t 2 f 16 "21 23" 100 0 0 100 int24gt - )); +DATA(insert OID = 162 ( int24gt PGUID 12 f t t t 2 f 16 "21 23" 100 0 0 100 int24gt - )); DESCR("greater-than"); -DATA(insert OID = 163 ( int42gt PGUID 11 f t t t 2 f 16 "23 21" 100 0 0 100 int42gt - )); +DATA(insert OID = 163 ( int42gt PGUID 12 f t t t 2 f 16 "23 21" 100 0 0 100 int42gt - )); DESCR("greater-than"); -DATA(insert OID = 164 ( int24ne PGUID 11 f t t t 2 f 16 "21 23" 100 0 0 100 int24ne - )); +DATA(insert OID = 164 ( int24ne PGUID 12 f t t t 2 f 16 "21 23" 100 0 0 100 int24ne - )); DESCR("not equal"); -DATA(insert OID = 165 ( int42ne PGUID 11 f t t t 2 f 16 "23 21" 100 0 0 100 int42ne - )); +DATA(insert OID = 165 ( int42ne PGUID 12 f t t t 2 f 16 "23 21" 100 0 0 100 int42ne - )); DESCR("not equal"); -DATA(insert OID = 166 ( int24le PGUID 11 f t t t 2 f 16 "21 23" 100 0 0 100 int24le - )); +DATA(insert OID = 166 ( int24le PGUID 12 f t t t 2 f 16 "21 23" 100 0 0 100 int24le - )); DESCR("less-than-or-equal"); -DATA(insert OID = 167 ( int42le PGUID 11 f t t t 2 f 16 "23 21" 100 0 0 100 int42le - )); +DATA(insert OID = 167 ( int42le PGUID 12 f t t t 2 f 16 "23 21" 100 0 0 100 int42le - )); DESCR("less-than-or-equal"); -DATA(insert OID = 168 ( int24ge PGUID 11 f t t t 2 f 16 "21 23" 100 0 0 100 int24ge - )); +DATA(insert OID = 168 ( int24ge PGUID 12 f t t t 2 f 16 "21 23" 100 0 0 100 int24ge - )); DESCR("greater-than-or-equal"); -DATA(insert OID = 169 ( int42ge PGUID 11 f t t t 2 f 16 "23 21" 100 0 0 100 int42ge - )); +DATA(insert OID = 169 ( int42ge PGUID 12 f t t t 2 f 16 "23 21" 100 0 0 100 int42ge - )); DESCR("greater-than-or-equal"); -DATA(insert OID = 170 ( int24mul PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100 int24mul - )); +DATA(insert OID = 170 ( int24mul PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100 int24mul - )); DESCR("multiply"); -DATA(insert OID = 171 ( int42mul PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100 int42mul - )); +DATA(insert OID = 171 ( int42mul PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100 int42mul - )); DESCR("multiply"); -DATA(insert OID = 172 ( int24div PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100 int24div - )); +DATA(insert OID = 172 ( int24div PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100 int24div - )); DESCR("divide"); -DATA(insert OID = 173 ( int42div PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100 int42div - )); +DATA(insert OID = 173 ( int42div PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100 int42div - )); DESCR("divide"); -DATA(insert OID = 174 ( int24mod PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100 int24mod - )); +DATA(insert OID = 174 ( int24mod PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100 int24mod - )); DESCR("modulus"); -DATA(insert OID = 175 ( int42mod PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100 int42mod - )); +DATA(insert OID = 175 ( int42mod PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100 int42mod - )); DESCR("modulus"); -DATA(insert OID = 176 ( int2pl PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100 int2pl - )); +DATA(insert OID = 176 ( int2pl PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100 int2pl - )); DESCR("addition"); -DATA(insert OID = 177 ( int4pl PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100 int4pl - )); +DATA(insert OID = 177 ( int4pl PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100 int4pl - )); DESCR("addition"); -DATA(insert OID = 178 ( int24pl PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100 int24pl - )); +DATA(insert OID = 178 ( int24pl PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100 int24pl - )); DESCR("addition"); -DATA(insert OID = 179 ( int42pl PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100 int42pl - )); +DATA(insert OID = 179 ( int42pl PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100 int42pl - )); DESCR("addition"); -DATA(insert OID = 180 ( int2mi PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100 int2mi - )); +DATA(insert OID = 180 ( int2mi PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100 int2mi - )); DESCR("subtract"); -DATA(insert OID = 181 ( int4mi PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100 int4mi - )); +DATA(insert OID = 181 ( int4mi PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100 int4mi - )); DESCR("subtract"); -DATA(insert OID = 182 ( int24mi PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100 int24mi - )); +DATA(insert OID = 182 ( int24mi PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100 int24mi - )); DESCR("subtract"); -DATA(insert OID = 183 ( int42mi PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100 int42mi - )); +DATA(insert OID = 183 ( int42mi PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100 int42mi - )); DESCR("subtract"); -DATA(insert OID = 184 ( oideq PGUID 11 f t t t 2 f 16 "26 26" 100 0 0 100 oideq - )); +DATA(insert OID = 184 ( oideq PGUID 12 f t t t 2 f 16 "26 26" 100 0 0 100 oideq - )); DESCR("equal"); -DATA(insert OID = 185 ( oidne PGUID 11 f t t t 2 f 16 "26 26" 100 0 0 100 oidne - )); +DATA(insert OID = 185 ( oidne PGUID 12 f t t t 2 f 16 "26 26" 100 0 0 100 oidne - )); DESCR("not equal"); DATA(insert OID = 186 ( box_same PGUID 11 f t t t 2 f 16 "603 603" 100 0 0 100 box_same - )); DESCR("same as"); @@ -440,9 +440,9 @@ DESCR("larger of two"); DATA(insert OID = 211 ( float4smaller PGUID 11 f t t t 2 f 700 "700 700" 100 0 0 100 float4smaller - )); DESCR("smaller of two"); -DATA(insert OID = 212 ( int4um PGUID 11 f t t t 1 f 23 "23" 100 0 0 100 int4um - )); +DATA(insert OID = 212 ( int4um PGUID 12 f t t t 1 f 23 "23" 100 0 0 100 int4um - )); DESCR("negate"); -DATA(insert OID = 213 ( int2um PGUID 11 f t t t 1 f 21 "21" 100 0 0 100 int2um - )); +DATA(insert OID = 213 ( int2um PGUID 12 f t t t 1 f 21 "21" 100 0 0 100 int2um - )); DESCR("negate"); DATA(insert OID = 214 ( float8in PGUID 11 f t t t 1 f 701 "0" 100 0 0 100 float8in - )); @@ -489,13 +489,13 @@ DATA(insert OID = 233 ( dexp PGUID 11 f t t t 1 f 701 "701" 100 0 0 100 d DESCR("natural exponential (e^x)"); DATA(insert OID = 234 ( dlog1 PGUID 11 f t t t 1 f 701 "701" 100 0 0 100 dlog1 - )); DESCR("natural logarithm"); -DATA(insert OID = 235 ( float8 PGUID 11 f t t t 1 f 701 "21" 100 0 0 100 i2tod - )); +DATA(insert OID = 235 ( float8 PGUID 12 f t t t 1 f 701 "21" 100 0 0 100 i2tod - )); DESCR("convert int2 to float8"); -DATA(insert OID = 236 ( float4 PGUID 11 f t t t 1 f 700 "21" 100 0 0 100 i2tof - )); +DATA(insert OID = 236 ( float4 PGUID 12 f t t t 1 f 700 "21" 100 0 0 100 i2tof - )); DESCR("convert int2 to float4"); -DATA(insert OID = 237 ( int2 PGUID 11 f t t t 1 f 21 "701" 100 0 0 100 dtoi2 - )); +DATA(insert OID = 237 ( int2 PGUID 12 f t t t 1 f 21 "701" 100 0 0 100 dtoi2 - )); DESCR("convert float8 to int2"); -DATA(insert OID = 238 ( int2 PGUID 11 f t t t 1 f 21 "700" 100 0 0 100 ftoi2 - )); +DATA(insert OID = 238 ( int2 PGUID 12 f t t t 1 f 21 "700" 100 0 0 100 ftoi2 - )); DESCR("convert float4 to int2"); DATA(insert OID = 239 ( line_distance PGUID 11 f t t t 2 f 701 "628 628" 100 0 0 100 line_distance - )); DESCR("distance between"); @@ -573,7 +573,7 @@ DESCR("Current date and time with microseconds"); DATA(insert OID = 275 ( isfinite PGUID 11 f t f t 1 f 16 "702" 100 0 0 100 abstime_finite - )); DESCR(""); -DATA(insert OID = 276 ( int2fac PGUID 11 f t t t 1 f 23 "21" 100 0 0 100 int2fac - )); +DATA(insert OID = 276 ( int2fac PGUID 12 f t t t 1 f 23 "21" 100 0 0 100 int2fac - )); DESCR(""); DATA(insert OID = 277 ( inter_sl PGUID 11 f t t t 2 f 16 "601 628" 100 0 0 100 inter_sl - )); @@ -656,11 +656,11 @@ DATA(insert OID = 311 ( float8 PGUID 11 f t t t 1 f 701 "700" 100 0 0 100 DESCR("convert float4 to float8"); DATA(insert OID = 312 ( float4 PGUID 11 f t t t 1 f 700 "701" 100 0 0 100 dtof - )); DESCR("convert float8 to float4"); -DATA(insert OID = 313 ( int4 PGUID 11 f t t t 1 f 23 "21" 100 0 0 100 i2toi4 - )); +DATA(insert OID = 313 ( int4 PGUID 12 f t t t 1 f 23 "21" 100 0 0 100 i2toi4 - )); DESCR("convert int2 to int4"); -DATA(insert OID = 314 ( int2 PGUID 11 f t t t 1 f 21 "23" 100 0 0 100 i4toi2 - )); +DATA(insert OID = 314 ( int2 PGUID 12 f t t t 1 f 21 "23" 100 0 0 100 i4toi2 - )); DESCR("convert int4 to int2"); -DATA(insert OID = 315 ( int2vectoreq PGUID 11 f t t t 2 f 16 "22 22" 100 0 0 100 int2vectoreq - )); +DATA(insert OID = 315 ( int2vectoreq PGUID 12 f t t t 2 f 16 "22 22" 100 0 0 100 int2vectoreq - )); DESCR("equal"); DATA(insert OID = 316 ( float8 PGUID 11 f t t t 1 f 701 "23" 100 0 0 100 i4tod - )); DESCR("convert int4 to float8"); @@ -730,31 +730,31 @@ DESCR("(internal)"); DATA(insert OID = 348 ( poly_out PGUID 11 f t t t 1 f 23 "0" 100 0 1 0 poly_out - )); DESCR("(internal)"); -DATA(insert OID = 350 ( btint2cmp PGUID 11 f t t t 2 f 23 "21 21" 100 0 0 100 btint2cmp - )); +DATA(insert OID = 350 ( btint2cmp PGUID 12 f t t t 2 f 23 "21 21" 100 0 0 100 btint2cmp - )); DESCR("btree less-equal-greater"); -DATA(insert OID = 351 ( btint4cmp PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100 btint4cmp - )); +DATA(insert OID = 351 ( btint4cmp PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100 btint4cmp - )); DESCR("btree less-equal-greater"); -DATA(insert OID = 842 ( btint8cmp PGUID 11 f t t t 2 f 23 "20 20" 100 0 0 100 btint8cmp - )); +DATA(insert OID = 842 ( btint8cmp PGUID 12 f t t t 2 f 23 "20 20" 100 0 0 100 btint8cmp - )); DESCR("btree less-equal-greater"); -DATA(insert OID = 352 ( btint42cmp PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100 btint42cmp - )); +DATA(insert OID = 352 ( btint42cmp PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100 btint42cmp - )); DESCR("btree less-equal-greater"); -DATA(insert OID = 353 ( btint24cmp PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100 btint24cmp - )); +DATA(insert OID = 353 ( btint24cmp PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100 btint24cmp - )); DESCR("btree less-equal-greater"); -DATA(insert OID = 354 ( btfloat4cmp PGUID 11 f t t t 2 f 23 "700 700" 100 0 0 100 btfloat4cmp - )); +DATA(insert OID = 354 ( btfloat4cmp PGUID 12 f t t t 2 f 23 "700 700" 100 0 0 100 btfloat4cmp - )); DESCR("btree less-equal-greater"); -DATA(insert OID = 355 ( btfloat8cmp PGUID 11 f t t t 2 f 23 "701 701" 100 0 0 100 btfloat8cmp - )); +DATA(insert OID = 355 ( btfloat8cmp PGUID 12 f t t t 2 f 23 "701 701" 100 0 0 100 btfloat8cmp - )); DESCR("btree less-equal-greater"); -DATA(insert OID = 356 ( btoidcmp PGUID 11 f t t t 2 f 23 "26 26" 100 0 0 100 btoidcmp - )); +DATA(insert OID = 356 ( btoidcmp PGUID 12 f t t t 2 f 23 "26 26" 100 0 0 100 btoidcmp - )); DESCR("btree less-equal-greater"); -DATA(insert OID = 404 ( btoidvectorcmp PGUID 11 f t t t 2 f 23 "30 30" 100 0 0 100 btoidvectorcmp - )); +DATA(insert OID = 404 ( btoidvectorcmp PGUID 12 f t t t 2 f 23 "30 30" 100 0 0 100 btoidvectorcmp - )); DESCR("btree less-equal-greater"); DATA(insert OID = 357 ( btabstimecmp PGUID 11 f t f t 2 f 23 "702 702" 100 0 0 100 btabstimecmp - )); DESCR("btree less-equal-greater"); -DATA(insert OID = 358 ( btcharcmp PGUID 11 f t t t 2 f 23 "18 18" 100 0 0 100 btcharcmp - )); +DATA(insert OID = 358 ( btcharcmp PGUID 12 f t t t 2 f 23 "18 18" 100 0 0 100 btcharcmp - )); DESCR("btree less-equal-greater"); -DATA(insert OID = 359 ( btnamecmp PGUID 11 f t t t 2 f 23 "19 19" 100 0 0 100 btnamecmp - )); +DATA(insert OID = 359 ( btnamecmp PGUID 12 f t t t 2 f 23 "19 19" 100 0 0 100 btnamecmp - )); DESCR("btree less-equal-greater"); -DATA(insert OID = 360 ( bttextcmp PGUID 11 f t t t 2 f 23 "25 25" 100 0 0 100 bttextcmp - )); +DATA(insert OID = 360 ( bttextcmp PGUID 12 f t t t 2 f 23 "25 25" 100 0 0 100 bttextcmp - )); DESCR("btree less-equal-greater"); DATA(insert OID = 361 ( lseg_distance PGUID 11 f t t t 2 f 701 "601 601" 100 0 0 100 lseg_distance - )); @@ -795,7 +795,7 @@ DESCR("convert name to char()"); DATA(insert OID = 409 ( name PGUID 11 f t t t 1 f 19 "1042" 100 0 0 100 bpchar_name - )); DESCR("convert char() to name"); -DATA(insert OID = 438 ( hashcostestimate PGUID 11 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100 hashcostestimate - )); +DATA(insert OID = 438 ( hashcostestimate PGUID 12 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100 hashcostestimate - )); DESCR("hash index cost estimator"); DATA(insert OID = 440 ( hashgettuple PGUID 11 f t f t 2 f 23 "0" 100 0 0 100 hashgettuple - )); @@ -816,25 +816,25 @@ DATA(insert OID = 447 ( hashrestrpos PGUID 11 f t f t 1 f 23 "0" 100 0 0 100 DESCR("hash(internal)"); DATA(insert OID = 448 ( hashbuild PGUID 11 f t f t 9 f 23 "0" 100 0 0 100 hashbuild - )); DESCR("hash(internal)"); -DATA(insert OID = 449 ( hashint2 PGUID 11 f t t t 1 f 23 "21" 100 0 0 100 hashint2 - )); +DATA(insert OID = 449 ( hashint2 PGUID 12 f t t t 1 f 23 "21" 100 0 0 100 hashint2 - )); DESCR("hash"); -DATA(insert OID = 450 ( hashint4 PGUID 11 f t t t 1 f 23 "23" 100 0 0 100 hashint4 - )); +DATA(insert OID = 450 ( hashint4 PGUID 12 f t t t 1 f 23 "23" 100 0 0 100 hashint4 - )); DESCR("hash"); -DATA(insert OID = 949 ( hashint8 PGUID 11 f t t t 1 f 23 "20" 100 0 0 100 hashint8 - )); +DATA(insert OID = 949 ( hashint8 PGUID 12 f t t t 1 f 23 "20" 100 0 0 100 hashint8 - )); DESCR("hash"); -DATA(insert OID = 451 ( hashfloat4 PGUID 11 f t t t 1 f 23 "700" 100 0 0 100 hashfloat4 - )); +DATA(insert OID = 451 ( hashfloat4 PGUID 12 f t t t 1 f 23 "700" 100 0 0 100 hashfloat4 - )); DESCR("hash"); -DATA(insert OID = 452 ( hashfloat8 PGUID 11 f t t t 1 f 23 "701" 100 0 0 100 hashfloat8 - )); +DATA(insert OID = 452 ( hashfloat8 PGUID 12 f t t t 1 f 23 "701" 100 0 0 100 hashfloat8 - )); DESCR("hash"); -DATA(insert OID = 453 ( hashoid PGUID 11 f t t t 1 f 23 "26" 100 0 0 100 hashoid - )); +DATA(insert OID = 453 ( hashoid PGUID 12 f t t t 1 f 23 "26" 100 0 0 100 hashoid - )); DESCR("hash"); -DATA(insert OID = 454 ( hashchar PGUID 11 f t t t 1 f 23 "18" 100 0 0 100 hashchar - )); +DATA(insert OID = 454 ( hashchar PGUID 12 f t t t 1 f 23 "18" 100 0 0 100 hashchar - )); DESCR("hash"); -DATA(insert OID = 455 ( hashname PGUID 11 f t t t 1 f 23 "19" 100 0 0 100 hashname - )); +DATA(insert OID = 455 ( hashname PGUID 12 f t t t 1 f 23 "19" 100 0 0 100 hashname - )); DESCR("hash"); -DATA(insert OID = 456 ( hashtext PGUID 11 f t t t 1 f 23 "25" 100 0 0 100 hashtext - )); +DATA(insert OID = 456 ( hashtext PGUID 12 f t t t 1 f 23 "25" 100 0 0 100 hashtext - )); DESCR("hash"); -DATA(insert OID = 457 ( hashoidvector PGUID 11 f t t t 1 f 23 "30" 100 0 0 100 hashoidvector - )); +DATA(insert OID = 457 ( hashoidvector PGUID 12 f t t t 1 f 23 "30" 100 0 0 100 hashoidvector - )); DESCR("hash"); DATA(insert OID = 458 ( text_larger PGUID 11 f t t t 2 f 25 "25 25" 100 0 0 100 text_larger - )); DESCR("larger of two"); @@ -898,9 +898,9 @@ DATA(insert OID = 1285 ( int4notin PGUID 11 f t f t 2 f 16 "23 0" 100 0 0 1 DESCR("not in"); DATA(insert OID = 1286 ( oidnotin PGUID 11 f t f t 2 f 16 "26 0" 100 0 0 100 oidnotin - )); DESCR("not in"); -DATA(insert OID = 1287 ( int44in PGUID 11 f t t t 1 f 22 "0" 100 0 0 100 int44in - )); +DATA(insert OID = 1287 ( int44in PGUID 12 f t t t 1 f 22 "0" 100 0 0 100 int44in - )); DESCR("(internal)"); -DATA(insert OID = 653 ( int44out PGUID 11 f t t t 1 f 23 "0" 100 0 0 100 int44out - )); +DATA(insert OID = 653 ( int44out PGUID 12 f t t t 1 f 23 "0" 100 0 0 100 int44out - )); DESCR("(internal)"); DATA(insert OID = 655 ( namelt PGUID 11 f t t t 2 f 16 "19 19" 100 0 0 100 namelt - )); DESCR("less-than"); @@ -920,31 +920,31 @@ DESCR("truncate varchar()"); DATA(insert OID = 676 ( mktinterval PGUID 11 f t f t 2 f 704 "702 702" 100 0 0 100 mktinterval - )); DESCR("convert to tinterval"); -DATA(insert OID = 619 ( oidvectorne PGUID 11 f t t t 2 f 16 "30 30" 100 0 0 100 oidvectorne - )); +DATA(insert OID = 619 ( oidvectorne PGUID 12 f t t t 2 f 16 "30 30" 100 0 0 100 oidvectorne - )); DESCR("less-than"); -DATA(insert OID = 677 ( oidvectorlt PGUID 11 f t t t 2 f 16 "30 30" 100 0 0 100 oidvectorlt - )); +DATA(insert OID = 677 ( oidvectorlt PGUID 12 f t t t 2 f 16 "30 30" 100 0 0 100 oidvectorlt - )); DESCR("less-than"); -DATA(insert OID = 678 ( oidvectorle PGUID 11 f t t t 2 f 16 "30 30" 100 0 0 100 oidvectorle - )); +DATA(insert OID = 678 ( oidvectorle PGUID 12 f t t t 2 f 16 "30 30" 100 0 0 100 oidvectorle - )); DESCR("less-than-or-equal"); -DATA(insert OID = 679 ( oidvectoreq PGUID 11 f t t t 2 f 16 "30 30" 100 0 0 100 oidvectoreq - )); +DATA(insert OID = 679 ( oidvectoreq PGUID 12 f t t t 2 f 16 "30 30" 100 0 0 100 oidvectoreq - )); DESCR("equal"); -DATA(insert OID = 680 ( oidvectorge PGUID 11 f t t t 2 f 16 "30 30" 100 0 0 100 oidvectorge - )); +DATA(insert OID = 680 ( oidvectorge PGUID 12 f t t t 2 f 16 "30 30" 100 0 0 100 oidvectorge - )); DESCR("greater-than-or-equal"); -DATA(insert OID = 681 ( oidvectorgt PGUID 11 f t t t 2 f 16 "30 30" 100 0 0 100 oidvectorgt - )); +DATA(insert OID = 681 ( oidvectorgt PGUID 12 f t t t 2 f 16 "30 30" 100 0 0 100 oidvectorgt - )); DESCR("greater-than"); /* OIDS 700 - 799 */ DATA(insert OID = 710 ( getpgusername PGUID 11 f t f t 0 f 19 "0" 100 0 0 100 getpgusername - )); DESCR("Return username"); -DATA(insert OID = 711 ( userfntest PGUID 11 f t t t 1 f 23 "23" 100 0 0 100 userfntest - )); +DATA(insert OID = 711 ( userfntest PGUID 12 f t t t 1 f 23 "23" 100 0 0 100 userfntest - )); DESCR(""); -DATA(insert OID = 713 ( oidrand PGUID 11 f t f t 2 f 16 "26 23" 100 0 0 100 oidrand - )); +DATA(insert OID = 713 ( oidrand PGUID 12 f t f t 2 f 16 "26 23" 100 0 0 100 oidrand - )); DESCR("random"); -DATA(insert OID = 715 ( oidsrand PGUID 11 f t f t 1 f 16 "23" 100 0 0 100 oidsrand - )); +DATA(insert OID = 715 ( oidsrand PGUID 12 f t f t 1 f 16 "23" 100 0 0 100 oidsrand - )); DESCR("seed random number generator"); -DATA(insert OID = 716 ( oideqint4 PGUID 11 f t t t 2 f 16 "26 23" 100 0 0 100 oideqint4 - )); +DATA(insert OID = 716 ( oideqint4 PGUID 12 f t t t 2 f 16 "26 23" 100 0 0 100 oideqint4 - )); DESCR("equal"); -DATA(insert OID = 717 ( int4eqoid PGUID 11 f t t t 2 f 16 "23 26" 100 0 0 100 int4eqoid - )); +DATA(insert OID = 717 ( int4eqoid PGUID 12 f t t t 2 f 16 "23 26" 100 0 0 100 int4eqoid - )); DESCR("equal"); DATA(insert OID = 720 ( octet_length PGUID 11 f t t t 1 f 23 "17" 100 0 0 100 byteaoctetlen - )); @@ -1000,16 +1000,16 @@ DESCR("array"); DATA(insert OID = 752 ( filename_in PGUID 11 f t t t 1 f 605 "0" 100 0 0 100 filename_in - )); DESCR("(internal)"); -DATA(insert OID = 753 ( filename_out PGUID 11 f t t t 2 f 19 "0 0" 100 0 0 100 filename_out - )); +DATA(insert OID = 753 ( filename_out PGUID 11 f t t t 2 f 23 "0 0" 100 0 0 100 filename_out - )); DESCR("(internal)"); -DATA(insert OID = 760 ( smgrin PGUID 11 f t f t 1 f 210 "0" 100 0 0 100 smgrin - )); +DATA(insert OID = 760 ( smgrin PGUID 12 f t f t 1 f 210 "0" 100 0 0 100 smgrin - )); DESCR("storage manager(internal)"); -DATA(insert OID = 761 ( smgrout PGUID 11 f t f t 1 f 23 "0" 100 0 0 100 smgrout - )); +DATA(insert OID = 761 ( smgrout PGUID 12 f t f t 1 f 23 "0" 100 0 0 100 smgrout - )); DESCR("storage manager(internal)"); -DATA(insert OID = 762 ( smgreq PGUID 11 f t f t 2 f 16 "210 210" 100 0 0 100 smgreq - )); +DATA(insert OID = 762 ( smgreq PGUID 12 f t f t 2 f 16 "210 210" 100 0 0 100 smgreq - )); DESCR("storage manager"); -DATA(insert OID = 763 ( smgrne PGUID 11 f t f t 2 f 16 "210 210" 100 0 0 100 smgrne - )); +DATA(insert OID = 763 ( smgrne PGUID 12 f t f t 2 f 16 "210 210" 100 0 0 100 smgrne - )); DESCR("storage manager"); DATA(insert OID = 764 ( lo_import PGUID 11 f t f t 1 f 26 "25" 100 0 0 100 lo_import - )); @@ -1017,20 +1017,20 @@ DESCR("large object import"); DATA(insert OID = 765 ( lo_export PGUID 11 f t f t 2 f 23 "26 25" 100 0 0 100 lo_export - )); DESCR("large object export"); -DATA(insert OID = 766 ( int4inc PGUID 11 f t t t 1 f 23 "23" 100 0 0 100 int4inc - )); +DATA(insert OID = 766 ( int4inc PGUID 12 f t t t 1 f 23 "23" 100 0 0 100 int4inc - )); DESCR("increment"); -DATA(insert OID = 767 ( int2inc PGUID 11 f t t t 1 f 21 "21" 100 0 0 100 int2inc - )); +DATA(insert OID = 767 ( int2inc PGUID 12 f t t t 1 f 21 "21" 100 0 0 100 int2inc - )); DESCR("increment"); -DATA(insert OID = 768 ( int4larger PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100 int4larger - )); +DATA(insert OID = 768 ( int4larger PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100 int4larger - )); DESCR("larger of two"); -DATA(insert OID = 769 ( int4smaller PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100 int4smaller - )); +DATA(insert OID = 769 ( int4smaller PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100 int4smaller - )); DESCR("smaller of two"); -DATA(insert OID = 770 ( int2larger PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100 int2larger - )); +DATA(insert OID = 770 ( int2larger PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100 int2larger - )); DESCR("larger of two"); -DATA(insert OID = 771 ( int2smaller PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100 int2smaller - )); +DATA(insert OID = 771 ( int2smaller PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100 int2smaller - )); DESCR("smaller of two"); -DATA(insert OID = 772 ( gistcostestimate PGUID 11 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100 gistcostestimate - )); +DATA(insert OID = 772 ( gistcostestimate PGUID 12 f t f t 7 f 0 "0 0 0 0 0 0 0" 100 0 0 100 gistcostestimate - )); DESCR("gist cost estimator"); DATA(insert OID = 774 ( gistgettuple PGUID 11 f t f t 2 f 23 "0" 100 0 0 100 gistgettuple - )); DESCR("gist(internal)"); @@ -1066,11 +1066,11 @@ DESCR("greater-than-or-equal"); /* OIDS 800 - 899 */ -DATA(insert OID = 817 ( oid PGUID 11 f t t t 1 f 26 "25" 100 0 0 100 text_oid -)); +DATA(insert OID = 817 ( oid PGUID 12 f t t t 1 f 26 "25" 100 0 0 100 text_oid -)); DESCR("convert text to oid"); -DATA(insert OID = 818 ( int2 PGUID 11 f t t t 1 f 21 "25" 100 0 0 100 text_int2 -)); +DATA(insert OID = 818 ( int2 PGUID 12 f t t t 1 f 21 "25" 100 0 0 100 text_int2 -)); DESCR("convert text to int2"); -DATA(insert OID = 819 ( int4 PGUID 11 f t t t 1 f 23 "25" 100 0 0 100 text_int4 -)); +DATA(insert OID = 819 ( int4 PGUID 12 f t t t 1 f 23 "25" 100 0 0 100 text_int4 -)); DESCR("convert text to int4"); DATA(insert OID = 838 ( float8 PGUID 11 f t t t 1 f 701 "25" 100 0 0 100 text_float8 -)); @@ -1114,22 +1114,22 @@ DESCR("matches LIKE expression"); DATA(insert OID = 859 ( namenlike PGUID 11 f t t t 2 f 16 "19 25" 100 0 0 100 namenlike - )); DESCR("does not match LIKE expression"); -DATA(insert OID = 860 ( bpchar PGUID 11 f t t t 1 f 1042 "18" 100 0 0 100 char_bpchar - )); +DATA(insert OID = 860 ( bpchar PGUID 12 f t t t 1 f 1042 "18" 100 0 0 100 char_bpchar - )); DESCR("convert char to char()"); -DATA(insert OID = 861 ( char PGUID 11 f t t t 1 f 18 "1042" 100 0 0 100 bpchar_char - )); +DATA(insert OID = 861 ( char PGUID 12 f t t t 1 f 18 "1042" 100 0 0 100 bpchar_char - )); DESCR("convert char() to char"); DATA(insert OID = 862 ( int4_mul_cash PGUID 11 f t t t 2 f 790 "23 790" 100 0 0 100 int4_mul_cash - )); DESCR("multiply"); -DATA(insert OID = 863 ( int2_mul_cash PGUID 11 f t t t 2 f 790 "21 790" 100 0 0 100 int2_mul_cash - )); +DATA(insert OID = 863 ( int2_mul_cash PGUID 12 f t t t 2 f 790 "21 790" 100 0 0 100 int2_mul_cash - )); DESCR("multiply"); DATA(insert OID = 864 ( cash_mul_int4 PGUID 11 f t t t 2 f 790 "790 23" 100 0 0 100 cash_mul_int4 - )); DESCR("multiply"); DATA(insert OID = 865 ( cash_div_int4 PGUID 11 f t t t 2 f 790 "790 23" 100 0 0 100 cash_div_int4 - )); DESCR("divide"); -DATA(insert OID = 866 ( cash_mul_int2 PGUID 11 f t t t 2 f 790 "790 21" 100 0 0 100 cash_mul_int2 - )); +DATA(insert OID = 866 ( cash_mul_int2 PGUID 12 f t t t 2 f 790 "790 21" 100 0 0 100 cash_mul_int2 - )); DESCR("multiply"); -DATA(insert OID = 867 ( cash_div_int2 PGUID 11 f t t t 2 f 790 "790 21" 100 0 0 100 cash_div_int2 - )); +DATA(insert OID = 867 ( cash_div_int2 PGUID 12 f t t t 2 f 790 "790 21" 100 0 0 100 cash_div_int2 - )); DESCR("divide"); DATA(insert OID = 886 ( cash_in PGUID 11 f t t t 1 f 790 "0" 100 0 0 100 cash_in - )); @@ -1178,13 +1178,13 @@ DESCR(""); DATA(insert OID = 939 ( revertpoly PGUID 11 f t f t 1 f 604 "604" 100 0 0 100 revertpoly - )); DESCR(""); -DATA(insert OID = 940 ( mod PGUID 11 f t t t 2 f 21 "21 21" 100 0 0 100 int2mod - )); +DATA(insert OID = 940 ( mod PGUID 12 f t t t 2 f 21 "21 21" 100 0 0 100 int2mod - )); DESCR("modulus"); -DATA(insert OID = 941 ( mod PGUID 11 f t t t 2 f 23 "23 23" 100 0 0 100 int4mod - )); +DATA(insert OID = 941 ( mod PGUID 12 f t t t 2 f 23 "23 23" 100 0 0 100 int4mod - )); DESCR("modulus"); -DATA(insert OID = 942 ( mod PGUID 11 f t t t 2 f 23 "21 23" 100 0 0 100 int24mod - )); +DATA(insert OID = 942 ( mod PGUID 12 f t t t 2 f 23 "21 23" 100 0 0 100 int24mod - )); DESCR("modulus"); -DATA(insert OID = 943 ( mod PGUID 11 f t t t 2 f 23 "23 21" 100 0 0 100 int42mod - )); +DATA(insert OID = 943 ( mod PGUID 12 f t t t 2 f 23 "23 21" 100 0 0 100 int42mod - )); DESCR("modulus"); DATA(insert OID = 945 ( int8mod PGUID 11 f t t t 2 f 20 "20 20" 100 0 0 100 int8mod - )); @@ -1192,17 +1192,17 @@ DESCR("modulus"); DATA(insert OID = 947 ( mod PGUID 11 f t t t 2 f 20 "20 20" 100 0 0 100 int8mod - )); DESCR("modulus"); -DATA(insert OID = 944 ( char PGUID 11 f t t t 1 f 18 "25" 100 0 0 100 text_char - )); +DATA(insert OID = 944 ( char PGUID 12 f t t t 1 f 18 "25" 100 0 0 100 text_char - )); DESCR("convert text to char"); -DATA(insert OID = 946 ( text PGUID 11 f t t t 1 f 25 "18" 100 0 0 100 char_text - )); +DATA(insert OID = 946 ( text PGUID 12 f t t t 1 f 25 "18" 100 0 0 100 char_text - )); DESCR("convert char to text"); -DATA(insert OID = 948 ( varchar PGUID 11 f t t t 1 f 25 "1043" 100 0 0 100 bpchar_char - )); +DATA(insert OID = 948 ( varchar PGUID 12 f t t t 1 f 25 "1043" 100 0 0 100 bpchar_char - )); DESCR("convert varchar() to text"); -DATA(insert OID = 950 ( istrue PGUID 11 f t t t 1 f 16 "16" 100 0 0 100 istrue - )); -DESCR(""); -DATA(insert OID = 951 ( isfalse PGUID 11 f t t t 1 f 16 "16" 100 0 0 100 isfalse - )); -DESCR(""); +DATA(insert OID = 950 ( istrue PGUID 12 f t t f 1 f 16 "16" 100 0 0 100 istrue - )); +DESCR("bool is true (not false or unknown)"); +DATA(insert OID = 951 ( isfalse PGUID 12 f t t f 1 f 16 "16" 100 0 0 100 isfalse - )); +DESCR("bool is false (not true or unknown)"); DATA(insert OID = 952 ( lo_open PGUID 11 f t f t 2 f 23 "26 23" 100 0 0 100 lo_open - )); DESCR("large object open"); @@ -1232,7 +1232,7 @@ DESCR("closest point to line on box"); DATA(insert OID = 964 ( lo_unlink PGUID 11 f t f t 1 f 23 "26" 100 0 0 100 lo_unlink - )); DESCR("large object unlink(delete)"); -DATA(insert OID = 972 ( regproctooid PGUID 11 f t t t 1 f 26 "24" 100 0 0 100 regproctooid - )); +DATA(insert OID = 972 ( regproctooid PGUID 12 f t t t 1 f 26 "24" 100 0 0 100 regproctooid - )); DESCR("get oid for regproc"); DATA(insert OID = 973 ( path_inter PGUID 11 f t t t 2 f 16 "602 602" 100 0 10 100 path_inter - )); @@ -1288,9 +1288,9 @@ DESCR("equal"); /* OIDS 1000 - 1999 */ -DATA(insert OID = 1029 ( nullvalue PGUID 11 f t t f 1 f 16 "0" 100 0 0 100 nullvalue - )); +DATA(insert OID = 1029 ( nullvalue PGUID 12 f t t f 1 f 16 "0" 100 0 0 100 nullvalue - )); DESCR("(internal)"); -DATA(insert OID = 1030 ( nonnullvalue PGUID 11 f t t f 1 f 16 "0" 100 0 0 100 nonnullvalue - )); +DATA(insert OID = 1030 ( nonnullvalue PGUID 12 f t t f 1 f 16 "0" 100 0 0 100 nonnullvalue - )); DESCR("(internal)"); DATA(insert OID = 1031 ( aclitemin PGUID 11 f t f t 1 f 1033 "0" 100 0 0 100 aclitemin - )); DESCR("(internal)"); @@ -1517,9 +1517,9 @@ DESCR("matches regex., case-insensitive"); DATA(insert OID = 1241 ( nameicregexne PGUID 11 f t t t 2 f 16 "19 25" 100 0 0 100 nameicregexne - )); DESCR("does not match regex., case-insensitive"); -DATA(insert OID = 1251 ( int4abs PGUID 11 f t t t 1 f 23 "23" 100 0 0 100 int4abs - )); +DATA(insert OID = 1251 ( int4abs PGUID 12 f t t t 1 f 23 "23" 100 0 0 100 int4abs - )); DESCR("absolute value"); -DATA(insert OID = 1253 ( int2abs PGUID 11 f t t t 1 f 21 "21" 100 0 0 100 int2abs - )); +DATA(insert OID = 1253 ( int2abs PGUID 12 f t t t 1 f 21 "21" 100 0 0 100 int2abs - )); DESCR("absolute value"); DATA(insert OID = 1263 ( interval PGUID 11 f t f t 1 f 1186 "25" 100 0 0 100 text_interval - )); @@ -1575,13 +1575,13 @@ DESCR("current transaction time"); /* OIDS 1300 - 1399 */ -DATA(insert OID = 1300 ( positionsel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 positionsel - )); +DATA(insert OID = 1300 ( positionsel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 positionsel - )); DESCR("restriction selectivity for position-comparison operators"); -DATA(insert OID = 1301 ( positionjoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 positionjoinsel - )); +DATA(insert OID = 1301 ( positionjoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 positionjoinsel - )); DESCR("join selectivity for position-comparison operators"); -DATA(insert OID = 1302 ( contsel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 contsel - )); +DATA(insert OID = 1302 ( contsel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 contsel - )); DESCR("restriction selectivity for containment comparison operators"); -DATA(insert OID = 1303 ( contjoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 contjoinsel - )); +DATA(insert OID = 1303 ( contjoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 contjoinsel - )); DESCR("join selectivity for containment comparison operators"); DATA(insert OID = 1304 ( overlaps PGUID 11 f t t t 4 f 16 "1184 1184 1184 1184" 100 0 1 0 overlaps_timestamp - )); @@ -1640,7 +1640,7 @@ DESCR("exponential"); DATA(insert OID = 1348 ( obj_description PGUID 14 f t f t 1 f 25 "26" 100 0 0 100 "select description from pg_description where objoid = $1" - )); DESCR("get description for object id"); -DATA(insert OID = 1349 ( oidvectortypes PGUID 11 f t f t 1 f 25 "30" 100 0 0 100 oidvectortypes - )); +DATA(insert OID = 1349 ( oidvectortypes PGUID 12 f t f t 1 f 25 "30" 100 0 0 100 oidvectortypes - )); DESCR("print type names of oidvector field"); @@ -1727,9 +1727,9 @@ DATA(insert OID = 1390 ( isfinite PGUID 11 f t f t 1 f 16 "1186" 100 0 0 100 DESCR("boolean test"); -DATA(insert OID = 1391 ( factorial PGUID 11 f t t t 1 f 23 "21" 100 0 0 100 int2fac - )); +DATA(insert OID = 1391 ( factorial PGUID 12 f t t t 1 f 23 "21" 100 0 0 100 int2fac - )); DESCR("factorial"); -DATA(insert OID = 1392 ( factorial PGUID 11 f t t t 1 f 23 "23" 100 0 0 100 int4fac - )); +DATA(insert OID = 1392 ( factorial PGUID 12 f t t t 1 f 23 "23" 100 0 0 100 int4fac - )); DESCR("factorial"); DATA(insert OID = 1393 ( factorial PGUID 11 f t t t 1 f 20 "20" 100 0 0 100 int8fac - )); DESCR("factorial"); @@ -1739,9 +1739,9 @@ DATA(insert OID = 1395 ( abs PGUID 11 f t t t 1 f 701 "701" 100 0 0 100 f DESCR("absolute value"); DATA(insert OID = 1396 ( abs PGUID 11 f t t t 1 f 20 "20" 100 0 0 100 int8abs - )); DESCR("absolute value"); -DATA(insert OID = 1397 ( abs PGUID 11 f t t t 1 f 23 "23" 100 0 0 100 int4abs - )); +DATA(insert OID = 1397 ( abs PGUID 12 f t t t 1 f 23 "23" 100 0 0 100 int4abs - )); DESCR("absolute value"); -DATA(insert OID = 1398 ( abs PGUID 11 f t t t 1 f 21 "21" 100 0 0 100 int2abs - )); +DATA(insert OID = 1398 ( abs PGUID 12 f t t t 1 f 21 "21" 100 0 0 100 int2abs - )); DESCR("absolute value"); /* OIDS 1400 - 1499 */ @@ -1783,6 +1783,11 @@ DESCR("lines horizontal?"); DATA(insert OID = 1416 ( point PGUID 11 f t t t 1 f 600 "718" 100 0 1 0 circle_center - )); DESCR("center of"); +DATA(insert OID = 1417 ( isnottrue PGUID 12 f t t f 1 f 16 "16" 100 0 0 100 isnottrue - )); +DESCR("bool is not true (ie, false or unknown)"); +DATA(insert OID = 1418 ( isnotfalse PGUID 12 f t t f 1 f 16 "16" 100 0 0 100 isnotfalse - )); +DESCR("bool is not false (ie, true or unknown)"); + DATA(insert OID = 1421 ( box PGUID 11 f t t t 2 f 603 "600 600" 100 0 0 100 box - )); DESCR("convert points to box"); DATA(insert OID = 1422 ( box_add PGUID 11 f t t t 2 f 603 "603 600" 100 0 0 100 box_add - )); @@ -2057,7 +2062,7 @@ DESCR("PI"); DATA(insert OID = 1618 ( interval_mul PGUID 11 f t t t 2 f 1186 "1186 701" 100 0 0 100 interval_mul - )); DESCR("multiply interval"); -DATA(insert OID = 1619 ( varchar PGUID 11 f t t t 1 f 1043 "23" 100 0 0 100 int4_text - )); +DATA(insert OID = 1619 ( varchar PGUID 12 f t t t 1 f 1043 "23" 100 0 0 100 int4_text - )); DESCR("convert int4 to varchar"); DATA(insert OID = 1620 ( ascii PGUID 11 f t t t 1 f 23 "25" 100 0 0 100 ascii - )); @@ -2308,11 +2313,11 @@ DESCR("host address"); DATA(insert OID = 683 ( network PGUID 11 f t t t 1 f 25 "869" 100 0 0 100 network_network - )); DESCR("network address"); -DATA(insert OID = 1691 ( boolle PGUID 11 f t t t 2 f 16 "16 16" 100 0 0 100 boolle - )); +DATA(insert OID = 1691 ( boolle PGUID 12 f t t t 2 f 16 "16 16" 100 0 0 100 boolle - )); DESCR("less-than-or-equal"); -DATA(insert OID = 1692 ( boolge PGUID 11 f t t t 2 f 16 "16 16" 100 0 0 100 boolge - )); +DATA(insert OID = 1692 ( boolge PGUID 12 f t t t 2 f 16 "16 16" 100 0 0 100 boolge - )); DESCR("greater-than-or-equal"); -DATA(insert OID = 1693 ( btboolcmp PGUID 11 f t t t 2 f 23 "16 16" 100 0 0 100 btboolcmp - )); +DATA(insert OID = 1693 ( btboolcmp PGUID 12 f t t t 2 f 23 "16 16" 100 0 0 100 btboolcmp - )); DESCR("btree less-equal-greater"); /* OID's 1700 - 1799 NUMERIC data type */ @@ -2414,9 +2419,9 @@ DATA(insert OID = 1779 ( int8 PGUID 11 f t t t 1 f 20 "1700" 100 0 0 100 nu DESCR("(internal)"); DATA(insert OID = 1781 ( numeric PGUID 11 f t t t 1 f 1700 "20" 100 0 0 100 int8_numeric - )); DESCR("(internal)"); -DATA(insert OID = 1782 ( numeric PGUID 11 f t t t 1 f 1700 "21" 100 0 0 100 int2_numeric - )); +DATA(insert OID = 1782 ( numeric PGUID 12 f t t t 1 f 1700 "21" 100 0 0 100 int2_numeric - )); DESCR("(internal)"); -DATA(insert OID = 1783 ( int2 PGUID 11 f t t t 1 f 21 "1700" 100 0 0 100 numeric_int2 - )); +DATA(insert OID = 1783 ( int2 PGUID 12 f t t t 1 f 21 "1700" 100 0 0 100 numeric_int2 - )); DESCR("(internal)"); /* formatting */ @@ -2439,30 +2444,35 @@ DESCR("convert text to timestamp"); DATA(insert OID = 1780 ( to_date PGUID 11 f t f t 2 f 1082 "25 25" 100 0 0 100 to_date - )); DESCR("convert text to date"); +DATA(insert OID = 1798 ( oidin PGUID 12 f t t t 1 f 26 "0" 100 0 0 100 oidin - )); +DESCR("(internal)"); +DATA(insert OID = 1799 ( oidout PGUID 12 f t t t 1 f 23 "0" 100 0 0 100 oidout - )); +DESCR("(internal)"); + /* Selectivity estimators for LIKE and related operators */ -DATA(insert OID = 1818 ( regexeqsel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 regexeqsel - )); +DATA(insert OID = 1818 ( regexeqsel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 regexeqsel - )); DESCR("restriction selectivity of regex match"); -DATA(insert OID = 1819 ( likesel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 likesel - )); +DATA(insert OID = 1819 ( likesel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 likesel - )); DESCR("restriction selectivity of LIKE"); -DATA(insert OID = 1820 ( icregexeqsel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 icregexeqsel - )); +DATA(insert OID = 1820 ( icregexeqsel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 icregexeqsel - )); DESCR("restriction selectivity of case-insensitive regex match"); -DATA(insert OID = 1821 ( regexnesel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 regexnesel - )); +DATA(insert OID = 1821 ( regexnesel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 regexnesel - )); DESCR("restriction selectivity of regex non-match"); -DATA(insert OID = 1822 ( nlikesel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 nlikesel - )); +DATA(insert OID = 1822 ( nlikesel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 nlikesel - )); DESCR("restriction selectivity of NOT LIKE"); -DATA(insert OID = 1823 ( icregexnesel PGUID 11 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 icregexnesel - )); +DATA(insert OID = 1823 ( icregexnesel PGUID 12 f t f t 5 f 701 "26 26 21 0 23" 100 0 0 100 icregexnesel - )); DESCR("restriction selectivity of case-insensitive regex non-match"); -DATA(insert OID = 1824 ( regexeqjoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 regexeqjoinsel - )); +DATA(insert OID = 1824 ( regexeqjoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 regexeqjoinsel - )); DESCR("join selectivity of regex match"); -DATA(insert OID = 1825 ( likejoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 likejoinsel - )); +DATA(insert OID = 1825 ( likejoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 likejoinsel - )); DESCR("join selectivity of LIKE"); -DATA(insert OID = 1826 ( icregexeqjoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 icregexeqjoinsel - )); +DATA(insert OID = 1826 ( icregexeqjoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 icregexeqjoinsel - )); DESCR("join selectivity of case-insensitive regex match"); -DATA(insert OID = 1827 ( regexnejoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 regexnejoinsel - )); +DATA(insert OID = 1827 ( regexnejoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 regexnejoinsel - )); DESCR("join selectivity of regex non-match"); -DATA(insert OID = 1828 ( nlikejoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 nlikejoinsel - )); +DATA(insert OID = 1828 ( nlikejoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 nlikejoinsel - )); DESCR("join selectivity of NOT LIKE"); -DATA(insert OID = 1829 ( icregexnejoinsel PGUID 11 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 icregexnejoinsel - )); +DATA(insert OID = 1829 ( icregexnejoinsel PGUID 12 f t f t 5 f 701 "26 26 21 26 21" 100 0 0 100 icregexnejoinsel - )); DESCR("join selectivity of case-insensitive regex non-match"); diff --git a/src/include/catalog/pg_type.h b/src/include/catalog/pg_type.h index 3f8665ebe1..ce9ba3b474 100644 --- a/src/include/catalog/pg_type.h +++ b/src/include/catalog/pg_type.h @@ -8,7 +8,7 @@ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: pg_type.h,v 1.88 2000/04/12 17:16:29 momjian Exp $ + * $Id: pg_type.h,v 1.89 2000/06/05 07:29:01 tgl Exp $ * * NOTES * the genbki.sh script reads this file and generates .bki @@ -191,7 +191,7 @@ DATA(insert OID = 25 ( text PGUID -1 -1 f b t \054 0 18 textin textout text DESCR("variable-length string, no limit specified"); #define TEXTOID 25 -DATA(insert OID = 26 ( oid PGUID 4 10 t b t \054 0 0 int4in int4out int4in int4out i _null_ )); +DATA(insert OID = 26 ( oid PGUID 4 10 t b t \054 0 0 oidin oidout oidin oidout i _null_ )); DESCR("object identifier(oid), maximum 4 billion"); #define OIDOID 26 @@ -214,21 +214,21 @@ DESCR("array of INDEX_MAX_KEYS oids, used in system tables"); DATA(insert OID = 32 ( SET PGUID -1 -1 f b t \054 0 0 textin textout textin textout i _null_ )); DESCR("set of tuples"); -DATA(insert OID = 71 ( pg_type PGUID 4 4 t c t \054 1247 0 foo bar foo bar i _null_)); -DATA(insert OID = 75 ( pg_attribute PGUID 4 4 t c t \054 1249 0 foo bar foo bar i _null_)); -DATA(insert OID = 81 ( pg_proc PGUID 4 4 t c t \054 1255 0 foo bar foo bar i _null_)); -DATA(insert OID = 83 ( pg_class PGUID 4 4 t c t \054 1259 0 foo bar foo bar i _null_)); -DATA(insert OID = 86 ( pg_shadow PGUID 4 4 t c t \054 1260 0 foo bar foo bar i _null_)); -DATA(insert OID = 87 ( pg_group PGUID 4 4 t c t \054 1261 0 foo bar foo bar i _null_)); -DATA(insert OID = 88 ( pg_database PGUID 4 4 t c t \054 1262 0 foo bar foo bar i _null_)); -DATA(insert OID = 90 ( pg_variable PGUID 4 4 t c t \054 1264 0 foo bar foo bar i _null_)); -DATA(insert OID = 99 ( pg_log PGUID 4 4 t c t \054 1269 0 foo bar foo bar i _null_)); +DATA(insert OID = 71 ( pg_type PGUID 4 4 t c t \054 1247 0 int4in int4out int4in int4out i _null_)); +DATA(insert OID = 75 ( pg_attribute PGUID 4 4 t c t \054 1249 0 int4in int4out int4in int4out i _null_)); +DATA(insert OID = 81 ( pg_proc PGUID 4 4 t c t \054 1255 0 int4in int4out int4in int4out i _null_)); +DATA(insert OID = 83 ( pg_class PGUID 4 4 t c t \054 1259 0 int4in int4out int4in int4out i _null_)); +DATA(insert OID = 86 ( pg_shadow PGUID 4 4 t c t \054 1260 0 int4in int4out int4in int4out i _null_)); +DATA(insert OID = 87 ( pg_group PGUID 4 4 t c t \054 1261 0 int4in int4out int4in int4out i _null_)); +DATA(insert OID = 88 ( pg_database PGUID 4 4 t c t \054 1262 0 int4in int4out int4in int4out i _null_)); +DATA(insert OID = 90 ( pg_variable PGUID 4 4 t c t \054 1264 0 int4in int4out int4in int4out i _null_)); +DATA(insert OID = 99 ( pg_log PGUID 4 4 t c t \054 1269 0 int4in int4out int4in int4out i _null_)); /* OIDS 100 - 199 */ -DATA(insert OID = 109 ( pg_attrdef PGUID 4 4 t c t \054 1215 0 foo bar foo bar i _null_)); -DATA(insert OID = 110 ( pg_relcheck PGUID 4 4 t c t \054 1216 0 foo bar foo bar i _null_)); -DATA(insert OID = 111 ( pg_trigger PGUID 4 4 t c t \054 1219 0 foo bar foo bar i _null_)); +DATA(insert OID = 109 ( pg_attrdef PGUID 4 4 t c t \054 1215 0 int4in int4out int4in int4out i _null_)); +DATA(insert OID = 110 ( pg_relcheck PGUID 4 4 t c t \054 1216 0 int4in int4out int4in int4out i _null_)); +DATA(insert OID = 111 ( pg_trigger PGUID 4 4 t c t \054 1219 0 int4in int4out int4in int4out i _null_)); /* OIDS 200 - 299 */ diff --git a/src/include/fmgr.h b/src/include/fmgr.h index fadb09d24e..6bbab9676c 100644 --- a/src/include/fmgr.h +++ b/src/include/fmgr.h @@ -11,7 +11,7 @@ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: fmgr.h,v 1.3 2000/05/30 04:24:56 tgl Exp $ + * $Id: fmgr.h,v 1.4 2000/06/05 07:29:02 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -101,12 +101,15 @@ extern void fmgr_info(Oid functionId, FmgrInfo *finfo); /* Macros for fetching arguments of standard types */ +#define PG_GETARG_DATUM(n) (fcinfo->arg[n]) #define PG_GETARG_INT32(n) DatumGetInt32(fcinfo->arg[n]) +#define PG_GETARG_UINT32(n) DatumGetUInt32(fcinfo->arg[n]) #define PG_GETARG_INT16(n) DatumGetInt16(fcinfo->arg[n]) #define PG_GETARG_CHAR(n) DatumGetChar(fcinfo->arg[n]) #define PG_GETARG_BOOL(n) DatumGetBool(fcinfo->arg[n]) #define PG_GETARG_OID(n) DatumGetObjectId(fcinfo->arg[n]) #define PG_GETARG_POINTER(n) DatumGetPointer(fcinfo->arg[n]) +#define PG_GETARG_CSTRING(n) DatumGetCString(fcinfo->arg[n]) #define PG_GETARG_NAME(n) DatumGetName(fcinfo->arg[n]) /* these macros hide the pass-by-reference-ness of the datatype: */ #define PG_GETARG_FLOAT4(n) DatumGetFloat4(fcinfo->arg[n]) @@ -115,10 +118,16 @@ extern void fmgr_info(Oid functionId, FmgrInfo *finfo); /* use this if you want the raw, possibly-toasted input datum: */ #define PG_GETARG_RAW_VARLENA_P(n) ((struct varlena *) PG_GETARG_POINTER(n)) /* use this if you want the input datum de-toasted: */ +#if 1 +/* VERY TEMPORARY until some TOAST support is committed ... */ +#define PG_GETARG_VARLENA_P(n) PG_GETARG_RAW_VARLENA_P(n) +#else +/* Eventually it will look more like this... */ #define PG_GETARG_VARLENA_P(n) \ (VARATT_IS_EXTENDED(PG_GETARG_RAW_VARLENA_P(n)) ? \ (struct varlena *) heap_tuple_untoast_attr((varattrib *) PG_GETARG_RAW_VARLENA_P(n)) : \ PG_GETARG_RAW_VARLENA_P(n)) +#endif /* GETARG macros for varlena types will typically look like this: */ #define PG_GETARG_TEXT_P(n) ((text *) PG_GETARG_VARLENA_P(n)) @@ -129,11 +138,13 @@ extern void fmgr_info(Oid functionId, FmgrInfo *finfo); /* Macros for returning results of standard types */ #define PG_RETURN_INT32(x) return Int32GetDatum(x) +#define PG_RETURN_UINT32(x) return UInt32GetDatum(x) #define PG_RETURN_INT16(x) return Int16GetDatum(x) #define PG_RETURN_CHAR(x) return CharGetDatum(x) #define PG_RETURN_BOOL(x) return BoolGetDatum(x) #define PG_RETURN_OID(x) return ObjectIdGetDatum(x) #define PG_RETURN_POINTER(x) return PointerGetDatum(x) +#define PG_RETURN_CSTRING(x) return CStringGetDatum(x) #define PG_RETURN_NAME(x) return NameGetDatum(x) /* these macros hide the pass-by-reference-ness of the datatype: */ #define PG_RETURN_FLOAT4(x) return Float4GetDatum(x) @@ -242,57 +253,19 @@ extern PGFunction load_external_function(char *filename, char *funcname); extern void load_file(char *filename); -/*------------------------------------------------------------------------- - * +/* * !!! OLD INTERFACE !!! * - * All the definitions below here are associated with the old fmgr API. - * They will go away as soon as we have converted all call points to use - * the new API. Note that old-style callee functions do not depend on - * these definitions, so we don't need to have converted all of them before - * dropping the old API ... just all the old-style call points. - * - *------------------------------------------------------------------------- + * fmgr() is the only remaining vestige of the old-style caller support + * functions. It's no longer used anywhere in the Postgres distribution, + * but we should leave it around for a release or two to ease the transition + * for user-supplied C functions. OidFunctionCallN() replaces it for new + * code. */ -/* ptr to func returning (char *) */ -#if defined(__mc68000__) && defined(__ELF__) -/* The m68k SVR4 ABI defines that pointers are returned in %a0 instead of - * %d0. So if a function pointer is declared to return a pointer, the - * compiler may look only into %a0, but if the called function was declared - * to return return an integer type, it puts its value only into %d0. So the - * caller doesn't pink up the correct return value. The solution is to - * declare the function pointer to return int, so the compiler picks up the - * return value from %d0. (Functions returning pointers put their value - * *additionally* into %d0 for compability.) The price is that there are - * some warnings about int->pointer conversions... - */ -typedef int32 ((*func_ptr) ()); -#else -typedef char *((*func_ptr) ()); -#endif - -#if 0 - -typedef struct { - char *data[FUNC_MAX_ARGS]; -} FmgrValues; - /* - * defined in fmgr.c + * DEPRECATED, DO NOT USE IN NEW CODE */ extern char *fmgr(Oid procedureId, ... ); -extern char *fmgr_faddr_link(char *arg0, ...); - -/* - * Macros for calling through the result of fmgr_info. - */ - -/* We don't make this static so fmgr_faddr() macro can access it */ -extern FmgrInfo *fmgr_pl_finfo; - -#define fmgr_faddr(finfo) (fmgr_pl_finfo = (finfo), (func_ptr) fmgr_faddr_link) - -#endif #endif /* FMGR_H */ diff --git a/src/include/storage/smgr.h b/src/include/storage/smgr.h index 64702ffe70..e9f8824f55 100644 --- a/src/include/storage/smgr.h +++ b/src/include/storage/smgr.h @@ -7,7 +7,7 @@ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: smgr.h,v 1.20 2000/04/12 17:16:52 momjian Exp $ + * $Id: smgr.h,v 1.21 2000/06/05 07:29:06 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -100,9 +100,9 @@ extern int mmshutdown(void); extern int MMShmemSize(void); /* smgrtype.c */ -extern char *smgrout(int2 i); -extern int2 smgrin(char *s); -extern bool smgreq(int2 a, int2 b); -extern bool smgrne(int2 a, int2 b); +extern Datum smgrout(PG_FUNCTION_ARGS); +extern Datum smgrin(PG_FUNCTION_ARGS); +extern Datum smgreq(PG_FUNCTION_ARGS); +extern Datum smgrne(PG_FUNCTION_ARGS); #endif /* SMGR_H */ diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h index 051a155a83..6dc9aa8165 100644 --- a/src/include/utils/builtins.h +++ b/src/include/utils/builtins.h @@ -7,7 +7,7 @@ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: builtins.h,v 1.112 2000/05/29 01:59:13 tgl Exp $ + * $Id: builtins.h,v 1.113 2000/06/05 07:29:07 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -33,108 +33,110 @@ * Defined in adt/ */ /* bool.c */ -extern bool boolin(char *b); -extern char *boolout(bool b); -extern bool booleq(bool arg1, bool arg2); -extern bool boolne(bool arg1, bool arg2); -extern bool boollt(bool arg1, bool arg2); -extern bool boolgt(bool arg1, bool arg2); -extern bool boolle(bool arg1, bool arg2); -extern bool boolge(bool arg1, bool arg2); -extern bool istrue(bool arg1); -extern bool isfalse(bool arg1); +extern Datum boolin(PG_FUNCTION_ARGS); +extern Datum boolout(PG_FUNCTION_ARGS); +extern Datum booleq(PG_FUNCTION_ARGS); +extern Datum boolne(PG_FUNCTION_ARGS); +extern Datum boollt(PG_FUNCTION_ARGS); +extern Datum boolgt(PG_FUNCTION_ARGS); +extern Datum boolle(PG_FUNCTION_ARGS); +extern Datum boolge(PG_FUNCTION_ARGS); +extern Datum istrue(PG_FUNCTION_ARGS); +extern Datum isfalse(PG_FUNCTION_ARGS); +extern Datum isnottrue(PG_FUNCTION_ARGS); +extern Datum isnotfalse(PG_FUNCTION_ARGS); /* char.c */ -extern int32 charin(char *ch); -extern char *charout(int32 ch); -extern int32 cidin(char *s); -extern char *cidout(int32 c); -extern bool chareq(int8 arg1, int8 arg2); -extern bool charne(int8 arg1, int8 arg2); -extern bool charlt(int8 arg1, int8 arg2); -extern bool charle(int8 arg1, int8 arg2); -extern bool chargt(int8 arg1, int8 arg2); -extern bool charge(int8 arg1, int8 arg2); -extern int8 charpl(int8 arg1, int8 arg2); -extern int8 charmi(int8 arg1, int8 arg2); -extern int8 charmul(int8 arg1, int8 arg2); -extern int8 chardiv(int8 arg1, int8 arg2); -extern bool cideq(int8 arg1, int8 arg2); -extern int8 text_char(text *arg1); -extern text *char_text(int8 arg1); +extern Datum charin(PG_FUNCTION_ARGS); +extern Datum charout(PG_FUNCTION_ARGS); +extern Datum chareq(PG_FUNCTION_ARGS); +extern Datum charne(PG_FUNCTION_ARGS); +extern Datum charlt(PG_FUNCTION_ARGS); +extern Datum charle(PG_FUNCTION_ARGS); +extern Datum chargt(PG_FUNCTION_ARGS); +extern Datum charge(PG_FUNCTION_ARGS); +extern Datum charpl(PG_FUNCTION_ARGS); +extern Datum charmi(PG_FUNCTION_ARGS); +extern Datum charmul(PG_FUNCTION_ARGS); +extern Datum chardiv(PG_FUNCTION_ARGS); +extern Datum text_char(PG_FUNCTION_ARGS); +extern Datum char_text(PG_FUNCTION_ARGS); +extern Datum cidin(PG_FUNCTION_ARGS); +extern Datum cidout(PG_FUNCTION_ARGS); +extern Datum cideq(PG_FUNCTION_ARGS); /* int.c */ -extern int32 int2in(char *num); -extern char *int2out(int16 sh); -extern int16 *int2vectorin(char *shs); -extern char *int2vectorout(int16 *shs); -extern bool int2vectoreq(int16 *arg1, int16 *arg2); -extern int32 *int44in(char *input_string); -extern char *int44out(int32 *an_array); -extern int32 int4in(char *num); -extern char *int4out(int32 l); -extern int32 i2toi4(int16 arg1); -extern int16 i4toi2(int32 arg1); -extern text *int2_text(int16 arg1); -extern int16 text_int2(text *arg1); -extern text *int4_text(int32 arg1); -extern int32 text_int4(text *arg1); -extern bool int4eq(int32 arg1, int32 arg2); -extern bool int4ne(int32 arg1, int32 arg2); -extern bool int4lt(int32 arg1, int32 arg2); -extern bool int4le(int32 arg1, int32 arg2); -extern bool int4gt(int32 arg1, int32 arg2); -extern bool int4ge(int32 arg1, int32 arg2); -extern bool int2eq(int16 arg1, int16 arg2); -extern bool int2ne(int16 arg1, int16 arg2); -extern bool int2lt(int16 arg1, int16 arg2); -extern bool int2le(int16 arg1, int16 arg2); -extern bool int2gt(int16 arg1, int16 arg2); -extern bool int2ge(int16 arg1, int16 arg2); -extern bool int24eq(int32 arg1, int32 arg2); -extern bool int24ne(int32 arg1, int32 arg2); -extern bool int24lt(int32 arg1, int32 arg2); -extern bool int24le(int32 arg1, int32 arg2); -extern bool int24gt(int32 arg1, int32 arg2); -extern bool int24ge(int32 arg1, int32 arg2); -extern bool int42eq(int32 arg1, int32 arg2); -extern bool int42ne(int32 arg1, int32 arg2); -extern bool int42lt(int32 arg1, int32 arg2); -extern bool int42le(int32 arg1, int32 arg2); -extern bool int42gt(int32 arg1, int32 arg2); -extern bool int42ge(int32 arg1, int32 arg2); -extern int32 int4um(int32 arg); -extern int32 int4pl(int32 arg1, int32 arg2); -extern int32 int4mi(int32 arg1, int32 arg2); -extern int32 int4mul(int32 arg1, int32 arg2); -extern int32 int4div(int32 arg1, int32 arg2); -extern int32 int4abs(int32 arg); -extern int32 int4inc(int32 arg); -extern int16 int2um(int16 arg); -extern int16 int2pl(int16 arg1, int16 arg2); -extern int16 int2mi(int16 arg1, int16 arg2); -extern int16 int2mul(int16 arg1, int16 arg2); -extern int16 int2div(int16 arg1, int16 arg2); -extern int16 int2abs(int16 arg); -extern int16 int2inc(int16 arg); -extern int32 int24pl(int32 arg1, int32 arg2); -extern int32 int24mi(int32 arg1, int32 arg2); -extern int32 int24mul(int32 arg1, int32 arg2); -extern int32 int24div(int32 arg1, int32 arg2); -extern int32 int42pl(int32 arg1, int32 arg2); -extern int32 int42mi(int32 arg1, int32 arg2); -extern int32 int42mul(int32 arg1, int32 arg2); -extern int32 int42div(int32 arg1, int32 arg2); -extern int32 int4mod(int32 arg1, int32 arg2); -extern int32 int2mod(int16 arg1, int16 arg2); -extern int32 int24mod(int32 arg1, int32 arg2); -extern int32 int42mod(int32 arg1, int32 arg2); -extern int32 int4fac(int32 arg1); -extern int32 int2fac(int16 arg1); -extern int16 int2larger(int16 arg1, int16 arg2); -extern int16 int2smaller(int16 arg1, int16 arg2); -extern int32 int4larger(int32 arg1, int32 arg2); -extern int32 int4smaller(int32 arg1, int32 arg2); +extern Datum int2in(PG_FUNCTION_ARGS); +extern Datum int2out(PG_FUNCTION_ARGS); +extern Datum int2vectorin(PG_FUNCTION_ARGS); +extern Datum int2vectorout(PG_FUNCTION_ARGS); +extern Datum int2vectoreq(PG_FUNCTION_ARGS); +extern Datum int44in(PG_FUNCTION_ARGS); +extern Datum int44out(PG_FUNCTION_ARGS); +extern Datum int4in(PG_FUNCTION_ARGS); +extern Datum int4out(PG_FUNCTION_ARGS); +extern Datum i2toi4(PG_FUNCTION_ARGS); +extern Datum i4toi2(PG_FUNCTION_ARGS); +extern Datum int2_text(PG_FUNCTION_ARGS); +extern Datum text_int2(PG_FUNCTION_ARGS); +extern Datum int4_text(PG_FUNCTION_ARGS); +extern Datum text_int4(PG_FUNCTION_ARGS); +extern Datum int4eq(PG_FUNCTION_ARGS); +extern Datum int4ne(PG_FUNCTION_ARGS); +extern Datum int4lt(PG_FUNCTION_ARGS); +extern Datum int4le(PG_FUNCTION_ARGS); +extern Datum int4gt(PG_FUNCTION_ARGS); +extern Datum int4ge(PG_FUNCTION_ARGS); +extern Datum int2eq(PG_FUNCTION_ARGS); +extern Datum int2ne(PG_FUNCTION_ARGS); +extern Datum int2lt(PG_FUNCTION_ARGS); +extern Datum int2le(PG_FUNCTION_ARGS); +extern Datum int2gt(PG_FUNCTION_ARGS); +extern Datum int2ge(PG_FUNCTION_ARGS); +extern Datum int24eq(PG_FUNCTION_ARGS); +extern Datum int24ne(PG_FUNCTION_ARGS); +extern Datum int24lt(PG_FUNCTION_ARGS); +extern Datum int24le(PG_FUNCTION_ARGS); +extern Datum int24gt(PG_FUNCTION_ARGS); +extern Datum int24ge(PG_FUNCTION_ARGS); +extern Datum int42eq(PG_FUNCTION_ARGS); +extern Datum int42ne(PG_FUNCTION_ARGS); +extern Datum int42lt(PG_FUNCTION_ARGS); +extern Datum int42le(PG_FUNCTION_ARGS); +extern Datum int42gt(PG_FUNCTION_ARGS); +extern Datum int42ge(PG_FUNCTION_ARGS); +extern Datum int4um(PG_FUNCTION_ARGS); +extern Datum int4pl(PG_FUNCTION_ARGS); +extern Datum int4mi(PG_FUNCTION_ARGS); +extern Datum int4mul(PG_FUNCTION_ARGS); +extern Datum int4div(PG_FUNCTION_ARGS); +extern Datum int4abs(PG_FUNCTION_ARGS); +extern Datum int4inc(PG_FUNCTION_ARGS); +extern Datum int2um(PG_FUNCTION_ARGS); +extern Datum int2pl(PG_FUNCTION_ARGS); +extern Datum int2mi(PG_FUNCTION_ARGS); +extern Datum int2mul(PG_FUNCTION_ARGS); +extern Datum int2div(PG_FUNCTION_ARGS); +extern Datum int2abs(PG_FUNCTION_ARGS); +extern Datum int2inc(PG_FUNCTION_ARGS); +extern Datum int24pl(PG_FUNCTION_ARGS); +extern Datum int24mi(PG_FUNCTION_ARGS); +extern Datum int24mul(PG_FUNCTION_ARGS); +extern Datum int24div(PG_FUNCTION_ARGS); +extern Datum int42pl(PG_FUNCTION_ARGS); +extern Datum int42mi(PG_FUNCTION_ARGS); +extern Datum int42mul(PG_FUNCTION_ARGS); +extern Datum int42div(PG_FUNCTION_ARGS); +extern Datum int4mod(PG_FUNCTION_ARGS); +extern Datum int2mod(PG_FUNCTION_ARGS); +extern Datum int24mod(PG_FUNCTION_ARGS); +extern Datum int42mod(PG_FUNCTION_ARGS); +extern Datum int4fac(PG_FUNCTION_ARGS); +extern Datum int2fac(PG_FUNCTION_ARGS); +extern Datum int2larger(PG_FUNCTION_ARGS); +extern Datum int2smaller(PG_FUNCTION_ARGS); +extern Datum int4larger(PG_FUNCTION_ARGS); +extern Datum int4smaller(PG_FUNCTION_ARGS); /* name.c */ extern NameData *namein(const char *s); @@ -168,20 +170,20 @@ extern void ltoa(int32 l, char *a); * Per-opclass comparison functions for new btrees. These are * stored in pg_amproc and defined in nbtree/ */ -extern int32 btint2cmp(int16 a, int16 b); -extern int32 btint4cmp(int32 a, int32 b); -extern int32 btint8cmp(int64 *a, int64 *b); -extern int32 btint24cmp(int16 a, int32 b); -extern int32 btint42cmp(int32 a, int16 b); -extern int32 btfloat4cmp(float32 a, float32 b); -extern int32 btfloat8cmp(float64 a, float64 b); -extern int32 btoidcmp(Oid a, Oid b); -extern int32 btoidvectorcmp(Oid *a, Oid *b); +extern Datum btboolcmp(PG_FUNCTION_ARGS); +extern Datum btint2cmp(PG_FUNCTION_ARGS); +extern Datum btint4cmp(PG_FUNCTION_ARGS); +extern Datum btint8cmp(PG_FUNCTION_ARGS); +extern Datum btint24cmp(PG_FUNCTION_ARGS); +extern Datum btint42cmp(PG_FUNCTION_ARGS); +extern Datum btfloat4cmp(PG_FUNCTION_ARGS); +extern Datum btfloat8cmp(PG_FUNCTION_ARGS); +extern Datum btoidcmp(PG_FUNCTION_ARGS); +extern Datum btoidvectorcmp(PG_FUNCTION_ARGS); extern int32 btabstimecmp(AbsoluteTime a, AbsoluteTime b); -extern int32 btcharcmp(char a, char b); -extern int32 btnamecmp(NameData *a, NameData *b); -extern int32 bttextcmp(struct varlena * a, struct varlena * b); -extern int32 btboolcmp(bool a, bool b); +extern Datum btcharcmp(PG_FUNCTION_ARGS); +extern Datum btnamecmp(PG_FUNCTION_ARGS); +extern Datum bttextcmp(PG_FUNCTION_ARGS); /* support routines for the rtree access method, by opclass */ extern BOX *rt_box_union(BOX *a, BOX *b); @@ -244,14 +246,14 @@ extern bool float8gt(float64 arg1, float64 arg2); extern bool float8ge(float64 arg1, float64 arg2); extern float64 ftod(float32 num); extern float64 i4tod(int32 num); -extern float64 i2tod(int16 num); +extern Datum i2tod(PG_FUNCTION_ARGS); extern float32 dtof(float64 num); extern int32 dtoi4(float64 num); -extern int16 dtoi2(float64 num); +extern Datum dtoi2(PG_FUNCTION_ARGS); extern float32 i4tof(int32 num); -extern float32 i2tof(int16 num); +extern Datum i2tof(PG_FUNCTION_ARGS); extern int32 ftoi4(float32 num); -extern int16 ftoi2(float32 num); +extern Datum ftoi2(PG_FUNCTION_ARGS); extern float64 text_float8(text *str); extern float32 text_float4(text *str); extern text *float8_text(float64 num); @@ -301,37 +303,33 @@ extern bool float84gt(float64 arg1, float32 arg2); extern bool float84ge(float64 arg1, float32 arg2); /* misc.c */ -extern bool nullvalue(Datum value, bool *isNull); -extern bool nonnullvalue(Datum value, bool *isNull); -extern bool oidrand(Oid o, int32 X); -extern bool oidsrand(int32 X); -extern int32 userfntest(int i); - -/* define macros to replace mixed-case function calls - tgl 97/04/27 */ -#define NullValue(v,b) nullvalue(v,b) -#define NonNullValue(v,b) nonnullvalue(v,b) +extern Datum nullvalue(PG_FUNCTION_ARGS); +extern Datum nonnullvalue(PG_FUNCTION_ARGS); +extern Datum oidrand(PG_FUNCTION_ARGS); +extern Datum oidsrand(PG_FUNCTION_ARGS); +extern Datum userfntest(PG_FUNCTION_ARGS); /* not_in.c */ extern bool int4notin(int32 not_in_arg, char *relation_and_attr); extern bool oidnotin(Oid the_oid, char *compare); /* oid.c */ -extern Oid *oidvectorin(char *oidString); -extern char *oidvectorout(Oid *oidArray); -extern Oid oidin(char *s); -extern char *oidout(Oid o); -extern bool oideq(Oid arg1, Oid arg2); -extern bool oidne(Oid arg1, Oid arg2); -extern bool oidvectoreq(Oid *arg1, Oid *arg2); -extern bool oidvectorne(Oid *arg1, Oid *arg2); -extern bool oidvectorlt(Oid *arg1, Oid *arg2); -extern bool oidvectorle(Oid *arg1, Oid *arg2); -extern bool oidvectorge(Oid *arg1, Oid *arg2); -extern bool oidvectorgt(Oid *arg1, Oid *arg2); -extern bool oideqint4(Oid arg1, int32 arg2); -extern bool int4eqoid(int32 arg1, Oid arg2); -extern text *oid_text(Oid arg1); -extern Oid text_oid(text *arg1); +extern Datum oidvectorin(PG_FUNCTION_ARGS); +extern Datum oidvectorout(PG_FUNCTION_ARGS); +extern Datum oidin(PG_FUNCTION_ARGS); +extern Datum oidout(PG_FUNCTION_ARGS); +extern Datum oideq(PG_FUNCTION_ARGS); +extern Datum oidne(PG_FUNCTION_ARGS); +extern Datum oidvectoreq(PG_FUNCTION_ARGS); +extern Datum oidvectorne(PG_FUNCTION_ARGS); +extern Datum oidvectorlt(PG_FUNCTION_ARGS); +extern Datum oidvectorle(PG_FUNCTION_ARGS); +extern Datum oidvectorge(PG_FUNCTION_ARGS); +extern Datum oidvectorgt(PG_FUNCTION_ARGS); +extern Datum oideqint4(PG_FUNCTION_ARGS); +extern Datum int4eqoid(PG_FUNCTION_ARGS); +extern Datum oid_text(PG_FUNCTION_ARGS); +extern Datum text_oid(PG_FUNCTION_ARGS); /* regexp.c */ extern bool nameregexeq(NameData *n, struct varlena * p); @@ -345,13 +343,13 @@ extern bool texticregexne(struct varlena * s, struct varlena * p); /* regproc.c */ -extern int32 regprocin(char *pro_name_and_oid); -extern char *regprocout(RegProcedure proid); -extern text *oidvectortypes(Oid *oidArray); -extern Oid regproctooid(RegProcedure rp); +extern Datum regprocin(PG_FUNCTION_ARGS); +extern Datum regprocout(PG_FUNCTION_ARGS); +extern Datum oidvectortypes(PG_FUNCTION_ARGS); +extern Datum regproctooid(PG_FUNCTION_ARGS); /* define macro to replace mixed-case function call - tgl 97/04/27 */ -#define RegprocToOid(rp) regproctooid(rp) +#define RegprocToOid(rp) ((Oid) (rp)) /* ruleutils.c */ extern text *pg_get_ruledef(NameData *rname); @@ -362,69 +360,34 @@ extern char *deparse_expression(Node *expr, List *rangetables, bool forceprefix); /* selfuncs.c */ -extern float64 eqsel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); -extern float64 neqsel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); -extern float64 scalarltsel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); -extern float64 scalargtsel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); -extern float64 regexeqsel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); -extern float64 likesel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); -extern float64 icregexeqsel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); -extern float64 regexnesel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); -extern float64 nlikesel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); -extern float64 icregexnesel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); +extern Datum eqsel(PG_FUNCTION_ARGS); +extern Datum neqsel(PG_FUNCTION_ARGS); +extern Datum scalarltsel(PG_FUNCTION_ARGS); +extern Datum scalargtsel(PG_FUNCTION_ARGS); +extern Datum regexeqsel(PG_FUNCTION_ARGS); +extern Datum icregexeqsel(PG_FUNCTION_ARGS); +extern Datum likesel(PG_FUNCTION_ARGS); +extern Datum regexnesel(PG_FUNCTION_ARGS); +extern Datum icregexnesel(PG_FUNCTION_ARGS); +extern Datum nlikesel(PG_FUNCTION_ARGS); -extern float64 eqjoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); -extern float64 neqjoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); -extern float64 scalarltjoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); -extern float64 scalargtjoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); -extern float64 regexeqjoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); -extern float64 likejoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); -extern float64 icregexeqjoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); -extern float64 regexnejoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); -extern float64 nlikejoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); -extern float64 icregexnejoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); +extern Datum eqjoinsel(PG_FUNCTION_ARGS); +extern Datum neqjoinsel(PG_FUNCTION_ARGS); +extern Datum scalarltjoinsel(PG_FUNCTION_ARGS); +extern Datum scalargtjoinsel(PG_FUNCTION_ARGS); +extern Datum regexeqjoinsel(PG_FUNCTION_ARGS); +extern Datum icregexeqjoinsel(PG_FUNCTION_ARGS); +extern Datum likejoinsel(PG_FUNCTION_ARGS); +extern Datum regexnejoinsel(PG_FUNCTION_ARGS); +extern Datum icregexnejoinsel(PG_FUNCTION_ARGS); +extern Datum nlikejoinsel(PG_FUNCTION_ARGS); -extern void btcostestimate(Query *root, RelOptInfo *rel, - IndexOptInfo *index, List *indexQuals, - Cost *indexStartupCost, - Cost *indexTotalCost, - Selectivity *indexSelectivity); -extern void rtcostestimate(Query *root, RelOptInfo *rel, - IndexOptInfo *index, List *indexQuals, - Cost *indexStartupCost, - Cost *indexTotalCost, - Selectivity *indexSelectivity); -extern void hashcostestimate(Query *root, RelOptInfo *rel, - IndexOptInfo *index, List *indexQuals, - Cost *indexStartupCost, - Cost *indexTotalCost, - Selectivity *indexSelectivity); -extern void gistcostestimate(Query *root, RelOptInfo *rel, - IndexOptInfo *index, List *indexQuals, - Cost *indexStartupCost, - Cost *indexTotalCost, - Selectivity *indexSelectivity); +extern Datum btcostestimate(PG_FUNCTION_ARGS); +extern Datum rtcostestimate(PG_FUNCTION_ARGS); +extern Datum hashcostestimate(PG_FUNCTION_ARGS); +extern Datum gistcostestimate(PG_FUNCTION_ARGS); +/* selfuncs.c supporting routines that are also used by optimizer code */ typedef enum { Pattern_Type_Like, Pattern_Type_Regex, Pattern_Type_Regex_IC @@ -452,12 +415,19 @@ extern ItemPointer currtid_byreloid(Oid relOid, ItemPointer); extern ItemPointer currtid_byrelname(const text *relName, ItemPointer); /* varchar.c */ + +/* bpchar and varchar are just a varlena header and some characters */ +#define PG_GETARG_BPCHAR_P(n) ((struct varlena *) PG_GETARG_VARLENA_P(n)) +#define PG_RETURN_BPCHAR_P(x) PG_RETURN_POINTER(x) +#define PG_GETARG_VARCHAR_P(n) ((struct varlena *) PG_GETARG_VARLENA_P(n)) +#define PG_RETURN_VARCHAR_P(x) PG_RETURN_POINTER(x) + extern char *bpcharin(char *s, int dummy, int32 atttypmod); extern char *bpcharout(char *s); extern char *bpchar(char *s, int32 slen); extern ArrayType *_bpchar(ArrayType *v, int32 slen); -extern char *char_bpchar(int32 c); -extern int32 bpchar_char(char *s); +extern Datum char_bpchar(PG_FUNCTION_ARGS); +extern Datum bpchar_char(PG_FUNCTION_ARGS); extern char *name_bpchar(NameData *s); extern NameData *bpchar_name(char *s); extern bool bpchareq(char *arg1, char *arg2); @@ -616,8 +586,8 @@ extern Numeric int4_numeric(int32 val); extern int32 numeric_int4(Numeric num); extern Numeric int8_numeric(int64 *val); extern int64 *numeric_int8(Numeric num); -extern Numeric int2_numeric(int16 val); -extern int16 numeric_int2(Numeric num); +extern Datum int2_numeric(PG_FUNCTION_ARGS); +extern Datum numeric_int2(PG_FUNCTION_ARGS); extern Numeric float4_numeric(float32 val); extern float32 numeric_float4(Numeric num); extern Numeric float8_numeric(float64 val); diff --git a/src/include/utils/cash.h b/src/include/utils/cash.h index 0530266f7e..ab688c46f8 100644 --- a/src/include/utils/cash.h +++ b/src/include/utils/cash.h @@ -37,9 +37,9 @@ extern Cash *cash_mul_int4(Cash *c, int4 i); extern Cash *cash_div_int4(Cash *c, int4 i); extern Cash *int4_mul_cash(int4 i, Cash *c); -extern Cash *cash_mul_int2(Cash *c, int2 s); -extern Cash *cash_div_int2(Cash *c, int2 s); -extern Cash *int2_mul_cash(int2 s, Cash *c); +extern Datum cash_mul_int2(PG_FUNCTION_ARGS); +extern Datum int2_mul_cash(PG_FUNCTION_ARGS); +extern Datum cash_div_int2(PG_FUNCTION_ARGS); extern Cash *cashlarger(Cash *c1, Cash *c2); extern Cash *cashsmaller(Cash *c1, Cash *c2); diff --git a/src/include/utils/catcache.h b/src/include/utils/catcache.h index cf9b1efc6f..31ec660b9a 100644 --- a/src/include/utils/catcache.h +++ b/src/include/utils/catcache.h @@ -7,7 +7,7 @@ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: catcache.h,v 1.21 2000/04/12 17:16:54 momjian Exp $ + * $Id: catcache.h,v 1.22 2000/06/05 07:29:07 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -17,6 +17,7 @@ /* #define CACHEDEBUG turns DEBUG elogs on */ #include "access/htup.h" +#include "fmgr.h" #include "lib/dllist.h" /* @@ -40,7 +41,6 @@ typedef struct catctup #define NCCBUCK 500 /* CatCache buckets */ #define MAXTUP 300 /* Maximum # of tuples cached per cache */ -typedef uint32 (*CCHashFunc) (Datum); typedef struct catcache { @@ -57,7 +57,7 @@ typedef struct catcache short cc_nkeys; short cc_size; short cc_key[4]; /* AttrNumber of each key */ - CCHashFunc cc_hashfunc[4]; /* hash function to use for each key */ + PGFunction cc_hashfunc[4]; /* hash function to use for each key */ ScanKeyData cc_skey[4]; struct catcache *cc_next; Dllist *cc_lrulist; /* LRU list, most recent first */ diff --git a/src/include/utils/geo_decls.h b/src/include/utils/geo_decls.h index 305b482a64..0a722fe81e 100644 --- a/src/include/utils/geo_decls.h +++ b/src/include/utils/geo_decls.h @@ -6,7 +6,7 @@ * Portions Copyright (c) 1996-2000, PostgreSQL, Inc * Portions Copyright (c) 1994, Regents of the University of California * - * $Id: geo_decls.h,v 1.27 2000/04/12 17:16:55 momjian Exp $ + * $Id: geo_decls.h,v 1.28 2000/06/05 07:29:07 tgl Exp $ * * NOTE * These routines do *not* use the float types from adt/. @@ -22,6 +22,7 @@ #define GEO_DECLS_H #include "access/attnum.h" +#include "fmgr.h" /*-------------------------------------------------------------------- * Useful floating point utilities and constants. @@ -360,17 +361,11 @@ extern double *circle_area(CIRCLE *circle); extern double circle_dt(CIRCLE *circle1, CIRCLE *circle2); /* geo_selfuncs.c */ -extern float64 areasel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); -extern float64 areajoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); -extern float64 positionsel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); -extern float64 positionjoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); -extern float64 contsel(Oid opid, Oid relid, AttrNumber attno, - Datum value, int32 flag); -extern float64 contjoinsel(Oid opid, Oid relid1, AttrNumber attno1, - Oid relid2, AttrNumber attno2); +extern Datum areasel(PG_FUNCTION_ARGS); +extern Datum areajoinsel(PG_FUNCTION_ARGS); +extern Datum positionsel(PG_FUNCTION_ARGS); +extern Datum positionjoinsel(PG_FUNCTION_ARGS); +extern Datum contsel(PG_FUNCTION_ARGS); +extern Datum contjoinsel(PG_FUNCTION_ARGS); #endif /* GEO_DECLS_H */ diff --git a/src/pl/plperl/plperl.c b/src/pl/plperl/plperl.c index e51c950ef6..66ae44373d 100644 --- a/src/pl/plperl/plperl.c +++ b/src/pl/plperl/plperl.c @@ -33,7 +33,7 @@ * ENHANCEMENTS, OR MODIFICATIONS. * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/pl/plperl/plperl.c,v 1.10 2000/05/30 04:24:57 tgl Exp $ + * $Header: /cvsroot/pgsql/src/pl/plperl/plperl.c,v 1.11 2000/06/05 07:29:11 tgl Exp $ * **********************************************************************/ @@ -858,7 +858,8 @@ plperl_trigger_handler(PG_FUNCTION_ARGS) Tcl_DStringAppendElement(&tcl_cmd, trigdata->tg_trigger->tgname); /* The oid of the trigger relation for argument TG_relid */ - stroid = oidout(trigdata->tg_relation->rd_id); + stroid = DatumGetCString(DirectFunctionCall1(oidout, + ObjectIdGetDatum(trigdata->tg_relation->rd_id))); Tcl_DStringAppendElement(&tcl_cmd, stroid); pfree(stroid); diff --git a/src/pl/plpgsql/src/gram.y b/src/pl/plpgsql/src/gram.y index 831ad83e8c..e76ddecb3c 100644 --- a/src/pl/plpgsql/src/gram.y +++ b/src/pl/plpgsql/src/gram.y @@ -4,7 +4,7 @@ * procedural language * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/gram.y,v 1.9 2000/05/29 21:25:07 momjian Exp $ + * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/gram.y,v 1.10 2000/06/05 07:29:14 tgl Exp $ * * This software is copyrighted by Jan Wieck - Hamburg. * @@ -433,7 +433,7 @@ decl_atttypmod : decl_atttypmodval : T_NUMBER { - $$ = int2in(yytext) + VARHDRSZ; + $$ = pg_atoi(yytext, sizeof(int16), '\0') + VARHDRSZ; } ; diff --git a/src/pl/tcl/pltcl.c b/src/pl/tcl/pltcl.c index b2bceb9218..37b413da2d 100644 --- a/src/pl/tcl/pltcl.c +++ b/src/pl/tcl/pltcl.c @@ -31,7 +31,7 @@ * ENHANCEMENTS, OR MODIFICATIONS. * * IDENTIFICATION - * $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.25 2000/05/30 04:24:59 tgl Exp $ + * $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.26 2000/06/05 07:29:13 tgl Exp $ * **********************************************************************/ @@ -905,7 +905,8 @@ pltcl_trigger_handler(PG_FUNCTION_ARGS) Tcl_DStringAppendElement(&tcl_cmd, trigdata->tg_trigger->tgname); /* The oid of the trigger relation for argument TG_relid */ - stroid = oidout(trigdata->tg_relation->rd_id); + stroid = DatumGetCString(DirectFunctionCall1(oidout, + ObjectIdGetDatum(trigdata->tg_relation->rd_id))); Tcl_DStringAppendElement(&tcl_cmd, stroid); pfree(stroid); diff --git a/src/test/regress/expected/opr_sanity.out b/src/test/regress/expected/opr_sanity.out index 5adf28926c..974575e53b 100644 --- a/src/test/regress/expected/opr_sanity.out +++ b/src/test/regress/expected/opr_sanity.out @@ -46,7 +46,7 @@ WHERE p1.oid != p2.oid AND -----+---------+-----+--------- (0 rows) --- Considering only built-in procs (prolang = 11), look for multiple uses +-- Considering only built-in procs (prolang = 11/12), look for multiple uses -- of the same internal function (ie, matching prosrc fields). It's OK to -- have several entries with different pronames for the same internal function, -- but conflicts in the number of arguments and other critical items should @@ -54,7 +54,9 @@ WHERE p1.oid != p2.oid AND SELECT p1.oid, p1.proname, p2.oid, p2.proname FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proisinh != p2.proisinh OR p1.proistrusted != p2.proistrusted OR p1.proiscachable != p2.proiscachable OR @@ -73,7 +75,9 @@ WHERE p1.oid != p2.oid AND SELECT DISTINCT p1.prorettype, p2.prorettype FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.prorettype < p2.prorettype); prorettype | prorettype ------------+------------ @@ -84,7 +88,9 @@ WHERE p1.oid != p2.oid AND SELECT DISTINCT p1.proargtypes[0], p2.proargtypes[0] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[0] < p2.proargtypes[0]); proargtypes | proargtypes -------------+------------- @@ -95,7 +101,9 @@ WHERE p1.oid != p2.oid AND SELECT DISTINCT p1.proargtypes[1], p2.proargtypes[1] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[1] < p2.proargtypes[1]); proargtypes | proargtypes -------------+------------- @@ -104,7 +112,9 @@ WHERE p1.oid != p2.oid AND SELECT DISTINCT p1.proargtypes[2], p2.proargtypes[2] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[2] < p2.proargtypes[2]); proargtypes | proargtypes -------------+------------- @@ -113,7 +123,9 @@ WHERE p1.oid != p2.oid AND SELECT DISTINCT p1.proargtypes[3], p2.proargtypes[3] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[3] < p2.proargtypes[3]); proargtypes | proargtypes -------------+------------- @@ -122,7 +134,9 @@ WHERE p1.oid != p2.oid AND SELECT DISTINCT p1.proargtypes[4], p2.proargtypes[4] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[4] < p2.proargtypes[4]); proargtypes | proargtypes -------------+------------- @@ -131,7 +145,9 @@ WHERE p1.oid != p2.oid AND SELECT DISTINCT p1.proargtypes[5], p2.proargtypes[5] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[5] < p2.proargtypes[5]); proargtypes | proargtypes -------------+------------- @@ -140,7 +156,9 @@ WHERE p1.oid != p2.oid AND SELECT DISTINCT p1.proargtypes[6], p2.proargtypes[6] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[6] < p2.proargtypes[6]); proargtypes | proargtypes -------------+------------- @@ -149,7 +167,9 @@ WHERE p1.oid != p2.oid AND SELECT DISTINCT p1.proargtypes[7], p2.proargtypes[7] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[7] < p2.proargtypes[7]); proargtypes | proargtypes -------------+------------- diff --git a/src/test/regress/input/create_function_2.source b/src/test/regress/input/create_function_2.source index ebc612261f..a135a8fa9c 100644 --- a/src/test/regress/input/create_function_2.source +++ b/src/test/regress/input/create_function_2.source @@ -35,7 +35,7 @@ CREATE FUNCTION pt_in_widget(point, widget) CREATE FUNCTION overpaid(emp) RETURNS bool AS '_OBJWD_/regress_DLSUFFIX_' - LANGUAGE 'c'; + LANGUAGE 'newC'; CREATE FUNCTION boxarea(box) RETURNS int4 diff --git a/src/test/regress/output/create_function_2.source b/src/test/regress/output/create_function_2.source index 2d86915cc1..f04cf7356c 100644 --- a/src/test/regress/output/create_function_2.source +++ b/src/test/regress/output/create_function_2.source @@ -27,7 +27,7 @@ CREATE FUNCTION pt_in_widget(point, widget) CREATE FUNCTION overpaid(emp) RETURNS bool AS '_OBJWD_/regress_DLSUFFIX_' - LANGUAGE 'c'; + LANGUAGE 'newC'; CREATE FUNCTION boxarea(box) RETURNS int4 AS '_OBJWD_/regress_DLSUFFIX_' diff --git a/src/test/regress/regress.c b/src/test/regress/regress.c index f58b0d9d8c..18fb2d1996 100644 --- a/src/test/regress/regress.c +++ b/src/test/regress/regress.c @@ -1,5 +1,5 @@ /* - * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.37 2000/05/29 01:59:15 tgl Exp $ + * $Header: /cvsroot/pgsql/src/test/regress/regress.c,v 1.38 2000/06/05 07:29:22 tgl Exp $ */ #include /* faked on sunos */ @@ -14,14 +14,14 @@ #define RDELIM ')' #define DELIM ',' -typedef void *TUPLE; +typedef TupleTableSlot *TUPLE; extern double *regress_dist_ptpath(Point *pt, PATH *path); extern double *regress_path_dist(PATH *p1, PATH *p2); extern PATH *poly2path(POLYGON *poly); extern Point *interpt_pp(PATH *p1, PATH *p2); extern void regress_lseg_construct(LSEG *lseg, Point *pt1, Point *pt2); -extern char overpaid(TUPLE tuple); +extern Datum overpaid(PG_FUNCTION_ARGS); extern int boxarea(BOX *box); extern char *reverse_name(char *string); @@ -176,16 +176,17 @@ Point *pt2; lseg->m = point_sl(pt1, pt2); } - -char -overpaid(tuple) -TUPLE tuple; +Datum +overpaid(PG_FUNCTION_ARGS) { + TUPLE tuple = (TUPLE) PG_GETARG_POINTER(0); bool isnull; long salary; salary = (long) GetAttributeByName(tuple, "salary", &isnull); - return salary > 699; + if (isnull) + PG_RETURN_NULL(); + PG_RETURN_BOOL(salary > 699); } /* New type "widget" @@ -395,13 +396,12 @@ funny_dup17(PG_FUNCTION_ARGS) if (SPI_processed > 0) { - selected = int4in( - SPI_getvalue( + selected = DatumGetInt32(DirectFunctionCall1(int4in, + CStringGetDatum(SPI_getvalue( SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1 - ) - ); + )))); } elog(NOTICE, "funny_dup17 (fired %s) on level %3d: %d/%d tuples inserted/selected", diff --git a/src/test/regress/sql/opr_sanity.sql b/src/test/regress/sql/opr_sanity.sql index e378171fd8..d87702f0e3 100644 --- a/src/test/regress/sql/opr_sanity.sql +++ b/src/test/regress/sql/opr_sanity.sql @@ -44,7 +44,7 @@ WHERE p1.oid != p2.oid AND p1.pronargs = p2.pronargs AND p1.proargtypes = p2.proargtypes; --- Considering only built-in procs (prolang = 11), look for multiple uses +-- Considering only built-in procs (prolang = 11/12), look for multiple uses -- of the same internal function (ie, matching prosrc fields). It's OK to -- have several entries with different pronames for the same internal function, -- but conflicts in the number of arguments and other critical items should @@ -53,7 +53,9 @@ WHERE p1.oid != p2.oid AND SELECT p1.oid, p1.proname, p2.oid, p2.proname FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proisinh != p2.proisinh OR p1.proistrusted != p2.proistrusted OR p1.proiscachable != p2.proiscachable OR @@ -70,55 +72,73 @@ WHERE p1.oid != p2.oid AND SELECT DISTINCT p1.prorettype, p2.prorettype FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.prorettype < p2.prorettype); SELECT DISTINCT p1.proargtypes[0], p2.proargtypes[0] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[0] < p2.proargtypes[0]); SELECT DISTINCT p1.proargtypes[1], p2.proargtypes[1] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[1] < p2.proargtypes[1]); SELECT DISTINCT p1.proargtypes[2], p2.proargtypes[2] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[2] < p2.proargtypes[2]); SELECT DISTINCT p1.proargtypes[3], p2.proargtypes[3] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[3] < p2.proargtypes[3]); SELECT DISTINCT p1.proargtypes[4], p2.proargtypes[4] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[4] < p2.proargtypes[4]); SELECT DISTINCT p1.proargtypes[5], p2.proargtypes[5] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[5] < p2.proargtypes[5]); SELECT DISTINCT p1.proargtypes[6], p2.proargtypes[6] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[6] < p2.proargtypes[6]); SELECT DISTINCT p1.proargtypes[7], p2.proargtypes[7] FROM pg_proc AS p1, pg_proc AS p2 WHERE p1.oid != p2.oid AND - p1.prosrc = p2.prosrc AND p1.prolang = 11 AND p2.prolang = 11 AND + p1.prosrc = p2.prosrc AND + (p1.prolang = 11 OR p1.prolang = 12) AND + (p2.prolang = 11 OR p2.prolang = 12) AND (p1.proargtypes[7] < p2.proargtypes[7]); -- **************** pg_operator ****************