ruby-oci8 2.2.0.2 → 2.2.12

data/ext/oci8/bind.c

@@ -11,6 +11,7 @@
 #endif
 
 static ID id_bind_type;
+static ID id_charset_form;
 static VALUE sym_length;
 static VALUE sym_length_semantics;
 static VALUE sym_char;
@@ -25,6 +26,29 @@ typedef struct {
     ub1 csfrm;
 } oci8_bind_string_t;
 
+static ub4 initial_chunk_size = 32 * 1024;
+static ub4 max_chunk_size = 8 * 1024 * 1024;
+
+typedef struct chunk {
+    struct chunk *next;
+    ub4 alloc_len;
+    ub4 used_len;
+    char buf[1];
+} chunk_t;
+
+typedef struct {
+    chunk_t *head;
+    chunk_t **tail;
+    chunk_t **inpos;
+} chunk_buf_t;
+
+typedef struct {
+    oci8_bind_t obind;
+    ub1 csfrm;
+} oci8_bind_long_t;
+
+#define IS_BIND_LONG(obind) (((oci8_bind_data_type_t*)obind->base.data_type)->dty == SQLT_CHR)
+
 const oci8_handle_data_type_t oci8_bind_data_type = {
     {
         "OCI8::BindType::Base",
@@ -61,7 +85,7 @@ static void bind_string_set(oci8_bind_t *obind, void *data, void **null_structp,
         rb_raise(rb_eArgError, "too long String to set. (%ld for %d)", RSTRING_LEN(val), obs->bytelen);
     }
     memcpy(vstr->buf, RSTRING_PTR(val), RSTRING_LEN(val));
-    vstr->size = RSTRING_LEN(val);
+    vstr->size = RSTRING_LENINT(val);
 }
 
 static void bind_string_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE param)
@@ -171,7 +195,7 @@ static void bind_raw_set(oci8_bind_t *obind, void *data, void **null_structp, VA
         rb_raise(rb_eArgError, "too long String to set. (%ld for %d)", RSTRING_LEN(val), obs->bytelen);
     }
     memcpy(vstr->buf, RSTRING_PTR(val), RSTRING_LEN(val));
