ruby-oci8 2.0.4 → 2.0.5

data/ext/oci8/oci8.c

@@ -263,12 +263,12 @@ static VALUE oci8_svcctx_initialize(int argc, VALUE *argv, VALUE self)
                          RSTRING_ORATEXT(vpassword), RSTRING_LEN(vpassword),
                          NIL_P(vdbname) ? NULL : RSTRING_ORATEXT(vdbname),
                          NIL_P(vdbname) ? 0 : RSTRING_LEN(vdbname));
+        if (IS_OCI_ERROR(rv)) {
+            oci8_raise(oci8_errhp, rv, NULL);
+        }
         svcctx->base.hp.svc = svchp;
         svcctx->base.type = OCI_HTYPE_SVCCTX;
         svcctx->logon_type = T_IMPLICIT;
-        if (rv != OCI_SUCCESS) {
-            oci8_raise(oci8_errhp, rv, NULL);
-        }
         break;
     case T_EXPLICIT:
         /* allocate OCI handles. */
@@ -313,7 +313,7 @@ static VALUE oci8_svcctx_initialize(int argc, VALUE *argv, VALUE self)
     }
     svcctx->pid = getpid();
     svcctx->is_autocommit = 0;
-#ifdef RUBY_VM
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
     svcctx->non_blocking = 1;
 #endif
     svcctx->long_read_len = INT2FIX(65535);
