ruby-oci8 2.1.2 → 2.1.3

data/ext/oci8/oci8.h

@@ -2,7 +2,7 @@
 /*
  * oci8.h - part of ruby-oci8
  *
- * Copyright (C) 2002-2011 KUBO Takehiro <kubo@jiubao.org>
+ * Copyright (C) 2002-2012 KUBO Takehiro <kubo@jiubao.org>
  */
 #ifndef _RUBY_OCI_H_
 #define _RUBY_OCI_H_ 1
@@ -126,7 +126,20 @@ typedef struct OCICPool OCICPool;
 #define STRINGIZE(name) #name
 #endif
 #ifndef RB_GC_GUARD
-#define RB_GC_GUARD(v) (*(volatile VALUE *)&(v))
+#ifdef __GNUC__
+#define RB_GC_GUARD_PTR(ptr) \
+    __extension__ ({volatile VALUE *rb_gc_guarded_ptr = (ptr); rb_gc_guarded_ptr;})
+#else
+#ifdef _MSC_VER
+#pragma optimize("", off)
+#endif
+static inline volatile VALUE *rb_gc_guarded_ptr(volatile VALUE *ptr) {return ptr;}
+#ifdef _MSC_VER
+#pragma optimize("", on)
+#endif
+#define RB_GC_GUARD_PTR(ptr) rb_gc_guarded_ptr(ptr)
+#endif
+#define RB_GC_GUARD(v) (*RB_GC_GUARD_PTR(&(v)))
 #endif
 
 /* new functions in ruby 1.9.
@@ -135,9 +148,6 @@ typedef struct OCICPool OCICPool;
 #if !defined(HAVE_RB_ERRINFO) && defined(HAVE_RUBY_ERRINFO)
 #define rb_errinfo() ruby_errinfo
 #endif
-#if !defined HAVE_TYPE_RB_BLOCKING_FUNCTION_T_ && !defined HAVE_TYPE_RB_BLOCKING_FUNCTION_TP
-typedef VALUE rb_blocking_function_t(void *);
-#endif
 
 #ifndef HAVE_TYPE_RB_ENCODING
 #define rb_enc_associate(str, enc) do {} while(0)
@@ -160,7 +170,11 @@ typedef VALUE rb_blocking_function_t(void *);
 #endif
 #endif
 
-#if defined(HAVE_NATIVETHREAD) || defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) || defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#define NATIVE_THREAD_WITH_GVL 1
+#endif
+
+#if defined(HAVE_NATIVETHREAD) || NATIVE_THREAD_WITH_GVL
 /*
  * oci8_errhp is a thread local object in ruby 1.9, rubinius
  * and ruby 1.8 configured with --enable-pthread.
@@ -213,7 +227,7 @@ typedef VALUE rb_blocking_function_t(void *);
 #define oci8_tls_get(key)        pthread_getspecific(key)
 #define oci8_tls_set(key, val)   pthread_setspecific((key), (val))
 #endif
-#endif /* HAVE_RB_THREAD_BLOCKING_REGION */
+#endif /* USE_THREAD_LOCAL_ERRHP */
 
 /* utility macros
  */