-    vstr->size = RSTRING_LEN(val);
+    vstr->size = RSTRING_LENINT(val);
 }
 
 static const oci8_bind_data_type_t bind_raw_data_type = {
@@ -224,9 +248,6 @@ static void bind_binary_double_init(oci8_bind_t *obind, VALUE svc, VALUE val, VA
     obind->alloc_sz = sizeof(double);
 }
 
-#ifndef SQLT_BDOUBLE
-#define SQLT_BDOUBLE 22
-#endif
 static const oci8_bind_data_type_t bind_binary_double_data_type = {
     {
         {
@@ -257,6 +278,347 @@ static VALUE bind_binary_double_alloc(VALUE klass)
     return oci8_allocate_typeddata(klass, &bind_binary_double_data_type.base);
 }
 
+/*
+ * bind_boolean
+ */
+static VALUE bind_boolean_get(oci8_bind_t *obind, void *data, void *null_struct)
+{
+    return *(int*)data ? Qtrue : Qfalse;
+}
+
+static void bind_boolean_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
+{
+    *(int*)data = RTEST(val) ? -1 : 0;
+}
+
+static void bind_boolean_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
+{
+    obind->value_sz = sizeof(int);
+    obind->alloc_sz = sizeof(int);
+}
+
+#ifndef SQLT_BOL
+#define SQLT_BOL 252
+#endif
+static const oci8_bind_data_type_t bind_boolean_data_type = {
+    {
+        {
+            "OCI8::BindType::Boolean",
+            {
+                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
+        },
+        oci8_bind_free,
+        sizeof(oci8_bind_t)
+    },
+    bind_boolean_get,
+    bind_boolean_set,
+    bind_boolean_init,
+    NULL,
+    NULL,
+    SQLT_BOL,
+};
+
+static VALUE bind_boolean_alloc(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &bind_boolean_data_type.base);
+}
+
+/*
+ * bind_long
+ */
+static chunk_t *next_chunk(chunk_buf_t *cb)
+{
+   chunk_t *chunk;
+
+   if (*cb->tail != NULL) {
+       chunk = *cb->tail;
+   } else {
+       ub4 alloc_len;
+       if (cb->head == NULL) {
+           alloc_len = initial_chunk_size;
+       } else {
+           alloc_len = ((chunk_t*)((size_t)cb->tail - offsetof(chunk_t, next)))->alloc_len * 2;
+           if (alloc_len > max_chunk_size) {
+               alloc_len = max_chunk_size;
+           }
+       }
+       chunk = xmalloc(offsetof(chunk_t, buf) + alloc_len);
+       chunk->next = NULL;
+       chunk->alloc_len = alloc_len;
+       *cb->tail = chunk;
+   }
+   cb->tail = &chunk->next;
+   return chunk;
+}
+
+static sb4 define_callback(void *octxp, OCIDefine *defnp, ub4 iter, void **bufpp, ub4 **alenp, ub1 *piecep, void **indp, ub2 **rcodep)
+{
+    oci8_bind_t *obind = (oci8_bind_t *)octxp;
+    chunk_buf_t *cb = ((chunk_buf_t*)obind->valuep) + iter;
+    chunk_t *chunk;
+
+    if (*piecep == OCI_FIRST_PIECE) {
+        cb->tail = &cb->head;
+    }
+    chunk = next_chunk(cb);
+    chunk->used_len = chunk->alloc_len;
+    *bufpp = chunk->buf;
+    *alenp = &chunk->used_len;
+    *indp = (void*)&obind->u.inds[iter];
+    *rcodep = NULL;
+    return OCI_CONTINUE;
+}
+
+static sb4 in_bind_callback(void *ictxp, OCIBind *bindp, ub4 iter, ub4 index, void **bufpp, ub4 *alenp, ub1 *piecep, void **indp)
+{
+    oci8_bind_t *obind = (oci8_bind_t *)ictxp;
+    chunk_buf_t *cb = ((chunk_buf_t*)obind->valuep) + iter;
+
+    if (cb->tail == &cb->head) {
+        /* empty string */
+        *bufpp = (void *)"";
+        *alenp = 0;
+        *piecep = OCI_ONE_PIECE;
+    } else {
+        chunk_t *chunk = *cb->inpos;
+        *bufpp = chunk->buf;
+        *alenp = chunk->used_len;
+        if (cb->tail == &cb->head->next) {
+            *piecep = OCI_ONE_PIECE;
+        } else if (cb->inpos == &cb->head) {
+            *piecep = OCI_FIRST_PIECE;
+            cb->inpos = &chunk->next;
+        } else if (&chunk->next != cb->tail) {
+            *piecep = OCI_NEXT_PIECE;
+            cb->inpos = &chunk->next;
+        } else {
+            *piecep = OCI_LAST_PIECE;
+            cb->inpos = &cb->head;
+        }
+    }
+    *indp = (void*)&obind->u.inds[iter];
+    return OCI_CONTINUE;
+}
+
+static sb4 out_bind_callback(void *octxp, OCIBind *bindp, ub4 iter, ub4 index, void **bufpp, ub4 **alenp, ub1 *piecep, void **indp, ub2 **rcodep)
+{
+    oci8_bind_t *obind = (oci8_bind_t *)octxp;
+    chunk_buf_t *cb = ((chunk_buf_t*)obind->valuep) + iter;
+    chunk_t *chunk;
+
+    if (*piecep == OCI_ONE_PIECE) {
+        *piecep = OCI_FIRST_PIECE;
+        cb->tail = &cb->head;
+    }
+    chunk = next_chunk(cb);
+    chunk->used_len = chunk->alloc_len;
+    *bufpp = chunk->buf;
+    *alenp = &chunk->used_len;
+    *indp = (void*)&obind->u.inds[iter];
+    *rcodep = NULL;
+    return OCI_CONTINUE;
+}
+
+static void bind_long_free(oci8_base_t *base)
+{
+    oci8_bind_t *obind = (oci8_bind_t *)base;
+    chunk_buf_t *cb = (chunk_buf_t *)obind->valuep;
+
+    if (cb != NULL) {
+        ub4 idx = 0;
+        do {
+            chunk_t *chunk, *chunk_next;
+            for (chunk = cb[idx].head; chunk != NULL; chunk = chunk_next) {
+                chunk_next = chunk->next;
+                xfree(chunk);
+            }
+        } while (++idx < obind->maxar_sz);
+    }
+    oci8_bind_free(base);
+}
+
+static VALUE bind_long_get(oci8_bind_t *obind, void *data, void *null_struct)
+{
+    chunk_buf_t *cb = (chunk_buf_t *)data;
+    chunk_t *chunk;
+    long len = 0;
+    VALUE str;
+    char *buf;
+
+    for (chunk = cb->head; chunk != *cb->tail; chunk = chunk->next) {
+        len += chunk->used_len;
+    }
+    str = rb_str_buf_new(len);
+    buf = RSTRING_PTR(str);
+    for (chunk = cb->head; chunk != *cb->tail; chunk = chunk->next) {
+        memcpy(buf, chunk->buf, chunk->used_len);
+        buf += chunk->used_len;
+    }
+    rb_str_set_len(str, len);
+    if (IS_BIND_LONG(obind)) {
+        rb_encoding *enc = rb_default_internal_encoding();
+
+        rb_enc_associate(str, oci8_encoding);
+        if (enc != NULL) {
+            str = rb_str_conv_enc(str, oci8_encoding, enc);
+        }
+    }
+    return str;
+}
+
+static void bind_long_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
+{
+    chunk_buf_t *cb = (chunk_buf_t *)data;
+    ub4 len;
+    const char *buf;
+
+    if (IS_BIND_LONG(obind)) {
+        OCI8StringValue(val);
+    } else {
+        StringValue(val);
+    }
+    len = (ub4)RSTRING_LEN(val);
+    buf = RSTRING_PTR(val);
+    cb->tail = &cb->head;
+    while (1) {
+        chunk_t *chunk = next_chunk(cb);
+        if (len <= chunk->alloc_len) {
+            memcpy(chunk->buf, buf, len);
+            chunk->used_len = len;
+            break;
+        }
+        memcpy(chunk->buf, buf, chunk->alloc_len);
+        chunk->used_len = chunk->alloc_len;
+        len -= chunk->alloc_len;
+        buf += chunk->alloc_len;
+    }
+}
+
+static void bind_long_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE param)
+{
+    if (IS_BIND_LONG(obind)) {
+        oci8_bind_long_t *obl = (oci8_bind_long_t *)obind;
+        VALUE nchar;
+
+        if (rb_respond_to(param, id_charset_form)) {
+            VALUE csfrm = rb_funcall(param, id_charset_form, 0);
+            nchar = (csfrm == sym_nchar) ? Qtrue : Qfalse;
+        } else {
+            Check_Type(param, T_HASH);
+            nchar = rb_hash_aref(param, sym_nchar);
+        }
+
+        if (RTEST(nchar)) {
+            obl->csfrm = SQLCS_NCHAR; /* bind as NCHAR/NVARCHAR2 */
+        } else {
+            obl->csfrm = SQLCS_IMPLICIT; /* bind as CHAR/VARCHAR2 */
+        }
+    }
+    obind->value_sz = SB4MAXVAL;
+    obind->alloc_sz = sizeof(chunk_buf_t);
+}
+
+static void bind_long_init_elem(oci8_bind_t *obind, VALUE svc)
+{
+    chunk_buf_t *cb = (chunk_buf_t *)obind->valuep;
+    ub4 idx = 0;
+
+    do {
+        cb[idx].tail = &cb[idx].head;
+        cb[idx].inpos = &cb[idx].head;
+    } while (++idx < obind->maxar_sz);
+}
+
+static void bind_long_post_bind_hook(oci8_bind_t *obind)
+{
+    oci8_bind_long_t *ds = (oci8_bind_long_t *)obind;
+
+    if (IS_BIND_LONG(obind)) {
+        chker2(OCIAttrSet(obind->base.hp.ptr, obind->base.type, (void*)&ds->csfrm, 0, OCI_ATTR_CHARSET_FORM, oci8_errhp),
+               &obind->base);
+    }
+    switch (obind->base.type) {
+    case OCI_HTYPE_DEFINE:
+        chker2(OCIDefineDynamic(obind->base.hp.dfn, oci8_errhp, obind, define_callback),
+               &obind->base);
+        break;
+    case OCI_HTYPE_BIND:
+        chker2(OCIBindDynamic(obind->base.hp.bnd, oci8_errhp, obind, in_bind_callback,
+                              obind, out_bind_callback),
+               &obind->base);
+        break;
+    }
+}
+
+static const oci8_bind_data_type_t bind_long_data_type = {
+    {
+        {
+            "OCI8::BindType::Long",
+            {
+                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_long_free,
+        sizeof(oci8_bind_long_t)
+    },
+    bind_long_get,
+    bind_long_set,
+    bind_long_init,
+    bind_long_init_elem,
+    NULL,
+    SQLT_CHR,
+    bind_long_post_bind_hook,
+};
+
+static VALUE bind_long_alloc(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &bind_long_data_type.base);
+}
+
+static const oci8_bind_data_type_t bind_long_raw_data_type = {
+    {
+        {
+            "OCI8::BindType::LongRaw",
+            {
+                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_long_free,
+        sizeof(oci8_bind_long_t)
+    },
+    bind_long_get,
+    bind_long_set,
+    bind_long_init,
+    bind_long_init_elem,
+    NULL,
+    SQLT_BIN,
+    bind_long_post_bind_hook,
+};
+
+static VALUE bind_long_raw_alloc(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &bind_long_raw_data_type.base);
+}
+
 static VALUE oci8_bind_get(VALUE self)
 {
     oci8_bind_t *obind = TO_BIND(self);
@@ -271,11 +633,20 @@ static VALUE oci8_bind_get(VALUE self)
     return data_type->get(obind, (void*)((size_t)obind->valuep + obind->alloc_sz * idx), null_structp);
 }
 
-static VALUE oci8_bind_get_data(VALUE self)
+static VALUE oci8_bind_get_data(int argc, VALUE *argv, VALUE self)
 {
     oci8_bind_t *obind = TO_BIND(self);
+    VALUE index;
 
-    if (obind->maxar_sz == 0) {
+    rb_scan_args(argc, argv, "01", &index);
+    if (!NIL_P(index)) {
+        ub4 idx = NUM2UINT(index);
+        if (idx >= obind->maxar_sz) {
+            rb_raise(rb_eRuntimeError, "data index is too big. (%u for %u)", idx, obind->maxar_sz);
+        }
+        obind->curar_idx = idx;
+        return rb_funcall(self, oci8_id_get, 0);
+    } else if (obind->maxar_sz == 0) {
         obind->curar_idx = 0;
         return rb_funcall(self, oci8_id_get, 0);
     } else {
@@ -329,7 +700,7 @@ static VALUE oci8_bind_set_data(VALUE self, VALUE val)
         ub4 idx;
         Check_Type(val, T_ARRAY);
 
-        size = RARRAY_LEN(val);
+        size = RARRAY_LENINT(val);
         if (size > obind->maxar_sz) {
             rb_raise(rb_eRuntimeError, "over the max array size");
         }
@@ -342,6 +713,36 @@ static VALUE oci8_bind_set_data(VALUE self, VALUE val)
     return self;
 }
 
+static VALUE get_initial_chunk_size(VALUE klass)
+{
+    return UINT2NUM(initial_chunk_size);
+}
+
+static VALUE set_initial_chunk_size(VALUE klass, VALUE arg)
+{
+    ub4 size = NUM2UINT(arg);
+    if (size == 0) {
+        rb_raise(rb_eArgError, "Could not set zero");
+    }
+    initial_chunk_size = size;
+    return arg;
+}
+
+static VALUE get_max_chunk_size(VALUE klass)
+{
+    return UINT2NUM(max_chunk_size);
+}
+
+static VALUE set_max_chunk_size(VALUE klass, VALUE arg)
+{
+    ub4 size = NUM2UINT(arg);
+    if (size == 0) {
+        rb_raise(rb_eArgError, "Could not set zero");
+    }
+    max_chunk_size = size;
+    return arg;
+}
+
 static VALUE oci8_bind_initialize(VALUE self, VALUE svc, VALUE val, VALUE length, VALUE max_array_size)
 {
     oci8_bind_t *obind = TO_BIND(self);
@@ -407,6 +808,7 @@ void Init_oci8_bind(VALUE klass)
 {
     cOCI8BindTypeBase = klass;
     id_bind_type = rb_intern("bind_type");
+    id_charset_form = rb_intern("charset_form");
     sym_length = ID2SYM(rb_intern("length"));
     sym_length_semantics = ID2SYM(rb_intern("length_semantics"));
     sym_char = ID2SYM(rb_intern("char"));
@@ -415,11 +817,21 @@ void Init_oci8_bind(VALUE klass)
     rb_define_method(cOCI8BindTypeBase, "initialize", oci8_bind_initialize, 4);
     rb_define_method(cOCI8BindTypeBase, "get", oci8_bind_get, 0);
     rb_define_method(cOCI8BindTypeBase, "set", oci8_bind_set, 1);
-    rb_define_private_method(cOCI8BindTypeBase, "get_data", oci8_bind_get_data, 0);
+    rb_define_private_method(cOCI8BindTypeBase, "get_data", oci8_bind_get_data, -1);
     rb_define_private_method(cOCI8BindTypeBase, "set_data", oci8_bind_set_data, 1);
 
+    rb_define_singleton_method(klass, "initial_chunk_size", get_initial_chunk_size, 0);
+    rb_define_singleton_method(klass, "initial_chunk_size=", set_initial_chunk_size, 1);
+    rb_define_singleton_method(klass, "max_chunk_size", get_max_chunk_size, 0);
+    rb_define_singleton_method(klass, "max_chunk_size=", set_max_chunk_size, 1);
+
     /* register primitive data types. */
     oci8_define_bind_class("String", &bind_string_data_type, bind_string_alloc);
     oci8_define_bind_class("RAW", &bind_raw_data_type, bind_raw_alloc);
     oci8_define_bind_class("BinaryDouble", &bind_binary_double_data_type, bind_binary_double_alloc);
+    if (oracle_client_version >= ORAVER_12_1) {
+        oci8_define_bind_class("Boolean", &bind_boolean_data_type, bind_boolean_alloc);
+    }
+    klass = oci8_define_bind_class("Long", &bind_long_data_type, bind_long_alloc);
+    klass = oci8_define_bind_class("LongRaw", &bind_long_data_type, bind_long_raw_alloc);
 }

data/ext/oci8/connection_pool.c

@@ -144,13 +144,13 @@ static VALUE oci8_cpool_initialize(int argc, VALUE *argv, VALUE self)
     chker2(OCIConnectionPoolCreate(oci8_envhp, oci8_errhp, cpool->base.hp.poolhp,
                                    &pool_name, &pool_name_len,
                                    NIL_P(dbname) ? NULL : RSTRING_ORATEXT(dbname),
-                                   NIL_P(dbname) ? 0 : RSTRING_LEN(dbname),
+                                   NIL_P(dbname) ? 0 : RSTRING_LENINT(dbname),
                                    FIX2UINT(conn_min), FIX2UINT(conn_max),
                                    FIX2UINT(conn_incr),
                                    NIL_P(username) ? NULL : RSTRING_ORATEXT(username),
-                                   NIL_P(username) ? 0 : RSTRING_LEN(username),
+                                   NIL_P(username) ? 0 : RSTRING_LENINT(username),
                                    NIL_P(password) ? NULL : RSTRING_ORATEXT(password),
-                                   NIL_P(password) ? 0 : RSTRING_LEN(password),
+                                   NIL_P(password) ? 0 : RSTRING_LENINT(password),
                                    OCI_DEFAULT),
            &cpool->base);
     RB_OBJ_WRITE(cpool->base.self, &cpool->pool_name, rb_str_new(TO_CHARPTR(pool_name), pool_name_len));

data/ext/oci8/encoding.c

@@ -23,7 +23,7 @@ rb_encoding *oci8_encoding;
  * Returns the Oracle character set name from the specified
  * character set ID if it is valid. Otherwise, +nil+ is returned.
  *
- * @param [Fixnum] charset_id   Oracle character set id
+ * @param [Integer] charset_id  Oracle character set id
  * @return [String]             Oracle character set name or nil
  * @since 2.2.0
  */
@@ -48,7 +48,7 @@ VALUE oci8_s_charset_id2name(VALUE klass, VALUE csid)
  * character set name if it is valid. Othewise, +nil+ is returned.
  *
  * @param [String] charset_name   Oracle character set name
- * @return [Fixnum]               Oracle character set id or nil
+ * @return [Integer]              Oracle character set id or nil
  * @since 2.2.0
  */
 static VALUE oci8_s_charset_name2id(VALUE klass, VALUE name)
@@ -71,7 +71,7 @@ static VALUE oci8_s_charset_name2id(VALUE klass, VALUE name)
  * internal buffer size of a string bind variable whose nls length
  * semantics is char.
  *
- * @return [Fixnum]  NLS ratio
+ * @return [Integer] NLS ratio
  * @since 2.1.0
  * @private
  */
@@ -150,7 +150,7 @@ static VALUE oci8_set_encoding(VALUE klass, VALUE encoding)
  * character set name if it is valid. Othewise, +nil+ is returned.
  *
  * @param [String] charset_name   Oracle character set name
- * @return [Fixnum]               Oracle character set id or nil
+ * @return [Integer]              Oracle character set id or nil
  * @since 2.0.0
  * @deprecated Use {OCI8.charset_name2id} instead.
  */
@@ -167,7 +167,7 @@ static VALUE oci8_charset_name2id(VALUE svc, VALUE name)
  * Returns the Oracle character set name from the specified
  * character set ID if it is valid. Otherwise, +nil+ is returned.
  *
- * @param [Fixnum] charset_id   Oracle character set id
+ * @param [Integer] charset_id  Oracle character set id
  * @return [String]             Oracle character set name or nil
  * @since 2.0.0
  * @deprecated Use {OCI8.charset_id2name} instead.

data/ext/oci8/env.c

@@ -14,11 +14,17 @@ OCIEnv *oci8_global_envhp;
 OCIEnv *oci8_make_envhp(void)
 {
     sword rv;
+    OCIEnv *envhp = NULL;
 
-    rv = OCIEnvCreate(&oci8_global_envhp, oci8_env_mode, NULL, NULL, NULL, NULL, 0, NULL);
+    rv = OCIEnvCreate(&envhp, oci8_env_mode, NULL, NULL, NULL, NULL, 0, NULL);
     if (rv != OCI_SUCCESS) {
-        oci8_raise_init_error();
+        if (envhp != NULL) {
+            oci8_env_free_and_raise(envhp, rv);
+        } else {
+            oci8_raise_init_error();
+        }
     }
+    oci8_global_envhp = envhp;
     return oci8_global_envhp;
 }
 

data/ext/oci8/error.c

@@ -75,6 +75,21 @@ retry:
     return rb_external_str_new_with_enc(errbuf, len, oci8_encoding);
 }
 
+/*
+ * Don't call rb_class_new_instance() with more than one argument in this function.
+ * This may be called before OCIError#initialize is defined in lib/oci8/oci8.rb.
+ */
+static VALUE oci_exception_new(VALUE klass, VALUE msg, VALUE code, VALUE sql, VALUE parse_error_offset)
+{
+    VALUE obj = rb_class_new_instance(NIL_P(msg) ? 0 : 1, &msg, klass);
+    if (rb_obj_is_kind_of(obj, eOCIError)) {
+        rb_ivar_set(obj, oci8_id_at_code, code);
+        rb_ivar_set(obj, oci8_id_at_sql, sql);
+        rb_ivar_set(obj, oci8_id_at_parse_error_offset, parse_error_offset);
+    }
+    return obj;
+}
+
 static VALUE oci8_make_exc(dvoid *errhp, sword status, ub4 type, OCIStmt *stmthp, const char *file, int line)
 {
     VALUE exc;
@@ -84,24 +99,19 @@ static VALUE oci8_make_exc(dvoid *errhp, sword status, ub4 type, OCIStmt *stmthp
     VALUE parse_error_offset = Qnil;
     VALUE sql = Qnil;
     int rv;
-    VALUE args[4];
-    int numarg = 1;
 
     switch (status) {
     case OCI_ERROR:
         exc = eOCIError;
         msg = get_error_msg(errhp, type, "Error", &errcode);
-        numarg = 4;
         break;
     case OCI_SUCCESS_WITH_INFO:
         exc = eOCISuccessWithInfo;
         msg = get_error_msg(errhp, type, "Error", &errcode);
-        numarg = 4;
         break;
     case OCI_NO_DATA:
         exc = eOCINoData;
         msg = get_error_msg(errhp, type, "No Data", &errcode);
-        numarg = 4;
         break;
     case OCI_INVALID_HANDLE:
         exc = eOCIInvalidHandle;
@@ -138,11 +148,7 @@ static VALUE oci8_make_exc(dvoid *errhp, sword status, ub4 type, OCIStmt *stmthp
             sql = rb_external_str_new_with_enc(TO_CHARPTR(text), size, oci8_encoding);
         }
     }
-    args[0] = msg;
-    args[1] = INT2FIX(errcode);
-    args[2] = sql;
-    args[3] = parse_error_offset;
-    exc = rb_class_new_instance(numarg, args, exc);
+    exc = oci_exception_new(exc, msg, INT2FIX(errcode), sql, parse_error_offset);
     return set_backtrace(exc, file, line);
 }
 
@@ -208,9 +214,13 @@ void oci8_do_raise(OCIError *errhp, sword status, OCIStmt *stmthp, const char *f
     rb_exc_raise(oci8_make_exc(errhp, status, OCI_HTYPE_ERROR, stmthp, file, line));
 }
 
-void oci8_do_env_raise(OCIEnv *envhp, sword status, const char *file, int line)
+void oci8_do_env_raise(OCIEnv *envhp, sword status, int free_envhp, const char *file, int line)
 {
-    rb_exc_raise(oci8_make_exc(envhp, status, OCI_HTYPE_ENV, NULL, file, line));
+    VALUE exc = oci8_make_exc(envhp, status, OCI_HTYPE_ENV, NULL, file, line);
+    if (free_envhp) {
+        OCIHandleFree(envhp, OCI_HTYPE_ENV);
+    }
+    rb_exc_raise(exc);
 }
 
 void oci8_do_raise_init_error(const char *file, int line)
@@ -255,11 +265,9 @@ VALUE oci8_get_error_message(ub4 msgno, const char *default_msg)
 void oci8_do_raise_by_msgno(ub4 msgno, const char *default_msg, const char *file, int line)
 {
     VALUE msg = oci8_get_error_message(msgno, default_msg);
-    VALUE args[2];
-    args[0] = msg;
-    args[1] = INT2FIX(-1);
+    VALUE exc = oci_exception_new(eOCIError, msg, INT2FIX(-1), Qnil, Qnil);
 
-    rb_exc_raise(set_backtrace(rb_class_new_instance(2, args, eOCIError), file, line));
+    rb_exc_raise(set_backtrace(exc, file, line));
 }
 
 void oci8_check_error_(sword status, oci8_base_t *base, OCIStmt *stmthp, const char *file, int line)