globegit-postgresql-plruby 0.5.4

data/postgresql-plruby.gemspec

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rbconfig'
+
+Gem::Specification.new do |spec|
+  spec.name       = 'globegit-postgresql-plruby'
+  spec.version    = '0.5.4'
+  spec.authors    = ['Akinori MUSHA', 'Guy Decoux']
+  spec.license    = 'Ruby'
+  spec.email      = 'akinori@musha.org'
+  spec.homepage   = 'https://github.com/knu/postgresql-plruby'
+  spec.summary    = 'Enable Ruby for use as a procedural language within PostgreSQL'
+  spec.test_files = Dir['test/test*']
+  spec.extensions = ['extconf.rb']
+  spec.files      = Dir['**/*'].reject{ |f| f.include?('git') || f.include?('tmp') }
+  
+  spec.rubyforge_project = 'plruby'
+
+  spec.extra_rdoc_files  = [
+    'README.markdown',
+    'Changes'
+  ] + Dir['ext/*.c']
+
+  spec.description = <<-EOF
+    PL/Ruby is a loadable procedural language for the PostgreSQL database
+    system that enables the Ruby language to create functions and trigger
+    procedures.
+  EOF
+
+  plruby_bin = 'plruby.' + Config::CONFIG['DLEXT']
+  plruby_dir = File.join('postgresql-plruby-' + spec.version.to_s, 'src') 
+  path_to_binary = File.join(Gem.dir, 'gems', plruby_dir, plruby_bin)
+  
+  possible_paths = Gem.path.map{ |path|
+    File.join(path, 'gems', plruby_dir, plruby_bin)
+  }
+
+  spec.post_install_message = <<-EOF
+
+    Now run the following commands from within a postgresql shell in order
+    to create the plruby language on in database server:
+
+    create function plruby_call_handler() returns language_handler
+    as '#{path_to_binary}'
+    language 'C';
+
+    create trusted language 'plruby'
+    handler plruby_call_handler
+    lancompiler 'PL/Ruby';
+
+    NOTE: Your actual path to #{plruby_bin} may be different. Possible
+    paths to the plruby binary are:
+
+    #{possible_paths.join("\n    ")}
+
+  EOF
+end

data/src/conversions.h

@@ -0,0 +1,5 @@
+#include "conversions/basic/conversions.h"
+#include "conversions/bitstring/conversions.h"
+#include "conversions/datetime/conversions.h"
+#include "conversions/geometry/conversions.h"
+#include "conversions/network/conversions.h"

data/src/conversions/basic/conversions.h

@@ -0,0 +1,25 @@
+{
+    extern void plruby_require(char *);
+
+    plruby_require("plruby/plruby_basic");
+    rb_hash_aset(plruby_classes, INT2NUM(OIDOID), rb_cFixnum);
+    rb_hash_aset(plruby_classes, INT2NUM(INT2OID), rb_cFixnum);
+    rb_hash_aset(plruby_classes, INT2NUM(INT4OID), rb_cFixnum);
+    rb_hash_aset(plruby_classes, INT2NUM(INT8OID), rb_cFixnum);
+
+    rb_hash_aset(plruby_classes, INT2NUM(FLOAT4OID), rb_cFloat);
+    rb_hash_aset(plruby_classes, INT2NUM(FLOAT8OID), rb_cFloat);
+    rb_hash_aset(plruby_classes, INT2NUM(CASHOID), rb_cFloat);
+    rb_hash_aset(plruby_classes, INT2NUM(NUMERICOID), rb_cFloat);
+
+    rb_hash_aset(plruby_classes, INT2NUM(TIMESTAMPOID), rb_cTime);
+    rb_hash_aset(plruby_classes, INT2NUM(TIMESTAMPTZOID), rb_cTime);
+    rb_hash_aset(plruby_classes, INT2NUM(ABSTIMEOID), rb_cTime);
+    rb_hash_aset(plruby_classes, INT2NUM(DATEOID), rb_cTime);
+    rb_hash_aset(plruby_classes, INT2NUM(RELTIMEOID), rb_cTime);
+    rb_hash_aset(plruby_classes, INT2NUM(INTERVALOID), rb_cTime);
+    rb_hash_aset(plruby_classes, INT2NUM(TIMETZOID), rb_cTime);
+    rb_hash_aset(plruby_classes, INT2NUM(TIMEOID), rb_cTime);
+
+    rb_hash_aset(plruby_classes, ULONG2NUM(BYTEAOID), rb_cString);
+}

