1996-08-28 03:59:28 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
*
|
1999-02-14 00:22:53 +01:00
|
|
|
* builtins.h
|
1997-09-07 07:04:48 +02:00
|
|
|
* Declarations for operations on built-in types.
|
1996-08-28 03:59:28 +02:00
|
|
|
*
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 1994, Regents of the University of California
|
|
|
|
|
*
|
2000-01-24 08:16:52 +01:00
|
|
|
* $Id: builtins.h,v 1.98 2000/01/24 07:16:47 tgl Exp $
|
1996-08-28 03:59:28 +02:00
|
|
|
*
|
|
|
|
|
* NOTES
|
1997-09-07 07:04:48 +02:00
|
|
|
* This should normally only be included by fmgr.h.
|
|
|
|
|
* Under no circumstances should it ever be included before
|
|
|
|
|
* including fmgr.h!
|
1998-07-08 16:10:30 +02:00
|
|
|
* fmgr.h does not seem to include this file, so don't know where this
|
1998-09-01 06:40:42 +02:00
|
|
|
* comment came from. Backend code must include this stuff explicitly
|
|
|
|
|
* as far as I can tell...
|
1998-07-08 16:10:30 +02:00
|
|
|
* - thomas 1998-06-08
|
1996-08-28 03:59:28 +02:00
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
#ifndef BUILTINS_H
|
|
|
|
|
#define BUILTINS_H
|
|
|
|
|
|
2000-01-23 00:50:30 +01:00
|
|
|
#include "access/heapam.h" /* for HeapTuple */
|
|
|
|
|
#include "nodes/relation.h" /* for amcostestimate parameters */
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "storage/itemptr.h"
|
|
|
|
|
#include "utils/array.h"
|
|
|
|
|
#include "utils/datetime.h"
|
1999-07-16 19:07:40 +02:00
|
|
|
#include "utils/geo_decls.h"
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "utils/inet.h"
|
1999-07-16 19:07:40 +02:00
|
|
|
#include "utils/int8.h"
|
|
|
|
|
#include "utils/nabstime.h"
|
1999-07-16 01:04:24 +02:00
|
|
|
#include "utils/numeric.h"
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Defined in adt/
|
1996-08-28 03:59:28 +02:00
|
|
|
*/
|
|
|
|
|
/* bool.c */
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool boolin(char *b);
|
1997-10-09 07:07:25 +02:00
|
|
|
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);
|
1997-10-30 17:45:12 +01:00
|
|
|
extern bool istrue(bool arg1);
|
|
|
|
|
extern bool isfalse(bool arg1);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* char.c */
|
1997-09-08 04:41:22 +02:00
|
|
|
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);
|
1998-12-14 00:36:48 +01:00
|
|
|
extern int8 text_char(text *arg1);
|
1999-05-25 18:15:34 +02:00
|
|
|
extern text *char_text(int8 arg1);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* int.c */
|
1997-09-08 04:41:22 +02:00
|
|
|
extern int32 int2in(char *num);
|
|
|
|
|
extern char *int2out(int16 sh);
|
2000-01-10 17:13:23 +01:00
|
|
|
extern int16 *int2vectorin(char *shs);
|
|
|
|
|
extern char *int2vectorout(int16 *shs);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern int32 *int44in(char *input_string);
|
1998-09-01 05:29:17 +02:00
|
|
|
extern char *int44out(int32 *an_array);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern int32 int4in(char *num);
|
|
|
|
|
extern char *int4out(int32 l);
|
|
|
|
|
extern int32 i2toi4(int16 arg1);
|
|
|
|
|
extern int16 i4toi2(int32 arg1);
|
1997-10-25 07:40:43 +02:00
|
|
|
extern text *int2_text(int16 arg1);
|
|
|
|
|
extern int16 text_int2(text *arg1);
|
|
|
|
|
extern text *int4_text(int32 arg1);
|
|
|
|
|
extern int32 text_int4(text *arg1);
|
1997-09-08 04:41:22 +02:00
|
|
|
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);
|
1997-09-08 23:56:23 +02:00
|
|
|
extern bool keyfirsteq(int16 *arg1, int16 arg2);
|
1997-09-08 04:41:22 +02:00
|
|
|
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 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 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);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* name.c */
|
2000-01-22 15:20:56 +01:00
|
|
|
extern NameData *namein(const char *s);
|
|
|
|
|
extern char *nameout(const NameData *s);
|
|
|
|
|
extern bool nameeq(const NameData *arg1, const NameData *arg2);
|
|
|
|
|
extern bool namene(const NameData *arg1, const NameData *arg2);
|
|
|
|
|
extern bool namelt(const NameData *arg1, const NameData *arg2);
|
|
|
|
|
extern bool namele(const NameData *arg1, const NameData *arg2);
|
|
|
|
|
extern bool namegt(const NameData *arg1, const NameData *arg2);
|
|
|
|
|
extern bool namege(const NameData *arg1, const NameData *arg2);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern int namecpy(Name n1, Name n2);
|
2000-01-22 15:20:56 +01:00
|
|
|
extern int namestrcpy(Name name, const char *str);
|
|
|
|
|
extern int namestrcmp(Name name, const char *str);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* numutils.c */
|
|
|
|
|
/* XXX hack. HP-UX has a ltoa (with different arguments) already. */
|
1998-02-02 04:11:37 +01:00
|
|
|
#ifdef __hpux
|
1996-08-28 03:59:28 +02:00
|
|
|
#define ltoa pg_ltoa
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* hpux */
|
1997-09-08 04:41:22 +02:00
|
|
|
extern int32 pg_atoi(char *s, int size, int c);
|
1999-12-16 02:25:23 +01:00
|
|
|
/* XXX hack. QNX has itoa and ltoa (with different arguments) already. */
|
|
|
|
|
#ifdef __QNX__
|
|
|
|
|
#define itoa pg_itoa
|
|
|
|
|
#define ltoa pg_ltoa
|
|
|
|
|
#endif /* QNX */
|
1997-09-08 04:41:22 +02:00
|
|
|
extern void itoa(int i, char *a);
|
|
|
|
|
extern void ltoa(int32 l, char *a);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/*
|
1997-09-07 07:04:48 +02:00
|
|
|
* Per-opclass comparison functions for new btrees. These are
|
|
|
|
|
* stored in pg_amproc and defined in nbtree/
|
1996-08-28 03:59:28 +02:00
|
|
|
*/
|
1997-09-08 04:41:22 +02:00
|
|
|
extern int32 btint2cmp(int16 a, int16 b);
|
|
|
|
|
extern int32 btint4cmp(int32 a, int32 b);
|
1999-05-26 00:43:53 +02:00
|
|
|
extern int32 btint8cmp(int64 *a, int64 *b);
|
1997-09-08 04:41:22 +02:00
|
|
|
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);
|
2000-01-10 17:13:23 +01:00
|
|
|
extern int32 btoidvectorcmp(Oid *a, Oid *b);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern int32 btabstimecmp(AbsoluteTime a, AbsoluteTime b);
|
|
|
|
|
extern int32 btcharcmp(char a, char b);
|
1997-09-08 23:56:23 +02:00
|
|
|
extern int32 btnamecmp(NameData *a, NameData *b);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern int32 bttextcmp(struct varlena * a, struct varlena * b);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* support routines for the rtree access method, by opclass */
|
1997-09-08 22:59:27 +02:00
|
|
|
extern BOX *rt_box_union(BOX *a, BOX *b);
|
|
|
|
|
extern BOX *rt_box_inter(BOX *a, BOX *b);
|
|
|
|
|
extern void rt_box_size(BOX *a, float *size);
|
|
|
|
|
extern void rt_bigbox_size(BOX *a, float *size);
|
1997-09-08 23:56:23 +02:00
|
|
|
extern void rt_poly_size(POLYGON *a, float *size);
|
|
|
|
|
extern POLYGON *rt_poly_union(POLYGON *a, POLYGON *b);
|
|
|
|
|
extern POLYGON *rt_poly_inter(POLYGON *a, POLYGON *b);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* projection utilities */
|
1997-09-07 07:04:48 +02:00
|
|
|
/* extern char *GetAttributeByName();
|
1996-08-28 03:59:28 +02:00
|
|
|
extern char *GetAttributeByNum(); ,
|
|
|
|
|
in executor/executor.h*/
|
|
|
|
|
|
|
|
|
|
|
1997-09-08 04:41:22 +02:00
|
|
|
extern int32 pqtest(struct varlena * vlena);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* arrayfuncs.c */
|
|
|
|
|
|
|
|
|
|
/* date.c */
|
1999-03-14 17:44:02 +01:00
|
|
|
extern RelativeTime reltimein(char *timestring);
|
|
|
|
|
extern char *reltimeout(RelativeTime timevalue);
|
1996-08-28 03:59:28 +02:00
|
|
|
extern TimeInterval tintervalin(char *intervalstr);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern char *tintervalout(TimeInterval interval);
|
1997-09-08 23:56:23 +02:00
|
|
|
extern RelativeTime timespan_reltime(TimeSpan *timespan);
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
extern TimeSpan *reltime_timespan(RelativeTime reltime);
|
1996-08-28 03:59:28 +02:00
|
|
|
extern TimeInterval mktinterval(AbsoluteTime t1, AbsoluteTime t2);
|
|
|
|
|
extern AbsoluteTime timepl(AbsoluteTime t1, RelativeTime t2);
|
|
|
|
|
extern AbsoluteTime timemi(AbsoluteTime t1, RelativeTime t2);
|
1997-09-07 07:04:48 +02:00
|
|
|
|
1996-08-28 03:59:28 +02:00
|
|
|
/* extern RelativeTime abstimemi(AbsoluteTime t1, AbsoluteTime t2); static*/
|
1997-09-08 04:41:22 +02:00
|
|
|
extern int ininterval(AbsoluteTime t, TimeInterval interval);
|
1996-08-28 03:59:28 +02:00
|
|
|
extern RelativeTime intervalrel(TimeInterval interval);
|
|
|
|
|
extern AbsoluteTime timenow(void);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool reltimeeq(RelativeTime t1, RelativeTime t2);
|
|
|
|
|
extern bool reltimene(RelativeTime t1, RelativeTime t2);
|
|
|
|
|
extern bool reltimelt(RelativeTime t1, RelativeTime t2);
|
|
|
|
|
extern bool reltimegt(RelativeTime t1, RelativeTime t2);
|
|
|
|
|
extern bool reltimele(RelativeTime t1, RelativeTime t2);
|
|
|
|
|
extern bool reltimege(RelativeTime t1, RelativeTime t2);
|
1997-09-20 18:24:39 +02:00
|
|
|
extern bool intervalsame(TimeInterval i1, TimeInterval i2);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool intervaleq(TimeInterval i1, TimeInterval i2);
|
1997-09-20 18:24:39 +02:00
|
|
|
extern bool intervalne(TimeInterval i1, TimeInterval i2);
|
|
|
|
|
extern bool intervallt(TimeInterval i1, TimeInterval i2);
|
|
|
|
|
extern bool intervalgt(TimeInterval i1, TimeInterval i2);
|
|
|
|
|
extern bool intervalle(TimeInterval i1, TimeInterval i2);
|
|
|
|
|
extern bool intervalge(TimeInterval i1, TimeInterval i2);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool intervalleneq(TimeInterval i, RelativeTime t);
|
|
|
|
|
extern bool intervallenne(TimeInterval i, RelativeTime t);
|
|
|
|
|
extern bool intervallenlt(TimeInterval i, RelativeTime t);
|
|
|
|
|
extern bool intervallengt(TimeInterval i, RelativeTime t);
|
|
|
|
|
extern bool intervallenle(TimeInterval i, RelativeTime t);
|
|
|
|
|
extern bool intervallenge(TimeInterval i, RelativeTime t);
|
|
|
|
|
extern bool intervalct(TimeInterval i1, TimeInterval i2);
|
|
|
|
|
extern bool intervalov(TimeInterval i1, TimeInterval i2);
|
1996-08-28 03:59:28 +02:00
|
|
|
extern AbsoluteTime intervalstart(TimeInterval i);
|
|
|
|
|
extern AbsoluteTime intervalend(TimeInterval i);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern text *timeofday(void);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* filename.c */
|
1997-09-08 04:41:22 +02:00
|
|
|
extern char *filename_in(char *file);
|
|
|
|
|
extern char *filename_out(char *s);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* float.c */
|
1997-09-08 04:41:22 +02:00
|
|
|
extern void CheckFloat8Val(double val); /* used by lex */
|
|
|
|
|
extern float32 float4in(char *num);
|
|
|
|
|
extern char *float4out(float32 num);
|
|
|
|
|
extern float64 float8in(char *num);
|
|
|
|
|
extern char *float8out(float64 num);
|
|
|
|
|
extern float32 float4abs(float32 arg1);
|
|
|
|
|
extern float32 float4um(float32 arg1);
|
|
|
|
|
extern float32 float4larger(float32 arg1, float32 arg2);
|
|
|
|
|
extern float32 float4smaller(float32 arg1, float32 arg2);
|
|
|
|
|
extern float64 float8abs(float64 arg1);
|
|
|
|
|
extern float64 float8um(float64 arg1);
|
|
|
|
|
extern float64 float8larger(float64 arg1, float64 arg2);
|
|
|
|
|
extern float64 float8smaller(float64 arg1, float64 arg2);
|
|
|
|
|
extern float32 float4pl(float32 arg1, float32 arg2);
|
|
|
|
|
extern float32 float4mi(float32 arg1, float32 arg2);
|
|
|
|
|
extern float32 float4mul(float32 arg1, float32 arg2);
|
|
|
|
|
extern float32 float4div(float32 arg1, float32 arg2);
|
|
|
|
|
extern float32 float4inc(float32 arg1);
|
|
|
|
|
extern float64 float8pl(float64 arg1, float64 arg2);
|
|
|
|
|
extern float64 float8mi(float64 arg1, float64 arg2);
|
|
|
|
|
extern float64 float8mul(float64 arg1, float64 arg2);
|
|
|
|
|
extern float64 float8div(float64 arg1, float64 arg2);
|
|
|
|
|
extern float64 float8inc(float64 arg1);
|
|
|
|
|
extern bool float4eq(float32 arg1, float32 arg2);
|
|
|
|
|
extern bool float4ne(float32 arg1, float32 arg2);
|
|
|
|
|
extern bool float4lt(float32 arg1, float32 arg2);
|
|
|
|
|
extern bool float4le(float32 arg1, float32 arg2);
|
|
|
|
|
extern bool float4gt(float32 arg1, float32 arg2);
|
|
|
|
|
extern bool float4ge(float32 arg1, float32 arg2);
|
|
|
|
|
extern bool float8eq(float64 arg1, float64 arg2);
|
|
|
|
|
extern bool float8ne(float64 arg1, float64 arg2);
|
|
|
|
|
extern bool float8lt(float64 arg1, float64 arg2);
|
|
|
|
|
extern bool float8le(float64 arg1, float64 arg2);
|
|
|
|
|
extern bool float8gt(float64 arg1, float64 arg2);
|
|
|
|
|
extern bool float8ge(float64 arg1, float64 arg2);
|
|
|
|
|
extern float64 ftod(float32 num);
|
|
|
|
|
extern float64 i4tod(int32 num);
|
|
|
|
|
extern float64 i2tod(int16 num);
|
|
|
|
|
extern float32 dtof(float64 num);
|
|
|
|
|
extern int32 dtoi4(float64 num);
|
|
|
|
|
extern int16 dtoi2(float64 num);
|
|
|
|
|
extern float32 i4tof(int32 num);
|
|
|
|
|
extern float32 i2tof(int16 num);
|
|
|
|
|
extern int32 ftoi4(float32 num);
|
|
|
|
|
extern int16 ftoi2(float32 num);
|
1998-11-17 15:36:51 +01:00
|
|
|
extern float64 text_float8(text *str);
|
|
|
|
|
extern float32 text_float4(text *str);
|
|
|
|
|
extern text *float8_text(float64 num);
|
|
|
|
|
extern text *float4_text(float32 num);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern float64 dround(float64 arg1);
|
|
|
|
|
extern float64 dtrunc(float64 arg1);
|
|
|
|
|
extern float64 dsqrt(float64 arg1);
|
|
|
|
|
extern float64 dcbrt(float64 arg1);
|
|
|
|
|
extern float64 dpow(float64 arg1, float64 arg2);
|
|
|
|
|
extern float64 dexp(float64 arg1);
|
|
|
|
|
extern float64 dlog1(float64 arg1);
|
|
|
|
|
extern float64 float48pl(float32 arg1, float64 arg2);
|
|
|
|
|
extern float64 float48mi(float32 arg1, float64 arg2);
|
|
|
|
|
extern float64 float48mul(float32 arg1, float64 arg2);
|
|
|
|
|
extern float64 float48div(float32 arg1, float64 arg2);
|
|
|
|
|
extern float64 float84pl(float64 arg1, float32 arg2);
|
|
|
|
|
extern float64 float84mi(float64 arg1, float32 arg2);
|
|
|
|
|
extern float64 float84mul(float64 arg1, float32 arg2);
|
|
|
|
|
extern float64 float84div(float64 arg1, float32 arg2);
|
|
|
|
|
extern bool float48eq(float32 arg1, float64 arg2);
|
|
|
|
|
extern bool float48ne(float32 arg1, float64 arg2);
|
|
|
|
|
extern bool float48lt(float32 arg1, float64 arg2);
|
|
|
|
|
extern bool float48le(float32 arg1, float64 arg2);
|
|
|
|
|
extern bool float48gt(float32 arg1, float64 arg2);
|
|
|
|
|
extern bool float48ge(float32 arg1, float64 arg2);
|
|
|
|
|
extern bool float84eq(float64 arg1, float32 arg2);
|
|
|
|
|
extern bool float84ne(float64 arg1, float32 arg2);
|
|
|
|
|
extern bool float84lt(float64 arg1, float32 arg2);
|
|
|
|
|
extern bool float84le(float64 arg1, float32 arg2);
|
|
|
|
|
extern bool float84gt(float64 arg1, float32 arg2);
|
|
|
|
|
extern bool float84ge(float64 arg1, float32 arg2);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
1997-03-15 00:34:16 +01:00
|
|
|
/* geo_ops.c, geo_selfuncs.c */
|
1997-09-08 22:59:27 +02:00
|
|
|
extern double *box_area(BOX *box);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* misc.c */
|
1997-09-08 23:56:23 +02:00
|
|
|
extern bool nullvalue(Datum value, bool *isNull);
|
|
|
|
|
extern bool nonnullvalue(Datum value, bool *isNull);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool oidrand(Oid o, int32 X);
|
|
|
|
|
extern bool oidsrand(int32 X);
|
|
|
|
|
extern int32 userfntest(int i);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
1997-04-27 21:24:16 +02:00
|
|
|
/* 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)
|
|
|
|
|
|
1996-08-28 03:59:28 +02:00
|
|
|
/* not_in.c */
|
1999-03-15 04:24:32 +01:00
|
|
|
extern bool int4notin(int32 not_in_arg, char *relation_and_attr);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool oidnotin(Oid the_oid, char *compare);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* oid.c */
|
2000-01-10 17:13:23 +01:00
|
|
|
extern Oid *oidvectorin(char *oidString);
|
|
|
|
|
extern char *oidvectorout(Oid *oidArray);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern Oid oidin(char *s);
|
|
|
|
|
extern char *oidout(Oid o);
|
|
|
|
|
extern bool oideq(Oid arg1, Oid arg2);
|
|
|
|
|
extern bool oidne(Oid arg1, Oid arg2);
|
2000-01-10 17:13:23 +01:00
|
|
|
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);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool oideqint4(Oid arg1, int32 arg2);
|
|
|
|
|
extern bool int4eqoid(int32 arg1, Oid arg2);
|
1997-10-25 07:40:43 +02:00
|
|
|
extern text *oid_text(Oid arg1);
|
1998-02-26 05:46:47 +01:00
|
|
|
extern Oid text_oid(text *arg1);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* regexp.c */
|
1997-09-08 23:56:23 +02:00
|
|
|
extern bool nameregexeq(NameData *n, struct varlena * p);
|
|
|
|
|
extern bool nameregexne(NameData *s, struct varlena * p);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool textregexeq(struct varlena * s, struct varlena * p);
|
|
|
|
|
extern bool textregexne(struct varlena * s, struct varlena * p);
|
1997-09-08 23:56:23 +02:00
|
|
|
extern bool nameicregexeq(NameData *s, struct varlena * p);
|
|
|
|
|
extern bool nameicregexne(NameData *s, struct varlena * p);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool texticregexeq(struct varlena * s, struct varlena * p);
|
|
|
|
|
extern bool texticregexne(struct varlena * s, struct varlena * p);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
/* regproc.c */
|
1998-08-31 09:55:50 +02:00
|
|
|
extern int32 regprocin(char *pro_name_and_oid);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern char *regprocout(RegProcedure proid);
|
2000-01-10 17:13:23 +01:00
|
|
|
extern text *oidvectortypes(Oid *oidArray);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern Oid regproctooid(RegProcedure rp);
|
1997-04-27 21:24:16 +02:00
|
|
|
|
|
|
|
|
/* define macro to replace mixed-case function call - tgl 97/04/27 */
|
|
|
|
|
#define RegprocToOid(rp) regproctooid(rp)
|
1996-08-28 03:59:28 +02:00
|
|
|
|
1999-10-04 01:55:40 +02:00
|
|
|
/* ruleutils.c */
|
|
|
|
|
extern text *pg_get_ruledef(NameData *rname);
|
|
|
|
|
extern text *pg_get_viewdef(NameData *rname);
|
|
|
|
|
extern text *pg_get_indexdef(Oid indexrelid);
|
|
|
|
|
extern NameData *pg_get_userbyid(int32 uid);
|
|
|
|
|
extern char *deparse_expression(Node *expr, List *rangetables,
|
|
|
|
|
bool forceprefix);
|
|
|
|
|
|
1996-08-28 03:59:28 +02:00
|
|
|
/* selfuncs.c */
|
1999-08-01 06:54:25 +02:00
|
|
|
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);
|
2000-01-24 08:16:52 +01:00
|
|
|
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);
|
1997-09-08 04:41:22 +02:00
|
|
|
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);
|
2000-01-24 08:16:52 +01:00
|
|
|
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 bool convert_to_scalar(Datum value, Oid typid, double *scaleval);
|
2000-01-23 00:50:30 +01:00
|
|
|
|
|
|
|
|
extern void btcostestimate(Query *root, RelOptInfo *rel,
|
|
|
|
|
IndexOptInfo *index, List *indexQuals,
|
|
|
|
|
Cost *indexAccessCost,
|
|
|
|
|
Selectivity *indexSelectivity);
|
|
|
|
|
extern void rtcostestimate(Query *root, RelOptInfo *rel,
|
|
|
|
|
IndexOptInfo *index, List *indexQuals,
|
|
|
|
|
Cost *indexAccessCost,
|
|
|
|
|
Selectivity *indexSelectivity);
|
|
|
|
|
extern void hashcostestimate(Query *root, RelOptInfo *rel,
|
|
|
|
|
IndexOptInfo *index, List *indexQuals,
|
|
|
|
|
Cost *indexAccessCost,
|
|
|
|
|
Selectivity *indexSelectivity);
|
|
|
|
|
extern void gistcostestimate(Query *root, RelOptInfo *rel,
|
|
|
|
|
IndexOptInfo *index, List *indexQuals,
|
|
|
|
|
Cost *indexAccessCost,
|
|
|
|
|
Selectivity *indexSelectivity);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* tid.c */
|
1999-10-11 08:28:29 +02:00
|
|
|
extern ItemPointer tidin(const char *str);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern char *tidout(ItemPointer itemPtr);
|
1999-10-11 08:28:29 +02:00
|
|
|
extern bool tideq(ItemPointer,ItemPointer);
|
|
|
|
|
extern bool tidne(ItemPointer,ItemPointer);
|
|
|
|
|
extern text *tid_text(ItemPointer);
|
|
|
|
|
extern ItemPointer text_tid(const text *);
|
|
|
|
|
extern ItemPointer currtid_byreloid(Oid relOid, ItemPointer);
|
|
|
|
|
extern ItemPointer currtid_byrelname(const text* relName, ItemPointer);
|
1997-03-12 22:28:14 +01:00
|
|
|
|
|
|
|
|
/* timestamp.c */
|
1997-09-08 04:41:22 +02:00
|
|
|
extern time_t timestamp_in(const char *timestamp_str);
|
|
|
|
|
extern char *timestamp_out(time_t timestamp);
|
|
|
|
|
extern time_t now(void);
|
|
|
|
|
bool timestampeq(time_t t1, time_t t2);
|
|
|
|
|
bool timestampne(time_t t1, time_t t2);
|
|
|
|
|
bool timestamplt(time_t t1, time_t t2);
|
|
|
|
|
bool timestampgt(time_t t1, time_t t2);
|
|
|
|
|
bool timestample(time_t t1, time_t t2);
|
|
|
|
|
bool timestampge(time_t t1, time_t t2);
|
1997-12-23 20:55:51 +01:00
|
|
|
DateTime *timestamp_datetime(time_t timestamp);
|
|
|
|
|
time_t datetime_timestamp(DateTime *datetime);
|
1997-03-12 22:28:14 +01:00
|
|
|
|
1996-11-10 04:06:38 +01:00
|
|
|
/* varchar.c */
|
1998-07-12 23:29:40 +02:00
|
|
|
extern char *bpcharin(char *s, int dummy, int32 atttypmod);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern char *bpcharout(char *s);
|
1998-05-10 00:45:14 +02:00
|
|
|
extern char *bpchar(char *s, int32 slen);
|
1999-05-03 21:10:48 +02:00
|
|
|
extern ArrayType *_bpchar(ArrayType *v, int32 slen);
|
1998-05-10 00:45:14 +02:00
|
|
|
extern char *char_bpchar(int32 c);
|
|
|
|
|
extern int32 bpchar_char(char *s);
|
1998-05-29 15:37:29 +02:00
|
|
|
extern char *name_bpchar(NameData *s);
|
|
|
|
|
extern NameData *bpchar_name(char *s);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool bpchareq(char *arg1, char *arg2);
|
|
|
|
|
extern bool bpcharne(char *arg1, char *arg2);
|
|
|
|
|
extern bool bpcharlt(char *arg1, char *arg2);
|
|
|
|
|
extern bool bpcharle(char *arg1, char *arg2);
|
|
|
|
|
extern bool bpchargt(char *arg1, char *arg2);
|
|
|
|
|
extern bool bpcharge(char *arg1, char *arg2);
|
|
|
|
|
extern int32 bpcharcmp(char *arg1, char *arg2);
|
1997-12-16 16:55:17 +01:00
|
|
|
extern int32 bpcharlen(char *arg);
|
1998-04-27 19:10:50 +02:00
|
|
|
extern int32 bpcharoctetlen(char *arg);
|
1997-12-16 16:55:17 +01:00
|
|
|
extern uint32 hashbpchar(struct varlena * key);
|
|
|
|
|
|
1998-07-12 23:29:40 +02:00
|
|
|
extern char *varcharin(char *s, int dummy, int32 atttypmod);
|
1997-12-16 16:55:17 +01:00
|
|
|
extern char *varcharout(char *s);
|
1998-05-10 00:45:14 +02:00
|
|
|
extern char *varchar(char *s, int32 slen);
|
1999-05-03 21:10:48 +02:00
|
|
|
extern ArrayType *_varchar(ArrayType *v, int32 slen);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool varchareq(char *arg1, char *arg2);
|
|
|
|
|
extern bool varcharne(char *arg1, char *arg2);
|
|
|
|
|
extern bool varcharlt(char *arg1, char *arg2);
|
|
|
|
|
extern bool varcharle(char *arg1, char *arg2);
|
|
|
|
|
extern bool varchargt(char *arg1, char *arg2);
|
|
|
|
|
extern bool varcharge(char *arg1, char *arg2);
|
|
|
|
|
extern int32 varcharcmp(char *arg1, char *arg2);
|
1997-12-16 16:55:17 +01:00
|
|
|
extern int32 varcharlen(char *arg);
|
1998-04-27 19:10:50 +02:00
|
|
|
extern int32 varcharoctetlen(char *arg);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern uint32 hashvarchar(struct varlena * key);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
|
|
|
|
/* varlena.c */
|
1997-12-16 16:55:17 +01:00
|
|
|
extern text *textin(char *inputText);
|
1998-01-01 06:42:40 +01:00
|
|
|
extern char *textout(text *vlena);
|
1997-12-16 16:55:17 +01:00
|
|
|
extern text *textcat(text *arg1, text *arg2);
|
1998-01-01 06:42:40 +01:00
|
|
|
extern bool texteq(text *arg1, text *arg2);
|
|
|
|
|
extern bool textne(text *arg1, text *arg2);
|
1998-09-01 06:40:42 +02:00
|
|
|
extern int varstr_cmp(char *arg1, int len1, char *arg2, int len2);
|
1998-01-01 06:42:40 +01:00
|
|
|
extern bool text_lt(text *arg1, text *arg2);
|
|
|
|
|
extern bool text_le(text *arg1, text *arg2);
|
|
|
|
|
extern bool text_gt(text *arg1, text *arg2);
|
|
|
|
|
extern bool text_ge(text *arg1, text *arg2);
|
1998-12-08 07:18:34 +01:00
|
|
|
extern text *text_larger(text *arg1, text *arg2);
|
|
|
|
|
extern text *text_smaller(text *arg1, text *arg2);
|
1997-12-16 16:55:17 +01:00
|
|
|
extern int32 textlen(text *arg);
|
1998-04-27 19:10:50 +02:00
|
|
|
extern int32 textoctetlen(text *arg);
|
1997-12-16 16:55:17 +01:00
|
|
|
extern int32 textpos(text *arg1, text *arg2);
|
1998-01-01 06:42:40 +01:00
|
|
|
extern text *text_substr(text *string, int32 m, int32 n);
|
1998-05-29 15:37:29 +02:00
|
|
|
extern text *name_text(NameData *s);
|
|
|
|
|
extern NameData *text_name(text *s);
|
1997-12-16 16:55:17 +01:00
|
|
|
|
|
|
|
|
extern struct varlena *byteain(char *inputText);
|
1998-02-26 05:46:47 +01:00
|
|
|
extern char *byteaout(struct varlena * vlena);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern int32 byteaGetSize(struct varlena * v);
|
|
|
|
|
extern int32 byteaGetByte(struct varlena * v, int32 n);
|
|
|
|
|
extern int32 byteaGetBit(struct varlena * v, int32 n);
|
1997-09-07 07:04:48 +02:00
|
|
|
extern struct varlena *byteaSetByte(struct varlena * v, int32 n, int32 newByte);
|
|
|
|
|
extern struct varlena *byteaSetBit(struct varlena * v, int32 n, int32 newBit);
|
1996-08-28 03:59:28 +02:00
|
|
|
|
1997-03-15 00:34:16 +01:00
|
|
|
/* datetime.c */
|
1997-09-08 04:41:22 +02:00
|
|
|
extern DateADT date_in(char *datestr);
|
|
|
|
|
extern char *date_out(DateADT dateVal);
|
|
|
|
|
extern bool date_eq(DateADT dateVal1, DateADT dateVal2);
|
|
|
|
|
extern bool date_ne(DateADT dateVal1, DateADT dateVal2);
|
|
|
|
|
extern bool date_lt(DateADT dateVal1, DateADT dateVal2);
|
|
|
|
|
extern bool date_le(DateADT dateVal1, DateADT dateVal2);
|
|
|
|
|
extern bool date_gt(DateADT dateVal1, DateADT dateVal2);
|
|
|
|
|
extern bool date_ge(DateADT dateVal1, DateADT dateVal2);
|
|
|
|
|
extern int date_cmp(DateADT dateVal1, DateADT dateVal2);
|
|
|
|
|
extern DateADT date_larger(DateADT dateVal1, DateADT dateVal2);
|
|
|
|
|
extern DateADT date_smaller(DateADT dateVal1, DateADT dateVal2);
|
|
|
|
|
extern int32 date_mi(DateADT dateVal1, DateADT dateVal2);
|
|
|
|
|
extern DateADT date_pli(DateADT dateVal, int32 days);
|
|
|
|
|
extern DateADT date_mii(DateADT dateVal, int32 days);
|
From: Thomas Lockhart <Thomas.G.Lockhart@jpl.nasa.gov>
Subject: [HACKERS] More date time functions
Here are some additional patches mostly related to the date and time
data types. It includes some type conversion routines to move between
the different date types and some other date manipulation routines such
as date_part(units,datetime).
I noticed Edmund Mergl et al's neat trick for getting function overloading
for builtin functions, so started to use that for the date and time stuff.
Later, if someone figures out how to get function overloading directly
for internal C code, then we can move to that technique.
These patches include documentation updates (don't faint!) for the built-in
man page. Doesn't yet include mention of timestamp, since I don't know
much about it and since it may change a bit to become a _real_ ANSI timestamp
which would include parser support for the declaration syntax (what do you
think, Dan?).
The patches were developed on the 970330 release, but have been rebuilt
off of the 970402 release. The first patch below is to get libpq to compile,
on my Linux box, but is not related to the rest of the patches and you can
choose not to apply that one at this time. Thanks in advance, scrappy!
1997-04-02 20:36:24 +02:00
|
|
|
extern DateTime *date_datetime(DateADT date);
|
1997-09-08 23:56:23 +02:00
|
|
|
extern DateADT datetime_date(DateTime *datetime);
|
1997-12-23 20:55:51 +01:00
|
|
|
extern DateTime *datetime_datetime(DateADT date, TimeADT *time);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern DateADT abstime_date(AbsoluteTime abstime);
|
1997-03-15 00:34:16 +01:00
|
|
|
|
|
|
|
|
extern TimeADT *time_in(char *timestr);
|
1997-09-08 23:56:23 +02:00
|
|
|
extern char *time_out(TimeADT *time);
|
|
|
|
|
extern bool time_eq(TimeADT *time1, TimeADT *time2);
|
|
|
|
|
extern bool time_ne(TimeADT *time1, TimeADT *time2);
|
|
|
|
|
extern bool time_lt(TimeADT *time1, TimeADT *time2);
|
|
|
|
|
extern bool time_le(TimeADT *time1, TimeADT *time2);
|
|
|
|
|
extern bool time_gt(TimeADT *time1, TimeADT *time2);
|
|
|
|
|
extern bool time_ge(TimeADT *time1, TimeADT *time2);
|
|
|
|
|
extern int time_cmp(TimeADT *time1, TimeADT *time2);
|
1997-10-25 07:40:43 +02:00
|
|
|
extern TimeADT *datetime_time(DateTime *datetime);
|
1998-08-19 04:04:17 +02:00
|
|
|
extern int32 int4reltime(int32 timevalue);
|
1996-11-10 04:06:38 +01:00
|
|
|
|
|
|
|
|
/* like.c */
|
1997-09-08 23:56:23 +02:00
|
|
|
extern bool namelike(NameData *n, struct varlena * p);
|
|
|
|
|
extern bool namenlike(NameData *s, struct varlena * p);
|
1997-09-08 04:41:22 +02:00
|
|
|
extern bool textlike(struct varlena * s, struct varlena * p);
|
|
|
|
|
extern bool textnlike(struct varlena * s, struct varlena * p);
|
1996-11-10 04:06:38 +01:00
|
|
|
|
1997-03-09 21:41:02 +01:00
|
|
|
/* oracle_compat.c */
|
|
|
|
|
|
1997-09-08 23:56:23 +02:00
|
|
|
extern text *lower(text *string);
|
|
|
|
|
extern text *upper(text *string);
|
|
|
|
|
extern text *initcap(text *string);
|
|
|
|
|
extern text *lpad(text *string1, int4 len, text *string2);
|
|
|
|
|
extern text *rpad(text *string1, int4 len, text *string2);
|
|
|
|
|
extern text *ltrim(text *string, text *set);
|
|
|
|
|
extern text *rtrim(text *string, text *set);
|
|
|
|
|
extern text *translate(text *string, char from, char to);
|
1997-03-09 21:41:02 +01:00
|
|
|
|
1996-08-28 03:59:28 +02:00
|
|
|
/* acl.c */
|
|
|
|
|
|
1998-10-03 07:41:01 +02:00
|
|
|
/* inet_net_ntop.c */
|
1999-05-25 18:15:34 +02:00
|
|
|
char *inet_net_ntop(int af, const void *src, int bits, char *dst, size_t size);
|
|
|
|
|
char *inet_cidr_ntop(int af, const void *src, int bits, char *dst, size_t size);
|
1998-10-03 07:41:01 +02:00
|
|
|
|
|
|
|
|
/* inet_net_pton.c */
|
1999-05-25 18:15:34 +02:00
|
|
|
int inet_net_pton(int af, const char *src, void *dst, size_t size);
|
1998-10-03 07:41:01 +02:00
|
|
|
|
1998-10-22 22:40:50 +02:00
|
|
|
/* network.c */
|
1998-10-08 02:19:47 +02:00
|
|
|
inet *inet_in(char *str);
|
1999-05-25 18:15:34 +02:00
|
|
|
char *inet_out(inet *addr);
|
1998-10-22 15:16:27 +02:00
|
|
|
inet *cidr_in(char *str);
|
|
|
|
|
char *cidr_out(inet *addr);
|
1999-05-25 18:15:34 +02:00
|
|
|
bool network_lt(inet *a1, inet *a2);
|
|
|
|
|
bool network_le(inet *a1, inet *a2);
|
|
|
|
|
bool network_eq(inet *a1, inet *a2);
|
|
|
|
|
bool network_ge(inet *a1, inet *a2);
|
|
|
|
|
bool network_gt(inet *a1, inet *a2);
|
|
|
|
|
bool network_ne(inet *a1, inet *a2);
|
|
|
|
|
bool network_sub(inet *a1, inet *a2);
|
|
|
|
|
bool network_subeq(inet *a1, inet *a2);
|
|
|
|
|
bool network_sup(inet *a1, inet *a2);
|
|
|
|
|
bool network_supeq(inet *a1, inet *a2);
|
|
|
|
|
int4 network_cmp(inet *a1, inet *a2);
|
|
|
|
|
|
|
|
|
|
text *network_network(inet *addr);
|
|
|
|
|
text *network_netmask(inet *addr);
|
|
|
|
|
int4 network_masklen(inet *addr);
|
|
|
|
|
text *network_broadcast(inet *addr);
|
|
|
|
|
text *network_host(inet *addr);
|
1998-10-03 07:41:01 +02:00
|
|
|
|
|
|
|
|
/* mac.c */
|
|
|
|
|
macaddr *macaddr_in(char *str);
|
1999-05-25 18:15:34 +02:00
|
|
|
char *macaddr_out(macaddr *addr);
|
|
|
|
|
bool macaddr_lt(macaddr *a1, macaddr *a2);
|
|
|
|
|
bool macaddr_le(macaddr *a1, macaddr *a2);
|
|
|
|
|
bool macaddr_eq(macaddr *a1, macaddr *a2);
|
|
|
|
|
bool macaddr_ge(macaddr *a1, macaddr *a2);
|
|
|
|
|
bool macaddr_gt(macaddr *a1, macaddr *a2);
|
|
|
|
|
bool macaddr_ne(macaddr *a1, macaddr *a2);
|
|
|
|
|
int4 macaddr_cmp(macaddr *a1, macaddr *a2);
|
|
|
|
|
text *macaddr_manuf(macaddr *addr);
|
1998-10-03 07:41:01 +02:00
|
|
|
|
1998-12-30 20:56:35 +01:00
|
|
|
/* numeric.c */
|
|
|
|
|
Numeric numeric_in(char *str, int dummy, int32 typmod);
|
1999-05-25 18:15:34 +02:00
|
|
|
char *numeric_out(Numeric num);
|
1998-12-30 20:56:35 +01:00
|
|
|
Numeric numeric(Numeric num, int32 typmod);
|
|
|
|
|
Numeric numeric_abs(Numeric num);
|
|
|
|
|
Numeric numeric_sign(Numeric num);
|
|
|
|
|
Numeric numeric_round(Numeric num, int32 scale);
|
|
|
|
|
Numeric numeric_trunc(Numeric num, int32 scale);
|
|
|
|
|
Numeric numeric_ceil(Numeric num);
|
|
|
|
|
Numeric numeric_floor(Numeric num);
|
1999-09-29 23:13:31 +02:00
|
|
|
int32 numeric_cmp(Numeric num1, Numeric num2);
|
1998-12-30 20:56:35 +01:00
|
|
|
bool numeric_eq(Numeric num1, Numeric num2);
|
|
|
|
|
bool numeric_ne(Numeric num1, Numeric num2);
|
|
|
|
|
bool numeric_gt(Numeric num1, Numeric num2);
|
|
|
|
|
bool numeric_ge(Numeric num1, Numeric num2);
|
|
|
|
|
bool numeric_lt(Numeric num1, Numeric num2);
|
|
|
|
|
bool numeric_le(Numeric num1, Numeric num2);
|
|
|
|
|
Numeric numeric_add(Numeric num1, Numeric num2);
|
|
|
|
|
Numeric numeric_sub(Numeric num1, Numeric num2);
|
|
|
|
|
Numeric numeric_mul(Numeric num1, Numeric num2);
|
|
|
|
|
Numeric numeric_div(Numeric num1, Numeric num2);
|
|
|
|
|
Numeric numeric_mod(Numeric num1, Numeric num2);
|
|
|
|
|
Numeric numeric_inc(Numeric num);
|
|
|
|
|
Numeric numeric_dec(Numeric num);
|
|
|
|
|
Numeric numeric_smaller(Numeric num1, Numeric num2);
|
|
|
|
|
Numeric numeric_larger(Numeric num1, Numeric num2);
|
|
|
|
|
Numeric numeric_sqrt(Numeric num);
|
|
|
|
|
Numeric numeric_exp(Numeric num);
|
|
|
|
|
Numeric numeric_ln(Numeric num);
|
|
|
|
|
Numeric numeric_log(Numeric num1, Numeric num2);
|
|
|
|
|
Numeric numeric_power(Numeric num1, Numeric num2);
|
|
|
|
|
Numeric int4_numeric(int32 val);
|
|
|
|
|
int32 numeric_int4(Numeric num);
|
|
|
|
|
Numeric float4_numeric(float32 val);
|
|
|
|
|
float32 numeric_float4(Numeric num);
|
|
|
|
|
Numeric float8_numeric(float64 val);
|
|
|
|
|
float64 numeric_float8(Numeric num);
|
|
|
|
|
|
1999-09-30 16:54:24 +02:00
|
|
|
/* ri_triggers.c */
|
|
|
|
|
HeapTuple RI_FKey_check_ins(FmgrInfo *proinfo);
|
|
|
|
|
HeapTuple RI_FKey_check_upd(FmgrInfo *proinfo);
|
2000-01-06 21:47:01 +01:00
|
|
|
HeapTuple RI_FKey_noaction_del(FmgrInfo *proinfo);
|
|
|
|
|
HeapTuple RI_FKey_noaction_upd(FmgrInfo *proinfo);
|
1999-09-30 16:54:24 +02:00
|
|
|
HeapTuple RI_FKey_cascade_del(FmgrInfo *proinfo);
|
|
|
|
|
HeapTuple RI_FKey_cascade_upd(FmgrInfo *proinfo);
|
|
|
|
|
HeapTuple RI_FKey_restrict_del(FmgrInfo *proinfo);
|
|
|
|
|
HeapTuple RI_FKey_restrict_upd(FmgrInfo *proinfo);
|
|
|
|
|
HeapTuple RI_FKey_setnull_del(FmgrInfo *proinfo);
|
|
|
|
|
HeapTuple RI_FKey_setnull_upd(FmgrInfo *proinfo);
|
|
|
|
|
HeapTuple RI_FKey_setdefault_del(FmgrInfo *proinfo);
|
|
|
|
|
HeapTuple RI_FKey_setdefault_upd(FmgrInfo *proinfo);
|
1998-10-03 07:41:01 +02:00
|
|
|
|
1998-09-01 06:40:42 +02:00
|
|
|
#endif /* BUILTINS_H */
|
