globegit-postgresql-plruby 0.5.4

data/src/conversions/convcommon.h

@@ -0,0 +1,129 @@
+#include "package.h"
+
+#include <postgres.h>
+#include <catalog/pg_type.h>
+#include <utils/builtins.h>
+#include <lib/stringinfo.h>
+#include "package.h"
+#include <ruby.h>
+#include "package.h"
+
+#define CPY_FREE(p0_, p1_, size_) do {		\
+    void *p2_ = (void *)p1_;			\
+    memcpy((p0_), (p2_), (size_));		\
+    pfree(p2_);					\
+} while (0)
+
+#if PG_PL_VERSION >= 74
+
+#define PL_MDUMP(name_,func_)                                   \
+static VALUE                                                    \
+name_(int argc, VALUE *argv, VALUE obj)                         \
+{                                                               \
+    void *mac;                                                  \
+    char *res;                                                  \
+    VALUE result;                                               \
+                                                                \
+    Data_Get_Struct(obj, void, mac);                            \
+    res = (char *)PLRUBY_DFC1(func_, mac);                      \
+    result = rb_tainted_str_new(VARDATA(res), VARSIZE(res));    \
+    pfree(res);                                                 \
+    return result;                                              \
+}
+
+#define PL_MLOAD(name_,func_,type_)                                     \
+static VALUE                                                            \
+name_(VALUE obj, VALUE a)                                               \
+{                                                                       \
+    StringInfoData si;                                                  \
+    type_ *mac0, *mac1;                                                 \
+                                                                        \
+    if (TYPE(a) != T_STRING || !RSTRING_LEN(a)) {                      \
+        rb_raise(rb_eArgError, "expected a String object");             \
+    }                                                                   \
+    initStringInfo(&si);                                                \
+    appendBinaryStringInfo(&si, RSTRING_PTR(a), RSTRING_LEN(a));      \
+    mac1 = (type_ *)PLRUBY_DFC1(func_, &si);                            \
+    pfree(si.data);                                                     \
+    Data_Get_Struct(obj, type_, mac0);                                  \
+    CPY_FREE(mac0, mac1, sizeof(type_));                                \
+    return obj;                                                         \
+}
+
+#define PL_MLOADVAR(name_,func_,type_,size_)                            \
+static VALUE                                                            \
+name_(VALUE obj, VALUE a)                                               \
+{                                                                       \
+    StringInfoData si;                                                  \
+    type_ *mac0, *mac1;                                                 \
+    int szl;                                                            \
+                                                                        \
+    if (TYPE(a) != T_STRING || !RSTRING_LEN(a)) {                      \
+        rb_raise(rb_eArgError, "expected a String object");             \
+    }                                                                   \
+    initStringInfo(&si);                                                \
+    appendBinaryStringInfo(&si, RSTRING_PTR(a), RSTRING_LEN(a));      \
+    mac1 = (type_ *)PLRUBY_DFC1(func_, &si);                            \
+    pfree(si.data);                                                     \
+    Data_Get_Struct(obj, type_, mac0);                                  \
+    free(mac0);                                                         \
+    szl = size_(mac1);                                                  \
+    mac0 = (type_ *)ALLOC_N(char, szl);                                 \
+    CPY_FREE(mac0, mac1, szl);                                          \
+    RDATA(obj)->data = mac0;                                            \
+    return obj;                                                         \
+}
+
+#ifndef RUBY_CAN_USE_MARSHAL_LOAD
+extern VALUE plruby_s_load _((VALUE, VALUE));
+#endif
+
+#else
+
+#define PL_MDUMP(name_,func_)
+#define PL_MLOAD(name_,func_,type_) 
+#define PL_MLOADVAR(name_,func_,type_,size_)
+
+#endif
+
+extern VALUE plruby_to_s _((VALUE));
+extern VALUE plruby_s_new _((int, VALUE *, VALUE));
+extern VALUE plruby_define_void_class _((char *, char *));
+#ifndef HAVE_RB_INITIALIZE_COPY
+extern VALUE plruby_clone _((VALUE));
+#endif
+extern Oid plruby_datum_oid _((VALUE, int *));
+extern VALUE plruby_datum_set _((VALUE, Datum));
+extern VALUE plruby_datum_get _((VALUE, Oid *));
+
+#ifndef StringValuePtr
+#define StringValuePtr(x) STR2CSTR(x)
+#endif
+
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x_) RSTRING(x_)->ptr
+# define RSTRING_LEN(x_) RSTRING(x_)->len
+#endif
+
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x_) RARRAY(x_)->ptr
+# define RARRAY_LEN(x_) RARRAY(x_)->len
+#endif
+
+#ifndef RHASH_TBL
+#define RHASH_TBL(x_) (RHASH(x_)->tbl)
+#endif
+
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(x_) (RFLOAT(x_)->value)
+#endif
+
+extern Datum plruby_dfc0 _((PGFunction));
+extern Datum plruby_dfc1 _((PGFunction, Datum));
+extern Datum plruby_dfc2 _((PGFunction, Datum, Datum));
+extern Datum plruby_dfc3 _((PGFunction, Datum, Datum, Datum));
+
+#define PLRUBY_DFC0(a_) plruby_dfc0(a_)
+#define PLRUBY_DFC1(a_,b_) plruby_dfc1(a_,PointerGetDatum(b_))
+#define PLRUBY_DFC2(a_,b_,c_) plruby_dfc2(a_,PointerGetDatum(b_),PointerGetDatum(c_))
+#define PLRUBY_DFC3(a_,b_,c_,d_) plruby_dfc3(a_,PointerGetDatum(b_),PointerGetDatum(c_),PointerGetDatum(d_))

