globegit-postgresql-plruby 0.5.4

data/src/plruby.h

@@ -0,0 +1,324 @@
+#include <unistd.h>
+#include <fcntl.h>
+#include <setjmp.h>
+
+#include "postgres.h"
+#include "executor/spi.h"
+#include "executor/executor.h"
+#include "commands/trigger.h"
+#include "utils/elog.h"
+#include "utils/builtins.h"
+#include "fmgr.h"
+#include "access/heapam.h"
+
+#include "tcop/tcopprot.h"
+#include "utils/syscache.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_language.h"
+#include "catalog/pg_type.h"
+
+#include "nodes/makefuncs.h"
+#include "nodes/nodes.h"
+#include "parser/parse_type.h"
+#include "utils/lsyscache.h"
+#include "funcapi.h"
+
+#include "utils/array.h"
+
+#if PG_PL_VERSION >= 75
+#include "nodes/pg_list.h"
+#include "utils/typcache.h"
+#include "access/xact.h"
+#endif
+
+#if PG_PL_VERSION >= 81
+#include "utils/memutils.h"
+#endif
+
+#include "package.h"
+
+#include <ruby.h>
+#if HAVE_RUBY_ST_H
+#include <ruby/st.h>
+#elif HAVE_ST_H
+#include <st.h>
+#endif
+
+#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 VALUE rb_thread_list();
+
+#ifndef SAFE_LEVEL
+#define SAFE_LEVEL 12
+#endif
+
+#ifndef MAIN_SAFE_LEVEL
+#ifdef PLRUBY_TIMEOUT
+#define MAIN_SAFE_LEVEL 3
+#else
+#define MAIN_SAFE_LEVEL SAFE_LEVEL
+#endif
+#endif
+
+#if SAFE_LEVEL <= MAIN_SAFE_LEVEL
+#define MAIN_SAFE_LEVEL SAFE_LEVEL
+#endif
+
+#ifdef PLRUBY_TIMEOUT
+
+extern int plruby_in_progress;
+extern int plruby_interrupted;
+
+#define PLRUBY_BEGIN(lvl_) do {                 \
+    int in_progress = plruby_in_progress;       \
+    if (plruby_interrupted) {                   \
+	rb_raise(pl_ePLruby, "timeout");        \
+    }                                           \
+    plruby_in_progress = lvl_;
+
+#define PLRUBY_END                                              \
+    plruby_in_progress = in_progress;                           \
+    if (plruby_interrupted) {                                   \
+        rb_raise(pl_ePLruby, "timeout");                        \
+    }                                                           \
+} while (0)
+
+#ifdef PG_PL_TRYCATCH
+
+#define PLRUBY_BEGIN_PROTECT(lvl_) do {         \
+    int in_progress = plruby_in_progress;       \
+    if (plruby_interrupted) {                   \
+        rb_raise(pl_ePLruby, "timeout");        \
+    }                                           \
+    plruby_in_progress = lvl_;                  \
+    PG_TRY();                                   \
+    {
+
+extern int errorcode;
+
+#define PLRUBY_END_PROTECT                      \
+    }                                           \
+    PG_CATCH();                                 \
+    {                                           \
+        plruby_in_progress = in_progress;       \
+        rb_raise(pl_eCatch, "propagate");       \
+    }                                           \
+    PG_END_TRY();                               \
+    plruby_in_progress = in_progress;           \
+    if (plruby_interrupted) {                   \
+        rb_raise(pl_ePLruby, "timeout");        \
+    }                                           \
+} while (0)
+
+#else
+    
+#define PLRUBY_BEGIN_PROTECT(lvl_) do {                                 \
+    sigjmp_buf save_restart;                                            \
+    int in_progress = plruby_in_progress;                               \
+    if (plruby_interrupted) {                                           \
+	rb_raise(pl_ePLruby, "timeout");                                \
+    }                                                                   \
+    memcpy(&save_restart, &Warn_restart, sizeof(save_restart));         \
+    if (sigsetjmp(Warn_restart, 1) != 0) {                              \
+        plruby_in_progress = in_progress;                               \
+        memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));     \
+        rb_raise(pl_eCatch, "propagate");                               \
+    }                                                                   \
+    plruby_in_progress = lvl_;
+
+#define PLRUBY_END_PROTECT                                      \
+    plruby_in_progress = in_progress;                           \
+    memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart)); \
+    if (plruby_interrupted) {                                   \
+        rb_raise(pl_ePLruby, "timeout");                        \
+    }                                                           \
+} while (0)
+
+#endif
+
+#else
+
+#define PLRUBY_BEGIN(lvl_)
+#define PLRUBY_END
+
+#ifdef PG_PL_TRYCATCH
+
+#define PLRUBY_BEGIN_PROTECT(lvl_) do {         \
+    PG_TRY();                                   \
+    {
+
+#define PLRUBY_END_PROTECT                      \
+    }                                           \
+    PG_CATCH();                                 \
+    {                                           \
+        rb_raise(pl_eCatch, "propagate");       \
+    }                                           \
+    PG_END_TRY();                               \
+} while (0)
+
+#else
+
+#define PLRUBY_BEGIN_PROTECT(lvl_) do {                                 \
+    sigjmp_buf save_restart;                                            \
+    memcpy(&save_restart, &Warn_restart, sizeof(save_restart));         \
+    if (sigsetjmp(Warn_restart, 1) != 0) {                              \
+        memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));     \
+        rb_raise(pl_eCatch, "propagate");                               \
+    }
+
+#define PLRUBY_END_PROTECT                                              \
+     memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));        \
+} while (0)
+   
+#endif
+
+#endif
+
+   
+
+enum { TG_OK, TG_SKIP };
+enum { TG_BEFORE, TG_AFTER, TG_ROW, TG_STATEMENT, TG_INSERT,
+       TG_DELETE, TG_UPDATE, TG_UNKNOWN }; 
+
+struct pl_thread_st {
+    PG_FUNCTION_ARGS;
+    int timeout;
+    Oid validator;
+};
+
+typedef struct pl_proc_desc
+{
+    char	   *proname;
+    TransactionId  fn_xmin;
+    CommandId      fn_cmin;
+    FmgrInfo	result_func;
+    Oid		result_elem;
+    Oid		result_oid;
+    int		result_len;
+    bool	result_is_array;
+    bool	result_val;
+    bool 	result_is_setof;
+    char	result_align;
+    int		nargs;
+#if PG_PL_VERSION >= 75
+    int         named_args;
+#endif
+    FmgrInfo	arg_func[FUNC_MAX_ARGS];
+    Oid		arg_elem[FUNC_MAX_ARGS];
+    Oid		arg_type[FUNC_MAX_ARGS];
+    int		arg_len[FUNC_MAX_ARGS];
+    bool	arg_is_array[FUNC_MAX_ARGS];
+    bool	arg_val[FUNC_MAX_ARGS];
+    char	arg_align[FUNC_MAX_ARGS];
+    int		arg_is_rel[FUNC_MAX_ARGS];
+    char result_type;
+} pl_proc_desc;
+
+struct portal_options {
+    VALUE argsv;
+    int count, output;
+    int block, save;
+};
+
+typedef struct pl_query_desc
+{
+    char qname[20];
+    void *plan;
+    int	 nargs;
+    Oid	*argtypes;
+    FmgrInfo *arginfuncs;
+    Oid *argtypelems;
+    int	*arglen;
+    bool       *arg_is_array;
+    bool       *arg_val;
+    char       *arg_align;
+    int cursor;
+    struct portal_options po;
+} pl_query_desc;
+
+struct PLportal {
+    Portal portal;
+    char *nulls;
+    Datum *argvalues;
+    int *arglen;
+    int nargs;
+    struct portal_options po;
+};
+
+#define GetPortal(obj, portal) do {			\
+    Data_Get_Struct(obj, struct PLportal, portal);	\
+    if (!portal->portal) {				\
+	rb_raise(pl_ePLruby, "cursor closed");		\
+    }							\
+} while (0)
+
+#define GetPlan(obj, qdesc) do {					\
+    Data_Get_Struct(obj, pl_query_desc, qdesc);				\
+    if (!qdesc->plan) {							\
+	rb_raise(pl_ePLruby, "plan was dropped during the session");	\
+    }									\
+} while (0)
+
+#define RET_HASH      1
+#define RET_ARRAY     2
+#define RET_DESC      4
+#define RET_DESC_ARR 12
+#define RET_BASIC    16
+
+extern VALUE plruby_s_new _((int, VALUE *, VALUE));
+extern VALUE plruby_build_tuple _((HeapTuple, TupleDesc, int));
+extern Datum plruby_to_datum _((VALUE, FmgrInfo *, Oid, Oid, int));
+extern Datum plruby_return_value _((struct pl_thread_st *,  pl_proc_desc *,
+                                    VALUE, VALUE));
+extern VALUE plruby_create_args _((struct pl_thread_st *, pl_proc_desc *));
+extern VALUE plruby_i_each _((VALUE, struct portal_options *));
+extern void plruby_exec_output _((VALUE, int, int *));
+extern VALUE plruby_to_s _((VALUE));
+
+extern Datum plruby_return_array _((VALUE, pl_proc_desc *));
+extern MemoryContext plruby_spi_context;
+
+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));
+
+#ifdef PLRUBY_ENABLE_CONVERSION
+extern VALUE plruby_classes, plruby_conversions;
+extern Oid plruby_datum_oid _((VALUE, int *));
+extern VALUE plruby_datum_set _((VALUE, Datum));
+extern Datum plruby_datum_get _((VALUE, Oid *));
+extern VALUE plruby_define_void_class _((char *, char *));
+#endif
+
+#define DFC1(a_, b_) DirectFunctionCall1((a_), (b_))
+
+#define OidGD(a_) ObjectIdGetDatum(a_)
+#define PointerGD(a_) PointerGetDatum(a_)
+#define NameGD(a_) NameGetDatum(a_)
+#define BoolGD(a_) BoolGetDatum(a_)
+#define IntGD(a_) Int32GetDatum(a_)
+#define CStringGD(a_) CStringGetDatum(a_)
+#define TupleGD(a_,b_) TupleGetDatum((a_),(b_))
+
+