@@ -333,6 +347,11 @@ struct oci8_bind {
 
 typedef struct oci8_logoff_strategy oci8_logoff_strategy_t;
 
+typedef struct oci8_temp_lob {
+    struct oci8_temp_lob *next;
+    OCILobLocator *lob;
+} oci8_temp_lob_t;
+
 typedef struct oci8_svcctx {
     oci8_base_t base;
     volatile VALUE executing_thread;
@@ -342,15 +361,16 @@ typedef struct oci8_svcctx {
     rb_pid_t pid;
     unsigned char state;
     char is_autocommit;
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+#ifdef NATIVE_THREAD_WITH_GVL
     char non_blocking;
 #endif
     VALUE long_read_len;
+    oci8_temp_lob_t *temp_lobs;
 } oci8_svcctx_t;
 
 struct oci8_logoff_strategy {
     void *(*prepare)(oci8_svcctx_t *svcctx);
-    rb_blocking_function_t *execute;
+    void *(*execute)(void *);
 };
 
 typedef struct {
@@ -428,7 +448,6 @@ extern ID oci8_id_at_last_error;
 extern ID oci8_id_new;
 extern ID oci8_id_get;
 extern ID oci8_id_set;
-extern ID oci8_id_keys;
 extern ID oci8_id_oci8_vtable;
 #ifdef CHAR_IS_NOT_A_SHORTCUT_TO_ID
 extern ID oci8_id_add_op; /* ID of the addition operator '+' */
@@ -449,7 +468,7 @@ VALUE oci8_define_class_under(VALUE outer, const char *name, oci8_base_vtable_t
 VALUE oci8_define_bind_class(const char *name, const oci8_bind_vtable_t *vptr);
 void oci8_link_to_parent(oci8_base_t *base, oci8_base_t *parent);
 void oci8_unlink_from_parent(oci8_base_t *base);
-sword oci8_blocking_region(oci8_svcctx_t *svcctx, rb_blocking_function_t func, void *data);
+sword oci8_call_without_gvl(oci8_svcctx_t *svcctx, void *(*func)(void *), void *data);
 sword oci8_exec_sql(oci8_svcctx_t *svcctx, const char *sql_text, ub4 num_define_vars, oci8_exec_sql_var_t *define_vars, ub4 num_bind_vars, oci8_exec_sql_var_t *bind_vars, int raise_on_error);
 #if defined RUNTIME_API_CHECK
 void *oci8_find_symbol(const char *symbol_name);
@@ -471,7 +490,7 @@ void oci8_check_error_(sword status, oci8_base_t *base, OCIStmt *stmthp, const c
 void Init_oci8_handle(void);
 
 /* oci8.c */
-VALUE Init_oci8(void);
+void Init_oci8(VALUE *out);
 void oci8_do_parse_connect_string(VALUE conn_str, VALUE *user, VALUE *pass, VALUE *dbname, VALUE *mode);
 oci8_svcctx_t *oci8_get_svcctx(VALUE obj);
 OCISvcCtx *oci8_get_oci_svcctx(VALUE obj);
@@ -496,8 +515,6 @@ void oci8_bind_free(oci8_base_t *base);
 void oci8_bind_hp_obj_mark(oci8_base_t *base);
 void Init_oci8_bind(VALUE cOCI8BindTypeBase);
 oci8_bind_t *oci8_get_bind(VALUE obj);
-void oci8_bind_set_data(VALUE self, VALUE val);
-VALUE oci8_bind_get_data(VALUE self);
 
 /* metadata.c */
 extern VALUE cOCI8MetadataBase;
@@ -551,11 +568,7 @@ VALUE oci8_make_interval_ds(OCIInterval *s);
 void Init_oci_object(VALUE mOCI);
 
 /* attr.c */
-VALUE oci8_get_sb1_attr(oci8_base_t *base, ub4 attrtype, OCIStmt *stmtp);
 VALUE oci8_get_ub2_attr(oci8_base_t *base, ub4 attrtype, OCIStmt *stmtp);
-VALUE oci8_get_sb2_attr(oci8_base_t *base, ub4 attrtype, OCIStmt *stmtp);
-VALUE oci8_get_ub4_attr(oci8_base_t *base, ub4 attrtype, OCIStmt *stmtp);
-VALUE oci8_get_string_attr(oci8_base_t *base, ub4 attrtype, OCIStmt *stmtp);
 VALUE oci8_get_rowid_attr(oci8_base_t *base, ub4 attrtype, OCIStmt *stmtp);
 
 /* encoding.c */

data/ext/oci8/oci8lib.c

@@ -4,12 +4,14 @@
  */
 
 #include "oci8.h"
+#ifdef HAVE_RUBY_THREAD_H
+#include <ruby/thread.h>
+#endif
 
 ID oci8_id_at_last_error;
 ID oci8_id_new;
 ID oci8_id_get;
 ID oci8_id_set;
-ID oci8_id_keys;
 ID oci8_id_oci8_vtable;
 #ifdef CHAR_IS_NOT_A_SHORTCUT_TO_ID
 ID oci8_id_add_op;
@@ -80,7 +82,6 @@ Init_oci8lib()
     oci8_id_new = rb_intern("new");
     oci8_id_get = rb_intern("get");
     oci8_id_set = rb_intern("set");
-    oci8_id_keys = rb_intern("keys");
     oci8_id_oci8_vtable = rb_intern("__oci8_vtable__");
 #ifdef CHAR_IS_NOT_A_SHORTCUT_TO_ID
     oci8_id_add_op = rb_intern("+");
@@ -100,7 +101,7 @@ Init_oci8lib()
     Init_oci8_handle();
 
     /* OCI8 class */
-    cOCI8 = Init_oci8();
+    Init_oci8(&cOCI8);
 
     /* OCI8::ConnectionPool class */
     Init_oci8_connection_pool(cOCI8);
@@ -201,74 +202,106 @@ void oci8_unlink_from_parent(oci8_base_t *base)
     base->parent = NULL;
 }
 
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+#ifdef NATIVE_THREAD_WITH_GVL
 
-#if 0
-typedef struct {
-    dvoid *hndlp;
+static void oci8_unblock_func(void *user_data)
+{
+    oci8_svcctx_t *svcctx = (oci8_svcctx_t *)user_data;
+    OCIBreak(svcctx->base.hp.ptr, oci8_errhp);
+}
+
+typedef struct free_temp_lob_arg_t {
+    oci8_svcctx_t *svcctx;
+    OCISvcCtx *svchp;
     OCIError *errhp;
-} ocibreak_arg_t;
+    OCILobLocator *lob;
+} free_temp_lob_arg_t;
 
-static VALUE call_OCIBreak(void *user_data)
+static void *free_temp_lob(void *user_data)
 {
-    ocibreak_arg_t *arg = (ocibreak_arg_t *)user_data;
-    OCIBreak(arg->hndlp, arg->errhp);
-    return Qnil;
+    free_temp_lob_arg_t *data = (free_temp_lob_arg_t *)user_data;
+    sword rv = OCILobFreeTemporary(data->svchp, data->errhp, data->lob);
+
+    data->svcctx->executing_thread = Qnil;
+    return (void*)(VALUE)rv;
 }
 
-static void oci8_unblock_func(void *user_data)
+/* ruby 1.9 */
+sword oci8_call_without_gvl(oci8_svcctx_t *svcctx, void *(*func)(void *), void *data)
 {
-    oci8_svcctx_t *svcctx = (oci8_svcctx_t *)user_data;
-    if (svcctx->base.hp.ptr != NULL) {
-        ocibreak_arg_t arg;
-        arg.hndlp = svcctx->base.hp.ptr;
-        arg.errhp = oci8_errhp;
-        rb_thread_blocking_region(call_OCIBreak, &arg, NULL, NULL);
+    oci8_temp_lob_t *lob;
+    OCIError *errhp = oci8_errhp;
+
+    if (!NIL_P(svcctx->executing_thread)) {
+        rb_raise(rb_eRuntimeError /* FIXME */, "executing in another thread");
     }
-}
+
+    lob = svcctx->temp_lobs;
+    while (lob != NULL) {
+        oci8_temp_lob_t *lob_next = lob->next;
+
+        if (svcctx->non_blocking) {
+            free_temp_lob_arg_t arg;
+            sword rv;
+
+            arg.svcctx = svcctx;
+            arg.svchp = svcctx->base.hp.svc;
+            arg.errhp = errhp;
+            arg.lob = lob->lob;
+
+            svcctx->executing_thread = rb_thread_current();
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+            rv = (sword)(VALUE)rb_thread_call_without_gvl(free_temp_lob, &arg, oci8_unblock_func, svcctx);
 #else
-static void oci8_unblock_func(void *user_data)
-{
-    oci8_svcctx_t *svcctx = (oci8_svcctx_t *)user_data;
-    OCIBreak(svcctx->base.hp.ptr, oci8_errhp);
-}
+            rv = (sword)rb_thread_blocking_region((VALUE(*)(void*))free_temp_lob, &arg, oci8_unblock_func, svcctx);
 #endif
+            if (rv == OCI_ERROR) {
+                if (oci8_get_error_code(errhp) == 1013) {
+                    rb_raise(eOCIBreak, "Canceled by user request.");
+                }
+            }
+        } else {
+            OCILobFreeTemporary(svcctx->base.hp.svc, errhp, lob->lob);
+        }
+        OCIDescriptorFree(lob->lob, OCI_DTYPE_LOB);
+
+        xfree(lob);
+        svcctx->temp_lobs = lob = lob_next;
+    }
 
-/* ruby 1.9 */
-sword oci8_blocking_region(oci8_svcctx_t *svcctx, rb_blocking_function_t func, void *data)
-{
     if (svcctx->non_blocking) {
         sword rv;
 
-        if (!NIL_P(svcctx->executing_thread)) {
-            rb_raise(rb_eRuntimeError /* FIXME */, "executing in another thread");
-        }
         svcctx->executing_thread = rb_thread_current();
         /* Note: executing_thread is cleard at the end of the blocking function. */
-        rv = (sword)rb_thread_blocking_region(func, data, oci8_unblock_func, svcctx);
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+        rv = (sword)(VALUE)rb_thread_call_without_gvl(func, data, oci8_unblock_func, svcctx);
+#else
+        rv = (sword)rb_thread_blocking_region((VALUE(*)(void*))func, data, oci8_unblock_func, svcctx);
+#endif
         if (rv == OCI_ERROR) {
-            if (oci8_get_error_code(oci8_errhp) == 1013) {
+            if (oci8_get_error_code(errhp) == 1013) {
                 rb_raise(eOCIBreak, "Canceled by user request.");
             }
         }
         return rv;
     } else {
-        return (sword)func(data);
+        return (sword)(VALUE)func(data);
     }
 }
-#else /* HAVE_RB_THREAD_BLOCKING_REGION */
+#else /* NATIVE_THREAD_WITH_GVL */
 
 /* ruby 1.8 */
 typedef struct {
     oci8_svcctx_t *svcctx;
-    rb_blocking_function_t *func;
+    void *(*func)(void *);
     void *data;
 } blocking_region_arg_t;
 
 static VALUE blocking_function_execute(blocking_region_arg_t *arg)
 {
     oci8_svcctx_t *svcctx = arg->svcctx;
-    rb_blocking_function_t *func = arg->func;
+    void *(*func)(void *) = arg->func;
     void *data = arg->data;
     struct timeval tv;
     sword rv;
@@ -276,7 +309,7 @@ static VALUE blocking_function_execute(blocking_region_arg_t *arg)
     tv.tv_sec = 0;
     tv.tv_usec = 10000;
     svcctx->executing_thread = rb_thread_current();
-    while ((rv = func(data)) == OCI_STILL_EXECUTING) {
+    while ((rv = (sword)(VALUE)func(data)) == OCI_STILL_EXECUTING) {
         rb_thread_wait_for(tv);
         if (tv.tv_usec < 500000)
             tv.tv_usec <<= 1;
@@ -303,7 +336,7 @@ static VALUE blocking_function_ensure(oci8_svcctx_t *svcctx)
     return Qnil;
 }
 
-sword oci8_blocking_region(oci8_svcctx_t *svcctx, rb_blocking_function_t func, void *data)
+sword oci8_call_without_gvl(oci8_svcctx_t *svcctx, void *(*func)(void *), void *data)
 {
     blocking_region_arg_t arg;
 
@@ -315,7 +348,7 @@ sword oci8_blocking_region(oci8_svcctx_t *svcctx, rb_blocking_function_t func, v
     }
     return (sword)rb_ensure(blocking_function_execute, (VALUE)&arg, blocking_function_ensure, (VALUE)svcctx);
 }
-#endif /* HAVE_RB_THREAD_BLOCKING_REGION */
+#endif /* NATIVE_THREAD_WITH_GVL */
 
 typedef struct {
     oci8_svcctx_t *svcctx;

data/ext/oci8/ocihandle.c

@@ -419,8 +419,9 @@ static VALUE attr_get_binary(VALUE self, VALUE attr_type)
 static VALUE attr_get_integer(VALUE self, VALUE attr_type)
 {
     oci8_base_t *base = DATA_PTR(self);
+    OCINumber onum;
     union {
-        OCINumber *value;
+        void *value;
         ub8 dummy; /* padding for incorrect attrtype to protect the stack */
     } v;
     ub4 size = 0;
@@ -428,7 +429,11 @@ static VALUE attr_get_integer(VALUE self, VALUE attr_type)
     v.dummy = 0;
     Check_Type(attr_type, T_FIXNUM);
     chker2(OCIAttrGet(base->hp.ptr, base->type, &v.value, &size, FIX2INT(attr_type), oci8_errhp), base);
-    return oci8_make_integer(v.value, oci8_errhp);
+
+    memset(&onum, 0, sizeof(onum));
+    onum.OCINumberPart[0] = size;
+    memcpy(&onum.OCINumberPart[1], v.value, size);
+    return oci8_make_integer(&onum, oci8_errhp);
 }
 
 /*

data/ext/oci8/ocinumber.c

@@ -32,7 +32,7 @@ static ID id_denominator;
 static ID id_Rational;
 static ID id_BigDecimal;
 
-#ifndef T_RATIONAL
+#ifndef rb_Rational2
 static VALUE cRational;
 #endif
 static VALUE cBigDecimal;
@@ -51,7 +51,7 @@ static OCINumber const_mPI2; /* -PI/2 */
 #endif
 #define RBOCI8_T_ORANUMBER (T_MASK + 1)
 #define RBOCI8_T_BIGDECIMAL (T_MASK + 2)
-#ifdef T_RATIONAL
+#ifdef rb_Rational2
 #define RBOCI8_T_RATIONAL T_RATIONAL
 #else
 #define RBOCI8_T_RATIONAL (T_MASK + 3)
@@ -63,7 +63,7 @@ static int rboci8_type(VALUE obj)
     VALUE klass;
 
     switch (type) {
-#ifndef T_RATIONAL
+#ifndef rb_Rational2
     case T_OBJECT:
         klass = CLASS_OF(obj);
         if (cRational != 0) {
@@ -1262,7 +1262,7 @@ static VALUE onum_round(int argc, VALUE *argv, VALUE self)
  *
  *  @param [Integer]
  *  @return [OraNumber]
- *  @todo returns {Integer} when <i>decplace</i> is not specified.
+ *  @todo returns <i>Integer</i> when <i>decplace</i> is not specified.
  */
 static VALUE onum_trunc(int argc, VALUE *argv, VALUE self)
 {
@@ -1435,7 +1435,7 @@ static VALUE onum_to_r(VALUE self)
     } else {
         y = rb_funcall(INT2FIX(10), rb_intern("**"), 1, INT2FIX(nshift));
     }
-#ifdef T_RATIONAL
+#ifdef rb_Rational2
     return rb_Rational(x, y);
 #else
     if (!cRational) {

data/ext/oci8/stmt.c

@@ -3,29 +3,11 @@
  * stmt.c - part of ruby-oci8
  *         implement the methods of OCIStmt.
  *
- * Copyright (C) 2002-2010 KUBO Takehiro <kubo@jiubao.org>
+ * Copyright (C) 2002-2012 KUBO Takehiro <kubo@jiubao.org>
  *
  */
 #include "oci8.h"
 
-static VALUE oci8_sym_select_stmt;
-static VALUE oci8_sym_update_stmt;
-static VALUE oci8_sym_delete_stmt;
-static VALUE oci8_sym_insert_stmt;
-static VALUE oci8_sym_create_stmt;
-static VALUE oci8_sym_drop_stmt;
-static VALUE oci8_sym_alter_stmt;
-static VALUE oci8_sym_begin_stmt;
-static VALUE oci8_sym_declare_stmt;
-static ID id_at_column_metadata;
-static ID id_at_actual_array_size;
-static ID id_at_max_array_size;
-static ID id_each_value;
-static ID id_at_names;
-static ID id_empty_p;
-static ID id_at_con;
-static ID id_clear;
-
 VALUE cOCIStmt;
 
 #define TO_STMT(obj) ((oci8_stmt_t *)oci8_get_handle((obj), cOCIStmt))
@@ -33,8 +15,6 @@ VALUE cOCIStmt;
 typedef struct {
     oci8_base_t base;
     VALUE svc;
-    VALUE binds;
-    VALUE defns;
     int use_stmt_release;
 } oci8_stmt_t;
 
@@ -42,16 +22,12 @@ static void oci8_stmt_mark(oci8_base_t *base)
 {
     oci8_stmt_t *stmt = (oci8_stmt_t *)base;
     rb_gc_mark(stmt->svc);
-    rb_gc_mark(stmt->binds);
-    rb_gc_mark(stmt->defns);
 }
 
 static void oci8_stmt_free(oci8_base_t *base)
 {
     oci8_stmt_t *stmt = (oci8_stmt_t *)base;
     stmt->svc = Qnil;
-    stmt->binds = Qnil;
-    stmt->defns = Qnil;
     if (stmt->use_stmt_release) {
         OCIStmtRelease(base->hp.stmt, oci8_errhp, NULL, 0, OCI_DEFAULT);
         base->type = 0;
@@ -65,19 +41,24 @@ static oci8_base_vtable_t oci8_stmt_vtable = {
     sizeof(oci8_stmt_t),
 };
 
-static VALUE oci8_stmt_initialize(int argc, VALUE *argv, VALUE self)
+/*
+ * call-seq:
+ *   __initialize(connection, sql_statement)
+ *
+ * @param [OCI8] connection
+ * @param [String] sql_statement
+ *
+ * @private
+ */
+static VALUE oci8_stmt_initialize(VALUE self, VALUE svc, VALUE sql)
 {
     oci8_stmt_t *stmt = DATA_PTR(self);
     oci8_svcctx_t *svcctx;
-    VALUE svc;
-    VALUE sql;
     sword rv;
 
-    rb_scan_args(argc, argv, "11", &svc, &sql);
-
     svcctx = oci8_get_svcctx(svc);
     oci8_check_pid_consistency(svcctx);
-    if (argc > 1 && oracle_client_version >= ORAVER_9_2) {
+    if (!NIL_P(sql) && oracle_client_version >= ORAVER_9_2) {
         OCI8SafeStringValue(sql);
 
         rv = OCIStmtPrepare2(svcctx->base.hp.svc, &stmt->base.hp.stmt, oci8_errhp, RSTRING_ORATEXT(sql), RSTRING_LEN(sql), NULL, 0, OCI_NTV_SYNTAX, OCI_DEFAULT);
@@ -92,7 +73,7 @@ static VALUE oci8_stmt_initialize(int argc, VALUE *argv, VALUE self)
             oci8_env_raise(oci8_envhp, rv);
         }
         stmt->base.type = OCI_HTYPE_STMT;
-        if (argc > 1) {
+        if (!NIL_P(sql)) {
             OCI8SafeStringValue(sql);
             rv = OCIStmtPrepare(stmt->base.hp.stmt, oci8_errhp, RSTRING_ORATEXT(sql), RSTRING_LEN(sql), OCI_NTV_SYNTAX, OCI_DEFAULT);
             if (IS_OCI_ERROR(rv)) {
@@ -101,17 +82,20 @@ static VALUE oci8_stmt_initialize(int argc, VALUE *argv, VALUE self)
         }
     }
     stmt->svc = svc;
-    stmt->binds = rb_hash_new();
-    stmt->defns = rb_ary_new();
-    rb_ivar_set(stmt->base.self, id_at_column_metadata, rb_ary_new());
-    rb_ivar_set(stmt->base.self, id_at_names, Qnil);
-    rb_ivar_set(stmt->base.self, id_at_con, svc);
-    rb_ivar_set(stmt->base.self, id_at_max_array_size, Qnil);
 
     oci8_link_to_parent((oci8_base_t*)stmt, (oci8_base_t*)DATA_PTR(svc));
     return Qnil;
 }
 
+/*
+ * call-seq:
+ *   __define(position, bindobj)
+ *
+ * @param [Integer] position
+ * @param [OCI8::BindType::Base] bindobj
+ *
+ * @private
+ */
 static VALUE oci8_define_by_pos(VALUE self, VALUE vposition, VALUE vbindobj)
 {
     oci8_stmt_t *stmt = TO_STMT(self);
@@ -141,16 +125,18 @@ static VALUE oci8_define_by_pos(VALUE self, VALUE vposition, VALUE vbindobj)
     if (vptr->post_bind_hook != NULL) {
         vptr->post_bind_hook(obind);
     }
-    if (position - 1 < RARRAY_LEN(stmt->defns)) {
-        VALUE old_value = RARRAY_PTR(stmt->defns)[position - 1];
-        if (!NIL_P(old_value)) {
-            oci8_base_free((oci8_base_t*)oci8_get_bind(old_value));
-        }
-    }
-    rb_ary_store(stmt->defns, position - 1, obind->base.self);
     return obind->base.self;
 }
 
+/*
+ * call-seq:
+ *   __bind(placeholder, bindobj)
+ *
+ * @param [Integer, String or Symbol] placeholder
+ * @param [OCI8::BindType::Base] bindobj
+ *
+ * @private
+ */
 static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
 {
     oci8_stmt_t *stmt = TO_STMT(self);
@@ -160,7 +146,6 @@ static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
     oci8_bind_t *obind;
     const oci8_bind_vtable_t *vptr;
     sword status;
-    VALUE old_value;
     void *indp;
 
     if (NIL_P(vplaceholder)) { /* 1 */
@@ -207,11 +192,6 @@ static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
     if (vptr->post_bind_hook != NULL) {
         vptr->post_bind_hook(obind);
     }
-    old_value = rb_hash_aref(stmt->binds, vplaceholder);
-    if (!NIL_P(old_value)) {
-        oci8_base_free((oci8_base_t*)oci8_get_bind(old_value));
-    }
-    rb_hash_aset(stmt->binds, vplaceholder, obind->base.self);
     return obind->base.self;
 }
 
@@ -232,59 +212,39 @@ static sword oci8_call_stmt_execute(oci8_svcctx_t *svcctx, oci8_stmt_t *stmt, ub
     return rv;
 }
 
+/*
+ * call-seq:
+ *   __execute(iteration_count)
+ *
+ * @param [Integer] iteration_count
+ *
+ * @private
+ */
 static VALUE oci8_stmt_execute(VALUE self, VALUE iteration_count)
 {
     oci8_stmt_t *stmt = TO_STMT(self);
     oci8_svcctx_t *svcctx = oci8_get_svcctx(stmt->svc);
-    ub4 iters;
-    ub4 mode;
 
-    if (oci8_get_ub2_attr(&stmt->base, OCI_ATTR_STMT_TYPE, stmt->base.hp.stmt) == INT2FIX(OCI_STMT_SELECT)) {
-        iters = 0;
-        mode = OCI_DEFAULT;
-    } else {
-        if(!NIL_P(iteration_count)) 
-            iters = NUM2INT(iteration_count);
-        else 
-            iters = 1;
-        mode = svcctx->is_autocommit ? OCI_COMMIT_ON_SUCCESS : OCI_DEFAULT;
-    }
-    chker3(oci8_call_stmt_execute(svcctx, stmt, iters, mode),
+    chker3(oci8_call_stmt_execute(svcctx, stmt, NUM2UINT(iteration_count),
+                                  svcctx->is_autocommit ? OCI_COMMIT_ON_SUCCESS : OCI_DEFAULT),
            &stmt->base, stmt->base.hp.stmt);
     return self;
 }
 
-static VALUE each_value(VALUE obj)
-{
-    return rb_funcall(obj, id_each_value, 0);
-}
-
-static VALUE clear_binds_iterator_proc(VALUE val, VALUE arg)
-{
-    if(!NIL_P(val)) {
-        oci8_base_free((oci8_base_t*)oci8_get_bind(val));
-    }
-    return Qnil;
-}
-
-static VALUE oci8_stmt_clear_binds(VALUE self)
+/*
+ * call-seq:
+ *   __fetch(connection)
+ *
+ * @param [OCI8] connection
+ * @return [true or false] true on success and false when all rows are fetched.
+ *
+ * @private
+ */
+static VALUE oci8_stmt_fetch(VALUE self, VALUE svc)
 {
     oci8_stmt_t *stmt = TO_STMT(self);
-
-    if(!RTEST(rb_funcall(stmt->binds, id_empty_p, 0)))
-    {
-        rb_iterate(each_value, stmt->binds, clear_binds_iterator_proc, Qnil);
-        rb_funcall(stmt->binds,id_clear,0);
-    }
-
-    return self;
-}
-
-static VALUE oci8_stmt_do_fetch(oci8_stmt_t *stmt, oci8_svcctx_t *svcctx)
-{
-    VALUE ary;
+    oci8_svcctx_t *svcctx = oci8_get_svcctx(svc);
     sword rv;
-    long idx;
     oci8_bind_t *obind;
     const oci8_bind_vtable_t *vptr;
 
@@ -302,46 +262,21 @@ static VALUE oci8_stmt_do_fetch(oci8_stmt_t *stmt, oci8_svcctx_t *svcctx)
     }
     rv = OCIStmtFetch_nb(svcctx, stmt->base.hp.stmt, oci8_errhp, 1, OCI_FETCH_NEXT, OCI_DEFAULT);
     if (rv == OCI_NO_DATA) {
-        return Qnil;
+        return Qfalse;
     }
     chker3(rv, &svcctx->base, stmt->base.hp.stmt);
-    ary = rb_ary_new2(RARRAY_LEN(stmt->defns));
-    for (idx = 0; idx < RARRAY_LEN(stmt->defns); idx++) {
-        rb_ary_store(ary, idx, oci8_bind_get_data(RARRAY_PTR(stmt->defns)[idx]));
-    }
-    return ary;
+    return Qtrue;
 }
 
 /*
- * Gets fetched data as array. This is available for select
- * statement only.
+ * call-seq:
+ *   __paramGet(pos)
+ *
+ * @param [Fixnum] pos Column position which starts from one
+ * @return [OCI8::Metadata::Base]
  *
- * example:
- *   conn = OCI8.new('scott', 'tiger')
- *   cursor = conn.exec('SELECT * FROM emp')
- *   while r = cursor.fetch()
- *     puts r.join(',')
- *   end
- *   cursor.close
- *   conn.logoff
+ * @private
  */
-static VALUE oci8_stmt_fetch(VALUE self)
-{
-    oci8_stmt_t *stmt = TO_STMT(self);
-    oci8_svcctx_t *svcctx = oci8_get_svcctx(stmt->svc);
-
-    if (rb_block_given_p()) {
-        for (;;) {
-            VALUE rs = oci8_stmt_do_fetch(stmt, svcctx);
-            if (NIL_P(rs))
-                return self; /* NEED TO CHECK 0.1 behavior. */
-            rb_yield(rs);
-        }
-    } else {
-        return oci8_stmt_do_fetch(stmt, svcctx);
-    }
-}
-
 static VALUE oci8_stmt_get_param(VALUE self, VALUE pos)
 {
     oci8_stmt_t *stmt = TO_STMT(self);
@@ -357,73 +292,15 @@ static VALUE oci8_stmt_get_param(VALUE self, VALUE pos)
 }
 
 /*
- * gets the type of SQL statement as follows.
- * * OCI8::STMT_SELECT
- * * OCI8::STMT_UPDATE
- * * OCI8::STMT_DELETE
- * * OCI8::STMT_INSERT
- * * OCI8::STMT_CREATE
- * * OCI8::STMT_DROP
- * * OCI8::STMT_ALTER
- * * OCI8::STMT_BEGIN (PL/SQL block which starts with a BEGIN keyword)
- * * OCI8::STMT_DECLARE (PL/SQL block which starts with a DECLARE keyword)
- * * Other Fixnum value undocumented in Oracle manuals.
- *
- * <em>Changes between ruby-oci8 1.0 and 2.0.</em>
- *
- * [ruby-oci8 2.0] OCI8::STMT_* are Symbols. (:select_stmt, :update_stmt, etc.)
- * [ruby-oci8 1.0] OCI8::STMT_* are Fixnums. (1, 2, 3, etc.)
- */
-static VALUE oci8_stmt_get_stmt_type(VALUE self)
-{
-    oci8_base_t *base = oci8_get_handle(self, cOCIStmt);
-    VALUE stmt_type = oci8_get_ub2_attr(base, OCI_ATTR_STMT_TYPE, base->hp.stmt);
-    switch (FIX2INT(stmt_type)) {
-    case OCI_STMT_SELECT:
-        return oci8_sym_select_stmt;
-    case OCI_STMT_UPDATE:
-        return oci8_sym_update_stmt;
-    case OCI_STMT_DELETE:
-        return oci8_sym_delete_stmt;
-    case OCI_STMT_INSERT:
-        return oci8_sym_insert_stmt;
-    case OCI_STMT_CREATE:
-        return oci8_sym_create_stmt;
-    case OCI_STMT_DROP:
-        return oci8_sym_drop_stmt;
-    case OCI_STMT_ALTER:
-        return oci8_sym_alter_stmt;
-    case OCI_STMT_BEGIN:
-        return oci8_sym_begin_stmt;
-    case OCI_STMT_DECLARE:
-        return oci8_sym_declare_stmt;
-    default:
-        return stmt_type;
-    }
-}
-
-/*
- * Returns the number of processed rows.
- */
-static VALUE oci8_stmt_get_row_count(VALUE self)
-{
-    oci8_base_t *base = oci8_get_handle(self, cOCIStmt);
-    return oci8_get_ub4_attr(base, OCI_ATTR_ROW_COUNT, base->hp.stmt);
-}
-
-/*
- * Get the rowid of the last inserted/updated/deleted row.
+ * Get the rowid of the last inserted, updated or deleted row.
  * This cannot be used for select statements.
  *
- * example:
+ * @example
  *   cursor = conn.parse('INSERT INTO foo_table values(:1, :2)', 1, 2)
  *   cursor.exec
- *   cursor.rowid # => the inserted row's rowid
+ *   cursor.rowid # => "AAAFlLAAEAAAAG9AAA", the inserted row's rowid
  *
- * <em>Changes between ruby-oci8 1.0.3 and 1.0.4.</em>
- *
- * [ruby-oci8 1.0.4 or upper] The return value is a String.
- * [ruby-oci8 1.0.3 or lower] It returns an OCIRowid object.
+ * @return [String]
  */
 static VALUE oci8_stmt_get_rowid(VALUE self)
 {
@@ -431,158 +308,6 @@ static VALUE oci8_stmt_get_rowid(VALUE self)
     return oci8_get_rowid_attr(base, OCI_ATTR_ROWID, base->hp.stmt);
 }
 
-static VALUE oci8_stmt_get_param_count(VALUE self)
-{
-    oci8_base_t *base = oci8_get_handle(self, cOCIStmt);
-    return oci8_get_ub4_attr(base, OCI_ATTR_PARAM_COUNT, base->hp.stmt);
-}
-
-/*
- * call-seq:
- *   [key]
- *
- * Gets the value of the bind variable.
- *
- * In case of binding explicitly, use same key with that of
- * OCI8::Cursor#bind_param. A placeholder can be bound by
- * name or position. If you bind by name, use that name. If you bind
- * by position, use the position.
- *
- * example:
- *   cursor = conn.parse("BEGIN :out := 'BAR'; END;")
- *   cursor.bind_param(':out', 'FOO') # bind by name
- *   p cursor[':out'] # => 'FOO'
- *   p cursor[1] # => nil
- *   cursor.exec()
- *   p cursor[':out'] # => 'BAR'
- *   p cursor[1] # => nil
- *
- * example:
- *   cursor = conn.parse("BEGIN :out := 'BAR'; END;")
- *   cursor.bind_param(1, 'FOO') # bind by position
- *   p cursor[':out'] # => nil
- *   p cursor[1] # => 'FOO'
- *   cursor.exec()
- *   p cursor[':out'] # => nil
- *   p cursor[1] # => 'BAR'
- *
- * In case of binding by OCI8#exec or OCI8::Cursor#exec,
- * get the value by position, which starts from 1.
- *
- * example:
- *   cursor = conn.exec("BEGIN :out := 'BAR'; END;", 'FOO')
- *   # 1st bind variable is bound as String with width 3. Its initial value is 'FOO'
- *   # After execute, the value become 'BAR'.
- *   p cursor[1] # => 'BAR'
- */
-static VALUE oci8_stmt_aref(VALUE self, VALUE key)
-{
-    oci8_stmt_t *stmt = TO_STMT(self);
-    VALUE obj = rb_hash_aref(stmt->binds, key);
-    if (NIL_P(obj)) {
-        return Qnil;
-    }
-    return oci8_bind_get_data(obj);
-}
-
-/*
- * call-seq:
- *   [key] = val
- *
- * Sets the value to the bind variable. The way to specify the
- * +key+ is same with OCI8::Cursor#[]. This is available
- * to replace the value and execute many times.
- *
- * example1:
- *   cursor = conn.parse("INSERT INTO test(col1) VALUES(:1)")
- *   cursor.bind_params(1, nil, String, 3)
- *   ['FOO', 'BAR', 'BAZ'].each do |key|
- *     cursor[1] = key
- *     cursor.exec
- *   end
- *   cursor.close()
- *
- * example2:
- *   ['FOO', 'BAR', 'BAZ'].each do |key|
- *     conn.exec("INSERT INTO test(col1) VALUES(:1)", key)
- *   end
- *
- * Both example's results are same. But the former will use less resources.
- */
-static VALUE oci8_stmt_aset(VALUE self, VALUE key, VALUE val)
-{
-    long max_array_size;
-    long actual_array_size;
-    long bind_array_size;
-
-    oci8_stmt_t *stmt = TO_STMT(self);
-    VALUE obj = rb_hash_aref(stmt->binds, key);
-    if (NIL_P(obj)) {
-        return Qnil; /* ?? MUST BE ERROR? */
-    }
-
-    if(TYPE(val) == T_ARRAY) {
-        max_array_size = NUM2INT(rb_ivar_get(self, id_at_max_array_size));
-        actual_array_size = NUM2INT(rb_ivar_get(self, id_at_actual_array_size));
-        bind_array_size = RARRAY_LEN(val);
-
-        if(actual_array_size > 0 && bind_array_size != actual_array_size) {
-            rb_raise(rb_eRuntimeError, "all binding arrays hould be the same size");        
-        }
-        if(bind_array_size <= max_array_size && actual_array_size == 0) {
-            rb_ivar_set(self, id_at_actual_array_size, INT2NUM(bind_array_size));
-        }
-    }
-    oci8_bind_set_data(obj, val);
-    return val;
-}
-
-/*
- * call-seq:
- *   keys -> an Array
- *
- * Returns the keys of bind variables as array.
- */
-static VALUE oci8_stmt_keys(VALUE self)
-{
-    oci8_stmt_t *stmt = TO_STMT(self);
-    return rb_funcall(stmt->binds, oci8_id_keys, 0);
-}
-
-static VALUE oci8_stmt_defined_p(VALUE self, VALUE pos)
-{
-    oci8_stmt_t *stmt = TO_STMT(self);
-    long position = NUM2INT(pos);
-
-    if (position - 1 < RARRAY_LEN(stmt->defns)) {
-        VALUE value = RARRAY_PTR(stmt->defns)[position - 1];
-        if (!NIL_P(value)) {
-            return Qtrue;
-        }
-    }
-    return Qfalse;
-}
-
-/*
- * call-seq:
- *   prefetch_rows = aFixnum
- *
- * Set number of rows to be prefetched.
- * This can reduce the number of network round trips when fetching
- * many rows. The default value is one.
- *
- * FYI: Rails oracle adaptor uses 100 by default.
- */
-static VALUE oci8_stmt_set_prefetch_rows(VALUE self, VALUE rows)
-{
-    oci8_stmt_t *stmt = TO_STMT(self);
-    ub4 num = NUM2UINT(rows);
-
-    chker2(OCIAttrSet(stmt->base.hp.ptr, OCI_HTYPE_STMT, &num, 0, OCI_ATTR_PREFETCH_ROWS, oci8_errhp),
-           &stmt->base);
-    return Qfalse;
-}
-
 /*
  * bind_stmt
  */
@@ -646,40 +371,13 @@ void Init_oci8_stmt(VALUE cOCI8)
 #endif
     cOCIStmt = oci8_define_class_under(cOCI8, "Cursor", &oci8_stmt_vtable);
 
-    oci8_sym_select_stmt = ID2SYM(rb_intern("select_stmt"));
-    oci8_sym_update_stmt = ID2SYM(rb_intern("update_stmt"));
-    oci8_sym_delete_stmt = ID2SYM(rb_intern("delete_stmt"));
-    oci8_sym_insert_stmt = ID2SYM(rb_intern("insert_stmt"));
-    oci8_sym_create_stmt = ID2SYM(rb_intern("create_stmt"));
-    oci8_sym_drop_stmt = ID2SYM(rb_intern("drop_stmt"));
-    oci8_sym_alter_stmt = ID2SYM(rb_intern("alter_stmt"));
-    oci8_sym_begin_stmt = ID2SYM(rb_intern("begin_stmt"));
-    oci8_sym_declare_stmt = ID2SYM(rb_intern("declare_stmt"));
-    id_at_column_metadata = rb_intern("@column_metadata");
-    id_at_actual_array_size = rb_intern("@actual_array_size");
-    id_at_max_array_size = rb_intern("@max_array_size");
-    id_each_value = rb_intern("each_value");
-    id_at_names = rb_intern("@names");
-    id_at_con = rb_intern("@con");
-    id_empty_p = rb_intern("empty?");
-    id_clear = rb_intern("clear");
-
-    rb_define_private_method(cOCIStmt, "initialize", oci8_stmt_initialize, -1);
+    rb_define_private_method(cOCIStmt, "__initialize", oci8_stmt_initialize, 2);
     rb_define_private_method(cOCIStmt, "__define", oci8_define_by_pos, 2);
     rb_define_private_method(cOCIStmt, "__bind", oci8_bind, 2);
     rb_define_private_method(cOCIStmt, "__execute", oci8_stmt_execute, 1);
-    rb_define_private_method(cOCIStmt, "__clearBinds", oci8_stmt_clear_binds, 0);
-    rb_define_method(cOCIStmt, "fetch", oci8_stmt_fetch, 0);
+    rb_define_private_method(cOCIStmt, "__fetch", oci8_stmt_fetch, 1);
     rb_define_private_method(cOCIStmt, "__paramGet", oci8_stmt_get_param, 1);
-    rb_define_method(cOCIStmt, "type", oci8_stmt_get_stmt_type, 0);
-    rb_define_method(cOCIStmt, "row_count", oci8_stmt_get_row_count, 0);
     rb_define_method(cOCIStmt, "rowid", oci8_stmt_get_rowid, 0);
-    rb_define_private_method(cOCIStmt, "__param_count", oci8_stmt_get_param_count, 0);
-    rb_define_method(cOCIStmt, "[]", oci8_stmt_aref, 1);
-    rb_define_method(cOCIStmt, "[]=", oci8_stmt_aset, 2);
-    rb_define_method(cOCIStmt, "keys", oci8_stmt_keys, 0);
-    rb_define_private_method(cOCIStmt, "__defined?", oci8_stmt_defined_p, 1);
-    rb_define_method(cOCIStmt, "prefetch_rows=", oci8_stmt_set_prefetch_rows, 1);
 
     oci8_define_bind_class("Cursor", &bind_stmt_vtable);
 }