data/src/conversions/basic/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+if CONFIG["LIBRUBYARG"] == "$(LIBRUBYARG_SHARED)" && 
+      !enable_config("plruby-shared")
+   $LIBRUBYARG = ""
+end
+have_library('ruby18', 'ruby_init')
+create_makefile('plruby/plruby_basic')

data/src/conversions/basic/plruby_basic.c

@@ -0,0 +1,357 @@
+#include "convcommon.h"
+
+#include <utils/cash.h>
+#include <utils/date.h>
+#include <utils/nabstime.h>
+#include <utils/pg_locale.h>
+#include <utils/timestamp.h>
+#include <math.h>
+
+static double cash_divisor;
+static Timestamp epoch;
+static ID id_at, id_to_f, id_to_i, id_usec;
+
+static VALUE
+pl_fixnum_s_datum(VALUE obj, VALUE a)
+{
+    Oid typoid;
+    Datum value;
+
+    value = plruby_datum_get(a, &typoid);
+    switch (typoid) {
+    case OIDOID:
+	return UINT2NUM(DatumGetObjectId(value));
+
+    case INT2OID:
+	return INT2NUM(DatumGetInt16(value));
+
+    case INT4OID:
+	return INT2NUM(DatumGetInt32(value));
+
+    case INT8OID:
+	return LL2NUM(DatumGetInt64(value));
+
+    default:
+	rb_raise(rb_eArgError, "unknown OID type %d", typoid);
+    }
+}
+
+static VALUE
+pl_fixnum_to_datum(VALUE obj, VALUE a)
+{
+    Datum d;
+
+    switch (plruby_datum_oid(a, NULL)) {
+    case OIDOID:
+	d = ObjectIdGetDatum(NUM2UINT(obj));
+	break;
+
+    case INT2OID:
+	d = Int16GetDatum(NUM2INT(obj));
+	break;
+
+    case INT4OID:
+	d = Int32GetDatum(NUM2INT(obj));
+	break;
+
+    case INT8OID:
+	d = Int64GetDatum(NUM2LL(obj));
+	break;
+
+    default:
+	return Qnil;
+    }
+    return plruby_datum_set(a, d);
+}
+
+static VALUE
+pl_float_s_datum(VALUE obj, VALUE a)
+{
+    Oid typoid;
+    Datum value;
+    double result;
+
+    value = plruby_datum_get(a, &typoid);
+    switch (typoid) {
+    case FLOAT4OID:
+	result = DatumGetFloat4(value);
+	break;
+
+    case FLOAT8OID:
+	result = DatumGetFloat8(value);
+	break;
+
+    case CASHOID:
+        result = (double) *(Cash *) DatumGetPointer(value) / cash_divisor;
+        break;
+
+    case NUMERICOID:
+	result = DatumGetFloat8(plruby_dfc1(numeric_float8, value));
+	break;
+
+    default:
+	rb_raise(rb_eArgError, "unknown OID type %d", typoid);
+    }
+    return rb_float_new(result);
+}
+
+extern double round();
+
+static VALUE
+pl_float_to_datum(VALUE obj, VALUE a)
+{
+    double value;
+    Datum d;
+
+    value = RFLOAT_VALUE(obj);
+    switch (plruby_datum_oid(a, NULL)) {
+    case FLOAT4OID:
+        d = Float4GetDatum((float4)value);
+        break;
+
+    case FLOAT8OID:
+        d = Float8GetDatum((float8)value);
+        break;
+
+    case CASHOID:
+    {
+        Cash *cash = (Cash *) palloc(sizeof(Cash));
+        *cash = (Cash) round(value * cash_divisor);
+        d = PointerGetDatum(cash);
+        break;
+    }
+       
+    case NUMERICOID:
+        d = plruby_dfc1(float8_numeric, Float8GetDatum((float8)value));
+	break;
+
+    default:
+	return Qnil;
+    }
+    return plruby_datum_set(a, d);
+}
+
+static VALUE
+pl_str_s_datum(VALUE klass, VALUE a)
+{
+    bytea *data;
+    Oid typoid;
+    Datum value;
+
+    value = plruby_datum_get(a, &typoid);
+    if (typoid != BYTEAOID) {
+        return Qnil;
+    }
+    data = DatumGetByteaP(value);
+    return rb_str_new(VARDATA(data), VARSIZE(data) - VARHDRSZ);
+}
+
+static VALUE
+pl_str_to_datum(VALUE obj, VALUE a)
+{
+    bytea      *data;
+    size_t     len;
+
+    /* Converts BYTEA only. */
+    if (plruby_datum_oid(a, NULL) != BYTEAOID)
+       return Qnil;
+
+    len = RSTRING_LEN(obj);
+    data = palloc(VARHDRSZ + len);
+    memcpy(VARDATA(data), RSTRING_PTR(obj), len);
+#ifdef SET_VARSIZE
+    SET_VARSIZE(data, VARHDRSZ + len);
+#else
+    VARATT_SIZEP(data) = VARHDRSZ + len;
+#endif
+    return plruby_datum_set(a, PointerGetDatum(data));
+}
+
+static VALUE
+pl_time_s_datum(VALUE klass, VALUE a)
+{
+    Timestamp	ts;
+    Oid		typoid;
+    Datum	value;
+
+    /*
+     * INTERVAL and RELTIME are converted to Float (number of seconds).
+     * For INTERVALs containing nonzero month/year component, duration of one
+     * month is assumed to be 30*24*60*60 seconds.  A special type has to be
+     * created for this, because of the months/year components and also because
+     * long or short enough numbers do not convert back right (exponential
+     * notation of INTERVALs is not accepted by Postgres).
+     *
+     * TIMESTAMP, TIMESTAMP WITH TIME ZONE, ABSTIME, DATE are converted to klass
+     * (Time), naturally.
+     *
+     * TIME and TIME WITH TIME ZONE are also converted to klass (Time), as in
+     * the (totally broken anyway) 0.4.3 implementation.  The result is that
+     * specific time since Unix epoch.  That makes little sense (the reverse
+     * conversion of the result breaks anyway), but some at least.  A special
+     * type has to be created for this.
+     */
+    value = plruby_datum_get(a, &typoid);
+    switch (typoid) {
+	/* Time interval types. */
+
+    case RELTIMEOID:
+	value = plruby_dfc1(reltime_interval, value);
+	/* ... */
+    case INTERVALOID:
+	{
+	    Interval *iv = DatumGetIntervalP(value);
+
+	    return rb_float_new((double) iv->month * 30*24*60*60 + 
+		    iv->time
+#ifdef HAVE_INT64_TIMESTAMP
+		    / 1E6
+#endif
+		);
+	}
+
+	/*
+	 * Time of day types.
+	 *
+	 * No separate conversion code is written, abusing the coincidence of C
+	 * types used for TimeADT and Timestamp (int64 or double, depending on
+	 * HAVE_INT64_TIMESTAMP).  The proper implementation would use a special
+	 * type anyway, see above.
+	 */
+
+    case TIMETZOID:
+	{
+	    TimeTzADT *timetz = DatumGetTimeTzADTP(value);
+
+	    /* Shift according to the timezone. */
+	    ts = timetz->time + (Timestamp) timetz->zone
+#ifdef HAVE_INT64_TIMESTAMP
+		* 1000000
+#endif
+		;
+	}
+	goto convert;
+
+    case TIMEOID:
+	ts = (Timestamp) DatumGetTimeADT(value);
+	goto convert;
+
+	/* The rest of types end up as a Timestamp in `value'. */
+
+    case ABSTIMEOID:
+	value = plruby_dfc1(abstime_timestamptz, value);
+	break;
+
+    case DATEOID:
+	value = plruby_dfc1(date_timestamptz, value);
+	break;
+
+    case TIMESTAMPOID:
+    case TIMESTAMPTZOID:
+	break;
+
+    default:
+	rb_raise(rb_eTypeError, "%s: incompatible type OID %u",
+		rb_class2name(klass), typoid);
+    }
+
+    ts = DatumGetTimestamp(value) - epoch;
+
+convert:
+    return rb_funcall(klass, id_at,
+#ifndef HAVE_INT64_TIMESTAMP
+	    1, rb_float_new(ts)
+#else
+	    2, LONG2NUM(ts / 1000000), ULONG2NUM(ts % 1000000)
+#endif
+	);
+}
+
+static VALUE
+pl_time_to_datum(VALUE obj, VALUE a)
+{
+    PGFunction	conv;
+    Datum	d;
+    int		typoid;
+
+    typoid = plruby_datum_oid(a, NULL);
+    switch (typoid) {
+    case ABSTIMEOID:
+    case DATEOID:
+    case TIMEOID:
+    case TIMESTAMPOID:
+    case TIMESTAMPTZOID:
+    case TIMETZOID:
+	break;
+
+    default:
+	return Qnil;
+    }
+
+    /* Convert Time to TimestampTz first. */
+#ifndef HAVE_INT64_TIMESTAMP
+    d = TimestampTzGetDatum(epoch + NUM2DBL(rb_funcall(obj, id_to_f, 0)));
+#else
+    d = TimestampTzGetDatum(epoch + (TimestampTz) 
+                            NUM2LONG(rb_funcall(obj, id_to_i, 0)) * 1000000 +
+                            NUM2ULONG(rb_funcall(obj, id_usec, 0)));
+#endif
+
+    conv = NULL;
+    switch (typoid) {
+    case ABSTIMEOID:
+	conv = timestamptz_abstime;
+	break;
+
+    case DATEOID:
+	conv = timestamptz_date;
+	break;
+
+    case TIMEOID:
+	conv = timestamptz_time;
+	break;
+
+    case TIMESTAMPOID:
+	conv = timestamptz_timestamp;
+	break;
+
+    case TIMESTAMPTZOID:
+	break;
+
+    case TIMETZOID:
+	conv = timestamptz_timetz;
+	break;
+    }
+
+    if (conv == NULL) {
+        return Qnil;
+    }
+    d = plruby_dfc1(conv, d);
+    return plruby_datum_set(a, d);
+}
+
+void Init_plruby_basic()
+{
+    int fpoint;
+    struct lconv *lconvert = PGLC_localeconv();
+
+    fpoint = lconvert->frac_digits;
+    if (fpoint < 0 || fpoint > 10) {
+        fpoint = 2;
+    }
+    cash_divisor = pow(10.0, fpoint);
+    epoch = SetEpochTimestamp();
+    id_at = rb_intern("at");
+    id_to_f = rb_intern("to_f");
+    id_to_i = rb_intern("to_i");
+    id_usec = rb_intern("usec");
+
+    rb_define_singleton_method(rb_cFixnum, "from_datum", pl_fixnum_s_datum, 1);
+    rb_define_method(rb_cFixnum, "to_datum", pl_fixnum_to_datum, 1);
+    rb_define_singleton_method(rb_cFloat, "from_datum", pl_float_s_datum, 1);
+    rb_define_method(rb_cFloat, "to_datum", pl_float_to_datum, 1);
+    rb_define_singleton_method(rb_cString, "from_datum", pl_str_s_datum, 1);
+    rb_define_method(rb_cString, "to_datum", pl_str_to_datum, 1);
+    rb_define_singleton_method(rb_cTime, "from_datum", pl_time_s_datum, 1);
+    rb_define_method(rb_cTime, "to_datum", pl_time_to_datum, 1);
+}