opensourcemirror
/
postgresql
mirror of git://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Date/Time updates from Thomas...

This commit is contained in:
Marc G. Fournier 1997-03-14 23:21:12 +00:00
parent 71fd8d4a4b
commit 53d8be3bbf
19 changed files with 3380 additions and 1424 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/backend/access/rtree/rtproc.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtproc.c,v 1.5 1996/11/10 02:58:53 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtproc.c,v 1.6 1997/03/14 23:17:41 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
@ -15,7 +15,7 @@
#include <postgres.h>
#include <utils/builtins.h>
#include <utils/geo-decls.h>
#include <utils/geo_decls.h>
#ifndef HAVE_MEMMOVE
# include <regex/utils.h>
#else

4
src/backend/access/rtree/rtree.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.11 1997/01/10 09:47:28 vadim Exp $
* $Header: /cvsroot/pgsql/src/backend/access/rtree/Attic/rtree.c,v 1.12 1997/03/14 23:17:46 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
@ -20,7 +20,7 @@
#include <storage/lmgr.h>
#include <access/rtree.h>
#include <storage/bufmgr.h>
#include <utils/geo-decls.h>
#include <utils/geo_decls.h>
#include <executor/executor.h>
#include <access/heapam.h>
#include <fmgr.h>

13
src/backend/access/transam/xact.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.7 1997/03/12 20:41:14 scrappy Exp $
* $Header: /cvsroot/pgsql/src/backend/access/transam/xact.c,v 1.8 1997/03/14 23:18:16 scrappy Exp $
*
* NOTES
* Transaction aborts can now occur two ways:
@ -171,7 +171,14 @@ TransactionState CurrentTransactionState =
&CurrentTransactionStateData;
/* ----------------
* info returned when the system is desabled
* info returned when the system is disabled
*
* Apparently a lot of this code is inherited from other prototype systems.
* For DisabledStartTime, use a symbolic value to make the relationships clearer.
* The old value of 1073741823 corresponds to a date in y2004, which is coming closer
* every day. It appears that if we return a value guaranteed larger than
* any real time associated with a transaction then comparisons in other
* modules will still be correct. Let's use BIG_ABSTIME for this. tgl 2/14/97
*
* Note: I have no idea what the significance of the
* 1073741823 in DisabledStartTime.. I just carried
@ -183,7 +190,7 @@ TransactionId DisabledTransactionId = (TransactionId)-1;
CommandId DisabledCommandId = (CommandId) -1;
AbsoluteTime DisabledStartTime = (AbsoluteTime) 1073741823;
AbsoluteTime DisabledStartTime = (AbsoluteTime) BIG_ABSTIME; /* 1073741823; */
/* ----------------
* overflow flag

4
src/backend/bootstrap/bootstrap.c
View File

@ -7,7 +7,7 @@
* Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.16 1997/03/12 20:57:33 scrappy Exp $
* $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.17 1997/03/14 23:18:32 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
@ -89,7 +89,7 @@
#include "catalog/catname.h"
#include "utils/geo-decls.h"
#include "utils/geo_decls.h"
#include "utils/builtins.h"
#include "catalog/index.h"

7
src/backend/utils/adt/Makefile
View File

@ -4,7 +4,7 @@
# Makefile for utils/adt
#
# IDENTIFICATION
# $Header: /cvsroot/pgsql/src/backend/utils/adt/Makefile,v 1.6 1997/03/12 21:27:03 scrappy Exp $
# $Header: /cvsroot/pgsql/src/backend/utils/adt/Makefile,v 1.7 1997/03/14 23:19:50 scrappy Exp $
#
#-------------------------------------------------------------------------
@ -20,8 +20,9 @@ CFLAGS+=$(INCLUDE_OPT)
OBJS = acl.o arrayfuncs.o arrayutils.o bool.o char.o chunk.o date.o \
datum.o dt.o filename.o float.o geo_ops.o geo_selfuncs.o int.o \
misc.o nabstime.o name.o not_in.o numutils.o oid.o \
oidname.o oidint2.o oidint4.o oracle_compat.o regexp.o regproc.o selfuncs.o \
tid.o varchar.o varlena.o sets.o datetimes.o like.o timestamp.o
oidname.o oidint2.o oidint4.o oracle_compat.o regexp.o regproc.o \
selfuncs.o \
tid.o varchar.o varlena.o sets.o datetime.o like.o timestamp.o
all: SUBSYS.o

10
src/backend/utils/adt/bool.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/bool.c,v 1.2 1996/11/03 06:53:03 scrappy Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/bool.c,v 1.3 1997/03/14 23:19:52 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
@ -24,12 +24,12 @@
/*
* boolin - converts "t" or "f" to 1 or 0
*/
int32
bool
boolin(char *b)
{
if (b == NULL)
elog(WARN, "Bad input string for type bool");
return((int32) (*b == 't') || (*b == 'T'));
return((bool) (*b == 't') || (*b == 'T'));
}
/*
@ -49,13 +49,13 @@ boolout(long b)
* PUBLIC ROUTINES *
*****************************************************************************/
int32
bool
booleq(int8 arg1, int8 arg2)
{
return(arg1 == arg2);
}
int32
bool
boolne(int8 arg1, int8 arg2)
{
return(arg1 != arg2);

116
src/backend/utils/adt/char.c
View File

@ -12,7 +12,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.2 1996/09/10 06:41:34 scrappy Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/char.c,v 1.3 1997/03/14 23:19:54 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
@ -127,25 +127,25 @@ char *char16out(char *s)
* PUBLIC ROUTINES *
*****************************************************************************/
int32 chareq(int8 arg1, int8 arg2) { return(arg1 == arg2); }
int32 charne(int8 arg1, int8 arg2) { return(arg1 != arg2); }
bool chareq(int8 arg1, int8 arg2) { return(arg1 == arg2); }
bool charne(int8 arg1, int8 arg2) { return(arg1 != arg2); }
#ifdef UNSIGNED_CHAR_TEXT
int32 charlt(int8 arg1, int8 arg2) { return((uint8)arg1 < (uint8)arg2); }
int32 charle(int8 arg1, int8 arg2) { return((uint8)arg1 <= (uint8)arg2); }
int32 chargt(int8 arg1, int8 arg2) { return((uint8)arg1 > (uint8)arg2); }
int32 charge(int8 arg1, int8 arg2) { return((uint8)arg1 >= (uint8)arg2); }
bool charlt(int8 arg1, int8 arg2) { return((uint8)arg1 < (uint8)arg2); }
bool charle(int8 arg1, int8 arg2) { return((uint8)arg1 <= (uint8)arg2); }
bool chargt(int8 arg1, int8 arg2) { return((uint8)arg1 > (uint8)arg2); }
bool charge(int8 arg1, int8 arg2) { return((uint8)arg1 >= (uint8)arg2); }
#else
int32 charlt(int8 arg1, int8 arg2) { return(arg1 < arg2); }
int32 charle(int8 arg1, int8 arg2) { return(arg1 <= arg2); }
int32 chargt(int8 arg1, int8 arg2) { return(arg1 > arg2); }
int32 charge(int8 arg1, int8 arg2) { return(arg1 >= arg2); }
bool charlt(int8 arg1, int8 arg2) { return(arg1 < arg2); }
bool charle(int8 arg1, int8 arg2) { return(arg1 <= arg2); }
bool chargt(int8 arg1, int8 arg2) { return(arg1 > arg2); }
bool charge(int8 arg1, int8 arg2) { return(arg1 >= arg2); }
#endif
int8 charpl(int8 arg1, int8 arg2) { return(arg1 + arg2); }
int8 charmi(int8 arg1, int8 arg2) { return(arg1 - arg2); }
int8 charmul(int8 arg1, int8 arg2) { return(arg1 * arg2); }
int8 chardiv(int8 arg1, int8 arg2) { return(arg1 / arg2); }
int32 cideq(int8 arg1, int8 arg2) { return(arg1 == arg2); }
bool cideq(int8 arg1, int8 arg2) { return(arg1 == arg2); }
/*
* char16eq - returns 1 iff arguments are equal
@ -161,48 +161,48 @@ int32 cideq(int8 arg1, int8 arg2) { return(arg1 == arg2); }
* char16ge - returns 1 iff a <= b
*
*/
int32 char16eq(char *arg1, char *arg2)
bool char16eq(char *arg1, char *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
return(strncmp(arg1, arg2, 16) == 0);
}
int32 char16ne(char *arg1, char *arg2)
bool char16ne(char *arg1, char *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
return(strncmp(arg1, arg2, 16) != 0);
}
int32 char16lt(char *arg1, char *arg2)
bool char16lt(char *arg1, char *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((int32) (strncmp(arg1, arg2, 16) < 0));
return((bool) 0);
return((bool) (strncmp(arg1, arg2, 16) < 0));
}
int32 char16le(char *arg1, char *arg2)
bool char16le(char *arg1, char *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((int32) (strncmp(arg1, arg2, 16) <= 0));
return((bool) 0);
return((bool) (strncmp(arg1, arg2, 16) <= 0));
}
int32 char16gt(char *arg1, char *arg2)
bool char16gt(char *arg1, char *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
return((int32) (strncmp(arg1, arg2, 16) > 0));
return((bool) (strncmp(arg1, arg2, 16) > 0));
}
int32 char16ge(char *arg1, char *arg2)
bool char16ge(char *arg1, char *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
return((int32) (strncmp(arg1, arg2, 16) >= 0));
return((bool) (strncmp(arg1, arg2, 16) >= 0));
}
@ -229,32 +229,32 @@ char *char2out(uint16 s)
return(result);
}
int32 char2eq(uint16 a, uint16 b)
bool char2eq(uint16 a, uint16 b)
{
return(strncmp((char *) &a, (char *) &b, 2) == 0);
}
int32 char2ne(uint16 a, uint16 b)
bool char2ne(uint16 a, uint16 b)
{
return(strncmp((char *) &a, (char *) &b, 2) != 0);
}
int32 char2lt(uint16 a, uint16 b)
bool char2lt(uint16 a, uint16 b)
{
return(strncmp((char *) &a, (char *) &b, 2) < 0);
}
int32 char2le(uint16 a, uint16 b)
bool char2le(uint16 a, uint16 b)
{
return(strncmp((char *) &a, (char *) &b, 2) <= 0);
}
int32 char2gt(uint16 a, uint16 b)
bool char2gt(uint16 a, uint16 b)
{
return(strncmp((char *) &a, (char *) &b, 2) > 0);
}
int32 char2ge(uint16 a, uint16 b)
bool char2ge(uint16 a, uint16 b)
{
return(strncmp((char *) &a, (char *) &b, 2) >= 0);
}
@ -289,32 +289,32 @@ char *char4out(s)
return(result);
}
int32 char4eq(uint32 a, uint32 b)
bool char4eq(uint32 a, uint32 b)
{
return(strncmp((char *) &a, (char *) &b, 4) == 0);
}
int32 char4ne(uint32 a, uint32 b)
bool char4ne(uint32 a, uint32 b)
{
return(strncmp((char *) &a, (char *) &b, 4) != 0);
}
int32 char4lt(uint32 a, uint32 b)
bool char4lt(uint32 a, uint32 b)
{
return(strncmp((char *) &a, (char *) &b, 4) < 0);
}
int32 char4le(uint32 a, uint32 b)
bool char4le(uint32 a, uint32 b)
{
return(strncmp((char *) &a, (char *) &b, 4) <= 0);
}
int32 char4gt(uint32 a, uint32 b)
bool char4gt(uint32 a, uint32 b)
{
return(strncmp((char *) &a, (char *) &b, 4) > 0);
}
int32 char4ge(uint32 a, uint32 b)
bool char4ge(uint32 a, uint32 b)
{
return(strncmp((char *) &a, (char *) &b, 4) >= 0);
}
@ -351,46 +351,46 @@ char *char8out(char *s)
return(result);
}
int32 char8eq(char *arg1, char *arg2)
bool char8eq(char *arg1, char *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return(strncmp(arg1, arg2, 8) == 0);
return((bool) 0);
return((bool) strncmp(arg1, arg2, 8) == 0);
}
int32 char8ne(char *arg1, char *arg2)
bool char8ne(char *arg1, char *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return(strncmp(arg1, arg2, 8) != 0);
return((bool) 0);
return((bool) strncmp(arg1, arg2, 8) != 0);
}
int32 char8lt(char *arg1, char *arg2)
bool char8lt(char *arg1, char *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return(strncmp(arg1, arg2, 8) < 0);
return((bool) 0);
return((bool) strncmp(arg1, arg2, 8) < 0);
}
int32 char8le(char *arg1, char *arg2)
bool char8le(char *arg1, char *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return(strncmp(arg1, arg2, 8) <= 0);
return((bool) 0);
return((bool) strncmp(arg1, arg2, 8) <= 0);
}
int32 char8gt(char *arg1, char *arg2)
bool char8gt(char *arg1, char *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return(strncmp(arg1, arg2, 8) > 0);
return((bool) 0);
return((bool) strncmp(arg1, arg2, 8) > 0);
}
int32 char8ge(char *arg1, char *arg2)
bool char8ge(char *arg1, char *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return(strncmp(arg1, arg2, 8) >= 0);
return((bool) 0);
return((bool) strncmp(arg1, arg2, 8) >= 0);
}
int32 char8cmp(char *arg1, char *arg2)