data/src/conversions/datetime/conversions.h

@@ -0,0 +1,13 @@
+{
+    VALUE tmp;
+
+#if RUBY_CAN_USE_AUTOLOAD
+    rb_funcall(rb_mKernel, rb_intern("autoload"), 2, rb_str_new2("Tinterval"),
+               rb_str_new2("plruby/plruby_datetime"));
+    tmp = INT2NUM(rb_intern("Tinterval"));
+    rb_hash_aset(plruby_conversions, INT2NUM(TINTERVALOID), tmp);
+#else
+    tmp = plruby_define_void_class("Tinterval", "plruby/plruby_datetime");
+    rb_hash_aset(plruby_classes, INT2NUM(TINTERVALOID), tmp);
+#endif
+}    

data/src/conversions/datetime/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_datetime')

data/src/conversions/datetime/plruby_datetime.c

@@ -0,0 +1,269 @@
+#include "convcommon.h"
+
+#include <utils/date.h>
+#include <utils/nabstime.h>
+
+static VALUE pl_cTinter, pl_mMarshal;
+
+static char *
+pl_dequote(char *src)
+{
+    char *origin;
+
+    while (*src && *src != '"') ++src;
+    if (*src != '"') {
+	rb_raise(rb_eArgError, "Invalid Tinterval");
+    }
+    ++src;
+    origin = src;
+    while (*src && *src != '"') ++src;
+    if (*src != '"') {
+	rb_raise(rb_eArgError, "Invalid Tinterval");
+    }
+    *src = 0;
+    return origin;
+}
+
+struct pl_tint {
+    VALUE low, high;
+};
+
+static void
+pl_tint_mark(struct pl_tint *tint)
+{
+    rb_gc_mark(tint->low);
+    rb_gc_mark(tint->high);
+}
+
+static VALUE
+pl_tint_s_alloc(VALUE obj)
+{
+    struct pl_tint *tint;
+    return Data_Make_Struct(obj, struct pl_tint, pl_tint_mark, free, tint);
+}
+
+static VALUE
+pl_tint_s_from_string(VALUE obj, VALUE str)
+{
+    char *first, *second, *tmp;
+    VALUE d0, d1;
+    struct pl_tint *tint;
+    VALUE res;
+
+    tmp = StringValuePtr(str);
+    first = pl_dequote(tmp);
+    second = pl_dequote(first + strlen(first) + 1);
+    d0 = rb_dbl2big(DatumGetTimestamp(PLRUBY_DFC1(date_timestamp, 
+                                                  PLRUBY_DFC1(date_in, first))));
+    d1 = rb_dbl2big(DatumGetTimestamp(PLRUBY_DFC1(date_timestamp, 
+                                                  PLRUBY_DFC1(date_in, second))));
+    res = Data_Make_Struct(obj, struct pl_tint, pl_tint_mark, free, tint);
+    tint->low = rb_funcall(rb_cTime, rb_intern("at"), 1, d0);
+    tint->high = rb_funcall(rb_cTime, rb_intern("at"), 1, d1);
+    if (OBJ_TAINTED(str)) OBJ_TAINT(res);
+    return res;
+}
+
+static VALUE
+pl_tint_s_datum(VALUE obj, VALUE a)
+{
+    TimeIntervalData *interval;
+    Oid typoid;
+    VALUE tmp, res;
+
+    interval = (TimeIntervalData *)plruby_datum_get(a, &typoid);
+    if (typoid != TINTERVALOID) {
+        rb_raise(rb_eArgError, "invalid argument");
+    }
+    res = rb_ary_new2(2);
+    tmp = rb_dbl2big(DatumGetTimestamp(PLRUBY_DFC1(abstime_timestamp, 
+                                                   interval->data[0])));
+    tmp = rb_funcall(rb_cTime, rb_intern("at"), 1, tmp);
+    OBJ_TAINT(tmp);
+    rb_ary_push(res, tmp);
+    tmp = rb_dbl2big(DatumGetTimestamp(PLRUBY_DFC1(abstime_timestamp, 
+                                                   interval->data[1])));
+    tmp = rb_funcall(rb_cTime, rb_intern("at"), 1, tmp);
+    OBJ_TAINT(tmp);
+    rb_ary_push(res, tmp);
+    OBJ_TAINT(res);
+    return res;
+}
+
+#if PG_PL_VERSION >= 74
+	
+static VALUE
+pl_tint_mdump(int argc, VALUE *argv, VALUE obj)
+{
+    struct pl_tint *tint;
+    VALUE ary;
+
+    Data_Get_Struct(obj, struct pl_tint, tint);
+    ary = rb_ary_new2(2);
+    rb_ary_push(ary, tint->low);
+    rb_ary_push(ary, tint->high);
+    return rb_funcall(pl_mMarshal, rb_intern("dump"), 1, ary);
+}
+
+static VALUE
+pl_tint_mload(VALUE obj, VALUE a)
+{
+    struct pl_tint *tint;
+
+    if (TYPE(a) != T_STRING || !RSTRING_LEN(a)) {
+        rb_raise(rb_eArgError, "expected a String object");
+    }
+    a = rb_funcall(pl_mMarshal, rb_intern("load"), 1, a);
+    if (TYPE(a) != T_ARRAY || RARRAY_LEN(a) != 2) {
+        rb_raise(rb_eArgError, "expected an Array with 2 elements");
+    }
+    if (!rb_obj_is_kind_of(RARRAY_PTR(a)[0], rb_cTime) ||
+        !rb_obj_is_kind_of(RARRAY_PTR(a)[1], rb_cTime)) {
+	rb_raise(rb_eArgError, "need 2 Times objects");
+    }
+    Data_Get_Struct(obj, struct pl_tint, tint);
+    tint->low = RARRAY_PTR(a)[0];
+    tint->high = RARRAY_PTR(a)[1];
+    return obj;
+}
+
+#endif
+    
+static VALUE
+pl_tint_init(VALUE obj, VALUE a, VALUE b)
+{
+    struct pl_tint *tint;
+
+    if (!rb_obj_is_kind_of(a, rb_cTime) || !rb_obj_is_kind_of(b, rb_cTime)) {
+	rb_raise(rb_eArgError, "need 2 Times objects");
+    }
+    Data_Get_Struct(obj, struct pl_tint, tint);
+    tint->low = a;
+    tint->high = b;
+    if (OBJ_TAINTED(a) || OBJ_TAINTED(b)) OBJ_TAINT(obj);
+    return obj;
+}
+
+static VALUE
+pl_tint_low(VALUE obj)
+{
+    struct pl_tint *tint;
+    VALUE res;
+
+    Data_Get_Struct(obj, struct pl_tint, tint);
+    res = rb_obj_dup(tint->low);
+    if (OBJ_TAINTED(obj)) OBJ_TAINT(res);
+    return res;
+}
+
+static VALUE
+pl_tint_lowset(VALUE obj, VALUE a)
+{
+    struct pl_tint *tint;
+
+    Data_Get_Struct(obj, struct pl_tint, tint);
+    if (!rb_obj_is_kind_of(a, rb_cTime)) {
+	rb_raise(rb_eArgError, "need a Time object");
+    }
+    tint->low = a;
+    if (OBJ_TAINTED(a)) OBJ_TAINT(obj);
+    return a;
+}
+
+static VALUE
+pl_tint_high(VALUE obj)
+{
+    struct pl_tint *tint;
+    VALUE res;
+
+    Data_Get_Struct(obj, struct pl_tint, tint);
+    res = rb_obj_dup(tint->high);
+    if (OBJ_TAINTED(obj)) OBJ_TAINT(res);
+    return res;
+}
+
+static VALUE
+pl_tint_highset(VALUE obj, VALUE a)
+{
+    struct pl_tint *tint;
+
+    Data_Get_Struct(obj, struct pl_tint, tint);
+    if (!rb_obj_is_kind_of(a, rb_cTime)) {
+	rb_raise(rb_eArgError, "need a Time object");
+    }
+    tint->high = a;
+    if (OBJ_TAINTED(a)) OBJ_TAINT(obj);
+    return a;
+}
+
+#define tinterval_str "[\"%s\" \"%s\"]"
+
+static VALUE
+pl_tint_to_s(VALUE obj)
+{
+    char *tmp, *t0, *t1;
+    VALUE v0, v1;
+    struct pl_tint *tint;
+
+    Data_Get_Struct(obj, struct pl_tint, tint);
+    v0 = plruby_to_s(tint->low);
+    t0 = StringValuePtr(v0);
+    v1 = plruby_to_s(tint->high);
+    t1 = StringValuePtr(v1);
+    tmp = ALLOCA_N(char, strlen(tinterval_str) + strlen(t0) + strlen(t1) + 1);
+    sprintf(tmp, tinterval_str, t0, t1);
+    if (OBJ_TAINTED(obj)) {
+	return rb_tainted_str_new2(tmp);
+    }
+    return rb_str_new2(tmp);
+}
+
+static VALUE
+pl_tint_init_copy(VALUE copy, VALUE orig)
+{
+    struct pl_tint *t0, *t1;
+
+    if (copy == orig) return copy;
+    if (TYPE(orig) != T_DATA ||
+        RDATA(orig)->dmark != (RUBY_DATA_FUNC)pl_tint_mark) {
+        rb_raise(rb_eTypeError, "wrong argument type to clone");
+    }
+    Data_Get_Struct(orig, struct pl_tint, t0);
+    Data_Get_Struct(copy, struct pl_tint, t1);
+    t1->low = rb_obj_dup(t0->low);
+    t1->high = rb_obj_dup(t0->high);
+    return copy;
+}
+
+void Init_plruby_datetime()
+{
+    pl_mMarshal = rb_const_get(rb_cObject, rb_intern("Marshal"));
+    pl_cTinter = rb_define_class("Tinterval", rb_cObject);
+    rb_undef_method(CLASS_OF(pl_cTinter), "method_missing");
+#if HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_define_alloc_func(pl_cTinter, pl_tint_s_alloc);
+#else
+    rb_define_singleton_method(pl_cTinter, "allocate", pl_tint_s_alloc, 0);
+#endif
+    rb_define_singleton_method(pl_cTinter, "new", plruby_s_new, -1);
+    rb_define_singleton_method(pl_cTinter, "from_string", pl_tint_s_from_string, 1);
+    rb_define_singleton_method(pl_cTinter, "from_datum", pl_tint_s_datum, 1);
+    rb_define_method(pl_cTinter, "initialize", pl_tint_init, 2);
+#ifndef HAVE_RB_INITIALIZE_COPY
+    rb_define_method(pl_cTinter, "clone", plruby_clone, 0);
+#endif
+    rb_define_method(pl_cTinter, "initialize_copy", pl_tint_init_copy, 1);
+#if PG_PL_VERSION >= 74
+    rb_define_method(pl_cTinter, "marshal_load", pl_tint_mload, 1);
+    rb_define_method(pl_cTinter, "marshal_dump", pl_tint_mdump, -1);
+#ifndef RUBY_CAN_USE_MARSHAL_LOAD
+    rb_define_singleton_method(pl_cTinter, "_load", plruby_s_load, 1);
+    rb_define_alias(pl_cTinter, "_dump", "marshal_dump");
+#endif
+#endif
+    rb_define_method(pl_cTinter, "low", pl_tint_low, 0);
+    rb_define_method(pl_cTinter, "low=", pl_tint_lowset, 1);
+    rb_define_method(pl_cTinter, "high", pl_tint_high, 0);
+    rb_define_method(pl_cTinter, "high=", pl_tint_highset, 1);
+    rb_define_method(pl_cTinter, "to_s", pl_tint_to_s, 0);
+}