@@ -417,7 +417,7 @@ static VALUE oci8_rollback(VALUE self)
 static VALUE oci8_non_blocking_p(VALUE self)
 {
     oci8_svcctx_t *svcctx = DATA_PTR(self);
-#ifdef RUBY_VM
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
     return svcctx->non_blocking ? Qtrue : Qfalse;
 #else
     sb1 non_blocking;
@@ -470,7 +470,7 @@ static VALUE oci8_non_blocking_p(VALUE self)
 static VALUE oci8_set_non_blocking(VALUE self, VALUE val)
 {
     oci8_svcctx_t *svcctx = DATA_PTR(self);
-#ifdef RUBY_VM
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
     svcctx->non_blocking = RTEST(val);
 #else
     sb1 non_blocking;
@@ -560,14 +560,14 @@ static VALUE oci8_set_long_read_len(VALUE self, VALUE val)
 static VALUE oci8_break(VALUE self)
 {
     oci8_svcctx_t *svcctx = DATA_PTR(self);
-#ifndef RUBY_VM
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
     sword rv;
 #endif
 
     if (NIL_P(svcctx->executing_thread)) {
         return Qfalse;
     }
-#ifndef RUBY_VM
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
     rv = OCIBreak(svcctx->base.hp.ptr, oci8_errhp);
     if (rv != OCI_SUCCESS)
         oci8_raise(oci8_errhp, rv, NULL);
@@ -992,12 +992,7 @@ VALUE Init_oci8(void)
 
 oci8_svcctx_t *oci8_get_svcctx(VALUE obj)
 {
-    oci8_base_t *base;
-    Check_Handle(obj, cOCI8, base);
-    if (base->type == 0) {
-        rb_raise(eOCIException, "invalid argument %s was freed already.", rb_class2name(CLASS_OF(obj)));
-    }
-    return (oci8_svcctx_t *)base;
+    return (oci8_svcctx_t *)oci8_get_handle(obj, cOCI8);
 }
 
 OCISvcCtx *oci8_get_oci_svcctx(VALUE obj)

data/ext/oci8/oci8.h

@@ -2,7 +2,7 @@
 /*
  * oci8.h - part of ruby-oci8
  *
- * Copyright (C) 2002-2009 KUBO Takehiro <kubo@jiubao.org>
+ * Copyright (C) 2002-2011 KUBO Takehiro <kubo@jiubao.org>
  */
 #ifndef _RUBY_OCI_H_
 #define _RUBY_OCI_H_ 1
@@ -74,10 +74,10 @@ typedef orasb8 sb8;
 #ifndef HAVE_TYPE_ORATEXT
 typedef unsigned char oratext;
 #endif
-#ifndef HAVE_TYPE_OCIDATETIME_
+#if !defined HAVE_TYPE_OCIDATETIME_ && !defined HAVE_TYPE_OCIDATETIMEP
 typedef struct OCIDateTime OCIDateTime;
 #endif
-#ifndef HAVE_TYPE_OCIINTERVAL_
+#if !defined HAVE_TYPE_OCIINTERVAL_ && !defined HAVE_TYPE_OCIINTERVALP
 typedef struct OCIInterval OCIInterval;
 #endif
 #ifndef HAVE_TYPE_OCICALLBACKLOBREAD2
@@ -90,10 +90,10 @@ typedef sb4 (*OCICallbackLobWrite2)(dvoid *ctxp, dvoid *bufp, oraub8 *lenp,
                                     ub1 *piece, dvoid **changed_bufpp,
                                     oraub8 *changed_lenp);
 #endif
-#ifndef HAVE_TYPE_OCIADMIN_
+#if !defined HAVE_TYPE_OCIADMIN_ && !defined HAVE_TYPE_OCIADMINP
 typedef struct OCIAdmin OCIAdmin;
 #endif
-#ifndef HAVE_TYPE_OCIMSG_
+#if !defined HAVE_TYPE_OCIMSG_ && !defined HAVE_TYPE_OCIMSGP
 typedef struct OCIMsg  OCIMsg;
 #endif
 
@@ -116,9 +116,6 @@ typedef struct OCIMsg  OCIMsg;
 /* new macros in ruby 1.9.
  * define compatible macros for ruby 1.8 or lower.
  */
-#ifndef RCLASS_SUPER
-#define RCLASS_SUPER(c) RCLASS(c)->super
-#endif
 #ifndef RFLOAT_VALUE
 #define RFLOAT_VALUE(obj) RFLOAT(obj)->value
 #endif
@@ -135,7 +132,7 @@ typedef struct OCIMsg  OCIMsg;
 #if !defined(HAVE_RB_ERRINFO) && defined(HAVE_RUBY_ERRINFO)
 #define rb_errinfo() ruby_errinfo
 #endif
-#ifndef RUBY_VM
+#ifndef HAVE_TYPE_RB_BLOCKING_FUNCTION_T
 typedef VALUE rb_blocking_function_t(void *);
 #endif
 
@@ -149,6 +146,17 @@ typedef VALUE rb_blocking_function_t(void *);
 #define rb_usascii_str_new_cstr(ptr) rb_str_new2(ptr)
 #endif
 
+/* a new function in ruby 1.9.3.
+ * define a compatible macro for ruby 1.9.2 or lower.
+ */
+#ifndef HAVE_RB_CLASS_SUPERCLASS
+#ifdef RCLASS_SUPER
+#define rb_class_superclass(cls) RCLASS_SUPER(cls)
+#else
+#define rb_class_superclass(cls) (RCLASS(cls)->super)
+#endif
+#endif
+
 /* macros depends on the compiler.
  *  LIKELY(x)      hint for the compiler that 'x' is 1(TRUE) in many cases.
  *  UNLIKELY(x)    hint for the compiler that 'x' is 0(FALSE) in many cases.
@@ -173,10 +181,6 @@ typedef VALUE rb_blocking_function_t(void *);
 #endif
 
 /* macros to access thread-local storage.
- *
- *  int oci8_tls_key_init(oci8_tls_key_t *key);
- *    initialie a key to access thread-local storege
- *    This returns 0 on success or error number.
  *
  *  void *oci8_tls_get(oci8_tls_key_t key);
  *    get a value associated with the key.
@@ -185,26 +189,20 @@ typedef VALUE rb_blocking_function_t(void *);
  *    set a value to the key.
  *
  */
-#ifdef RUBY_VM
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
 /* ruby 1.9 */
 #if defined(_WIN32)
 #include <windows.h>
 #define oci8_tls_key_t           DWORD
-#define oci8_tls_key_init(key_p) \
-    ((*(key_p) = TlsAlloc()), \
-    (*(key_p) == 0xFFFFFFFF) ? GetLastError() : 0)
 #define oci8_tls_get(key)        TlsGetValue(key)
 #define oci8_tls_set(key, val)   TlsSetValue((key), (val))
-#elif defined(HAVE_PTHREAD_H)
+#else
 #include <pthread.h>
 #define oci8_tls_key_t           pthread_key_t
-#define oci8_tls_key_init(key_p) pthread_key_create((key_p), NULL)
 #define oci8_tls_get(key)        pthread_getspecific(key)
 #define oci8_tls_set(key, val)   pthread_setspecific((key), (val))
-#else
-#error unsupported thread API
 #endif
-#endif /* RUBY_VM */
+#endif /* HAVE_RB_THREAD_BLOCKING_REGION */
 
 /* utility macros
  */
@@ -310,7 +308,7 @@ typedef struct  {
     OCIServer *srvhp;
     rb_pid_t pid;
     char is_autocommit;
-#ifdef RUBY_VM
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
     char non_blocking;
 #endif
     VALUE long_read_len;
@@ -364,7 +362,7 @@ typedef struct {
  *   extern OCIError *oci8_errhp;
  */
 #define oci8_envhp (LIKELY(oci8_global_envhp != NULL) ? oci8_global_envhp : oci8_make_envhp())
-#ifdef RUBY_VM
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
 #define oci8_errhp oci8_get_errhp()
 #else
 #define oci8_errhp (LIKELY(oci8_global_errhp != NULL) ? oci8_global_errhp : oci8_make_errhp())
@@ -374,7 +372,7 @@ typedef struct {
 extern ub4 oci8_env_mode;
 extern OCIEnv *oci8_global_envhp;
 OCIEnv *oci8_make_envhp(void);
-#ifdef RUBY_VM
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
 extern oci8_tls_key_t oci8_tls_key; /* native thread key */
 OCIError *oci8_make_errhp(void);
 
@@ -396,6 +394,17 @@ extern ID oci8_id_get;
 extern ID oci8_id_set;
 extern ID oci8_id_keys;
 extern ID oci8_id_oci8_class;
+#ifdef CHAR_IS_NOT_A_SHORTCUT_TO_ID
+extern ID oci8_id_add_op; /* ID of the addition operator '+' */
+extern ID oci8_id_sub_op; /* ID of the subtraction operator '-' */
+extern ID oci8_id_mul_op; /* ID of the multiplication operator '*' */
+extern ID oci8_id_div_op; /* ID of the division operator '/' */
+#else
+#define oci8_id_add_op '+'
+#define oci8_id_sub_op '-'
+#define oci8_id_mul_op '*'
+#define oci8_id_div_op '/'
+#endif
 extern int oci8_in_finalizer;
 extern VALUE oci8_cOCIHandle;
 void oci8_base_free(oci8_base_t *base);
@@ -409,6 +418,7 @@ sword oci8_exec_sql(oci8_svcctx_t *svcctx, const char *sql_text, ub4 num_define_
 #if defined RUNTIME_API_CHECK
 void *oci8_find_symbol(const char *symbol_name);
 #endif
+oci8_base_t *oci8_get_handle(VALUE obj, VALUE klass);
 
 /* error.c */
 extern VALUE eOCIException;
@@ -460,6 +470,10 @@ VALUE oci8_make_clob(oci8_svcctx_t *svcctx, OCILobLocator *s);
 VALUE oci8_make_nclob(oci8_svcctx_t *svcctx, OCILobLocator *s);
 VALUE oci8_make_blob(oci8_svcctx_t *svcctx, OCILobLocator *s);
 VALUE oci8_make_bfile(oci8_svcctx_t *svcctx, OCILobLocator *s);
+void oci8_assign_clob(oci8_svcctx_t *svcctx, VALUE lob, OCILobLocator **dest);
+void oci8_assign_nclob(oci8_svcctx_t *svcctx, VALUE lob, OCILobLocator **dest);
+void oci8_assign_blob(oci8_svcctx_t *svcctx, VALUE lob, OCILobLocator **dest);
+void oci8_assign_bfile(oci8_svcctx_t *svcctx, VALUE lob, OCILobLocator **dest);
 
 /* oradate.c */
 void Init_ora_date(void);

data/ext/oci8/oci8lib.c

@@ -15,6 +15,12 @@ ID oci8_id_get;
 ID oci8_id_set;
 ID oci8_id_keys;
 ID oci8_id_oci8_class;
+#ifdef CHAR_IS_NOT_A_SHORTCUT_TO_ID
+ID oci8_id_add_op;
+ID oci8_id_sub_op;
+ID oci8_id_mul_op;
+ID oci8_id_div_op;
+#endif
 int oci8_in_finalizer = 0;
 VALUE oci8_cOCIHandle;
 
@@ -38,11 +44,16 @@ void oci8_base_free(oci8_base_t *base)
     base->hp.ptr = NULL;
 }
 
+#ifdef HAVE_RB_SET_END_PROC
 static void at_exit_func(VALUE val)
 {
     oci8_in_finalizer = 1;
 }
+#endif
 
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
 void
 Init_oci8lib()
 {
@@ -65,7 +76,15 @@ Init_oci8lib()
     oci8_id_set = rb_intern("set");
     oci8_id_keys = rb_intern("keys");
     oci8_id_oci8_class = rb_intern("__oci8_class__");
+#ifdef CHAR_IS_NOT_A_SHORTCUT_TO_ID
+    oci8_id_add_op = rb_intern("+");
+    oci8_id_sub_op = rb_intern("-");
+    oci8_id_mul_op = rb_intern("*");
+    oci8_id_div_op = rb_intern("/");
+#endif
+#ifdef HAVE_RB_SET_END_PROC
     rb_set_end_proc(at_exit_func, Qnil);
+#endif
 
     Init_oci8_error();
     Init_oci8_env();
@@ -196,7 +215,7 @@ void oci8_unlink_from_parent(oci8_base_t *base)
     base->parent = NULL;
 }
 
-#ifdef RUBY_VM
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
 
 #if 0
 typedef struct {
@@ -251,7 +270,7 @@ sword oci8_blocking_region(oci8_svcctx_t *svcctx, rb_blocking_function_t func, v
         return (sword)func(data);
     }
 }
-#else /* RUBY_VM */
+#else /* HAVE_RB_THREAD_BLOCKING_REGION */
 
 /* ruby 1.8 */
 sword oci8_blocking_region(oci8_svcctx_t *svcctx, rb_blocking_function_t func, void *data)
@@ -281,7 +300,7 @@ sword oci8_blocking_region(oci8_svcctx_t *svcctx, rb_blocking_function_t func, v
     svcctx->executing_thread = Qnil;
     return rv;
 }
-#endif /* RUBY_VM */
+#endif /* HAVE_RB_THREAD_BLOCKING_REGION */
 
 typedef struct {
     oci8_svcctx_t *svcctx;
@@ -468,3 +487,19 @@ void *oci8_find_symbol(const char *symbol_name)
 #endif /* defined _WIN32 */
 }
 #endif /* RUNTIME_API_CHECK */
+
+oci8_base_t *oci8_get_handle(VALUE obj, VALUE klass)
+{
+    oci8_base_t *hp;
+
+    if (!rb_obj_is_kind_of(obj, klass)) {
+        rb_raise(rb_eTypeError, "invalid argument %s (expect %s)",
+                 rb_obj_classname(obj), rb_class2name(klass));
+    }
+    Data_Get_Struct(obj, oci8_base_t, hp);
+    if (hp->type == 0) {
+        rb_raise(rb_eRuntimeError, "%s was already closed.",
+                 rb_obj_classname(obj));
+    }
+    return hp;
+}

data/ext/oci8/ocidatetime.c

@@ -3,7 +3,7 @@
  *  ocidatetime.c
  *
  * $Author: kubo $
- * $Date: 2009-10-18 22:46:48 +0900 (Sun, 18 Oct 2009) $
+ * $Date: 2011-06-12 22:14:51 +0900 (日, 12  6月 2011) $
  *
  * Copyright (C) 2005-2008 KUBO Takehiro <kubo@jiubao.org>
  *
@@ -102,7 +102,37 @@ static const oci8_bind_class_t bind_ocidate_class = {
 
 #if defined RUNTIME_API_CHECK || ORACLE_CLIENT_VERSION >= ORAVER_9_0
 
-VALUE oci8_make_ocitimestamp(OCIDateTime *dttm)
+static void bind_init_elem_common(oci8_bind_t *obind, VALUE svc, ub4 type)
+{
+    ub4 idx = 0;
+    sword rv;
+
+    do {
+        rv = OCIDescriptorAlloc(oci8_envhp, (dvoid*)((dvoid**)obind->valuep + idx), type, 0, 0);
+        if (rv != OCI_SUCCESS)
+            oci8_env_raise(oci8_envhp, rv);
+    } while (++idx < obind->maxar_sz);
+}
+
+static void bind_free_common(oci8_base_t *base, ub4 type)
+{
+    oci8_bind_t *obind = (oci8_bind_t *)base;
+
+    if (obind->valuep != NULL) {
+        ub4 idx = 0;
+        void **pp = (void**)obind->valuep;
+
+        do {
+            if (pp[idx] != NULL) {
+                OCIDescriptorFree(pp[idx], type);
+                pp[idx] = NULL;
+            }
+        } while (++idx < obind->maxar_sz);
+    }
+    oci8_bind_free(base);
+}
+
+VALUE oci8_make_ocitimestamp_tz(OCIDateTime *dttm)
 {
     sb2 year;
     ub1 month;
@@ -113,13 +143,10 @@ VALUE oci8_make_ocitimestamp(OCIDateTime *dttm)
     ub4 fsec;
     sb1 tz_hour;
     sb1 tz_minute;
-    sword rv;
-    int have_tz;
 
     oci_lc(OCIDateTimeGetDate(oci8_envhp, oci8_errhp, dttm, &year, &month, &day));
     oci_lc(OCIDateTimeGetTime(oci8_envhp, oci8_errhp, dttm, &hour, &minute, &sec, &fsec));
-    rv = OCIDateTimeGetTimeZoneOffset(oci8_envhp, oci8_errhp, dttm, &tz_hour, &tz_minute);
-    have_tz = (rv == OCI_SUCCESS);
+    oci_lc(OCIDateTimeGetTimeZoneOffset(oci8_envhp, oci8_errhp, dttm, &tz_hour, &tz_minute));
     return rb_ary_new3(9,
                        INT2FIX(year),
                        INT2FIX(month),
@@ -128,11 +155,11 @@ VALUE oci8_make_ocitimestamp(OCIDateTime *dttm)
                        INT2FIX(minute),
                        INT2FIX(sec),
                        INT2FIX(fsec),
-                       have_tz ? INT2FIX(tz_hour) : Qnil,
-                       have_tz ? INT2FIX(tz_minute) : Qnil);
+                       INT2FIX(tz_hour),
+                       INT2FIX(tz_minute));
 }
 
-OCIDateTime *oci8_set_ocitimestamp(OCIDateTime *dttm, VALUE val, VALUE svc)
+OCIDateTime *oci8_set_ocitimestamp_tz(OCIDateTime *dttm, VALUE val, VALUE svc)
 {
     long year;
     long month;
@@ -214,35 +241,12 @@ OCIDateTime *oci8_set_ocitimestamp(OCIDateTime *dttm, VALUE val, VALUE svc)
     return dttm;
 }
 
-typedef struct {
-    oci8_bind_t obind;
-    ub4 type;
-} oci8_bind_dsc_t;
-
-static void oci8_bind_dsc_free(oci8_base_t *base)
+static VALUE bind_ocitimestamp_tz_get(oci8_bind_t *obind, void *data, void *null_struct)
 {
-    oci8_bind_t *obind = (oci8_bind_t *)base;
-    ub4 type = ((oci8_bind_dsc_t *)base)->type;
-    if (obind->valuep != NULL) {
-        ub4 idx = 0;
-        void **pp = (void**)obind->valuep;
-
-        do {
-            if (pp[idx] != NULL) {
-                OCIDescriptorFree(pp[idx], type);
-                pp[idx] = NULL;
-            }
-        } while (++idx < obind->maxar_sz);
-    }
-    oci8_bind_free(base);
-}
-
-static VALUE bind_ocitimestamp_get(oci8_bind_t *obind, void *data, void *null_struct)
-{
-    return oci8_make_ocitimestamp(*(OCIDateTime **)data);
+    return oci8_make_ocitimestamp_tz(*(OCIDateTime **)data);
 }
 
-static void bind_ocitimestamp_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
+static void bind_ocitimestamp_tz_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
 {
     oci8_base_t *parent;
     oci8_base_t *svcctx;
@@ -259,41 +263,36 @@ static void bind_ocitimestamp_set(oci8_bind_t *obind, void *data, void **null_st
                  parent, parent ? parent->type : -1,
                  svcctx, svcctx ? svcctx->type : -1);
     }
-    oci8_set_ocitimestamp(*(OCIDateTime **)data, val, svcctx->self);
+    oci8_set_ocitimestamp_tz(*(OCIDateTime **)data, val, svcctx->self);
 }
 
-static void bind_ocitimestamp_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
+static void bind_ocitimestamp_tz_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
 {
-    oci8_bind_dsc_t *obind_dsc = (oci8_bind_dsc_t *)obind;
-
     oci8_link_to_parent((oci8_base_t*)obind, (oci8_base_t*)oci8_get_svcctx(svc));
     obind->value_sz = sizeof(OCIDateTime *);
     obind->alloc_sz = sizeof(OCIDateTime *);
-    obind_dsc->type = OCI_DTYPE_TIMESTAMP_TZ;
 }
 
-static void bind_ocitimestamp_init_elem(oci8_bind_t *obind, VALUE svc)
+static void bind_ocitimestamp_tz_init_elem(oci8_bind_t *obind, VALUE svc)
 {
-    ub4 idx = 0;
-    sword rv;
+    bind_init_elem_common(obind, svc, OCI_DTYPE_TIMESTAMP_TZ);
+}
 
-    do {
-        rv = OCIDescriptorAlloc(oci8_envhp, (dvoid*)((OCIDateTime**)obind->valuep + idx), OCI_DTYPE_TIMESTAMP_TZ, 0, 0);
-        if (rv != OCI_SUCCESS)
-            oci8_env_raise(oci8_envhp, rv);
-    } while (++idx < obind->maxar_sz);
+static void bind_ocitimestamp_tz_free(oci8_base_t *base)
+{
+    bind_free_common(base, OCI_DTYPE_TIMESTAMP_TZ);
 }
 
-static const oci8_bind_class_t bind_ocitimestamp_class = {
+static const oci8_bind_class_t bind_ocitimestamp_tz_class = {
     {
         NULL,
-        oci8_bind_dsc_free,
-        sizeof(oci8_bind_dsc_t)
+        bind_ocitimestamp_tz_free,
+        sizeof(oci8_bind_t)
     },
-    bind_ocitimestamp_get,
-    bind_ocitimestamp_set,
-    bind_ocitimestamp_init,
-    bind_ocitimestamp_init_elem,
+    bind_ocitimestamp_tz_get,
+    bind_ocitimestamp_tz_set,
+    bind_ocitimestamp_tz_init,
+    bind_ocitimestamp_tz_init_elem,
     NULL,
     NULL,
     NULL,
@@ -417,23 +416,18 @@ static void bind_ociinterval_ym_set(oci8_bind_t *obind, void *data, void **null_
 
 static void bind_ociinterval_ym_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
 {
-    oci8_bind_dsc_t *obind_dsc = (oci8_bind_dsc_t *)obind;
-
     obind->value_sz = sizeof(OCIInterval*);
     obind->alloc_sz = sizeof(OCIInterval*);
-    obind_dsc->type = OCI_DTYPE_INTERVAL_YM;
 }
 
 static void bind_ociinterval_ym_init_elem(oci8_bind_t *obind, VALUE svc)
 {
-    ub4 idx = 0;
-    sword rv;
+    bind_init_elem_common(obind, svc, OCI_DTYPE_INTERVAL_YM);
+}
 
-    do {
-        rv = OCIDescriptorAlloc(oci8_envhp, (dvoid*)((OCIDateTime**)obind->valuep + idx), OCI_DTYPE_INTERVAL_YM, 0, 0);
-        if (rv != OCI_SUCCESS)
-            oci8_env_raise(oci8_envhp, rv);
-    } while (++idx < obind->maxar_sz);
+static void bind_ociinterval_ym_free(oci8_base_t *base)
+{
+    bind_free_common(base, OCI_DTYPE_INTERVAL_YM);
 }
 
 static VALUE bind_ociinterval_ds_get(oci8_bind_t *obind, void *data, void *null_struct)
@@ -448,30 +442,25 @@ static void bind_ociinterval_ds_set(oci8_bind_t *obind, void *data, void **null_
 
 static void bind_ociinterval_ds_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
 {
-    oci8_bind_dsc_t *obind_dsc = (oci8_bind_dsc_t *)obind;
-
     obind->value_sz = sizeof(OCIInterval *);
     obind->alloc_sz = sizeof(OCIInterval *);
-    obind_dsc->type = OCI_DTYPE_INTERVAL_DS;
 }
 
 static void bind_ociinterval_ds_init_elem(oci8_bind_t *obind, VALUE svc)
 {
-    ub4 idx = 0;
-    sword rv;
+    bind_init_elem_common(obind, svc, OCI_DTYPE_INTERVAL_DS);
+}
 
-    do {
-        rv = OCIDescriptorAlloc(oci8_envhp, (dvoid*)((OCIInterval**)obind->valuep + idx), OCI_DTYPE_INTERVAL_DS, 0, 0);
-        if (rv != OCI_SUCCESS)
-            oci8_env_raise(oci8_envhp, rv);
-    } while (++idx < obind->maxar_sz);
+static void bind_ociinterval_ds_free(oci8_base_t *base)
+{
+    bind_free_common(base, OCI_DTYPE_INTERVAL_DS);
 }
 
 static const oci8_bind_class_t bind_ociinterval_ym_class = {
     {
         NULL,
-        oci8_bind_dsc_free,
-        sizeof(oci8_bind_dsc_t)
+        bind_ociinterval_ym_free,
+        sizeof(oci8_bind_t)
     },
     bind_ociinterval_ym_get,
     bind_ociinterval_ym_set,
@@ -486,8 +475,8 @@ static const oci8_bind_class_t bind_ociinterval_ym_class = {
 static const oci8_bind_class_t bind_ociinterval_ds_class = {
     {
         NULL,
-        oci8_bind_dsc_free,
-        sizeof(oci8_bind_dsc_t)
+        bind_ociinterval_ds_free,
+        sizeof(oci8_bind_t)
     },
     bind_ociinterval_ds_get,
     bind_ociinterval_ds_set,
@@ -507,7 +496,7 @@ void Init_oci_datetime(void)
 
 #if defined RUNTIME_API_CHECK || ORACLE_CLIENT_VERSION >= ORAVER_9_0
     if (oracle_client_version >= ORAVER_9_0) {
-        oci8_define_bind_class("OCITimestamp", &bind_ocitimestamp_class);
+        oci8_define_bind_class("OCITimestampTZ", &bind_ocitimestamp_tz_class);
         oci8_define_bind_class("OCIIntervalYM", &bind_ociinterval_ym_class);
         oci8_define_bind_class("OCIIntervalDS", &bind_ociinterval_ds_class);
     }