ruby-oci8 2.1.7 → 2.1.8

data/ext/oci8/ocidatetime.c

@@ -2,7 +2,7 @@
 /*
  *  ocidatetime.c
  *
- * Copyright (C) 2005-2011 KUBO Takehiro <kubo@jiubao.org>
+ * Copyright (C) 2005-2014 Kubo Takehiro <kubo@jiubao.org>
  *
  */
 #include "oci8.h"
@@ -27,37 +27,37 @@ OCIDate *oci8_set_ocidate(OCIDate *od, VALUE val)
         rb_raise(rb_eRuntimeError, "invalid array size %ld", RARRAY_LEN(val));
     }
     /* year */
-    year = NUM2LONG(RARRAY_PTR(val)[0]);
+    year = NUM2LONG(RARRAY_AREF(val, 0));
     if (year < -4712 || 9999 < year) {
         rb_raise(rb_eRuntimeError, "out of year range: %ld", year);
     }
     od->OCIDateYYYY = (sb2)year;
     /* month */
-    month = NUM2LONG(RARRAY_PTR(val)[1]);
+    month = NUM2LONG(RARRAY_AREF(val, 1));
     if (month < 0 || 12 < month) {
         rb_raise(rb_eRuntimeError, "out of month range: %ld", month);
     }
     od->OCIDateMM = (ub1)month;
     /* day */
-    day = NUM2LONG(RARRAY_PTR(val)[2]);
+    day = NUM2LONG(RARRAY_AREF(val, 2));
     if (day < 0 || 31 < day) {
         rb_raise(rb_eRuntimeError, "out of day range: %ld", day);
     }
     od->OCIDateDD = (ub1)day;
     /* hour */
-    hour = NUM2LONG(RARRAY_PTR(val)[3]);
+    hour = NUM2LONG(RARRAY_AREF(val, 3));
     if (hour < 0 || 23 < hour) {
         rb_raise(rb_eRuntimeError, "out of hour range: %ld", hour);
     }
     od->OCIDateTime.OCITimeHH = (ub1)hour;
     /* minute */
-    minute = NUM2LONG(RARRAY_PTR(val)[4]);
+    minute = NUM2LONG(RARRAY_AREF(val, 4));
     if (minute < 0 || 59 < minute) {
         rb_raise(rb_eRuntimeError, "out of minute range: %ld", minute);
     }
     od->OCIDateTime.OCITimeMI = (ub1)minute;
     /* second */
-    second = NUM2LONG(RARRAY_PTR(val)[5]);
+    second = NUM2LONG(RARRAY_AREF(val, 5));
     if (second < 0 || 59 < second) {
         rb_raise(rb_eRuntimeError, "out of second range: %ld", second);
     }
@@ -149,42 +149,42 @@ OCIDateTime *oci8_set_ocitimestamp_tz(OCIDateTime *dttm, VALUE val, VALUE svc)
         rb_raise(rb_eRuntimeError, "invalid array size %ld", RARRAY_LEN(val));
     }
     /* year */
-    year = NUM2LONG(RARRAY_PTR(val)[0]);
+    year = NUM2LONG(RARRAY_AREF(val, 0));
     if (year < -4712 || 9999 < year) {
         rb_raise(rb_eRuntimeError, "out of year range: %ld", year);
     }
     /* month */
-    month = NUM2LONG(RARRAY_PTR(val)[1]);
+    month = NUM2LONG(RARRAY_AREF(val, 1));
     if (month < 0 || 12 < month) {
         rb_raise(rb_eRuntimeError, "out of month range: %ld", month);
     }
     /* day */
-    day = NUM2LONG(RARRAY_PTR(val)[2]);
+    day = NUM2LONG(RARRAY_AREF(val, 2));
     if (day < 0 || 31 < day) {
         rb_raise(rb_eRuntimeError, "out of day range: %ld", day);
     }
     /* hour */
-    hour = NUM2LONG(RARRAY_PTR(val)[3]);
+    hour = NUM2LONG(RARRAY_AREF(val, 3));
     if (hour < 0 || 23 < hour) {
         rb_raise(rb_eRuntimeError, "out of hour range: %ld", hour);
     }
     /* minute */
-    minute = NUM2LONG(RARRAY_PTR(val)[4]);
+    minute = NUM2LONG(RARRAY_AREF(val, 4));
     if (minute < 0 || 60 < minute) {
         rb_raise(rb_eRuntimeError, "out of minute range: %ld", minute);
     }
     /* second */
-    sec = NUM2LONG(RARRAY_PTR(val)[5]);
+    sec = NUM2LONG(RARRAY_AREF(val, 5));
     if (sec < 0 || 60 < sec) {
         rb_raise(rb_eRuntimeError, "out of second range: %ld", sec);
     }
     /* sec_fraction */