data/src/pltrans.c

@@ -0,0 +1,388 @@
+#include "plruby.h"
+
+#if PG_PL_VERSION >= 75
+
+#define PG_PL_READ_UNCOMMITTED 0
+#define PG_PL_READ_COMMITTED   1
+#define PG_PL_REPETABLE_READ   2
+#define PG_PL_SERIALIZABLE     3
+
+#define PL_ELOG_DEBUG 0
+
+#if PL_ELOG_DEBUG
+#define pl_elog(a,b) elog(a,b)
+#else
+#define pl_elog(a,b)
+#endif
+
+static int      pl_in_transaction = 0;
+static VALUE pl_eCatch, pl_ePLruby, pl_cTrans;
+
+struct pl_trans {
+    VALUE name;
+    int commit;
+};
+
+static void
+pl_trans_mark(void *trans)
+{
+}
+
+#define GetTrans(obj_, trans_) do {                                     \
+    if (TYPE(obj_) != T_DATA ||                                         \
+        RDATA(obj_)->dmark != (RUBY_DATA_FUNC)pl_trans_mark) {          \
+        rb_raise(rb_eArgError,                                           \
+                 "transaction method called with a wrong object");      \
+    }                                                                   \
+    Data_Get_Struct(obj_, struct pl_trans, trans_);                     \
+} while (0)
+
+static char *savename = "savepoint_name";
+
+static DefElem *
+make_defelem(char *name, VALUE arg)
+{
+    DefElem *f = makeNode(DefElem);
+    f->defname = name;
+    f->arg = (Node *)makeString(RSTRING_PTR(arg));
+    return f;
+}
+
+        
+static VALUE
+pl_intern_commit(VALUE obj)
+{
+    struct pl_trans *trans;
+    int rc;
+
+    pl_elog(NOTICE, "==> pl_intern_commit");
+    GetTrans(obj, trans);
+    PLRUBY_BEGIN_PROTECT(1);
+    if (NIL_P(trans->name)) {
+        if (!trans->commit) {
+            pl_elog(NOTICE, "ReleaseCurrentSubTransaction");
+            trans->commit = Qtrue;
+            if ((rc =  SPI_finish()) != SPI_OK_FINISH) {
+                elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(rc));
+            }
+            ReleaseCurrentSubTransaction();
+        }
+    }
+    else {
+	List *list;
+
+        pl_elog(NOTICE, "ReleaseSavepoint");
+	list = list_make1(make_defelem(savename, trans->name));
+        trans->name = Qnil;
+        trans->commit = Qtrue;
+        ReleaseSavepoint(list);
+        CommitTransactionCommand();
+        StartTransactionCommand();
+    }
+    PLRUBY_END_PROTECT;
+    pl_elog(NOTICE, "<== pl_intern_commit");
+    return Qnil;
+}
+
+struct pl_throw {
+    VALUE txn;
+    int commit;
+};
+
+static void
+pl_throw_mark(struct pl_throw *plt)
+{
+    rb_gc_mark(plt->txn);
+}
+
+static VALUE
+pl_commit(VALUE obj)
+{
+    VALUE res;
+    struct pl_throw *plt;
+
+    pl_elog(NOTICE, "pl_commit");
+    if (!IsSubTransaction()) {
+        rb_raise(pl_ePLruby, "outside a transaction");
+    }
+    res = Data_Make_Struct(pl_cTrans, struct pl_throw, pl_throw_mark, free, plt);
+    plt->commit = Qtrue;
+    plt->txn = obj;
+    rb_throw("__plruby__transaction__", res);
+    return Qnil;
+}
+
+static VALUE
+pl_intern_abort(VALUE obj)
+{
+    struct pl_trans *trans;
+    int rc;
+
+    pl_elog(NOTICE, "==> pl_intern_abort");
+    if (!IsSubTransaction()) {
+        rb_raise(pl_ePLruby, "outside a transaction");
+    }
+    GetTrans(obj, trans);
+    PLRUBY_BEGIN_PROTECT(1);
+    if (NIL_P(trans->name)) {
+        if (!trans->commit) {
+            pl_elog(NOTICE, "RollbackAndReleaseCurrentSubTransaction");
+            trans->commit = Qtrue;
+            if ((rc =  SPI_finish()) != SPI_OK_FINISH) {
+                elog(ERROR, "SPI_finish failed: %s", SPI_result_code_string(rc));
+            }
+            RollbackAndReleaseCurrentSubTransaction();
+        }
+    }
+    else {
+	List *list;
+
+        pl_elog(NOTICE, "RollbackToSavepoint");
+	list = list_make1(make_defelem(savename, trans->name));
+        trans->name = Qnil;
+        trans->commit = Qtrue;
+        RollbackToSavepoint(list);
+        CommitTransactionCommand();
+        RollbackAndReleaseCurrentSubTransaction();
+    }
+    PLRUBY_END_PROTECT;
+    pl_elog(NOTICE, "<== pl_intern_abort");
+    return Qnil;
+}
+
+static VALUE
+pl_intern_error(VALUE obj)
+{
+    struct pl_trans *trans;
+
+    pl_elog(NOTICE, "==> pl_intern_error");
+    if (!IsSubTransaction()) {
+        rb_raise(pl_ePLruby, "outside a transaction");
+    }
+    GetTrans(obj, trans);
+    PLRUBY_BEGIN_PROTECT(1);
+    pl_elog(NOTICE, "RollbackAndReleaseCurrentSubTransaction");
+    trans->commit = Qtrue;
+    RollbackAndReleaseCurrentSubTransaction();
+    PLRUBY_END_PROTECT;
+    pl_elog(NOTICE, "<== pl_intern_error");
+    return Qnil;
+}
+
+static VALUE
+pl_abort(VALUE obj)
+{
+    VALUE res;
+    struct pl_throw *plt;
+
+    pl_elog(NOTICE, "pl_abort");
+    if (!IsSubTransaction()) {
+        rb_raise(pl_ePLruby, "outside a transaction");
+    }
+    res = Data_Make_Struct(pl_cTrans, struct pl_throw, pl_throw_mark, free, plt);
+    plt->commit = Qfalse;
+    plt->txn = obj;
+    rb_throw("__plruby__transaction__", res);
+    return Qnil;
+}
+
+static VALUE
+pl_exec(VALUE val, VALUE args, VALUE self)
+{
+    rb_yield(args);
+    return Qnil;
+}
+
+static VALUE
+pl_catch(VALUE obj)
+{
+    VALUE res;
+    struct pl_throw *plt;
+
+    pl_elog(NOTICE, "pl_catch");
+    res = rb_catch("__plruby__transaction__", pl_exec, obj);
+    if (TYPE(res) == T_DATA &&
+        RDATA(res)->dmark == (RUBY_DATA_FUNC)pl_throw_mark) { 
+        Data_Get_Struct(res, struct pl_throw, plt);
+        if (plt->commit) {
+            pl_intern_commit(obj);
+        }
+        else {
+            pl_intern_abort(obj);
+        }
+        if (obj != plt->txn) {
+            rb_throw("__plruby__transaction__", res);
+        }
+    }
+    else {
+        pl_intern_commit(obj);
+    }
+    return Qnil;
+}
+        
+
+static VALUE
+pl_transaction(VALUE obj)
+{
+    struct pl_trans *trans;
+    VALUE res;
+    int state, rc, begin_sub;
+    MemoryContext orig_context = 0;
+
+
+    pl_elog(NOTICE, "==> pl_transaction");
+    if (!rb_block_given_p()) {
+        rb_raise(rb_eArgError, "no block given");
+    }
+    res = Data_Make_Struct(pl_cTrans, struct pl_trans, pl_trans_mark, 0, trans);
+    trans->name = Qnil;
+    PLRUBY_BEGIN_PROTECT(1);
+    if (IsSubTransaction()) {
+        char name[1024];
+
+        pl_elog(NOTICE, "DefineSavepoint");
+        sprintf(name, "__plruby__%d__", pl_in_transaction);
+        DefineSavepoint(name);
+        CommitTransactionCommand();
+        StartTransactionCommand();
+        pl_in_transaction++;
+        begin_sub = Qfalse;
+        trans->name = rb_str_new2(name);
+    }
+    else {
+        pl_in_transaction = 0;
+        pl_elog(NOTICE, "BeginTransactionBlock");
+        orig_context = CurrentMemoryContext;
+        SPI_push();
+        BeginInternalSubTransaction(NULL);
+        MemoryContextSwitchTo(orig_context);
+        if ((rc = SPI_connect()) != SPI_OK_CONNECT) {
+            elog(ERROR, "SPI_connect in transaction failed : %s", 
+                 SPI_result_code_string(rc));
+        }
+        begin_sub = Qtrue;
+    }
+    PLRUBY_END_PROTECT;
+    pl_elog(NOTICE, "==> rb_protect");
+    rb_protect(pl_catch, res, &state);
+    pl_elog(NOTICE, "<== rb_protect");
+    if (state) {
+        VALUE error = rb_gv_get("$!");
+        if (begin_sub && CLASS_OF(error) == pl_eCatch) {
+            if (!trans->commit) {
+                rb_protect(pl_intern_error, res, 0);
+            }
+        }
+        else {
+            if (!trans->commit) {
+                rb_protect(pl_intern_abort, res, 0);
+            }
+            if (begin_sub) {
+                MemoryContextSwitchTo(orig_context);
+                SPI_pop();
+            }
+        }
+        rb_jump_tag(state);
+    }
+    Data_Get_Struct(res, struct pl_trans, trans);
+    if (begin_sub) {
+        pl_elog(NOTICE, "commit");
+        if (!trans->commit) {
+            rb_protect(pl_intern_commit, res, 0);
+        }
+        MemoryContextSwitchTo(orig_context);
+        SPI_pop();
+    }
+    pl_elog(NOTICE, "<== pl_transaction");
+    return Qnil;
+}
+        
+#endif
+
+#if PG_PL_VERSION >= 81
+
+static VALUE
+pl_savepoint(VALUE obj, VALUE a)
+{
+    if (!IsTransactionBlock() || !IsSubTransaction()) {
+	rb_raise(pl_ePLruby, "savepoint called outside a transaction");
+    }
+    a = plruby_to_s(a);
+    pl_elog(NOTICE, "====> definesavepoint");
+    PLRUBY_BEGIN_PROTECT(1);
+    DefineSavepoint(RSTRING_PTR(a));
+    CommitTransactionCommand();
+    StartTransactionCommand();
+    PLRUBY_END_PROTECT;
+    pl_elog(NOTICE, "<==== definesavepoint");
+    return Qnil;
+}
+
+static VALUE
+pl_release(VALUE obj, VALUE a)
+{
+    if (!IsTransactionBlock() || !IsSubTransaction()) {
+	rb_raise(pl_ePLruby, "release called outside a transaction");
+    }
+    a = plruby_to_s(a);
+    pl_elog(NOTICE, "====> releasesavepoint");
+    PLRUBY_BEGIN_PROTECT(1);
+    ReleaseSavepoint(list_make1(make_defelem("savepoint_name", a)));
+    CommitTransactionCommand();
+    StartTransactionCommand();
+    PLRUBY_END_PROTECT;
+    pl_elog(NOTICE, "<==== releasesavepoint");
+    return Qnil;
+}
+
+static VALUE
+pl_rollback(VALUE obj, VALUE a)
+{
+    if (!IsTransactionBlock() || !IsSubTransaction()) {
+	rb_raise(pl_ePLruby, "rollback called outside a transaction");
+    }
+    a = plruby_to_s(a);
+    pl_elog(NOTICE, "====> rollbacksavepoint");
+    PLRUBY_BEGIN_PROTECT(1);
+    RollbackToSavepoint(list_make1(make_defelem("savepoint_name", a)));
+    CommitTransactionCommand();
+    RollbackAndReleaseCurrentSubTransaction();
+    PLRUBY_END_PROTECT;
+    pl_elog(NOTICE, "<==== rollbacksavepoint");
+    return Qnil;
+}
+
+#endif
+    
+void
+Init_plruby_trans()
+{
+#if PG_PL_VERSION >= 75
+    VALUE pl_mPL;
+
+    pl_mPL = rb_const_get(rb_cObject, rb_intern("PL"));
+    pl_ePLruby = rb_const_get(pl_mPL, rb_intern("Error"));
+    pl_eCatch = rb_const_get(pl_mPL, rb_intern("Catch"));
+
+    rb_define_global_const("READ_UNCOMMITED", INT2FIX(PG_PL_READ_UNCOMMITTED));
+    rb_define_global_const("READ_COMMITED", INT2FIX(PG_PL_READ_COMMITTED));
+    rb_define_global_const("REPETABLE_READ", INT2FIX(PG_PL_REPETABLE_READ));
+    rb_define_global_const("SERIALIZABLE", INT2FIX(PG_PL_SERIALIZABLE));
+    rb_define_global_function("transaction", pl_transaction, 0);
+#if PG_PL_VERSION >= 81
+    rb_define_global_function("savepoint", pl_savepoint, 1);
+    rb_define_global_function("release_savepoint", pl_release, 1);
+    rb_define_global_function("rollback_to_savepoint", pl_rollback, 1);
+#endif
+    pl_cTrans = rb_define_class_under(pl_mPL, "Transaction", rb_cObject);
+#if HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_undef_alloc_func(pl_cTrans);
+#else
+    rb_undef_method(CLASS_OF(pl_cTrans), "allocate");
+#endif
+    rb_undef_method(CLASS_OF(pl_cTrans), "new");
+    rb_define_method(pl_cTrans, "commit", pl_commit, 0);
+    rb_define_method(pl_cTrans, "abort", pl_abort, 0);
+    rb_define_method(pl_cTrans, "rollback", pl_abort, 0);
+#endif
+}