*
*
* 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
#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)
- {
- loop = (len + 8 - 1) >> 3;
+ /*
+ * 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))
- {
- 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
-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);
}
/*
* 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: )
*
*
* "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
} while (--loop);
}
}
- return n;
+ PG_RETURN_UINT32(n);
}
*
*
* 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;
+ int64 a = PG_GETARG_INT64(0);
+ int64 b = PG_GETARG_INT64(1);
+
+ if (a > b)
+ PG_RETURN_INT32(1);
+ else if (a == b)
+ PG_RETURN_INT32(0);
else
- return -1;
+ PG_RETURN_INT32(-1);
}
-int32
-btint24cmp(int16 a, int32 b)
+Datum
+btint24cmp(PG_FUNCTION_ARGS)
{
- return ((int32) a) - b;
+ 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);
}
-int32
-btint42cmp(int32 a, int16 b)
+Datum
+btint42cmp(PG_FUNCTION_ARGS)
{
- return a - ((int32) b);
+ 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);
}
-int32
-btfloat4cmp(float32 a, float32 b)
+Datum
+btfloat4cmp(PG_FUNCTION_ARGS)
{
- if (*a > *b)
- return 1;
- else if (*a == *b)
- return 0;
+ 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
- return -1;
+ PG_RETURN_INT32(-1);
}
-int32
-btfloat8cmp(float64 a, float64 b)
+Datum
+btfloat8cmp(PG_FUNCTION_ARGS)
{
- if (*a > *b)
- return 1;
- else if (*a == *b)
- return 0;
+ 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
- return -1;
+ PG_RETURN_INT32(-1);
}
-int32
-btoidcmp(Oid a, Oid b)
+Datum
+btoidcmp(PG_FUNCTION_ARGS)
{
+ Oid a = PG_GETARG_OID(0);
+ Oid b = PG_GETARG_OID(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
-btoidvectorcmp(Oid *a, Oid *b)
+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;
{
do
{
- res = (int) (*ap++ - *bp++);
+ res = (int) *ap++ - (int) *bp++;
len--;
} while (res == 0 && len != 0);
}
#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
*/
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);
}
/*-------------------------------------------------------------------------
*
* 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
*-------------------------------------------------------------------------
*/
-
#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);
}
/* ----------------------------------------------------------------
* 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
TransactionIdAdd(TransactionId *xid, int value)
{
*xid += value;
- return;
}
* 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 $
*
*-------------------------------------------------------------------------
*/
#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);
{"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},
/*** 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);
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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);
}
done = 1;
else
{
- loaded_oid = oidin(string);
+ loaded_oid = DatumGetObjectId(DirectFunctionCall1(oidin,
+ CStringGetDatum(string)));
if (loaded_oid == InvalidOid)
elog(ERROR, "COPY TEXT: Invalid Oid");
}
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
{
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:
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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));
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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))));
}
}
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))));
}
}
}
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))));
}
}
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))));
}
}
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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);
}
*
*
* 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.
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));
}
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
#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"
static AclItem default_aclitem = {ACL_ID_WORLD,
ACL_IDTYPE_WORLD,
ACL_WORLD_DEFAULT};
- extern char *int2out();
char *tmpname;
if (!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);
}
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
*
* 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:
}
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)
+{
+ bool arg1 = PG_GETARG_BOOL(0);
+ bool arg2 = PG_GETARG_BOOL(1);
+
+ PG_RETURN_BOOL(arg1 <= arg2);
+}
+
+Datum
+boolge(PG_FUNCTION_ARGS)
+{
+ bool arg1 = PG_GETARG_BOOL(0);
+ bool arg2 = PG_GETARG_BOOL(1);
+
+ PG_RETURN_BOOL(arg1 >= arg2);
+}
+
+/*
+ * 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.
+ */
+
+Datum
+istrue(PG_FUNCTION_ARGS)
{
- return arg1 <= arg2;
+ bool b;
+
+ if (PG_ARGISNULL(0))
+ PG_RETURN_BOOL(false);
+
+ b = PG_GETARG_BOOL(0);
+
+ PG_RETURN_BOOL(b);
}
-bool
-boolge(bool arg1, bool arg2)
+Datum
+isfalse(PG_FUNCTION_ARGS)
{
- return arg1 >= arg2;
+ bool b;
+
+ if (PG_ARGISNULL(0))
+ PG_RETURN_BOOL(false);
+
+ b = PG_GETARG_BOOL(0);
+
+ PG_RETURN_BOOL(! b);
}
-bool
-istrue(bool arg1)
+Datum
+isnottrue(PG_FUNCTION_ARGS)
{
- return arg1 == TRUE;
-} /* istrue() */
+ bool b;
-bool
-isfalse(bool arg1)
+ if (PG_ARGISNULL(0))
+ PG_RETURN_BOOL(true);
+
+ b = PG_GETARG_BOOL(0);
+
+ PG_RETURN_BOOL(! b);
+}
+
+Datum
+isnotfalse(PG_FUNCTION_ARGS)
{
- return arg1 != TRUE;
-} /* isfalse() */
+ bool b;
+
+ if (PG_ARGISNULL(0))
+ PG_RETURN_BOOL(true);
+
+ b = PG_GETARG_BOOL(0);
+
+ PG_RETURN_BOOL(b);
+}
* 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 <limits.h>
#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 [$]###[,]###[.##]
/* 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.
* 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.
*
* 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"
/*****************************************************************************
/*
* 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);
}
+/*****************************************************************************
+ * PUBLIC ROUTINES *
+ *****************************************************************************/
+
/*
- * cidin - converts "..." to internal representation.
+ * NOTE: comparisons are done as though char is unsigned (uint8).
+ * Arithmetic is done as though char is signed (int8).
*
- * NOTE: we must not use 'charin' because cid might be a non
- * printable character...
+ * You wanted consistency?
*/
-int32
-cidin(char *s)
-{
- CommandId c;
- if (s == NULL)
- c = 0;
- else
- c = atoi(s);
+Datum
+chareq(PG_FUNCTION_ARGS)
+{
+ char arg1 = PG_GETARG_CHAR(0);
+ char arg2 = PG_GETARG_CHAR(1);
- return (int32) c;
+ PG_RETURN_BOOL(arg1 == arg2);
}
-/*
- * cidout - converts a cid to "..."
- *
- * NOTE: we must no use 'charout' because cid might be a non
- * printable character...
- */
-char *
-cidout(int32 c)
+Datum
+charne(PG_FUNCTION_ARGS)
{
- char *result;
- CommandId c2;
+ char arg1 = PG_GETARG_CHAR(0);
+ char arg2 = PG_GETARG_CHAR(1);
- result = palloc(12);
- c2 = (CommandId) c;
- sprintf(result, "%u", (unsigned) (c2));
- return result;
+ PG_RETURN_BOOL(arg1 != arg2);
}
-
-/*****************************************************************************
- * PUBLIC ROUTINES *
- *****************************************************************************/
-
-bool
-chareq(int8 arg1, int8 arg2)
+Datum
+charlt(PG_FUNCTION_ARGS)
{
- return arg1 == arg2;
+ char arg1 = PG_GETARG_CHAR(0);
+ char arg2 = PG_GETARG_CHAR(1);
+
+ PG_RETURN_BOOL((uint8) arg1 < (uint8) arg2);
}
-bool
-charne(int8 arg1, int8 arg2)
+Datum
+charle(PG_FUNCTION_ARGS)
{
- return arg1 != arg2;
+ char arg1 = PG_GETARG_CHAR(0);
+ char arg2 = PG_GETARG_CHAR(1);
+
+ PG_RETURN_BOOL((uint8) arg1 <= (uint8) arg2);
}
-bool
-charlt(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
-charle(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);
}
-bool
-chargt(int8 arg1, int8 arg2)
+Datum
+charpl(PG_FUNCTION_ARGS)
{
- return (uint8) arg1 > (uint8) arg2;
+ char arg1 = PG_GETARG_CHAR(0);
+ char arg2 = PG_GETARG_CHAR(1);
+
+ PG_RETURN_CHAR((int8) arg1 + (int8) arg2);
}
-bool
-charge(int8 arg1, int8 arg2)
+Datum
+charmi(PG_FUNCTION_ARGS)
{
- return (uint8) arg1 >= (uint8) arg2;
+ char arg1 = PG_GETARG_CHAR(0);
+ char arg2 = PG_GETARG_CHAR(1);
+
+ PG_RETURN_CHAR((int8) arg1 - (int8) arg2);
}
-int8
-charpl(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
-charmi(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);
}
-int8
-charmul(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
-chardiv(int8 arg1, int8 arg2)
+Datum
+char_text(PG_FUNCTION_ARGS)
{
- return arg1 / arg2;
+ char arg1 = PG_GETARG_CHAR(0);
+ text *result = palloc(VARHDRSZ + 1);
+
+ VARSIZE(result) = VARHDRSZ + 1;
+ *(VARDATA(result)) = arg1;
+
+ PG_RETURN_TEXT_P(result);
}
-bool
-cideq(int8 arg1, int8 arg2)
+
+/*****************************************************************************
+ * USER I/O ROUTINES *
+ *****************************************************************************/
+
+/*
+ * cidin - converts CommandId to internal representation.
+ */
+Datum
+cidin(PG_FUNCTION_ARGS)
{
- return arg1 == arg2;
+ char *s = PG_GETARG_CSTRING(0);
+ CommandId c;
+
+ c = atoi(s);
+
+ /* XXX assume that CommandId is 32 bits... */
+ PG_RETURN_INT32((int32) c);
}
-int8
-text_char(text *arg1)
+/*
+ * cidout - converts a cid to external representation.
+ */
+Datum
+cidout(PG_FUNCTION_ARGS)
{
- return ((int8) *(VARDATA(arg1)));
+ /* 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);
}
-text *
-char_text(int8 arg1)
-{
- text *result;
+/*****************************************************************************
+ * PUBLIC ROUTINES *
+ *****************************************************************************/
- result = palloc(VARHDRSZ + 1);
- VARSIZE(result) = VARHDRSZ + 1;
- *(VARDATA(result)) = arg1;
+Datum
+cideq(PG_FUNCTION_ARGS)
+{
+ /* XXX assume that CommandId is 32 bits... */
+ CommandId arg1 = PG_GETARG_INT32(0);
+ CommandId arg2 = PG_GETARG_INT32(1);
- return result;
+ PG_RETURN_BOOL(arg1 == arg2);
}
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
#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
/*
* 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);
}
/*
* 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);
}
/*
- * 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);
}
/*
- * 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;
-
- result = (float32) palloc(sizeof(float32data));
+ int16 num = PG_GETARG_INT16(0);
+ float4 result;
- *result = num;
- return result;
+ result = num;
+ PG_RETURN_FLOAT4(result);
}
/* -----------------------------------------------------------------------
* 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
{
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 == '-')
*
*
* 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.
* 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);
}
/*
* 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);
}
/*
* 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);
}
/*-------------------------------------------------------------------------
*
* 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 $
*
*-------------------------------------------------------------------------
*/
*
* 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 <ctype.h>
+
#include "postgres.h"
+
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif
/*
* 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)
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)
;
}
*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);
}
/*
* 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);
}
* ===================
*/
-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;
-
- int len;
- char *str;
-
- str = int2out(arg1);
- len = (strlen(str) + VARHDRSZ);
-
- result = palloc(len);
+ int16 arg1 = PG_GETARG_INT16(0);
+ text *result = (text *) palloc(7+VARHDRSZ); /* sign,5 digits, '\0' */
- VARSIZE(result) = len;
- memmove(VARDATA(result), str, (len - VARHDRSZ));
-
- pfree(str);
-
- return result;
-} /* int2_text() */
+ itoa((int) arg1, VARDATA(result));
+ VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ;
+ PG_RETURN_TEXT_P(result);
+}
-int16
-text_int2(text *string)
+Datum
+text_int2(PG_FUNCTION_ARGS)
{
- int16 result;
-
+ text *string = PG_GETARG_TEXT_P(0);
+ Datum 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;
-
- int len;
- char *str;
-
- str = int4out(arg1);
- len = (strlen(str) + VARHDRSZ);
-
- result = palloc(len);
-
- VARSIZE(result) = len;
- memmove(VARDATA(result), str, (len - VARHDRSZ));
+ int32 arg1 = PG_GETARG_INT32(0);
+ text *result = (text *) palloc(12+VARHDRSZ); /* sign,10 digits,'\0' */
- pfree(str);
-
- return result;
-} /* int4_text() */
+ ltoa(arg1, VARDATA(result));
+ VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ;
+ PG_RETURN_TEXT_P(result);
+}
-int32
-text_int4(text *string)
+Datum
+text_int4(PG_FUNCTION_ARGS)
{
- int32 result;
-
+ text *string = PG_GETARG_TEXT_P(0);
+ Datum 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
+ * ============================
*/
/*
* 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);
}
/*
* 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)
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)
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);
}
*
*
* 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 <sys/types.h>
#include <sys/file.h>
#include <time.h>
+
#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);
}
/*
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
}
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);
}
*
* 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 $
*
* ----------
*/
* 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
init_var(&result);
- tmp = int4out(val);
+ tmp = DatumGetCString(DirectFunctionCall1(int4out,
+ Int32GetDatum(val)));
set_var_from_str(tmp, &result);
res = make_result(&result);
{
NumericVar x;
char *str;
- int32 result;
+ Datum result;
if (num == NULL)
return 0;
free_var(&x);
- result = int4in(str);
+ result = DirectFunctionCall1(int4in, CStringGetDatum(str));
pfree(str);
return result;
}
-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");
free_var(&x);
- result = int2in(str);
+ result = DirectFunctionCall1(int2in, CStringGetDatum(str));
pfree(str);
return result;
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
* 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++)
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)
;
}
*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);
+}
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
*
* 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())
{
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;
(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);
(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))
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))
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;
{
result[0] = '-';
result[1] = '\0';
- return result;
+ PG_RETURN_CSTRING(result);
}
if (!IsBootstrapProcessingMode())
(bits16) 0,
(AttrNumber) ObjectIdAttributeNumber,
(RegProcedure) F_INT4EQ,
- (Datum) proid);
+ ObjectIdGetDatum(proid));
procscan = heap_beginscan(proc, 0, SnapshotNow, 1, &key);
if (!HeapScanIsValid(procscan))
heap_close(proc, AccessShareLock);
elog(ERROR, "regprocout: could not begin scan of %s",
ProcedureRelationName);
- return 0;
}
proctup = heap_getnext(procscan, 0);
if (HeapTupleIsValid(proctup))
if (!isnull)
StrNCpy(result, s, NAMEDATALEN);
else
- elog(FATAL, "regprocout: null procedure %u", proid);
+ elog(ERROR, "regprocout: null procedure %u", proid);
}
else
{
heap_close(proc, AccessShareLock);
}
- return result;
+ PG_RETURN_CSTRING(result);
}
/*
* 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++)
strcat(VARDATA(result), "- ");
}
VARSIZE(result) = strlen(VARDATA(result)) + VARHDRSZ;
- return result;
+ PG_RETURN_TEXT_P(result);
}
* 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) */
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
/* 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
* 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;
selec = get_attdisbursion(relid, attno, 0.01);
}
- *result = (float64data) selec;
+ result = (float8) selec;
}
- return result;
+ PG_RETURN_FLOAT8(result);
}
/*
* 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);
}
/*
* 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;
&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. */
pfree(DatumGetPointer(hival));
pfree(DatumGetPointer(loval));
}
- *result = DEFAULT_INEQ_SEL;
- return result;
+ PG_RETURN_FLOAT8(DEFAULT_INEQ_SEL);
}
/* release temp storage if needed */
* 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)
{
* 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
{
numerator = val - low;
else
numerator = high - val;
- *result = numerator / denominator;
+ result = numerator / denominator;
}
}
- return result;
+ PG_RETURN_FLOAT8(result);
}
/*
*
* 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;
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
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);
* 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);
}
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));
/*
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);
*-------------------------------------------------------------------------
*/
-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;
*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);
}
/*-------------------------------------------------------------------------
*
* 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"
#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
* 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
* 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
*/
/* 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()
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
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
* ----------------------------------------------------------------
*/
-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)
{
/*
*/
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));
}
{
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);
*
*
* 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 $
*
*-------------------------------------------------------------------------
*/
#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);
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.
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
}
+/*
+ * !!! 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
*
* 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.
#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
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 */
* 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 $
*
*-------------------------------------------------------------------------
*/
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 */
* 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 $
*
*-------------------------------------------------------------------------
*/
*/
/* yyyymmddN */
-#define CATALOG_VERSION_NO 200005282
+#define CATALOG_VERSION_NO 200006021
#endif
* 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
/* 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 - - ));
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 - - ));
* 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
/* 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)");
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 - ));
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 - ));
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");
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 - ));
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");
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 - ));
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");
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 - ));
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 - ));
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");
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");
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 - ));
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 - ));
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)");
/* 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 -));
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 - ));
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 - ));
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");
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 - ));
/* 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)");
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 - ));
/* 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 - ));
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");
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");
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 */
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 - ));
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 - ));
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 */
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 */
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");
* 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
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
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 */
* 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 $
*
*-------------------------------------------------------------------------
*/
/* 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])
/* 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))
/* 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)
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 */
* 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 $
*
*-------------------------------------------------------------------------
*/
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 */
* 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 $
*
*-------------------------------------------------------------------------
*/
* 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);
* 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);
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);
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);
/* 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);
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 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 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 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 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 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
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);
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);
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);
* 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 $
*
*-------------------------------------------------------------------------
*/
/* #define CACHEDEBUG turns DEBUG elogs on */
#include "access/htup.h"
+#include "fmgr.h"
#include "lib/dllist.h"
/*
#define NCCBUCK 500 /* CatCache buckets */
#define MAXTUP 300 /* Maximum # of tuples cached per cache */
-typedef uint32 (*CCHashFunc) (Datum);
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 */
* 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/.
#define GEO_DECLS_H
#include "access/attnum.h"
+#include "fmgr.h"
/*--------------------------------------------------------------------
* Useful floating point utilities and constants.
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 */
* 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 $
*
**********************************************************************/
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);
* 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.
*
decl_atttypmodval : T_NUMBER
{
- $$ = int2in(yytext) + VARHDRSZ;
+ $$ = pg_atoi(yytext, sizeof(int16), '\0') + VARHDRSZ;
}
;
* 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 $
*
**********************************************************************/
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);
-----+---------+-----+---------
(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
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
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
------------+------------
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
-------------+-------------
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
-------------+-------------
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
-------------+-------------
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
-------------+-------------
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
-------------+-------------
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
-------------+-------------
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
-------------+-------------
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
-------------+-------------
CREATE FUNCTION overpaid(emp)
RETURNS bool
AS '_OBJWD_/regress_DLSUFFIX_'
- LANGUAGE 'c';
+ LANGUAGE 'newC';
CREATE FUNCTION boxarea(box)
RETURNS int4
CREATE FUNCTION overpaid(emp)
RETURNS bool
AS '_OBJWD_/regress_DLSUFFIX_'
- LANGUAGE 'c';
+ LANGUAGE 'newC';
CREATE FUNCTION boxarea(box)
RETURNS int4
AS '_OBJWD_/regress_DLSUFFIX_'
/*
- * $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 <float.h> /* faked on sunos */
#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);
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"
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",
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
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
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 ****************
projects / postgresql / commitdiff