--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile--
+# Makefile for Postgres 64-bit integer extensions
+#
+# Thomas G. Lockhart <Thomas.Lockhart@jpl.nasa.gov>
+#
+# This is a first attempt at 64-bit arithmetic for Postgres.
+# It takes advantage of "long long int" support in GNU C on 32-bit machines.
+# The modules are built and installed as user-defined types,
+# so destination directories are pointing away from the standard
+# Postgres areas. You will need to modify the paths to fit your machine.
+#
+# On my Linux box, I had to find an extra library for the division function (?).
+# For Alpha boxes, both the DEC and GNU compilers should need "long int" only.
+#
+#-------------------------------------------------------------------------
+
+ifndef PGDIR
+PGDIR= /opt/postgres/current
+endif
+
+SRCDIR= $(PGDIR)/src
+
+include $(SRCDIR)/Makefile.global
+
+# Comment out this re-declaration of LIBDIR
+# if you are installing as the postgres superuser
+# into a specific database or into template1.
+LIBDIR= /home/tgl/lib
+
+CFLAGS+= -I$(PGDIR)/include -I$(PGDIR)/src/include -I$(LIBPQDIR)
+
+# This extra library is for the 64-bit division routine on my Linux box
+# and probably will need to be commented-out for most other platforms.
+CLIBS+= /usr/lib/gcc-lib/i486-linux/2.7.2/libgcc.a
+
+TARGETS= int8.sql int8$(DLSUFFIX)
+
+all: $(TARGETS)
+
+int8$(DLSUFFIX): int8.o
+ $(CC) -shared -o int8$(DLSUFFIX) int8.o $(CLIBS)
+
+install:
+ $(MAKE) all
+ cp -p int8$(DLSUFFIX) $(LIBDIR)
+
+%.sql: %.source
+ if [ -z "$$USER" ]; then USER=$$LOGNAME; fi; \
+ if [ -z "$$USER" ]; then USER=`whoami`; fi; \
+ if [ -z "$$USER" ]; then echo 'Cannot deduce $$USER.'; exit 1; fi; \
+ rm -f $@; \
+ C=`pwd`; \
+ O=$C; \
+ if [ -d ${LIBDIR} ]; then O=${LIBDIR}; fi; \
+ sed -e "s:_CWD_:$$C:g" \
+ -e "s:_OBJWD_:$$O:g" \
+ -e "s:_DLSUFFIX_:$(DLSUFFIX):g" \
+ -e "s/_USER_/$$USER/g" < $< > $@
+
+clean:
+ rm -f $(TARGETS) int8.o
+
--- /dev/null
+ Postgres int8
+
+Thomas G. Lockhart <Thomas.Lockhart@jpl.nasa.gov>
+
+This is a first attempt at 64-bit integer arithmetic for Postgres. The code
+should support any 64-bit architecture and any 32-bit machine using a recent
+GNU C compiler. At the moment, DEC-Alpha and Linux/gcc are explicitly
+supported. The code uses "long long int" support in GNU C on 32-bit machines.
+This type is an extension to ANSI-C, and may not appear on any other compiler.
+
+The modules are built and installed as user-defined types, so destination
+ directories are pointing away from the standard Postgres areas.
+
+Other compilers and architectures should be supportable, so please let me know
+what changes were required to run on your machine, and I will fold those into
+this standard distribution.
+
+Good luck!
+
+ - Tom
+
+
+ Installation
+
+You will need to modify the Makefile paths to fit your machine. Since this
+is packaged as a "user-installable" type, the libraries and source code
+can reside outside of the standard Postgres areas.
+
+If you are compiling on a DEC-Alpha, then the code might compile
+and run without change. (I do a lot of code development on Alphas,
+but do not have a Postgres installation to test).
+
+ make
+ make install
+ psql dbname < int8.sql
+
+If you are running gcc on a 32-bit machine, you will probably need to:
+ - remove the extra library reference in the Makefile.
+ - if there are unresolved symbols when you try running, then find
+ the right library. The one I had chosen might be a clue.
+
+If you are not running gcc on a 32-bit machine, you will need to:
+ - redeclare the 64 bit data type.
+ - modify the scanf and printf() arguments to use the appropriate
+ 64-bit int arguments.
+
+On my Linux box, I had to find an extra library for the division function.
+For Alpha boxes, both the DEC and GNU compilers should need "long int" only.
+I have a reference to "__alpha" in the C source code, but have not tested it
+ and am not certain that this is the correct pre-defined symbol for that machine.
+
+itest.sql is a small test file which exercises some of the I/O, functions,
+ and boolean operators.
+
+int8:
+ =
+ <>
+ <
+ >
+ <=
+ >=
+
+ - unary minus
+ + addition
+ - subtraction
+ * multiplication
+ / division
+
+ int4() convert to 4-byte integer
+ float8() convert to double float
+
+Routines defined are:
+
+int64 *int8in(char *str);
+char *int8out(int64 *val);
+
+bool int8eq(int64 *val1, int64 *val2);
+bool int8ne(int64 *val1, int64 *val2);
+bool int8lt(int64 *val1, int64 *val2);
+bool int8gt(int64 *val1, int64 *val2);
+bool int8le(int64 *val1, int64 *val2);
+bool int8ge(int64 *val1, int64 *val2);
+
+bool int84eq(int64 *val1, int32 val2);
+bool int84ne(int64 *val1, int32 val2);
+bool int84lt(int64 *val1, int32 val2);
+bool int84gt(int64 *val1, int32 val2);
+bool int84le(int64 *val1, int32 val2);
+bool int84ge(int64 *val1, int32 val2);
+
+int64 *int8um(int64 *val);
+int64 *int8pl(int64 *val1, int64 *val2);
+int64 *int8mi(int64 *val1, int64 *val2);
+int64 *int8mul(int64 *val1, int64 *val2);
+int64 *int8div(int64 *val1, int64 *val2);
+
+int64 *int48(int32 val);
+int32 int84(int64 *val);
+
+int64 *dtoi8(float8 *val);
+float8 *i8tod(int64 *val);
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * int8.c--
+ * Internal 64-bit integer operations
+ *
+ *-------------------------------------------------------------------------
+ */
+#include <stdio.h> /* for sprintf proto, etc. */
+#include <stdlib.h> /* for strtod, etc. */
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+#include <math.h>
+#include <float.h>
+#include <limits.h>
+
+#include "postgres.h"
+#include "utils/palloc.h"
+
+#define MAXINT8LEN 25
+
+#define USE_LOCAL_CODE 1
+
+#if defined(__alpha) || defined(__GNUC__)
+#define HAVE_64BIT_INTS 1
+#endif
+
+#ifndef HAVE_64BIT_INTS
+typedef char[8] int64;
+
+#elif defined(__alpha)
+typedef long int int64;
+#define INT64_FORMAT "%ld"
+
+#elif defined(__GNUC__)
+typedef long long int int64;
+#define INT64_FORMAT "%Ld"
+
+#else
+typedef long int int64;
+#define INT64_FORMAT "%ld"
+#endif
+
+int64 *int8in(char *str);
+char *int8out(int64 *val);
+
+bool int8eq(int64 *val1, int64 *val2);
+bool int8ne(int64 *val1, int64 *val2);
+bool int8lt(int64 *val1, int64 *val2);
+bool int8gt(int64 *val1, int64 *val2);
+bool int8le(int64 *val1, int64 *val2);
+bool int8ge(int64 *val1, int64 *val2);
+
+bool int84eq(int64 *val1, int32 val2);
+bool int84ne(int64 *val1, int32 val2);
+bool int84lt(int64 *val1, int32 val2);
+bool int84gt(int64 *val1, int32 val2);
+bool int84le(int64 *val1, int32 val2);
+bool int84ge(int64 *val1, int32 val2);
+
+int64 *int8um(int64 *val);
+int64 *int8pl(int64 *val1, int64 *val2);
+int64 *int8mi(int64 *val1, int64 *val2);
+int64 *int8mul(int64 *val1, int64 *val2);
+int64 *int8div(int64 *val1, int64 *val2);
+
+int64 *int48(int32 val);
+int32 int84(int64 *val);
+#if FALSE
+int64 *int28(int16 val);
+int16 int82(int64 *val);
+#endif
+
+float64 i8tod(int64 *val);
+int64 *dtoi8(float64 val);
+
+#if USE_LOCAL_CODE
+
+#ifndef PALLOC
+#define PALLOC(p) palloc(p)
+#endif
+
+#ifndef PALLOCTYPE
+#define PALLOCTYPE(p) palloc(sizeof(p))
+#endif
+
+#endif
+
+/***********************************************************************
+ **
+ ** Routines for 64-bit integers.
+ **
+ ***********************************************************************/
+
+/*----------------------------------------------------------
+ * Formatting and conversion routines.
+ *---------------------------------------------------------*/
+
+/* int8in()
+ */
+int64 *int8in(char *str)
+{
+ int64 *result = PALLOCTYPE(int64);
+
+#if HAVE_64BIT_INTS
+ if (!PointerIsValid(str))
+ elog (WARN,"Bad (null) int8 external representation",NULL);
+
+ if (sscanf(str, INT64_FORMAT, result) != 1)
+ elog(WARN,"Bad int8 external representation '%s'",str);
+
+#else
+ elog(WARN,"64-bit integers are not supported",NULL);
+ result = NULL;
+#endif
+
+ return(result);
+} /* int8in() */
+
+
+/* int8out()
+ */
+char *int8out(int64 *val)
+{
+ char *result;
+
+ int len;
+ char buf[MAXINT8LEN+1];
+
+#if HAVE_64BIT_INTS
+ if (!PointerIsValid(val))
+ return(NULL);
+
+ if ((len = snprintf( buf, MAXINT8LEN, INT64_FORMAT, *val)) < 0)
+ elog (WARN,"Unable to format int8",NULL);
+
+ result = PALLOC(len+1);
+
+ strcpy(result, buf);
+
+#else
+ elog(WARN,"64-bit integers are not supported",NULL);
+ result = NULL;
+#endif
+
+ return( result);
+} /* int8out() */
+
+
+/*----------------------------------------------------------
+ * Relational operators for int8s.
+ *---------------------------------------------------------*/
+
+/* int8relop()
+ * Is val1 relop val2?
+ */
+bool int8eq(int64 *val1, int64 *val2)
+{
+ return(*val1 == *val2);
+} /* int8eq() */
+
+bool int8ne(int64 *val1, int64 *val2)
+{
+ return(*val1 != *val2);
+} /* int8ne() */
+
+bool int8lt(int64 *val1, int64 *val2)
+{
+ return(*val1 < *val2);
+} /* int8lt() */
+
+bool int8gt(int64 *val1, int64 *val2)
+{
+ return(*val1 > *val2);
+} /* int8gt() */
+
+bool int8le(int64 *val1, int64 *val2)
+{
+ return(*val1 <= *val2);
+} /* int8le() */
+
+bool int8ge(int64 *val1, int64 *val2)
+{
+ return(*val1 >= *val2);
+} /* int8ge() */
+
+
+/* int84relop()
+ * Is 64-bit val1 relop 32-bit val2?
+ */
+bool int84eq(int64 *val1, int32 val2)
+{
+ return(*val1 == val2);
+} /* int84eq() */
+
+bool int84ne(int64 *val1, int32 val2)
+{
+ return(*val1 != val2);
+} /* int84ne() */
+
+bool int84lt(int64 *val1, int32 val2)
+{
+ return(*val1 < val2);
+} /* int84lt() */
+
+bool int84gt(int64 *val1, int32 val2)
+{
+ return(*val1 > val2);
+} /* int84gt() */
+
+bool int84le(int64 *val1, int32 val2)
+{
+ return(*val1 <= val2);
+} /* int84le() */
+
+bool int84ge(int64 *val1, int32 val2)
+{
+ return(*val1 >= val2);
+} /* int84ge() */
+
+
+/*----------------------------------------------------------
+ * Arithmetic operators on 64-bit integers.
+ *---------------------------------------------------------*/
+
+int64 *int8um(int64 *val)
+{
+ int64 *result = PALLOCTYPE(int64);
+
+ if (!PointerIsValid(val))
+ return NULL;
+
+ *result = (- *val);
+
+ return(result);
+} /* int8um() */
+
+int64 *int8pl(int64 *val1, int64 *val2)
+{
+ int64 *result = PALLOCTYPE(int64);
+
+ if ((!PointerIsValid(val1)) || (!PointerIsValid(val2)))
+ return NULL;
+
+ *result = *val1 + *val2;
+
+ return(result);
+} /* int8pl() */
+
+int64 *int8mi(int64 *val1, int64 *val2)
+{
+ int64 *result = PALLOCTYPE(int64);
+
+ if ((!PointerIsValid(val1)) || (!PointerIsValid(val2)))
+ return NULL;
+
+ *result = *val1 - *val2;
+
+ return(result);
+} /* int8mi() */
+
+int64 *int8mul(int64 *val1, int64 *val2)
+{
+ int64 *result = PALLOCTYPE(int64);
+
+ if ((!PointerIsValid(val1)) || (!PointerIsValid(val2)))
+ return NULL;
+
+ *result = *val1 * *val2;
+
+ return(result);
+} /* int8mul() */
+
+int64 *int8div(int64 *val1, int64 *val2)
+{
+ int64 *result = PALLOCTYPE(int64);
+
+ if ((!PointerIsValid(val1)) || (!PointerIsValid(val2)))
+ return NULL;
+
+ *result = *val1 / *val2;
+
+ return(result);
+} /* int8div() */
+
+
+/*----------------------------------------------------------
+ * Conversion operators.
+ *---------------------------------------------------------*/
+
+int64 *int48(int32 val)
+{
+ int64 *result = PALLOCTYPE(int64);
+
+ *result = val;
+
+ return(result);
+} /* int48() */
+
+int32 int84(int64 *val)
+{
+ int32 result;
+
+ if (!PointerIsValid(val))
+ elog(WARN,"Invalid (null) int64, can't convert int8 to int4",NULL);
+
+ if ((*val < INT_MIN) || (*val > INT_MAX))
+ elog(WARN,"int8 conversion to int4 is out of range",NULL);
+
+ result = *val;
+
+ return(result);
+} /* int84() */
+
+#if FALSE
+int64 *int28(int16 val)
+{
+ int64 *result;
+
+ if (!PointerIsValid(result = PALLOCTYPE(int64)))
+ elog(WARN,"Memory allocation failed, can't convert int8 to int2",NULL);
+
+ *result = val;
+
+ return(result);
+} /* int28() */
+
+int16 int82(int64 *val)
+{
+ int16 result;
+
+ if (!PointerIsValid(val))
+ elog(WARN,"Invalid (null) int8, can't convert to int2",NULL);
+
+ result = *val;
+
+ return(result);
+} /* int82() */
+#endif
+
+float64 i8tod(int64 *val)
+{
+ float64 result = PALLOCTYPE(float64data);
+
+ *result = *val;
+
+ return(result);
+} /* i8tod() */
+
+int64 *dtoi8(float64 val)
+{
+ int64 *result = PALLOCTYPE(int64);
+
+ if ((*val < (-pow(2,64)+1)) || (*val > (pow(2,64)-1)))
+ elog(WARN,"Floating point conversion to int64 is out of range",NULL);
+
+ *result = *val;
+
+ return(result);
+} /* dtoi8() */
+
--- /dev/null
+---------------------------------------------------------------------------
+--
+-- int8.sql-
+-- This file defines operators for 64-bit integers.
+--
+---------------------------------------------------------------------------
+
+LOAD '_OBJWD_/int8.so';
+
+CREATE FUNCTION int8in(opaque)
+ RETURNS int8
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE FUNCTION int8out(opaque)
+ RETURNS opaque
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE TYPE int8 (
+ internallength = 8,
+ input = int8in,
+ output = int8out
+);
+
+
+-----------------------------
+-- Create operators
+-----------------------------
+
+CREATE FUNCTION int8um(int8)
+ RETURNS int8
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR - (
+ rightarg = int8,
+ procedure = int8um
+);
+
+CREATE FUNCTION int8pl(int8,int8)
+ RETURNS int8
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR + (
+ leftarg = int8,
+ rightarg = int8,
+ procedure = int8pl,
+ commutator = +
+);
+
+CREATE FUNCTION int8mi(int8,int8)
+ RETURNS int8
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR - (
+ leftarg = int8,
+ rightarg = int8,
+ procedure = int8mi
+);
+
+CREATE FUNCTION int8mul(int8,int8)
+ RETURNS int8
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR * (
+ leftarg = int8,
+ rightarg = int8,
+ procedure = int8mul,
+ commutator = *
+);
+
+CREATE FUNCTION int8div(int8,int8)
+ RETURNS int8
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR / (
+ leftarg = int8,
+ rightarg = int8,
+ procedure = int8div
+);
+
+--
+-- 64-bit comparison operators
+--
+
+CREATE FUNCTION int8eq(int8,int8)
+ RETURNS bool
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR = (
+ leftarg = int8,
+ rightarg = int8,
+ procedure = int8eq,
+ commutator = =
+);
+
+CREATE FUNCTION int8ne(int8,int8)
+ RETURNS bool
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR <> (
+ leftarg = int8,
+ rightarg = int8,
+ procedure = int8ne,
+ commutator = <>
+);
+
+CREATE FUNCTION int8lt(int8,int8)
+ RETURNS bool
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR < (
+ leftarg = int8,
+ rightarg = int8,
+ procedure = int8lt
+);
+
+CREATE FUNCTION int8gt(int8,int8)
+ RETURNS bool
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR > (
+ leftarg = int8,
+ rightarg = int8,
+ procedure = int8gt
+);
+
+CREATE FUNCTION int8le(int8,int8)
+ RETURNS bool
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR <= (
+ leftarg = int8,
+ rightarg = int8,
+ procedure = int8le
+);
+
+CREATE FUNCTION int8ge(int8,int8)
+ RETURNS bool
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR >= (
+ leftarg = int8,
+ rightarg = int8,
+ procedure = int8ge
+);
+
+--
+-- 64-bit/32-bit comparison operators
+--
+
+CREATE FUNCTION int84eq(int8,int4)
+ RETURNS bool
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR = (
+ leftarg = int8,
+ rightarg = int4,
+ procedure = int84eq,
+ commutator = =
+);
+
+CREATE FUNCTION int84ne(int8,int4)
+ RETURNS bool
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR <> (
+ leftarg = int8,
+ rightarg = int4,
+ procedure = int84ne,
+ commutator = <>
+);
+
+CREATE FUNCTION int84lt(int8,int4)
+ RETURNS bool
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR < (
+ leftarg = int8,
+ rightarg = int4,
+ procedure = int84lt
+);
+
+CREATE FUNCTION int84gt(int8,int4)
+ RETURNS bool
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR > (
+ leftarg = int8,
+ rightarg = int4,
+ procedure = int84gt
+);
+
+CREATE FUNCTION int84le(int8,int4)
+ RETURNS bool
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR <= (
+ leftarg = int8,
+ rightarg = int4,
+ procedure = int84le
+);
+
+CREATE FUNCTION int84ge(int8,int4)
+ RETURNS bool
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE OPERATOR >= (
+ leftarg = int8,
+ rightarg = int4,
+ procedure = int84ge
+);
+
+--
+-- Conversion functions
+--
+
+CREATE FUNCTION int48(int4)
+ RETURNS int8
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE FUNCTION int84(int8)
+ RETURNS int4
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+--CREATE FUNCTION int28(int2)
+-- RETURNS int8
+-- AS '_OBJWD_/int8.so'
+-- LANGUAGE 'c';
+--
+--CREATE FUNCTION int82(int8)
+-- RETURNS int2
+-- AS '_OBJWD_/int8.so'
+-- LANGUAGE 'c';
+
+CREATE FUNCTION i8tod(int8)
+ RETURNS float8
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+CREATE FUNCTION dtoi8(float8)
+ RETURNS int8
+ AS '_OBJWD_/int8.so'
+ LANGUAGE 'c';
+
+--
+-- Generic conversion routines
+--
+
+CREATE FUNCTION int8(int4)
+ RETURNS int8
+ AS 'select int48($1)'
+ LANGUAGE 'sql';
+
+CREATE FUNCTION int8(float8)
+ RETURNS int8
+ AS 'select dtoi8($1)'
+ LANGUAGE 'sql';
+
+CREATE FUNCTION float8(int8)
+ RETURNS float8
+ AS 'select i8tod($1)'
+ LANGUAGE 'sql';
+
+CREATE FUNCTION int4(int8)
+ RETURNS int4
+ AS 'select int84($1)'
+ LANGUAGE 'sql';
+
--- /dev/null
+--
+-- Test int8 64-bit integers.
+--
+drop table qtest;
+create table qtest(q1 int8, q2 int8);
+
+insert into qtest values('123','456');
+insert into qtest values('123','4567890123456789');
+insert into qtest values('4567890123456789','123');
+insert into qtest values('4567890123456789','4567890123456789');
+insert into qtest values('4567890123456789','-4567890123456789');
+
+select * from qtest;
+
+select q1, -q1 as minus from qtest;
+
+select q1, q2, q1 + q2 as plus from qtest;
+select q1, q2, q1 - q2 as minus from qtest;
+select q1, q2, q1 * q2 as multiply from qtest
+ where q1 < 1000 or (q2 > 0 and q2 < 1000);
+--select q1, q2, q1 * q2 as multiply qtest
+-- where q1 < '1000'::int8 or (q2 > '0'::int8 and q2 < '1000'::int8);
+select q1, q2, q1 / q2 as divide from qtest;
+
+select q1, float8(q1) from qtest;
+select q2, float8(q2) from qtest;
+select q1, int8(float8(q1)) from qtest;
OSDN Git Service