-    fsec = NUM2LONG(RARRAY_PTR(val)[6]);
+    fsec = NUM2LONG(RARRAY_AREF(val, 6));
     if (fsec < 0 || 1000000000 < fsec) {
         rb_raise(rb_eRuntimeError, "out of sec_fraction range: %ld", fsec);
     }
     /* time zone */
-    if (NIL_P(RARRAY_PTR(val)[7]) && NIL_P(RARRAY_PTR(val)[8])) {
+    if (NIL_P(RARRAY_AREF(val, 7)) && NIL_P(RARRAY_AREF(val, 8))) {
         if (!NIL_P(svc)) {
             /* use session timezone. */
             seshp = oci8_get_oci_session(svc);
@@ -193,8 +193,8 @@ OCIDateTime *oci8_set_ocitimestamp_tz(OCIDateTime *dttm, VALUE val, VALUE svc)
         tzlen = 0;
     } else {
         snprintf(tz_str, sizeof(tz_str), "%+02ld:%02ld",
-                 NUM2LONG(RARRAY_PTR(val)[7]),
-                 NUM2LONG(RARRAY_PTR(val)[8]));
+                 NUM2LONG(RARRAY_AREF(val, 7)),
+                 NUM2LONG(RARRAY_AREF(val, 8)));
         tz_str[sizeof(tz_str) - 1] = '\0';
         tz = (OraText*)tz_str;
         tzlen = strlen(tz_str);
@@ -232,9 +232,20 @@ static void bind_ocitimestamp_free(oci8_base_t *base)
     bind_free_common(base, OCI_DTYPE_TIMESTAMP);
 }
 
-static const oci8_bind_vtable_t bind_ocitimestamp_vtable = {
+static const oci8_bind_data_type_t bind_ocitimestamp_data_type = {
     {
-        NULL,
+        {
+            "OCI8::BindType::OCITimestamp",
+            {
+                NULL,
+                oci8_handle_cleanup,
+                oci8_handle_size,
+            },
+            &oci8_bind_data_type.rb_data_type, NULL,
+#ifdef RUBY_TYPED_WB_PROTECTED
+            RUBY_TYPED_WB_PROTECTED,
+#endif
+        },
         bind_ocitimestamp_free,
         sizeof(oci8_bind_t)
     },
@@ -246,6 +257,11 @@ static const oci8_bind_vtable_t bind_ocitimestamp_vtable = {
     SQLT_TIMESTAMP
 };
 
+static VALUE bind_ocitimestamp_alloc(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &bind_ocitimestamp_data_type.base);
+}
+
 static VALUE bind_ocitimestamp_tz_get(oci8_bind_t *obind, void *data, void *null_struct)
 {
     return oci8_make_ocitimestamp(*(OCIDateTime **)data, TRUE);
@@ -288,9 +304,20 @@ static void bind_ocitimestamp_tz_free(oci8_base_t *base)
     bind_free_common(base, OCI_DTYPE_TIMESTAMP_TZ);
 }
 
-static const oci8_bind_vtable_t bind_ocitimestamp_tz_vtable = {
+static const oci8_bind_data_type_t bind_ocitimestamp_tz_data_type = {
     {
-        NULL,
+        {
+            "OCI8::BindType::OCITimestampTZ",
+            {
+                NULL,
+                oci8_handle_cleanup,
+                oci8_handle_size,
+            },
+            &oci8_bind_data_type.rb_data_type, NULL,
+#ifdef RUBY_TYPED_WB_PROTECTED
+            RUBY_TYPED_WB_PROTECTED,
+#endif
+        },
         bind_ocitimestamp_tz_free,
         sizeof(oci8_bind_t)
     },
@@ -302,6 +329,11 @@ static const oci8_bind_vtable_t bind_ocitimestamp_tz_vtable = {
     SQLT_TIMESTAMP_TZ
 };
 
+static VALUE bind_ocitimestamp_tz_alloc(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &bind_ocitimestamp_tz_data_type.base);
+}
+
 VALUE oci8_make_ociinterval_ym(OCIInterval *s)
 {
     sb4 year;
@@ -320,8 +352,8 @@ OCIInterval *oci8_set_ociinterval_ym(OCIInterval *intvl, VALUE val)
     if (RARRAY_LEN(val) != 2) {
         rb_raise(rb_eRuntimeError, "invalid array size %ld", RARRAY_LEN(val));
     }
-    year = NUM2INT(RARRAY_PTR(val)[0]);
-    month = NUM2INT(RARRAY_PTR(val)[1]);
+    year = NUM2INT(RARRAY_AREF(val, 0));
+    month = NUM2INT(RARRAY_AREF(val, 1));
     if (oracle_client_version >= ORAVERNUM(9, 2, 0, 3, 0)) {
         chkerr(OCIIntervalSetYearMonth(oci8_envhp, oci8_errhp,
                                        year, month, intvl));
@@ -372,11 +404,11 @@ OCIInterval *oci8_set_ociinterval_ds(OCIInterval *intvl, VALUE val)
     if (RARRAY_LEN(val) != 5) {
         rb_raise(rb_eRuntimeError, "invalid array size %ld", RARRAY_LEN(val));
     }
-    day = NUM2INT(RARRAY_PTR(val)[0]);
-    hour = NUM2INT(RARRAY_PTR(val)[1]);
-    minute = NUM2INT(RARRAY_PTR(val)[2]);
-    sec = NUM2INT(RARRAY_PTR(val)[3]);
-    fsec = NUM2INT(RARRAY_PTR(val)[4]);
+    day = NUM2INT(RARRAY_AREF(val, 0));
+    hour = NUM2INT(RARRAY_AREF(val, 1));
+    minute = NUM2INT(RARRAY_AREF(val, 2));
+    sec = NUM2INT(RARRAY_AREF(val, 3));
+    fsec = NUM2INT(RARRAY_AREF(val, 4));
     if (oracle_client_version >= ORAVERNUM(9, 2, 0, 3, 0)) {
         chkerr(OCIIntervalSetDaySecond(oci8_envhp, oci8_errhp,
                                        day, hour, minute, sec, fsec, intvl));
@@ -447,9 +479,20 @@ static void bind_ociinterval_ds_free(oci8_base_t *base)
     bind_free_common(base, OCI_DTYPE_INTERVAL_DS);
 }
 
-static const oci8_bind_vtable_t bind_ociinterval_ym_vtable = {
+static const oci8_bind_data_type_t bind_ociinterval_ym_data_type = {
     {
-        NULL,
+        {
+            "OCI8::BindType::OCIIntervalYM",
+            {
+                NULL,
+                oci8_handle_cleanup,
+                oci8_handle_size,
+            },
+            &oci8_bind_data_type.rb_data_type, NULL,
+#ifdef RUBY_TYPED_WB_PROTECTED
+            RUBY_TYPED_WB_PROTECTED,
+#endif
+        },
         bind_ociinterval_ym_free,
         sizeof(oci8_bind_t)
     },
@@ -461,9 +504,25 @@ static const oci8_bind_vtable_t bind_ociinterval_ym_vtable = {
     SQLT_INTERVAL_YM
 };
 
-static const oci8_bind_vtable_t bind_ociinterval_ds_vtable = {
+static VALUE bind_ociinterval_ym_alloc(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &bind_ociinterval_ym_data_type.base);
+}
+
+static const oci8_bind_data_type_t bind_ociinterval_ds_data_type = {
     {
-        NULL,
+        {
+            "OCI8::BindType::OCIIntervalDS",
+            {
+                NULL,
+                oci8_handle_cleanup,
+                oci8_handle_size,
+            },
+            &oci8_bind_data_type.rb_data_type, NULL,
+#ifdef RUBY_TYPED_WB_PROTECTED
+            RUBY_TYPED_WB_PROTECTED,
+#endif
+        },
         bind_ociinterval_ds_free,
         sizeof(oci8_bind_t)
     },
@@ -475,10 +534,15 @@ static const oci8_bind_vtable_t bind_ociinterval_ds_vtable = {
     SQLT_INTERVAL_DS
 };
 
+static VALUE bind_ociinterval_ds_alloc(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &bind_ociinterval_ds_data_type.base);
+}
+
 void Init_oci_datetime(void)
 {
-    oci8_define_bind_class("OCITimestamp", &bind_ocitimestamp_vtable);
-    oci8_define_bind_class("OCITimestampTZ", &bind_ocitimestamp_tz_vtable);
-    oci8_define_bind_class("OCIIntervalYM", &bind_ociinterval_ym_vtable);
-    oci8_define_bind_class("OCIIntervalDS", &bind_ociinterval_ds_vtable);
+    oci8_define_bind_class("OCITimestamp", &bind_ocitimestamp_data_type, bind_ocitimestamp_alloc);
+    oci8_define_bind_class("OCITimestampTZ", &bind_ocitimestamp_tz_data_type, bind_ocitimestamp_tz_alloc);
+    oci8_define_bind_class("OCIIntervalYM", &bind_ociinterval_ym_data_type, bind_ociinterval_ym_alloc);
+    oci8_define_bind_class("OCIIntervalDS", &bind_ociinterval_ds_data_type, bind_ociinterval_ds_alloc);
 }

data/ext/oci8/ocihandle.c

@@ -2,13 +2,15 @@
 /*
  * ocihandle.c
  *
- * Copyright (C) 2009-2013 Kubo Takehiro <kubo@jiubao.org>
+ * Copyright (C) 2009-2015 Kubo Takehiro <kubo@jiubao.org>
  *
  * implement OCIHandle
  *
  */
 #include "oci8.h"
 
+#define TO_HANDLE(obj) ((oci8_base_t*)oci8_check_typeddata((obj), &oci8_handle_data_type, 1))
+
 #ifdef _MSC_VER
 #define MAGIC_NUMBER 0xDEAFBEAFDEAFBEAFui64;
 #else
@@ -25,9 +27,19 @@ static long check_data_range(VALUE val, long min, long max, const char *type)
     return lval;
 }
 
-
-static oci8_base_vtable_t oci8_base_vtable = {
-    NULL,
+const oci8_handle_data_type_t oci8_handle_data_type = {
+    {
+        "OCIHandle",
+        {
+            NULL,
+            oci8_handle_cleanup,
+            oci8_handle_size,
+        },
+        NULL, NULL,
+#ifdef RUBY_TYPED_WB_PROTECTED
+        RUBY_TYPED_WB_PROTECTED,
+#endif
+    },
     NULL,
     sizeof(oci8_base_t),
 };
@@ -38,10 +50,10 @@ static VALUE oci8_handle_initialize(VALUE self)
 }
 
 /*
- * Clears the object internal structure and its dependents.
+ *  Clears the object internal structure and its dependents.
  *
- * @since 2.0.0
- * @private
+ *  @since 2.0.0
+ *  @private
  */
 static VALUE oci8_handle_free(VALUE self)
 {
@@ -51,14 +63,9 @@ static VALUE oci8_handle_free(VALUE self)
     return self;
 }
 
-static void oci8_handle_mark(oci8_base_t *base)
-{
-    if (base->vptr->mark != NULL)
-        base->vptr->mark(base);
-}
-
-static void oci8_handle_cleanup(oci8_base_t *base)
+void oci8_handle_cleanup(void *ptr)
 {
+    oci8_base_t *base = (oci8_base_t *)ptr;
     if (oci8_in_finalizer) {
         /* Do nothing when the program exits.
          * The first two words of memory addressed by VALUE datatype is
@@ -71,35 +78,43 @@ static void oci8_handle_cleanup(oci8_base_t *base)
     xfree(base);
 }
 
+size_t oci8_handle_size(const void *ptr)
+{
+    const oci8_base_t *base = (const oci8_base_t *)ptr;
+    const oci8_bind_t *bind = (const oci8_bind_t *)ptr;
+    size_t size = base->data_type->size;
+
+    if (base->hp.ptr != NULL) {
+        size += 256; /* I don't know the real size. Use 256 for now. */
+    }
+    switch (base->type) {
+    case OCI_HTYPE_DEFINE:
+    case OCI_HTYPE_BIND:
+        size += bind->alloc_sz * (bind->maxar_sz ? bind->maxar_sz : 1);
+    }
+    return size;
+}
+
 static VALUE oci8_s_allocate(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &oci8_handle_data_type);
+}
+
+VALUE oci8_allocate_typeddata(VALUE klass, const oci8_handle_data_type_t *data_type)
 {
     oci8_base_t *base;
-    const oci8_base_vtable_t *vptr;
-    VALUE superklass;
     VALUE obj;
 
-    superklass = klass;
-    while (!RTEST(rb_ivar_defined(superklass, oci8_id_oci8_vtable))) {
-        superklass = rb_class_superclass(superklass);
-        if (superklass == rb_cObject)
-            rb_raise(rb_eRuntimeError, "private method `new' called for %s:Class", rb_class2name(klass));
-    }
-    obj = rb_ivar_get(superklass, oci8_id_oci8_vtable);
-    vptr = DATA_PTR(obj);
-
-    base = xmalloc(vptr->size);
-    memset(base, 0, vptr->size);
+    base = xmalloc(data_type->size);
+    memset(base, 0, data_type->size);
 
-    obj = Data_Wrap_Struct(klass, oci8_handle_mark, oci8_handle_cleanup, base);
+    obj = TypedData_Wrap_Struct(klass, &data_type->rb_data_type, base);
     base->self = obj;
-    base->vptr = vptr;
+    base->data_type = data_type;
     base->parent = NULL;
     base->next = base;
     base->prev = base;
     base->children = NULL;
-    if (vptr->init != NULL) {
-        vptr->init(base);
-    }
     return obj;
 }
 
@@ -121,7 +136,7 @@ enum datatype {
 
 static VALUE attr_get_common(int argc, VALUE *argv, VALUE self, enum datatype datatype)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = oci8_check_typeddata(self, &oci8_handle_data_type, 0);
     VALUE attr_type;
     VALUE strict;
     VALUE args[6];
@@ -141,8 +156,24 @@ static VALUE attr_get_common(int argc, VALUE *argv, VALUE self, enum datatype da
     ub4 size = 0;
     sword rv;
 
-    if (base->type == 0) {
-        return Qnil;
+    if (base->closed) {
+        /* Returns nil when the backtrace includes `inspect'.
+         * Otherwise, raises an exception.
+         * IMO, `inspect' should not raise an exception.
+         */
+        volatile VALUE backtrace = rb_funcall(rb_cObject, rb_intern("caller"), 0);
+        if (TYPE(backtrace) == T_ARRAY) {
+            int i;
+            for (i = 0; i < RARRAY_LEN(backtrace); i++) {
+                volatile VALUE elem = RARRAY_AREF(backtrace, i);
+                char *s = StringValueCStr(elem);
+                if (strstr(s, "inspect") != NULL) {
+                    return Qnil;
+                }
+            }
+        }
+        /* check again just to raise an exception. */
+        oci8_check_typeddata(self, &oci8_handle_data_type, 1);
     }
 
     v.ub8val = MAGIC_NUMBER;
@@ -210,17 +241,16 @@ static VALUE attr_get_common(int argc, VALUE *argv, VALUE self, enum datatype da
 }
 
 /*
- * call-seq:
- *   attr_get_ub1(attr_type, strict = true)
+ * @overload attr_get_ub1(attr_type, strict = true)
  *
- * Gets the value of an attribute as `ub1' datatype.
+ *  Gets the value of an attribute as `ub1' datatype.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [Fixnum]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Fixnum]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_ub1(int argc, VALUE *argv, VALUE self)
 {
@@ -228,17 +258,16 @@ static VALUE attr_get_ub1(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_get_ub2(attr_type, strict = true)
+ * @overload attr_get_ub2(attr_type, strict = true)
  *
- * Gets the value of an attribute as `ub2' datatype.
+ *  Gets the value of an attribute as `ub2' datatype.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [Fixnum]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Fixnum]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_ub2(int argc, VALUE *argv, VALUE self)
 {
@@ -246,17 +275,16 @@ static VALUE attr_get_ub2(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_get_ub4(attr_type, strict = true)
+ * @overload attr_get_ub4(attr_type, strict = true)
  *
- * Gets the value of an attribute as `ub4' datatype.
+ *  Gets the value of an attribute as `ub4' datatype.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [Integer]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_ub4(int argc, VALUE *argv, VALUE self)
 {
@@ -264,17 +292,16 @@ static VALUE attr_get_ub4(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_get_ub8(attr_type, strict = true)
+ * @overload attr_get_ub8(attr_type, strict = true)
  *
- * Gets the value of an attribute as `ub8' datatype.
+ *  Gets the value of an attribute as `ub8' datatype.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [Integer]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_ub8(int argc, VALUE *argv, VALUE self)
 {
@@ -282,17 +309,16 @@ static VALUE attr_get_ub8(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_get_sb1(attr_type, strict = true)
+ * @overload attr_get_sb1(attr_type, strict = true)
  *
- * Gets the value of an attribute as `sb1' datatype.
+ *  Gets the value of an attribute as `sb1' datatype.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [Fixnum]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Fixnum]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_sb1(int argc, VALUE *argv, VALUE self)
 {
@@ -300,17 +326,16 @@ static VALUE attr_get_sb1(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_get_sb2(attr_type, strict = true)
+ * @overload attr_get_sb2(attr_type, strict = true)
  *
- * Gets the value of an attribute as `sb2' datatype.
+ *  Gets the value of an attribute as `sb2' datatype.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [Fixnum]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Fixnum]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_sb2(int argc, VALUE *argv, VALUE self)
 {
@@ -318,17 +343,16 @@ static VALUE attr_get_sb2(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_get_sb4(attr_type, strict = true)
+ * @overload attr_get_sb4(attr_type, strict = true)
  *
- * Gets the value of an attribute as `sb4' datatype.
+ *  Gets the value of an attribute as `sb4' datatype.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [Integer]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_sb4(int argc, VALUE *argv, VALUE self)
 {
@@ -336,17 +360,16 @@ static VALUE attr_get_sb4(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_get_sb8(attr_type, strict = true)
+ * @overload attr_get_sb8(attr_type, strict = true)
  *
- * Gets the value of an attribute as `sb8' datatype.
+ *  Gets the value of an attribute as `sb8' datatype.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [Integer]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_sb8(int argc, VALUE *argv, VALUE self)
 {
@@ -354,17 +377,16 @@ static VALUE attr_get_sb8(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_get_boolean(attr_type, strict = true)
+ * @overload attr_get_boolean(attr_type, strict = true)
  *
- * Gets the value of an attribute as `boolean' datatype.
+ *  Gets the value of an attribute as `boolean' datatype.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [true of false]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [true of false]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_boolean(int argc, VALUE *argv, VALUE self)
 {
@@ -372,22 +394,21 @@ static VALUE attr_get_boolean(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_get_string(attr_type, strict = true)
+ * @overload attr_get_string(attr_type, strict = true)
  *
- * Gets the value of an attribute as `oratext *' datatype.
- * The return value is converted to Encoding.default_internal or
- * tagged with {OCI8.encoding} when the ruby version is 1.9.
+ *  Gets the value of an attribute as `oratext *' datatype.
+ *  The return value is converted to Encoding.default_internal or
+ *  tagged with {OCI8.encoding} when the ruby version is 1.9.
  *
- * @note If the specified attr_type's datatype is not a
- *   pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is not a
+ *    pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [String]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [String]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_string(int argc, VALUE *argv, VALUE self)
 {
@@ -395,21 +416,20 @@ static VALUE attr_get_string(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_get_binary(attr_type, strict = true)
+ * @overload attr_get_binary(attr_type, strict = true)
  *
- * Gets the value of an attribute as `ub1 *' datatype.
- * The return value is tagged with ASCII-8BIT when the ruby version is 1.9.
+ *  Gets the value of an attribute as `ub1 *' datatype.
+ *  The return value is tagged with ASCII-8BIT when the ruby version is 1.9.
  *
- * @note If the specified attr_type's datatype is not a
- *   pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is not a
+ *    pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [String]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [String]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_binary(int argc, VALUE *argv, VALUE self)
 {
@@ -417,21 +437,20 @@ static VALUE attr_get_binary(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_get_integer(attr_type, strict = true)
+ * @overload attr_get_integer(attr_type, strict = true)
  *
- * Gets the value of an attribute as `ub1 *' datatype.
- * The return value is converted to Integer from internal Oracle NUMBER format.
+ *  Gets the value of an attribute as `ub1 *' datatype.
+ *  The return value is converted to Integer from internal Oracle NUMBER format.
  *
- * @note If the specified attr_type's datatype is not a
- *   pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is not a
+ *    pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [Fixnum]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Fixnum]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_integer(int argc, VALUE *argv, VALUE self)
 {
@@ -439,21 +458,20 @@ static VALUE attr_get_integer(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_get_oradate(attr_type, strict = true)
+ * @overload attr_get_oradate(attr_type, strict = true)
  *
- * Gets the value of an attribute as `ub1 *' datatype.
- * The return value is converted to OraDate.
+ *  Gets the value of an attribute as `ub1 *' datatype.
+ *  The return value is converted to OraDate.
  *
- * @note If the specified attr_type's datatype is not a
- *   pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is not a
+ *    pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
- * @return [OraDate]
+ *  @param [Fixnum] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [OraDate]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_get_oradate(int argc, VALUE *argv, VALUE self)
 {
@@ -461,24 +479,23 @@ static VALUE attr_get_oradate(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * call-seq:
- *   attr_set_ub1(attr_type, attr_value)
+ * @overload attr_set_ub1(attr_type, attr_value)
  *
- * Sets the value of an attribute as `ub1' datatype.
+ *  Sets the value of an attribute as `ub1' datatype.
  *
- * @note If the specified attr_type's datatype is a
- *   pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [Fixnum] attr_value
- * @return [self]
+ *  @param [Fixnum] attr_type
+ *  @param [Fixnum] attr_value
+ *  @return [self]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_set_ub1(VALUE self, VALUE attr_type, VALUE val)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = TO_HANDLE(self);
     ub1 value;
 
     /* validate arguments */
@@ -490,24 +507,23 @@ static VALUE attr_set_ub1(VALUE self, VALUE attr_type, VALUE val)
 }
 
 /*
- * call-seq:
- *   attr_set_ub2(attr_type, attr_value)
+ * @overload attr_set_ub2(attr_type, attr_value)
  *
- * Sets the value of an attribute as `ub2' datatype.
+ *  Sets the value of an attribute as `ub2' datatype.
  *
- * @note If the specified attr_type's datatype is a
- *   pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [Fixnum] attr_value
- * @return [self]
+ *  @param [Fixnum] attr_type
+ *  @param [Fixnum] attr_value
+ *  @return [self]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_set_ub2(VALUE self, VALUE attr_type, VALUE val)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = TO_HANDLE(self);
     ub2 value;
 
     /* validate arguments */
@@ -519,24 +535,23 @@ static VALUE attr_set_ub2(VALUE self, VALUE attr_type, VALUE val)
 }
 
 /*
- * call-seq:
- *   attr_set_ub4(attr_type, attr_value)
+ * @overload attr_set_ub4(attr_type, attr_value)
  *
- * Sets the value of an attribute as `ub4' datatype.
+ *  Sets the value of an attribute as `ub4' datatype.
  *
- * @note If the specified attr_type's datatype is a
- *   pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [Integer] attr_value
- * @return [self]
+ *  @param [Fixnum] attr_type
+ *  @param [Integer] attr_value
+ *  @return [self]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_set_ub4(VALUE self, VALUE attr_type, VALUE val)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = TO_HANDLE(self);
     ub4 value;
 
     /* validate arguments */
@@ -548,24 +563,23 @@ static VALUE attr_set_ub4(VALUE self, VALUE attr_type, VALUE val)
 }
 
 /*
- * call-seq:
- *   attr_set_ub8(attr_type, attr_value)
+ * @overload attr_set_ub8(attr_type, attr_value)
  *
- * Sets the value of an attribute as `ub8' datatype.
+ *  Sets the value of an attribute as `ub8' datatype.
  *
- * @note If the specified attr_type's datatype is a
- *   pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [Integer] attr_value
- * @return [self]
+ *  @param [Fixnum] attr_type
+ *  @param [Integer] attr_value
+ *  @return [self]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_set_ub8(VALUE self, VALUE attr_type, VALUE val)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = TO_HANDLE(self);
     ub8 value;
 
     /* validate arguments */
@@ -577,24 +591,23 @@ static VALUE attr_set_ub8(VALUE self, VALUE attr_type, VALUE val)
 }
 
 /*
- * call-seq:
- *   attr_set_sb1(attr_type, attr_value)
+ * @overload attr_set_sb1(attr_type, attr_value)
  *
- * Sets the value of an attribute as `sb1' datatype.
+ *  Sets the value of an attribute as `sb1' datatype.
  *
- * @note If the specified attr_type's datatype is a
- *   pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [Fixnum] attr_value
- * @return [self]
+ *  @param [Fixnum] attr_type
+ *  @param [Fixnum] attr_value
+ *  @return [self]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_set_sb1(VALUE self, VALUE attr_type, VALUE val)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = TO_HANDLE(self);
     sb1 value;
 
     /* validate arguments */
@@ -606,24 +619,23 @@ static VALUE attr_set_sb1(VALUE self, VALUE attr_type, VALUE val)
 }
 
 /*
- * call-seq:
- *   attr_set_sb2(attr_type, attr_value)
+ * @overload attr_set_sb2(attr_type, attr_value)
  *
- * Sets the value of an attribute as `sb2' datatype.
+ *  Sets the value of an attribute as `sb2' datatype.
  *
- * @note If the specified attr_type's datatype is a
- *  pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is a
+ *   pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [Fixnum] attr_value
- * @return [self]
+ *  @param [Fixnum] attr_type
+ *  @param [Fixnum] attr_value
+ *  @return [self]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_set_sb2(VALUE self, VALUE attr_type, VALUE val)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = TO_HANDLE(self);
     sb2 value;
 
     /* validate arguments */
@@ -635,24 +647,23 @@ static VALUE attr_set_sb2(VALUE self, VALUE attr_type, VALUE val)
 }
 
 /*
- * call-seq:
- *   attr_set_sb4(attr_type, attr_value)
+ * @overload attr_set_sb4(attr_type, attr_value)
  *
- * Sets the value of an attribute as `sb4' datatype.
+ *  Sets the value of an attribute as `sb4' datatype.
  *
- * @note If the specified attr_type's datatype is a
- *   pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [Integer] attr_value
- * @return [self]
+ *  @param [Fixnum] attr_type
+ *  @param [Integer] attr_value
+ *  @return [self]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_set_sb4(VALUE self, VALUE attr_type, VALUE val)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = TO_HANDLE(self);
     sb4 value;
 
     /* validate arguments */
@@ -664,24 +675,23 @@ static VALUE attr_set_sb4(VALUE self, VALUE attr_type, VALUE val)
 }
 
 /*
- * call-seq:
- *   attr_set_sb8(attr_type, attr_value)
+ * @overload attr_set_sb8(attr_type, attr_value)
  *
- * Sets the value of an attribute as `sb8' datatype.
+ *  Sets the value of an attribute as `sb8' datatype.
  *
- * @note If the specified attr_type's datatype is a
- *   pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [Integer] attr_value
- * @return [self]
+ *  @param [Fixnum] attr_type
+ *  @param [Integer] attr_value
+ *  @return [self]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_set_sb8(VALUE self, VALUE attr_type, VALUE val)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = TO_HANDLE(self);
     sb8 value;
 
     /* validate arguments */
@@ -693,24 +703,23 @@ static VALUE attr_set_sb8(VALUE self, VALUE attr_type, VALUE val)
 }
 
 /*
- * call-seq:
- *   attr_set_boolean(attr_type, attr_value)
+ * @overload attr_set_boolean(attr_type, attr_value)
  *
- * Sets the value of an attribute as `boolean' datatype.
+ *  Sets the value of an attribute as `boolean' datatype.
  *
- * @note If the specified attr_type's datatype is a
- *   pointer type, it causes a segmentation fault.
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
  *
- * @param [Fixnum] attr_type
- * @param [true or false] attr_value
- * @return [self]
+ *  @param [Fixnum] attr_type
+ *  @param [true or false] attr_value
+ *  @return [self]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_set_boolean(VALUE self, VALUE attr_type, VALUE val)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = TO_HANDLE(self);
     boolean value;
 
     /* validate arguments */