data/src/conversions/geometry/conversions.h

@@ -0,0 +1,37 @@
+{
+#if RUBY_CAN_USE_AUTOLOAD
+    rb_funcall(rb_mKernel, rb_intern("autoload"), 2, rb_str_new2("Point"),
+               rb_str_new2("plruby/plruby_geometry"));
+    rb_funcall(rb_mKernel, rb_intern("autoload"), 2, rb_str_new2("Segment"),
+               rb_str_new2("plruby/plruby_geometry"));
+    rb_funcall(rb_mKernel, rb_intern("autoload"), 2, rb_str_new2("Box"),
+               rb_str_new2("plruby/plruby_geometry"));
+    rb_funcall(rb_mKernel, rb_intern("autoload"), 2, rb_str_new2("Path"),
+               rb_str_new2("plruby/plruby_geometry"));
+    rb_funcall(rb_mKernel, rb_intern("autoload"), 2, rb_str_new2("Polygon"),
+               rb_str_new2("plruby/plruby_geometry"));
+    rb_funcall(rb_mKernel, rb_intern("autoload"), 2, rb_str_new2("Circle"),
+               rb_str_new2("plruby/plruby_geometry"));
+    rb_hash_aset(plruby_conversions, INT2NUM(POINTOID), INT2NUM(rb_intern("Point")));
+    rb_hash_aset(plruby_conversions, INT2NUM(LSEGOID), INT2NUM(rb_intern("Segment")));
+    rb_hash_aset(plruby_conversions, INT2NUM(BOXOID), INT2NUM(rb_intern("Box")));
+    rb_hash_aset(plruby_conversions, INT2NUM(PATHOID), INT2NUM(rb_intern("Path")));
+    rb_hash_aset(plruby_conversions, INT2NUM(POLYGONOID), INT2NUM(rb_intern("Polygon")));
+    rb_hash_aset(plruby_conversions, INT2NUM(CIRCLEOID), INT2NUM(rb_intern("Circle")));
+#else
+    VALUE tmp;
+
+    tmp = plruby_define_void_class("Point", "plruby/plruby_geometry");
+    rb_hash_aset(plruby_classes, INT2NUM(POINTOID), tmp);
+    tmp = plruby_define_void_class("Segment", "plruby/plruby_geometry");
+    rb_hash_aset(plruby_classes, INT2NUM(LSEGOID), tmp);
+    tmp = plruby_define_void_class("Box", "plruby/plruby_geometry");
+    rb_hash_aset(plruby_classes, INT2NUM(BOXOID), tmp);
+    tmp = plruby_define_void_class("Path", "plruby/plruby_geometry");
+    rb_hash_aset(plruby_classes, INT2NUM(PATHOID), tmp);
+    tmp = plruby_define_void_class("Polygon", "plruby/plruby_geometry");
+    rb_hash_aset(plruby_classes, INT2NUM(POLYGONOID), tmp);
+    tmp = plruby_define_void_class("Circle", "plruby/plruby_geometry");
+    rb_hash_aset(plruby_classes, INT2NUM(CIRCLEOID), tmp);
+#endif
+}