143
src/backend/utils/adt/date.c
View File

@ -1,7 +1,7 @@
/*-------------------------------------------------------------------------
*
* date.c--
* Functions for the built-in type "AbsoluteTime".
* Utilities for the built-in type "AbsoluteTime" (defined in nabstime).
* Functions for the built-in type "RelativeTime".
* Functions for the built-in type "TimeInterval".
*
@ -9,7 +9,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.5 1997/02/14 04:17:35 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.6 1997/03/14 23:19:57 scrappy Exp $
*
* NOTES
* This code is actually (almost) unused.
@ -35,25 +35,11 @@
#include "access/xact.h"
#include "utils/builtins.h" /* where function declarations go */
#include "utils/palloc.h"
#include "utils/dt.h"
#define TM_YEAR_BASE 1900 /* compatible to UNIX time */
#define EPOCH_YEAR 1970 /* compatible to UNIX time */
#define YEAR_MAX 2038 /* otherwise overflow */
#define YEAR_MIN 1902 /* otherwise overflow */
#define DAYS_PER_LYEAR 366
#define DAYS_PER_NYEAR 365
#define HOURS_PER_DAY 24
#define MINS_PER_HOUR 60
#define SECS_PER_MIN 60
#define MAX_LONG 2147483647 /* 2^31 */
/* absolute time definitions */
#define TIME_NOW_STR "now" /* represents time now */
#define TIME_EPOCH_STR "epoch" /* Jan 1 00:00:00 1970 GMT */
#define TIME_EPOCH_STR_LEN (sizeof(TIME_EPOCH_STR)-1)
#define INVALID_ABSTIME_STR "Undefined AbsTime"
#define INVALID_ABSTIME_STR_LEN (sizeof(INVALID_ABSTIME_STR)-1)
#ifndef USE_NEW_TIME_CODE
#define USE_NEW_TIME_CODE 1
#endif
#define INVALID_RELTIME_STR "Undefined RelTime"
#define INVALID_RELTIME_STR_LEN (sizeof(INVALID_RELTIME_STR)-1)
@ -66,10 +52,7 @@
* sixty-eight years on either side of that.
*/
#define IsCharDigit(C) isdigit(C)
#define IsCharA_Z(C) isalpha(C)
#define IsSpace(C) ((C) == ' ')
#define IsNull(C) ((C) == NULL)
#define T_INTERVAL_INVAL 0 /* data represents no valid interval */
#define T_INTERVAL_VALID 1 /* data represents a valid interval */
@ -101,20 +84,13 @@ static int sec_tab[] = {
3600, 3600, 86400, 86400, 604800, 604800,
2592000, 2592000, 31536000, 31536000 };
/* maximal values (in seconds) per unit which can be represented */
static int unit_max_quantity[] = {
2144448000, 2144448000, 35740800, 35740800,
595680, 595680, 24820, 24820, 3545, 3545,
827, 827, 68, 68 };
struct timeb *TimeDifferenceFromGMT = NULL;
/*
* Function prototypes -- internal to this file only
*/
static int correct_unit(char unit[], int *unptr);
static int correct_dir(char direction[], int *signptr);
static int istinterval(char *i_string,
AbsoluteTime *i_start,
AbsoluteTime *i_end);
@ -126,41 +102,45 @@ static int istinterval(char *i_string,
/*
* reltimein - converts a reltime string in an internal format
*/
int32 /* RelativeTime */
reltimein(char *timestring)
RelativeTime
reltimein(char *str)
{
int error;
int32 /* RelativeTime */ timeinsec;
int sign, unitnr;
long quantity;
error = isreltime(timestring, &sign, &quantity, &unitnr);
#ifdef DATEDEBUG
elog(DEBUG, "reltimein: isreltime(%s) returns error=%d, %d, %d, %d",
timestring, error, sign, quantity, unitnr);
#endif /* !DATEDEBUG */
if (error != 1) {
timeinsec = INVALID_RELTIME; /*invalid time representation */
} else {
/* this check is necessary, while no control on overflow */
if (quantity > unit_max_quantity[unitnr] || quantity < 0) {
#ifdef DATEDEBUG
elog(DEBUG, "reltimein: illegal quantity %d (< %d)",
quantity, unit_max_quantity[unitnr]);
#endif /* DATEDEBUG */
timeinsec = INVALID_RELTIME; /* illegal quantity */
} else {
timeinsec = sign * quantity * sec_tab[unitnr];
#ifdef DATEDEBUG
elog(DEBUG, "reltimein: computed timeinsec %d",
timeinsec);
#endif /* DATEDEBUG */
}
}
return(timeinsec);
}
RelativeTime result;
struct tm tt, *tm = &tt;
double fsec;
int dtype;
char *field[MAXDATEFIELDS];
int nf, ftype[MAXDATEFIELDS];
char lowstr[MAXDATELEN+1];
if (!PointerIsValid(str))
elog(WARN,"Bad (null) date external representation",NULL);
if (strlen(str) > MAXDATELEN)
elog( WARN, "Bad (length) reltime external representation '%s'",str);
if ((ParseDateTime( str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
|| (DecodeDateDelta( field, ftype, nf, &dtype, tm, &fsec) != 0))
elog(WARN,"Bad reltime external representation '%s'",str);
#ifdef DATEDEBUG
printf( "reltimein- %d fields are type %d (DTK_DATE=%d)\n", nf, dtype, DTK_DATE);
#endif
switch (dtype) {
case DTK_DELTA:
result = ((((tm->tm_hour*60)+tm->tm_min)*60)+tm->tm_sec);
result += (((tm->tm_year*365)+(tm->tm_mon*30)+tm->tm_mday)*(24*60*60));
return(result);
default:
return(INVALID_RELTIME);
};
elog(WARN,"Bad reltime (internal coding error) '%s'",str);
return(INVALID_RELTIME);
} /* reltimein() */
/*
@ -379,42 +359,42 @@ AbsoluteTime timenow()
* reltimele - returns 1, iff t1 less than or equal to t2
* reltimege - returns 1, iff t1 greater than or equal to t2
*/
int32 reltimeeq(RelativeTime t1, RelativeTime t2)
bool reltimeeq(RelativeTime t1, RelativeTime t2)
{
if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
return 0;
return(t1 == t2);
}
int32 reltimene(RelativeTime t1, RelativeTime t2)
bool reltimene(RelativeTime t1, RelativeTime t2)
{
if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
return 0;
return(t1 != t2);
}
int32 reltimelt(RelativeTime t1, RelativeTime t2)
bool reltimelt(RelativeTime t1, RelativeTime t2)
{
if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
return 0;
return(t1 < t2);
}
int32 reltimegt(RelativeTime t1, RelativeTime t2)
bool reltimegt(RelativeTime t1, RelativeTime t2)
{
if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
return 0;
return(t1 > t2);
}
int32 reltimele(RelativeTime t1, RelativeTime t2)
bool reltimele(RelativeTime t1, RelativeTime t2)
{
if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
return 0;
return(t1 <= t2);
}
int32 reltimege(RelativeTime t1, RelativeTime t2)
bool reltimege(RelativeTime t1, RelativeTime t2)
{
if (t1 == INVALID_RELTIME || t2 == INVALID_RELTIME)
return 0;
@ -425,7 +405,7 @@ int32 reltimege(RelativeTime t1, RelativeTime t2)
/*
* intervaleq - returns 1, iff interval i1 is equal to interval i2
*/
int32 intervaleq(TimeInterval i1, TimeInterval i2)
bool intervaleq(TimeInterval i1, TimeInterval i2)
{
if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
return(0); /* invalid interval */
@ -437,7 +417,7 @@ int32 intervaleq(TimeInterval i1, TimeInterval i2)
* intervalleneq - returns 1, iff length of interval i is equal to
* reltime t
*/
int32 intervalleneq(TimeInterval i, RelativeTime t)
bool intervalleneq(TimeInterval i, RelativeTime t)
{
RelativeTime rt;
@ -451,7 +431,7 @@ int32 intervalleneq(TimeInterval i, RelativeTime t)
* intervallenne - returns 1, iff length of interval i is not equal
* to reltime t
*/
int32 intervallenne(TimeInterval i, RelativeTime t)
bool intervallenne(TimeInterval i, RelativeTime t)
{
RelativeTime rt;
@ -465,7 +445,7 @@ int32 intervallenne(TimeInterval i, RelativeTime t)
* intervallenlt - returns 1, iff length of interval i is less than
* reltime t
*/
int32 intervallenlt(TimeInterval i, RelativeTime t)
bool intervallenlt(TimeInterval i, RelativeTime t)
{
RelativeTime rt;
@ -479,7 +459,7 @@ int32 intervallenlt(TimeInterval i, RelativeTime t)
* intervallengt - returns 1, iff length of interval i is greater than
* reltime t
*/
int32 intervallengt(TimeInterval i, RelativeTime t)
bool intervallengt(TimeInterval i, RelativeTime t)
{
RelativeTime rt;
@ -493,7 +473,7 @@ int32 intervallengt(TimeInterval i, RelativeTime t)
* intervallenle - returns 1, iff length of interval i is less or equal
* than reltime t
*/
int32 intervallenle(TimeInterval i, RelativeTime t)
bool intervallenle(TimeInterval i, RelativeTime t)
{
RelativeTime rt;
@ -507,7 +487,7 @@ int32 intervallenle(TimeInterval i, RelativeTime t)
* intervallenge - returns 1, iff length of interval i is greater or
* equal than reltime t
*/
int32 intervallenge(TimeInterval i, RelativeTime t)
bool intervallenge(TimeInterval i, RelativeTime t)
{
RelativeTime rt;
@ -520,7 +500,7 @@ int32 intervallenge(TimeInterval i, RelativeTime t)
/*
* intervalct - returns 1, iff interval i1 contains interval i2
*/
int32 intervalct(TimeInterval i1, TimeInterval i2)
bool intervalct(TimeInterval i1, TimeInterval i2)
{
if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
return(0);
@ -531,7 +511,7 @@ int32 intervalct(TimeInterval i1, TimeInterval i2)
/*
* intervalov - returns 1, iff interval i1 (partially) overlaps i2
*/
int32 intervalov(TimeInterval i1, TimeInterval i2)
bool intervalov(TimeInterval i1, TimeInterval i2)
{
if (i1->status == T_INTERVAL_INVAL || i2->status == T_INTERVAL_INVAL)
return(0);
@ -736,7 +716,6 @@ static int correct_dir(char direction[], int *signptr)
return (0); /* invalid direction descriptor */
}
/*
* istinterval - returns 1, iff i_string is a valid interval descr.
* 0, iff i_string is NOT a valid interval desc.

743
src/backend/utils/adt/datetime.c Normal file
View File

@ -0,0 +1,743 @@
/*-------------------------------------------------------------------------
*
* datetime.c--
* implements DATE and TIME data types specified in SQL-92 standard
*
* Copyright (c) 1994-5, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/datetime.c,v 1.1 1997/03/14 23:20:01 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
#include <stdio.h> /* for sprintf() */
#include <string.h>
#include <postgres.h>
#include <miscadmin.h>
#include <utils/builtins.h>
#include <utils/nabstime.h>
#include <utils/datetime.h>
static int day_tab[2][12] = {
{31,28,31,30,31,30,31,31,30,31,30,31},
{31,29,31,30,31,30,31,31,30,31,30,31} };
#define isleap(y) (((y % 4) == 0 && (y % 100) != 0) || (y % 400) == 0)
/*****************************************************************************
* Date ADT
*****************************************************************************/
/* date_in()
* Given date text string, convert to internal date format.
*/
#if USE_NEW_DATE
DateADT
date_in(char *str)
{
DateADT date;
#else
int4
date_in(char *str)
{
int4 result;
DateADT *date = (DateADT *)&result;
#endif
double fsec;
struct tm tt, *tm = &tt;
int tzp;
int dtype;
int nf;
char *field[MAXDATEFIELDS];
int ftype[MAXDATEFIELDS];
char lowstr[MAXDATELEN+1];
if (!PointerIsValid(str))
elog(WARN,"Bad (null) date external representation",NULL);
#ifdef DATEDEBUG
printf( "date_in- input string is %s\n", str);
#endif
if ((ParseDateTime( str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
|| (DecodeDateTime( field, ftype, nf, &dtype, tm, &fsec, &tzp) != 0))
elog(WARN,"Bad date external representation %s",str);
switch (dtype) {
#if FALSE
case DTK_DATE:
date = date2j(tm->tm_year,tm->tm_mon,tm->tm_mday);
time = time2j(tm->tm_hour,tm->tm_min,(double)tm->tm_sec);
if (tzp != 0) {
j2local(&date, &time, -(tzp*60));
} else {
j2local(&date, &time, -timezone);
};
break;
#endif
case DTK_EPOCH:
tm->tm_year = 1970;
tm->tm_mon = 1;
tm->tm_mday = 1;
case DTK_DATE:
break;
default:
elog(WARN,"Unrecognized date external representation %s",str);
};
#if FALSE
if (tm->tm_year < 70)
tm->tm_year += 2000;
else if (tm->tm_year < 100)
tm->tm_year += 1900;
#endif
if (tm->tm_year < 0 || tm->tm_year > 32767)
elog(WARN, "date_in: year must be limited to values 0 through 32767 in '%s'", str);
if (tm->tm_mon < 1 || tm->tm_mon > 12)
elog(WARN, "date_in: month must be limited to values 1 through 12 in '%s'", str);
if (tm->tm_mday < 1 || tm->tm_mday > day_tab[isleap(tm->tm_year)][tm->tm_mon-1])
elog(WARN, "date_in: day must be limited to values 1 through %d in '%s'",
day_tab[isleap(tm->tm_year)][tm->tm_mon-1], str);
#if USE_NEW_DATE
date = (date2j(tm->tm_year,tm->tm_mon,tm->tm_mday) - date2j(2000,1,1));
return(date);
#else
date->day = tm->tm_mday;
date->month = tm->tm_mon;
date->year = tm->tm_year;
return(result);
#endif
} /* date_in() */
/* date_out()
* Given internal format date, convert to text string.
*/
#if USE_NEW_DATE
char *
date_out(DateADT date)
{
#else
char *
date_out(int4 dateVal)
{
DateADT *date = (DateADT *)&dateVal;
#endif
char *result;
char buf[MAXDATELEN+1];
int year, month, day;
#if USE_NEW_DATE
j2date( (((int) date) + date2j(2000,1,1)), &year, &month, &day);
#else
day = date->day;
month = date->month;
year = date->year;
#endif
if (EuroDates == 1) /* Output European-format dates */
sprintf(buf, "%02d-%02d-%04d", day, month, year);
else
sprintf(buf, "%02d-%02d-%04d", month, day, year);
if (!PointerIsValid(result = PALLOC(strlen(buf)+1)))
elog(WARN,"Memory allocation failed, can't output date",NULL);
strcpy( result, buf);
return(result);
} /* date_out() */
#if USE_NEW_DATE
bool
date_eq(DateADT dateVal1, DateADT dateVal2)
{
return(dateVal1 == dateVal2);
}
bool
date_ne(DateADT dateVal1, DateADT dateVal2)
{
return(dateVal1 != dateVal2);
}
bool
date_lt(DateADT dateVal1, DateADT dateVal2)
{
return(dateVal1 < dateVal2);
} /* date_lt() */
bool
date_le(DateADT dateVal1, DateADT dateVal2)
{
return(dateVal1 <= dateVal2);
} /* date_le() */
bool
date_gt(DateADT dateVal1, DateADT dateVal2)
{
return(dateVal1 > dateVal2);
} /* date_gt() */
bool
date_ge(DateADT dateVal1, DateADT dateVal2)
{
return(dateVal1 >= dateVal2);
} /* date_ge() */
int
date_cmp(DateADT dateVal1, DateADT dateVal2)
{
if (dateVal1 < dateVal2) {
return -1;
} else if (dateVal1 > dateVal2) {
return 1;
};
return 0;
} /* date_cmp() */
DateADT
date_larger(DateADT dateVal1, DateADT dateVal2)
{
return(date_gt(dateVal1, dateVal2) ? dateVal1 : dateVal2);
} /* date_larger() */
DateADT
date_smaller(DateADT dateVal1, DateADT dateVal2)
{
return(date_lt(dateVal1, dateVal2) ? dateVal1 : dateVal2);
} /* date_smaller() */
/* Compute difference between two dates in days. */
int4
date_mi(DateADT dateVal1, DateADT dateVal2)
{
return(dateVal1-dateVal2);
} /* date_mi() */
/* Add a number of days to a date, giving a new date.
Must handle both positive and negative numbers of days. */
DateADT
date_pli(DateADT dateVal, int4 days)
{
return(dateVal+days);
} /* date_pli() */
/* Subtract a number of days from a date, giving a new date. */
DateADT
date_mii(DateADT dateVal, int4 days)
{
return(date_pli(dateVal, -days));
} /* date_mii() */
#else
bool
date_eq(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
return (date1->day==date2->day &&
date1->month==date2->month &&
date1->year==date2->year);
}
bool
date_ne(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
return (date1->day!=date2->day || date1->month!=date2->month ||
date1->year!=date2->year);
}
bool
date_lt(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
if (date1->year!=date2->year)
return (date1->year<date2->year);
if (date1->month!=date2->month)
return (date1->month<date2->month);
return (date1->day<date2->day);
}
bool
date_le(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
if (date1->year!=date2->year)
return (date1->year<=date2->year);
if (date1->month!=date2->month)
return (date1->month<=date2->month);
return (date1->day<=date2->day);
}
bool
date_gt(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
if (date1->year!=date2->year)
return (date1->year>date2->year);
if (date1->month!=date2->month)
return (date1->month>date2->month);
return (date1->day>date2->day);
}
bool
date_ge(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
if (date1->year!=date2->year)
return (date1->year>=date2->year);
if (date1->month!=date2->month)
return (date1->month>=date2->month);
return (date1->day>=date2->day);
}
int
date_cmp(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
if (date1->year!=date2->year)
return ((date1->year<date2->year) ? -1 : 1);
if (date1->month!=date2->month)
return ((date1->month<date2->month) ? -1 : 1);
if (date1->day!=date2->day)
return ((date1->day<date2->day) ? -1 : 1);
return 0;
}
int4
date_larger(int4 dateVal1, int4 dateVal2)
{
return (date_gt (dateVal1, dateVal2) ? dateVal1 : dateVal2);
}
int4
date_smaller(int4 dateVal1, int4 dateVal2)
{
return (date_lt (dateVal1, dateVal2) ? dateVal1 : dateVal2);
}
/* Compute difference between two dates in days. */
int32
date_mi(int4 dateVal1, int4 dateVal2)
{
#if USE_NEW_TIME_CODE
DateADT *date1, *date2;
int days;
date1 = (DateADT *) &dateVal1;
date2 = (DateADT *) &dateVal2;
days = (date2j(date1->year, date1->month, date1->day)
- date2j(date2->year, date2->month, date2->day));
#else
DateADT dv1, dv2;
DateADT *date1, *date2;
int32 days = 0;
int i;
/* This circumlocution allows us to assume that date1 is always
before date2. */
dv1 = date_smaller (dateVal1, dateVal2);
dv2 = date_larger (dateVal1, dateVal2);
date1 = (DateADT *) &dv1;
date2 = (DateADT *) &dv2;
/* Sum number of days in each full year between date1 and date2. */
for (i = date1->year + 1; i < date2->year; ++i)
days += isleap(i) ? 366 : 365;
if (days)
{
/* We need to wrap around the year. Add in number of days in each
full month from date1 to end of year. */
for (i = date1->month + 1; i <= 12; ++i)
days += day_tab[isleap(date1->year)][i - 1];
/* Add in number of days in each full month from start of year to
date2. */
for (i = 1; i < date2->month; ++i)
days += day_tab[isleap(date2->year)][i - 1];
}
else
{
/* Add in number of days in each full month from date1 to date2. */
for (i = date1->month + 1; i < date2->month; ++i)
days += day_tab[isleap(date1->year)][i - 1];
}
if (days || date1->month != date2->month)
{
/* Add in number of days left in month for date1. */
days += day_tab[isleap(date1->year)][date1->month - 1] - date1->day;
/* Add in day of month of date2. */
days += date2->day;
}
else
{
/* Everything's in the same month, so just subtract the days! */
days = date2->day - date1->day;
}
#endif
return (days);
}
/* Add a number of days to a date, giving a new date.
Must handle both positive and negative numbers of days. */
int4
date_pli(int4 dateVal, int32 days)
{
#if USE_NEW_TIME_CODE
DateADT *date1 = (DateADT *) &dateVal;
int date, year, month, day;
date = (date2j(date1->year, date1->month, date1->day) + days);
j2date( date, &year, &month, &day);
date1->year = year;
date1->month = month;
date1->day = day;
#else
DateADT *date1 = (DateADT *) &dateVal;
/* Use separate day variable because date1->day is a narrow type. */
int32 day = date1->day + days;
if (days > 0) {
/* Loop as long as day has wrapped around end of month. */
while (day > day_tab[isleap(date1->year)][date1->month - 1]) {
day -= day_tab[isleap(date1->year)][date1->month - 1];
if (++date1->month > 12) {
/* Month wrapped around. */
date1->month = 1;
++date1->year;
}
}
} else {
/* Loop as long as day has wrapped around beginning of month. */
while (day < 1) {
/* Decrement month first, because a negative day number
should be held as relative to the previous month's end. */
if (--date1->month < 1) {
/* Month wrapped around. */
date1->month = 12;
--date1->year;
}
day += day_tab[isleap(date1->year)][date1->month - 1];
}
}
date1->day = day;
#endif
return (dateVal);
} /* date_pli() */
/* Subtract a number of days from a date, giving a new date. */
int4
date_mii(int4 dateVal, int32 days)
{
return (date_pli(dateVal, -days));
}
#endif
/*****************************************************************************
* Time ADT
*****************************************************************************/
TimeADT *
time_in(char *str)
{
TimeADT *time;
double fsec;
struct tm tt, *tm = &tt;
int nf;
char lowstr[MAXDATELEN+1];
char *field[MAXDATEFIELDS];
int dtype;
int ftype[MAXDATEFIELDS];
if (!PointerIsValid(str))
elog(WARN,"Bad (null) time external representation",NULL);
if ((ParseDateTime( str, lowstr, field, ftype, MAXDATEFIELDS, &nf) != 0)
|| (DecodeTimeOnly( field, ftype, nf, &dtype, tm, &fsec) != 0))
elog(WARN,"Bad time external representation '%s'",str);
if ((tm->tm_hour < 0) || (tm->tm_hour > 23))
elog(WARN,"Hour must be limited to values 0 through 23 in '%s'",str);
if ((tm->tm_min < 0) || (tm->tm_min > 59))
elog(WARN,"Minute must be limited to values 0 through 59 in '%s'",str);
if ((tm->tm_sec < 0) || ((tm->tm_sec + fsec) >= 60))
elog(WARN,"Second must be limited to values 0 through < 60 in '%s'",str);
if (!PointerIsValid(time = PALLOCTYPE(TimeADT)))
elog(WARN,"Memory allocation failed, can't input time '%s'",str);
#if USE_NEW_TIME
*time = ((((tm->tm_hour*60)+tm->tm_min)*60)+tm->tm_sec+fsec);
#else
time->hr = tm->tm_hour;
time->min = tm->tm_min;
time->sec = (tm->tm_sec + fsec);
#endif
return(time);
} /* time_in() */
char *
time_out(TimeADT *time)
{
char *result;
char buf[32];
if (!PointerIsValid(time))
return NULL;
if (time->sec == 0.0) {
sprintf(buf, "%02d:%02d",
(int)time->hr, (int)time->min);
} else {
if (((int) time->sec) == time->sec) {
sprintf(buf, "%02d:%02d:%02d",
(int)time->hr, (int)time->min, (int)time->sec);
} else {
sprintf(buf, "%02d:%02d:%09.6f",
(int)time->hr, (int)time->min, time->sec);
};
};
if (!PointerIsValid(result = PALLOC(strlen(buf)+1)))
elog(WARN,"Memory allocation failed, can't output time",NULL);
strcpy( result, buf);
return(result);
} /* time_out() */
#if USE_NEW_TIME
bool
time_eq(TimeADT *time1, TimeADT *time2)
{
if (!PointerIsValid(time1) || !PointerIsValid(time2))
return(FALSE);
return(*time1 == *time2);
} /* time_eq() */
bool
time_ne(TimeADT *time1, TimeADT *time2)
{
if (!PointerIsValid(time1) || !PointerIsValid(time2))
return(FALSE);
return(*time1 != *time2);
} /* time_eq() */
bool
time_lt(TimeADT *time1, TimeADT *time2)
{
if (!PointerIsValid(time1) || !PointerIsValid(time2))
return(FALSE);
return(*time1 < *time2);
} /* time_eq() */
bool
time_le(TimeADT *time1, TimeADT *time2)
{
if (!PointerIsValid(time1) || !PointerIsValid(time2))
return(FALSE);
return(*time1 <= *time2);
} /* time_eq() */
bool
time_gt(TimeADT *time1, TimeADT *time2)
{
if (!PointerIsValid(time1) || !PointerIsValid(time2))
return(FALSE);
return(*time1 > *time2);
} /* time_eq() */
bool
time_ge(TimeADT *time1, TimeADT *time2)
{
if (!PointerIsValid(time1) || !PointerIsValid(time2))
return(FALSE);
return(*time1 >= *time2);
} /* time_eq() */
int
time_cmp(TimeADT *time1, TimeADT *time2)
{
return((*time1 < *time2)? -1: (((*time1 < *time2)? 1: 0)));
} /* time_cmp() */
#else
bool
time_eq(TimeADT *time1, TimeADT *time2)
{
return (time1->sec==time2->sec && time1->min==time2->min &&
time1->hr==time2->hr);
}
bool
time_ne(TimeADT *time1, TimeADT *time2)
{
return (time1->sec!=time2->sec || time1->min!=time2->min ||
time1->hr!=time2->hr);
}
bool
time_lt(TimeADT *time1, TimeADT *time2)
{
if (time1->hr!=time2->hr)
return (time1->hr<time2->hr);
if (time1->min!=time2->min)
return (time1->min<time2->min);
return (time1->sec<time2->sec);
}
bool
time_le(TimeADT *time1, TimeADT *time2)
{
if (time1->hr!=time2->hr)
return (time1->hr<=time2->hr);
if (time1->min!=time2->min)
return (time1->min<=time2->min);
return (time1->sec<=time2->sec);
}
bool
time_gt(TimeADT *time1, TimeADT *time2)
{
if (time1->hr!=time2->hr)
return (time1->hr>time2->hr);
if (time1->min!=time2->min)
return (time1->min>time2->min);
return (time1->sec>time2->sec);
}
bool
time_ge(TimeADT *time1, TimeADT *time2)
{
if (time1->hr!=time2->hr)
return (time1->hr>=time2->hr);
if (time1->min!=time2->min)
return (time1->min>=time2->min);
return (time1->sec>=time2->sec);
}
int
time_cmp(TimeADT *time1, TimeADT *time2)
{
if (time1->hr!=time2->hr)
return ((time1->hr<time2->hr) ? -1 : 1);
if (time1->min!=time2->min)
return ((time1->min<time2->min) ? -1 : 1);
if (time1->sec!=time2->sec)
return ((time1->sec<time2->sec) ? -1 : 1);
return 0;
}
#endif
int32 /* RelativeTime */
int42reltime(int32 timevalue)
{
return(timevalue);
}

476
src/backend/utils/adt/datetimes.c
View File

@ -1,476 +0,0 @@
/*-------------------------------------------------------------------------
*
* datetimes.c--
* implements DATE and TIME data types specified in SQL-92 standard
*
* Copyright (c) 1994-5, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/datetimes.c,v 1.9 1997/03/02 02:05:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include <stdio.h> /* for sprintf() */
#include <string.h>
#include <postgres.h>
#include <miscadmin.h>
#include <utils/builtins.h>
#include <utils/datetime.h>
static int day_tab[2][12] = {
{31,28,31,30,31,30,31,31,30,31,30,31},
{31,29,31,30,31,30,31,31,30,31,30,31} };
static int
isleap(int year)
{
return
(((year % 4) == 0 && (year % 100) != 0) || (year % 400) == 0);
}
/*****************************************************************************
* Date ADT
*****************************************************************************/
int4
date_in(char *datestr)
{
int d, m, y;
int4 result;
DateADT *date = (DateADT*)&result;
#if 0
# ifdef USE_SHORT_YEAR
# define CHECK_DATE_LEN(datestr) (strlen(datestr) >= 8)
# else
# define CHECK_DATE_LEN(datestr) (strlen(datestr) == 10)
# endif /* USE_SHORT_YEAR */
#else
# define CHECK_DATE_LEN(datestr) 1
#endif
if (EuroDates == 1) { /* Expect european format dates */
if (!CHECK_DATE_LEN(datestr) ||
sscanf(datestr, "%d%*c%d%*c%d", &d, &m, &y) != 3) {
elog(WARN, "date_in: date \"%s\" not of the form dd-mm-yyyy",
datestr);
}
} else {
if (!CHECK_DATE_LEN(datestr) ||
sscanf(datestr, "%d%*c%d%*c%d", &m, &d, &y) != 3) {
elog(WARN, "date_in: date \"%s\" not of the form mm-dd-yyyy",
datestr);
}
}
if (y < 0 || y > 32767)
elog(WARN, "date_in: year must be limited to values 0 through 32767 in \"%s\"", datestr);
if (m < 1 || m > 12)
elog(WARN, "date_in: month must be limited to values 1 through 12 in \"%s\"", datestr);
if (d < 1 || d > day_tab[isleap(y)][m-1])
elog(WARN, "date_in: day must be limited to values 1 through %d in \"%s\"",
day_tab[isleap(y)][m-1], datestr);
#ifdef USE_SHORT_YEAR
if (y < 100)
y += 1900; /* hack! */
#endif /* USE_SHORT_YEAR */
date->day = d;
date->month = m;
date->year = y;
return result;
}
char *
date_out(int4 dateVal)
{
char *datestr = palloc(11);
int4 dateStore;
DateADT *date;
/* DateADT is a structure that happens to be four bytes long,
trust me on this.... */
date = (DateADT*)&dateStore;
dateStore = dateVal;
if (EuroDates == 1) /* Output european format dates */
sprintf(datestr, "%02d-%02d-%04d",
(int)date->day, (int)date->month, (int)date->year);
else
sprintf(datestr, "%02d-%02d-%04d",
(int)date->month, (int)date->day, (int)date->year);
return datestr;
}
int
date_eq(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
return (date1->day==date2->day &&
date1->month==date2->month &&
date1->year==date2->year);
}
int
date_ne(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
return (date1->day!=date2->day || date1->month!=date2->month ||
date1->year!=date2->year);
}
int
date_lt(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
if (date1->year!=date2->year)
return (date1->year<date2->year);
if (date1->month!=date2->month)
return (date1->month<date2->month);
return (date1->day<date2->day);
}
int
date_le(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
if (date1->year!=date2->year)
return (date1->year<=date2->year);
if (date1->month!=date2->month)
return (date1->month<=date2->month);
return (date1->day<=date2->day);
}
int
date_gt(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
if (date1->year!=date2->year)
return (date1->year>date2->year);
if (date1->month!=date2->month)
return (date1->month>date2->month);
return (date1->day>date2->day);
}
int
date_ge(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
if (date1->year!=date2->year)
return (date1->year>=date2->year);
if (date1->month!=date2->month)
return (date1->month>=date2->month);
return (date1->day>=date2->day);
}
int
date_cmp(int4 dateVal1, int4 dateVal2)
{
int4 dateStore1 = dateVal1;
int4 dateStore2 = dateVal2;
DateADT *date1, *date2;
date1 = (DateADT*)&dateStore1;
date2 = (DateADT*)&dateStore2;
if (date1->year!=date2->year)
return ((date1->year<date2->year) ? -1 : 1);
if (date1->month!=date2->month)
return ((date1->month<date2->month) ? -1 : 1);
if (date1->day!=date2->day)
return ((date1->day<date2->day) ? -1 : 1);
return 0;
}
int4
date_larger(int4 dateVal1, int4 dateVal2)
{
return (date_gt (dateVal1, dateVal2) ? dateVal1 : dateVal2);
}
int4
date_smaller(int4 dateVal1, int4 dateVal2)
{
return (date_lt (dateVal1, dateVal2) ? dateVal1 : dateVal2);
}
/* Compute difference between two dates in days. */
int32
date_mi(int4 dateVal1, int4 dateVal2)
{
int4 dv1, dv2;
DateADT *date1, *date2;
int32 days = 0;
int i;
/* This circumlocution allows us to assume that date1 is always
before date2. */
dv1 = date_smaller (dateVal1, dateVal2);
dv2 = date_larger (dateVal1, dateVal2);
date1 = (DateADT *) &dv1;
date2 = (DateADT *) &dv2;
/* Sum number of days in each full year between date1 and date2. */
for (i = date1->year + 1; i < date2->year; ++i)
days += isleap (i) ? 366 : 365;
if (days)
{
/* We need to wrap around the year. Add in number of days in each
full month from date1 to end of year. */
for (i = date1->month + 1; i <= 12; ++i)
days += day_tab[isleap (date1->year)][i - 1];
/* Add in number of days in each full month from start of year to
date2. */
for (i = 1; i < date2->month; ++i)
days += day_tab[isleap (date2->year)][i - 1];
}
else
{
/* Add in number of days in each full month from date1 to date2. */
for (i = date1->month + 1; i < date2->month; ++i)
days += day_tab[isleap (date1->year)][i - 1];
}
if (days || date1->month != date2->month)
{
/* Add in number of days left in month for date1. */
days += day_tab[isleap (date1->year)][date1->month - 1] - date1->day;
/* Add in day of month of date2. */
days += date2->day;
}
else
{
/* Everything's in the same month, so just subtract the days! */
days = date2->day - date1->day;
}
return (days);
}
/* Add a number of days to a date, giving a new date.
Must handle both positive and negative numbers of days. */
int4
date_pli(int4 dateVal, int32 days)
{
DateADT *date1 = (DateADT *) &dateVal;
/* Use separate day variable because date1->day is a narrow type. */
int32 day = date1->day + days;
if (days > 0)
{
/* Loop as long as day has wrapped around end of month. */
while (day > day_tab[isleap (date1->year)][date1->month - 1])
{
day -= day_tab[isleap (date1->year)][date1->month - 1];
if (++date1->month > 12)
{
/* Month wrapped around. */
date1->month = 1;
++date1->year;
}
}
}
else
{
/* Loop as long as day has wrapped around beginning of month. */
while (day < 1)
{
/* Decrement month first, because a negative day number
should be held as relative to the previous month's end. */
if (--date1->month < 1)
{
/* Month wrapped around. */
date1->month = 12;
--date1->year;
}
day += day_tab[isleap (date1->year)][date1->month - 1];
}
}
date1->day = day;
return (dateVal);
}
/* Subtract a number of days from a date, giving a new date. */
int4
date_mii(int4 dateVal, int32 days)
{
return (date_pli (dateVal, -days));
}
/*****************************************************************************
* Time ADT
*****************************************************************************/
char *
time_in(char *timestr)
{
int h, m;
float sec;
TimeADT *time;
if (sscanf(timestr, "%d%*c%d%*c%f", &h, &m, &sec) != 3) {
sec = 0.0;
if (sscanf(timestr, "%d%*c%d", &h, &m) != 2) {
elog(WARN, "time_in: time \"%s\" not of the form hh:mm:ss",
timestr);
}
}
if (h < 0 || h > 23)
elog(WARN, "time_in: hour must be limited to values 0 through 23 in \"%s\"", timestr);
if (m < 0 || m > 59)
elog(WARN, "time_in: minute must be limited to values 0 through 59 in \"%s\"", timestr);
if (sec < 0 || sec >= 60.0)
elog(WARN, "time_in: second must be limited to values 0 through 59.999 in \"%s\"", timestr);
time = (TimeADT*)palloc(sizeof(TimeADT));
time->hr = h;
time->min = m;
time->sec = sec;
return (char*)time;
}
char *
time_out(TimeADT *time)
{
char *timestr = palloc(32);
int n;
float f;
if (time->sec == 0.0) {
sprintf(timestr, "%02d:%02d",
(int)time->hr, (int)time->min);
} else {
n = (int)time->sec;
f = (float)n;
if (f == time->sec) {
sprintf(timestr, "%02d:%02d:%02d",
(int)time->hr, (int)time->min, n);
} else {
sprintf(timestr, "%02d:%02d:%09.6f",
(int)time->hr, (int)time->min, time->sec);
}
}
return timestr;
}
int
time_eq(TimeADT *time1, TimeADT *time2)
{
return (time1->sec==time2->sec && time1->min==time2->min &&
time1->hr==time2->hr);
}
int
time_ne(TimeADT *time1, TimeADT *time2)
{
return (time1->sec!=time2->sec || time1->min!=time2->min ||
time1->hr!=time2->hr);
}
int
time_lt(TimeADT *time1, TimeADT *time2)
{
if (time1->hr!=time2->hr)
return (time1->hr<time2->hr);
if (time1->min!=time2->min)
return (time1->min<time2->min);
return (time1->sec<time2->sec);
}
int
time_le(TimeADT *time1, TimeADT *time2)
{
if (time1->hr!=time2->hr)
return (time1->hr<=time2->hr);
if (time1->min!=time2->min)
return (time1->min<=time2->min);
return (time1->sec<=time2->sec);
}
int
time_gt(TimeADT *time1, TimeADT *time2)
{
if (time1->hr!=time2->hr)
return (time1->hr>time2->hr);
if (time1->min!=time2->min)
return (time1->min>time2->min);
return (time1->sec>time2->sec);
}
int
time_ge(TimeADT *time1, TimeADT *time2)
{
if (time1->hr!=time2->hr)
return (time1->hr>=time2->hr);
if (time1->min!=time2->min)
return (time1->min>=time2->min);
return (time1->sec>=time2->sec);
}
int
time_cmp(TimeADT *time1, TimeADT *time2)
{
if (time1->hr!=time2->hr)
return ((time1->hr<time2->hr) ? -1 : 1);
if (time1->min!=time2->min)
return ((time1->min<time2->min) ? -1 : 1);
if (time1->sec!=time2->sec)
return ((time1->sec<time2->sec) ? -1 : 1);
return 0;
}
int32 /* RelativeTime */
int42reltime(int32 timevalue)
{
return(timevalue);
}

2189
src/backend/utils/adt/dt.c
View File

File diff suppressed because it is too large Load Diff

4
src/backend/utils/adt/geo_ops.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.1 1997/03/09 20:40:55 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_ops.c,v 1.2 1997/03/14 23:20:15 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
@ -18,7 +18,7 @@
#include "postgres.h"
#include "utils/geo-decls.h"
#include "utils/geo_decls.h"
#include "utils/palloc.h"
#define LDELIM '('

4
src/backend/utils/adt/geo_selfuncs.c
View File

@ -8,7 +8,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_selfuncs.c,v 1.1 1997/03/09 20:40:57 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/geo_selfuncs.c,v 1.2 1997/03/14 23:20:20 scrappy Exp $
*
* XXX These are totally bogus.
*
@ -17,7 +17,7 @@
#include "postgres.h"
#include "access/attnum.h"
#include "utils/geo-decls.h" /* where function declarations go */
#include "utils/geo_decls.h" /* where function declarations go */
#include "utils/palloc.h"
#include "utils/builtins.h"

52
src/backend/utils/adt/int.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.3 1996/11/06 10:30:55 scrappy Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/int.c,v 1.4 1997/03/14 23:20:26 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
@ -225,36 +225,36 @@ int16 i4toi2(int32 arg1)
* intgt - returns 1 iff arg1 > arg2
* intge - returns 1 iff arg1 >= arg2
*/
int32 int4eq(int32 arg1, int32 arg2) { return(arg1 == arg2); }
int32 int4ne(int32 arg1, int32 arg2) { return(arg1 != arg2); }
int32 int4lt(int32 arg1, int32 arg2) { return(arg1 < arg2); }
int32 int4le(int32 arg1, int32 arg2) { return(arg1 <= arg2); }
int32 int4gt(int32 arg1, int32 arg2) { return(arg1 > arg2); }
int32 int4ge(int32 arg1, int32 arg2) { return(arg1 >= arg2); }
bool int4eq(int32 arg1, int32 arg2) { return(arg1 == arg2); }
bool int4ne(int32 arg1, int32 arg2) { return(arg1 != arg2); }
bool int4lt(int32 arg1, int32 arg2) { return(arg1 < arg2); }
bool int4le(int32 arg1, int32 arg2) { return(arg1 <= arg2); }
bool int4gt(int32 arg1, int32 arg2) { return(arg1 > arg2); }
bool int4ge(int32 arg1, int32 arg2) { return(arg1 >= arg2); }
int32 int2eq(int16 arg1, int16 arg2) { return(arg1 == arg2); }
int32 int2ne(int16 arg1, int16 arg2) { return(arg1 != arg2); }
int32 int2lt(int16 arg1, int16 arg2) { return(arg1 < arg2); }
int32 int2le(int16 arg1, int16 arg2) { return(arg1 <= arg2); }
int32 int2gt(int16 arg1, int16 arg2) { return(arg1 > arg2); }
int32 int2ge(int16 arg1, int16 arg2) { return(arg1 >= arg2); }
bool int2eq(int16 arg1, int16 arg2) { return(arg1 == arg2); }
bool int2ne(int16 arg1, int16 arg2) { return(arg1 != arg2); }
bool int2lt(int16 arg1, int16 arg2) { return(arg1 < arg2); }
bool int2le(int16 arg1, int16 arg2) { return(arg1 <= arg2); }
bool int2gt(int16 arg1, int16 arg2) { return(arg1 > arg2); }
bool int2ge(int16 arg1, int16 arg2) { return(arg1 >= arg2); }
int32 int24eq(int32 arg1, int32 arg2) { return(arg1 == arg2); }
int32 int24ne(int32 arg1, int32 arg2) { return(arg1 != arg2); }
int32 int24lt(int32 arg1, int32 arg2) { return(arg1 < arg2); }
int32 int24le(int32 arg1, int32 arg2) { return(arg1 <= arg2); }
int32 int24gt(int32 arg1, int32 arg2) { return(arg1 > arg2); }
int32 int24ge(int32 arg1, int32 arg2) { return(arg1 >= arg2); }
bool int24eq(int32 arg1, int32 arg2) { return(arg1 == arg2); }
bool int24ne(int32 arg1, int32 arg2) { return(arg1 != arg2); }
bool int24lt(int32 arg1, int32 arg2) { return(arg1 < arg2); }
bool int24le(int32 arg1, int32 arg2) { return(arg1 <= arg2); }
bool int24gt(int32 arg1, int32 arg2) { return(arg1 > arg2); }
bool int24ge(int32 arg1, int32 arg2) { return(arg1 >= arg2); }
int32 int42eq(int32 arg1, int32 arg2) { return(arg1 == arg2); }
int32 int42ne(int32 arg1, int32 arg2) { return(arg1 != arg2); }
int32 int42lt(int32 arg1, int32 arg2) { return(arg1 < arg2); }
int32 int42le(int32 arg1, int32 arg2) { return(arg1 <= arg2); }
int32 int42gt(int32 arg1, int32 arg2) { return(arg1 > arg2); }
int32 int42ge(int32 arg1, int32 arg2) { return(arg1 >= arg2); }
bool int42eq(int32 arg1, int32 arg2) { return(arg1 == arg2); }
bool int42ne(int32 arg1, int32 arg2) { return(arg1 != arg2); }
bool int42lt(int32 arg1, int32 arg2) { return(arg1 < arg2); }
bool int42le(int32 arg1, int32 arg2) { return(arg1 <= arg2); }
bool int42gt(int32 arg1, int32 arg2) { return(arg1 > arg2); }
bool int42ge(int32 arg1, int32 arg2) { return(arg1 >= arg2); }
int32 keyfirsteq(int16 *arg1, int16 arg2) { return(*arg1 == arg2); }
bool keyfirsteq(int16 *arg1, int16 arg2) { return(*arg1 == arg2); }
/*
* int[24]pl - returns arg1 + arg2

883
src/backend/utils/adt/nabstime.c
View File

File diff suppressed because it is too large Load Diff

36
src/backend/utils/adt/name.c
View File

@ -11,7 +11,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/name.c,v 1.1.1.1 1996/07/09 06:22:04 scrappy Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/name.c,v 1.2 1997/03/14 23:20:43 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
@ -74,49 +74,49 @@ char *nameout(NameData *s)
* namege - returns 1 iff a <= b
*
*/
int32 nameeq(NameData *arg1, NameData *arg2)
bool nameeq(NameData *arg1, NameData *arg2)
{
if (!arg1 || !arg2)
return 0;
else
return (strncmp(arg1->data, arg2->data, NAMEDATALEN) == 0);
return ((bool) strncmp(arg1->data, arg2->data, NAMEDATALEN) == 0);
}
int32 namene(NameData *arg1, NameData *arg2)
bool namene(NameData *arg1, NameData *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return(strncmp(arg1->data, arg2->data, NAMEDATALEN) != 0);
return((bool) 0);
return((bool) (strncmp(arg1->data, arg2->data, NAMEDATALEN) != 0));
}
int32 namelt(NameData *arg1, NameData *arg2)
bool namelt(NameData *arg1, NameData *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((int32) (strncmp(arg1->data, arg2->data, NAMEDATALEN) < 0));
return((bool) 0);
return((bool) (strncmp(arg1->data, arg2->data, NAMEDATALEN) < 0));
}
int32 namele(NameData *arg1, NameData *arg2)
bool namele(NameData *arg1, NameData *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((int32) (strncmp(arg1->data, arg2->data, NAMEDATALEN) <= 0));
return((bool) 0);
return((bool) (strncmp(arg1->data, arg2->data, NAMEDATALEN) <= 0));
}
int32 namegt(NameData *arg1, NameData *arg2)
bool namegt(NameData *arg1, NameData *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
return((int32) (strncmp(arg1->data, arg2->data, NAMEDATALEN) > 0));
return((bool) (strncmp(arg1->data, arg2->data, NAMEDATALEN) > 0));
}
int32 namege(NameData *arg1, NameData *arg2)
bool namege(NameData *arg1, NameData *arg2)
{
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
return((int32) (strncmp(arg1->data, arg2->data, NAMEDATALEN) >= 0));
return((bool) (strncmp(arg1->data, arg2->data, NAMEDATALEN) >= 0));
}

10
src/backend/utils/adt/oid.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.5 1997/03/12 21:09:15 scrappy Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/oid.c,v 1.6 1997/03/14 23:20:52 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
@ -100,19 +100,19 @@ char *oidout(Oid o)
* PUBLIC ROUTINES *
*****************************************************************************/
int32 oideq(Oid arg1, Oid arg2)
bool oideq(Oid arg1, Oid arg2)
{
return(arg1 == arg2);
}
int32 oidne(Oid arg1, Oid arg2)
bool oidne(Oid arg1, Oid arg2)
{
return(arg1 != arg2);
}
int32 oid8eq(Oid arg1[], Oid arg2[])
bool oid8eq(Oid arg1[], Oid arg2[])
{
return (int32)(memcmp(arg1, arg2, 8 * sizeof(Oid)) == 0);
return (bool)(memcmp(arg1, arg2, 8 * sizeof(Oid)) == 0);
}
bool oideqint4(Oid arg1, int32 arg2)

66
src/backend/utils/adt/varchar.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.6 1996/11/10 03:03:20 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.7 1997/03/14 23:21:01 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
@ -180,13 +180,13 @@ bcTruelen(char *arg)
return (i+1);
}
int32
bool
bpchareq(char *arg1, char *arg2)
{
int len1, len2;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
len1 = bcTruelen(arg1);
len2 = bcTruelen(arg2);
@ -196,13 +196,13 @@ bpchareq(char *arg1, char *arg2)
return(strncmp(arg1+4, arg2+4, len1) == 0);
}
int32
bool
bpcharne(char *arg1, char *arg2)
{
int len1, len2;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
len1 = bcTruelen(arg1);
len2 = bcTruelen(arg2);
@ -212,14 +212,14 @@ bpcharne(char *arg1, char *arg2)
return(strncmp(arg1+4, arg2+4, len1) != 0);
}
int32
bool
bpcharlt(char *arg1, char *arg2)
{
int len1, len2;
int cmp;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
len1 = bcTruelen(arg1);
len2 = bcTruelen(arg2);
@ -230,32 +230,32 @@ bpcharlt(char *arg1, char *arg2)
return (cmp < 0);
}
int32
bool
bpcharle(char *arg1, char *arg2)
{
int len1, len2;
int cmp;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
len1 = bcTruelen(arg1);
len2 = bcTruelen(arg2);
cmp = strncmp(arg1+4, arg2+4, Min(len1,len2));
if (0 == cmp)
return (int32)(len1 <= len2 ? 1 : 0);
return (bool)(len1 <= len2 ? 1 : 0);
else
return (int32)(cmp <= 0);
return (bool)(cmp <= 0);
}
int32
bool
bpchargt(char *arg1, char *arg2)
{
int len1, len2;
int cmp;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
len1 = bcTruelen(arg1);
len2 = bcTruelen(arg2);
@ -266,22 +266,22 @@ bpchargt(char *arg1, char *arg2)
return (cmp > 0);
}
int32
bool
bpcharge(char *arg1, char *arg2)
{
int len1, len2;
int cmp;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
len1 = bcTruelen(arg1);
len2 = bcTruelen(arg2);
cmp = strncmp(arg1+4, arg2+4, Min(len1,len2));
if (0 == cmp)
return (int32)(len1 >= len2 ? 1 : 0);
return (bool)(len1 >= len2 ? 1 : 0);
else
return (int32)(cmp >= 0);
return (bool)(cmp >= 0);
}
int32
@ -319,13 +319,13 @@ vcTruelen(char *arg)
return i;
}
int32
bool
varchareq(char *arg1, char *arg2)
{
int len1, len2;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
len1 = vcTruelen(arg1);
len2 = vcTruelen(arg2);
@ -335,13 +335,13 @@ varchareq(char *arg1, char *arg2)
return(strncmp(arg1+4, arg2+4, len1) == 0);
}
int32
bool
varcharne(char *arg1, char *arg2)
{
int len1, len2;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
len1 = vcTruelen(arg1);
len2 = vcTruelen(arg2);
@ -351,14 +351,14 @@ varcharne(char *arg1, char *arg2)
return(strncmp(arg1+4, arg2+4, len1) != 0);
}
int32
bool
varcharlt(char *arg1, char *arg2)
{
int len1, len2;
int cmp;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
len1 = vcTruelen(arg1);
len2 = vcTruelen(arg2);
@ -369,32 +369,32 @@ varcharlt(char *arg1, char *arg2)
return (cmp < 0);
}
int32
bool
varcharle(char *arg1, char *arg2)
{
int len1, len2;
int cmp;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
len1 = vcTruelen(arg1);
len2 = vcTruelen(arg2);
cmp = strncmp(arg1+4, arg2+4, Min(len1,len2));
if (0 == cmp)
return (int32)( len1 <= len2 ? 1 : 0);
return (bool)( len1 <= len2 ? 1 : 0);
else
return (int32)(cmp <= 0);
return (bool)(cmp <= 0);
}
int32
bool
varchargt(char *arg1, char *arg2)
{
int len1, len2;
int cmp;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
len1 = vcTruelen(arg1);
len2 = vcTruelen(arg2);
@ -405,22 +405,22 @@ varchargt(char *arg1, char *arg2)
return (cmp > 0);
}
int32
bool
varcharge(char *arg1, char *arg2)
{
int len1, len2;
int cmp;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
len1 = vcTruelen(arg1);
len2 = vcTruelen(arg2);
cmp = strncmp(arg1+4, arg2+4, Min(len1,len2));
if (0 == cmp)
return (int32)(len1 >= len2 ? 1 : 0);
return (bool)(len1 >= len2 ? 1 : 0);
else
return (int32)(cmp >= 0);
return (bool)(cmp >= 0);
}

40
src/backend/utils/adt/varlena.c
View File

@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.10 1997/01/16 03:53:51 vadim Exp $
* $Header: /cvsroot/pgsql/src/backend/utils/adt/varlena.c,v 1.11 1997/03/14 23:21:12 scrappy Exp $
*
*-------------------------------------------------------------------------
*/
@ -255,16 +255,16 @@ textcat(text* t1, text* t2)
* texteq - returns 1 iff arguments are equal
* textne - returns 1 iff arguments are not equal
*/
int32
bool
texteq(struct varlena *arg1, struct varlena *arg2)
{
register int len;
register char *a1p, *a2p;
if (arg1 == NULL || arg2 == NULL)
return((int32) NULL);
return((bool) NULL);
if ((len = arg1->vl_len) != arg2->vl_len)
return((int32) 0);
return((bool) 0);
a1p = arg1->vl_dat;
a2p = arg2->vl_dat;
/*
@ -275,17 +275,17 @@ texteq(struct varlena *arg1, struct varlena *arg2)
len -= sizeof(int32);
while (len-- != 0)
if (*a1p++ != *a2p++)
return((int32) 0);
return((int32) 1);
return((bool) 0);
return((bool) 1);
}
int32
bool
textne(struct varlena *arg1, struct varlena *arg2)
{
return((int32) !texteq(arg1, arg2));
return((bool) !texteq(arg1, arg2));
}
int32
bool
text_lt(struct varlena *arg1, struct varlena *arg2)
{
int len;
@ -295,7 +295,7 @@ text_lt(struct varlena *arg1, struct varlena *arg2)
char *a1p, *a2p;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
a1p = (unsigned char *)VARDATA(arg1);
a2p = (unsigned char *)VARDATA(arg2);
@ -311,12 +311,12 @@ text_lt(struct varlena *arg1, struct varlena *arg2)
len--;
}
if (len)
return (int32) (*a1p < *a2p);
return (bool) (*a1p < *a2p);
else
return (int32) (arg1->vl_len < arg2->vl_len);
return (bool) (arg1->vl_len < arg2->vl_len);
}
int32
bool
text_le(struct varlena *arg1, struct varlena *arg2)
{
int len;
@ -326,7 +326,7 @@ text_le(struct varlena *arg1, struct varlena *arg2)
char *a1p, *a2p;
if (arg1 == NULL || arg2 == NULL)
return((int32) 0);
return((bool) 0);
a1p = (unsigned char *)VARDATA(arg1);
a2p = (unsigned char *)VARDATA(arg2);
@ -342,21 +342,21 @@ text_le(struct varlena *arg1, struct varlena *arg2)
len--;
}
if (len)
return (int32) (*a1p < *a2p);
return (bool) (*a1p < *a2p);
else
return ((int32) VARSIZE(arg1) <= VARSIZE(arg2));
return ((bool) VARSIZE(arg1) <= VARSIZE(arg2));
}
int32
bool
text_gt(struct varlena *arg1, struct varlena *arg2)
{
return ((int32) !text_le(arg1, arg2));
return ((bool) !text_le(arg1, arg2));
}
int32
bool
text_ge(struct varlena *arg1, struct varlena *arg2)
{
return ((int32) !text_lt(arg1, arg2));
return ((bool) !text_lt(arg1, arg2));
}
/*-------------------------------------------------------------