@@ -722,23 +731,22 @@ static VALUE attr_set_boolean(VALUE self, VALUE attr_type, VALUE val)
 }
 
 /*
- * call-seq:
- *   attr_set_string(attr_type, attr_value)
+ * @overload attr_set_string(attr_type, attr_value)
  *
- * Sets the value of an attribute as `oratext *' datatype.
- * +attr_value+ is converted to {OCI8.encoding} before it is set
- * when the ruby version is 1.9.
+ *  Sets the value of an attribute as `oratext *' datatype.
+ *  +attr_value+ is converted to {OCI8.encoding} before it is set
+ *  when the ruby version is 1.9.
  *
- * @param [Fixnum] attr_type
- * @param [String] attr_value
- * @return [self]
+ *  @param [Fixnum] attr_type
+ *  @param [String] attr_value
+ *  @return [self]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_set_string(VALUE self, VALUE attr_type, VALUE val)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = TO_HANDLE(self);
 
     /* validate arguments */
     Check_Type(attr_type, T_FIXNUM);
@@ -749,21 +757,20 @@ static VALUE attr_set_string(VALUE self, VALUE attr_type, VALUE val)
 }
 
 /*
- * call-seq:
- *   attr_set_binary(attr_type, attr_value)
+ * @overload attr_set_binary(attr_type, attr_value)
  *
- * Sets the value of an attribute as `ub1 *' datatype.
+ *  Sets the value of an attribute as `ub1 *' datatype.
  *
- * @param [Fixnum] attr_type
- * @param [String] attr_value
- * @return [self]
+ *  @param [Fixnum] attr_type
+ *  @param [String] attr_value
+ *  @return [self]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_set_binary(VALUE self, VALUE attr_type, VALUE val)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = TO_HANDLE(self);
 
     /* validate arguments */
     Check_Type(attr_type, T_FIXNUM);
@@ -774,23 +781,22 @@ static VALUE attr_set_binary(VALUE self, VALUE attr_type, VALUE val)
 }
 
 /*
- * call-seq:
- *   attr_set_integer(attr_type, number)
+ * @overload attr_set_integer(attr_type, number)
  *
- * Sets the value of an attribute as `ub1 *' datatype.
- * +number+ is converted to internal Oracle NUMBER format before
- * it is set.
+ *  Sets the value of an attribute as `ub1 *' datatype.
+ *  +number+ is converted to internal Oracle NUMBER format before
+ *  it is set.
  *
- * @param [Fixnum] attr_type
- * @param [Numeric] number
- * @return [self]
+ *  @param [Fixnum] attr_type
+ *  @param [Numeric] number
+ *  @return [self]
  *
- * @since 2.0.4
- * @private
+ *  @since 2.0.4
+ *  @private
  */
 static VALUE attr_set_integer(VALUE self, VALUE attr_type, VALUE val)
 {
-    oci8_base_t *base = DATA_PTR(self);
+    oci8_base_t *base = TO_HANDLE(self);
     OCINumber value;
 
     /* validate arguments */
@@ -803,8 +809,6 @@ static VALUE attr_set_integer(VALUE self, VALUE attr_type, VALUE val)
 
 void Init_oci8_handle(void)
 {
-    VALUE obj;
-
     /*
      * OCIHandle is the abstract base class of OCI handles and
      * OCI descriptors; opaque data types of Oracle Call Interface.
@@ -816,8 +820,6 @@ void Init_oci8_handle(void)
     rb_define_alloc_func(oci8_cOCIHandle, oci8_s_allocate);
     rb_define_method_nodoc(oci8_cOCIHandle, "initialize", oci8_handle_initialize, 0);
     rb_define_private_method(oci8_cOCIHandle, "free", oci8_handle_free, 0);
-    obj = Data_Wrap_Struct(rb_cObject, 0, 0, &oci8_base_vtable);
-    rb_ivar_set(oci8_cOCIHandle, oci8_id_oci8_vtable, obj);
 
     /* methods to get attributes */
     rb_define_private_method(oci8_cOCIHandle, "attr_get_ub1", attr_get_ub1, -1);