ruby-oci8 2.0.4 → 2.0.5

data/ext/oci8/attr.c

@@ -3,7 +3,7 @@
  * attr.c
  *
  * $Author: kubo $
- * $Date: 2009-05-17 19:08:39 +0900 (Sun, 17 May 2009) $
+ * $Date: 2009-05-17 19:08:39 +0900 (日, 17  5月 2009) $
  *
  * Copyright (C) 2002-2007 KUBO Takehiro <kubo@jiubao.org>
  */

data/ext/oci8/bind.c

@@ -3,7 +3,7 @@
  * bind.c
  *
  * $Author: kubo $
- * $Date: 2009-05-19 21:51:28 +0900 (Tue, 19 May 2009) $
+ * $Date: 2010-12-14 20:30:44 +0900 (火, 14 12月 2010) $
  *
  * Copyright (C) 2002-2008 KUBO Takehiro <kubo@jiubao.org>
  */
@@ -14,7 +14,7 @@ static ID id_bind_type;
 static VALUE cOCI8BindTypeBase;
 
 /*
- * bind_string
+ * bind_char and bind_nchar
  */
 static VALUE bind_string_get(oci8_bind_t *obind, void *data, void *null_struct)
 {
@@ -54,7 +54,7 @@ static void bind_string_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE len
     obind->alloc_sz = (sz + (sizeof(sb4) - 1)) & ~(sizeof(sb4) - 1);
 }
 
-static const oci8_bind_class_t bind_string_class = {
+static const oci8_bind_class_t bind_char_class = {
     {
         NULL,
         oci8_bind_free,
@@ -70,6 +70,23 @@ static const oci8_bind_class_t bind_string_class = {
     SQLT_LVC
 };
 
+static const oci8_bind_class_t bind_nchar_class = {
+    {
+        NULL,
+        oci8_bind_free,
+        sizeof(oci8_bind_t)
+    },
+    bind_string_get,
+    bind_string_set,
+    bind_string_init,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    SQLT_LVC,
+    SQLCS_NCHAR,
+};
+
 /*
  * bind_raw
  */
@@ -79,6 +96,18 @@ static VALUE bind_raw_get(oci8_bind_t *obind, void *data, void *null_struct)
     return rb_str_new(vstr->buf, vstr->size);
 }
 
+static void bind_raw_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
+{
+    oci8_vstr_t *vstr = (oci8_vstr_t *)data;
+
+    StringValue(val);
+    if (RSTRING_LEN(val) > obind->value_sz - sizeof(vstr->size)) {
+        rb_raise(rb_eArgError, "too long String to set. (%ld for %d)", RSTRING_LEN(val), obind->value_sz - (sb4)sizeof(vstr->size));
+    }
+    memcpy(vstr->buf, RSTRING_PTR(val), RSTRING_LEN(val));
+    vstr->size = RSTRING_LEN(val);
+}
+
 static const oci8_bind_class_t bind_raw_class = {
     {
         NULL,
@@ -86,7 +115,7 @@ static const oci8_bind_class_t bind_raw_class = {
         sizeof(oci8_bind_t)
     },
     bind_raw_get,
-    bind_string_set,
+    bind_raw_set,
     bind_string_init,
     NULL,
     NULL,
@@ -303,10 +332,6 @@ static VALUE oci8_bind_get(VALUE self)
     if (NIL_P(obind->tdo)) {
         if (obind->u.inds[idx] != 0)
             return Qnil;
-    } else {
-        null_structp = &obind->u.null_structs[idx];
-        if (*(OCIInd*)*null_structp != 0)
-            return Qnil;
     }
     return obc->get(obind, (void*)((size_t)obind->valuep + obind->alloc_sz * idx), null_structp);
 }
@@ -350,6 +375,7 @@ static VALUE oci8_bind_set(VALUE self, VALUE val)
             obind->u.inds[idx] = 0;
         } else {
             null_structp = &obind->u.null_structs[idx];
+            *(OCIInd*)obind->u.null_structs[idx] = 0;
         }
         obc->set(obind, (void*)((size_t)obind->valuep + obind->alloc_sz * idx), null_structp, val);
     }
@@ -451,7 +477,8 @@ void Init_oci8_bind(VALUE klass)
     rb_define_method(cOCI8BindTypeBase, "set", oci8_bind_set, 1);
 
     /* register primitive data types. */
-    oci8_define_bind_class("String", &bind_string_class);
+    oci8_define_bind_class("CHAR", &bind_char_class);
+    oci8_define_bind_class("NCHAR", &bind_nchar_class);
     oci8_define_bind_class("RAW", &bind_raw_class);
 #ifdef USE_DYNAMIC_FETCH
     oci8_define_bind_class("Long", &bind_long_class);

data/ext/oci8/env.c

@@ -2,28 +2,17 @@
 /*
  * env.c - part of ruby-oci8
  *
- * Copyright (C) 2002-2009 KUBO Takehiro <kubo@jiubao.org>
+ * Copyright (C) 2002-2011 KUBO Takehiro <kubo@jiubao.org>
  */
 #include "oci8.h"
 
-#if !defined(RUBY_VM)
-/* ruby_setenv for workaround ruby 1.8.4 */
-#include <util.h>
-#endif
-
-#ifdef _WIN32
-#ifdef HAVE_RUBY_WIN32_H
-#include <ruby/win32.h> /* for rb_w32_getenv() */
-#else
-#include <win32/win32.h> /* for rb_w32_getenv() */
-#endif
-#endif
-
-#ifdef HAVE_RUBY_UTIL_H
+#if defined(HAVE_RUBY_UTIL_H)
 #include <ruby/util.h>
+#elif defined(HAVE_UTIL_H)
+#include <util.h>
 #endif
 
-#ifdef RUBY_VM
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
 ub4 oci8_env_mode = OCI_OBJECT | OCI_THREADED;
 #else
 ub4 oci8_env_mode = OCI_OBJECT;
@@ -42,23 +31,53 @@ OCIEnv *oci8_make_envhp(void)
     return oci8_global_envhp;
 }
 
-#ifdef RUBY_VM
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
 /*
  * oci8_errhp is a thread local object in ruby 1.9.
  */
 
 oci8_tls_key_t oci8_tls_key; /* native thread key */
-static ID id_thread_key;     /* ruby's thread key */
 
-static void oci8_free_errhp(OCIError *errhp)
+/* This function is called on the native thread termination
+ * if the thread local errhp is not null.
+ */
+static void oci8_free_errhp(void *errhp)
 {
     OCIHandleFree(errhp, OCI_HTYPE_ERROR);
 }
 
+#ifdef _WIN32
+static int dllmain_is_called;
+
+__declspec(dllexport)
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+{
+    void *errhp;
+
+    switch (fdwReason) {
+    case DLL_PROCESS_ATTACH:
+        dllmain_is_called = 1;
+        break;
+    case DLL_THREAD_ATTACH:
+        /* do nothing */
+        break;
+    case DLL_THREAD_DETACH:
+        errhp = oci8_tls_get(oci8_tls_key);
+        if (errhp != NULL) {
+            oci8_free_errhp(errhp);
+        }
+        break;
+    case DLL_PROCESS_DETACH:
+        /* do nothing */
+        break;
+    }
+    return TRUE;
+}
+#endif
+
 OCIError *oci8_make_errhp(void)
 {
     OCIError *errhp;
-    VALUE obj;
     sword rv;
 
     /* create a new errhp. */
@@ -66,15 +85,9 @@ OCIError *oci8_make_errhp(void)
     if (rv != OCI_SUCCESS) {
         oci8_env_raise(oci8_envhp, rv);
     }
-    /* create a new ruby object which contains errhp to make
-     * sure that the errhp is freed when it become unnecessary.
+    /* Set the errhp to the thread local storage.
+     * It is freed by oci8_free_errhp().
      */
-    obj = Data_Wrap_Struct(rb_cObject, NULL, oci8_free_errhp, errhp);
-    /* set the ruby object to ruby's thread local storage to prevent
-     * it from being freed while the thread is available.
-     */
-    rb_thread_local_aset(rb_thread_current(), id_thread_key, obj);
-
     oci8_tls_set(oci8_tls_key, (void*)errhp);
     return errhp;
 }
@@ -97,11 +110,11 @@ OCIError *oci8_make_errhp(void)
 
 void Init_oci8_env(void)
 {
-#ifdef RUBY_VM
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
     int error;
 #endif
 
-#if !defined(RUBY_VM) && !defined(_WIN32)
+#if !defined(HAVE_RB_THREAD_BLOCKING_REGION) && !defined(_WIN32)
     /* workaround code.
      *
      * Some instant clients set the environment variables
@@ -147,9 +160,22 @@ void Init_oci8_env(void)
         }
     }
 
-#ifdef RUBY_VM
-    id_thread_key = rb_intern("__oci8_errhp__");
-    error = oci8_tls_key_init(&oci8_tls_key);
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+/* ruby 1.9 */
+#if defined(_WIN32)
+    if (!dllmain_is_called) {
+        /* sanity check */
+        rb_raise(rb_eRuntimeError, "DllMain is not unexpectedly called. This causes resource leaks.");
+    }
+    oci8_tls_key = TlsAlloc();
+    if (oci8_tls_key == 0xFFFFFFFF) {
+        error = GetLastError();
+    } else {
+        error = 0;
+    }
+#else
+    error = pthread_key_create(&oci8_tls_key, oci8_free_errhp);
+#endif
     if (error != 0) {
         rb_raise(rb_eRuntimeError, "Cannot create thread local key (errno = %d)", error);
     }

data/ext/oci8/error.c

@@ -10,6 +10,10 @@
 */
 #include "oci8.h"
 
+#ifndef DLEXT
+#define DLEXT ".so"
+#endif
+
 /* Exception */
 VALUE eOCIException;
 VALUE eOCIBreak;

data/ext/oci8/extconf.rb

@@ -105,12 +105,18 @@ have_func("localtime_r")
 have_header("intern.h")
 have_header("util.h")
 # ruby 1.9 headers
+have_header("ruby/util.h")
 have_type('rb_encoding', ['ruby/ruby.h', 'ruby/encoding.h'])
 
 # $! in C API
 have_var("ruby_errinfo", "ruby.h") # ruby 1.8
 have_func("rb_errinfo", "ruby.h")  # ruby 1.9
 
+have_type("rb_blocking_function_t", "ruby.h")
+have_func("rb_set_end_proc", "ruby.h")
+have_func("rb_class_superclass", "ruby.h")
+have_func("rb_thread_blocking_region", "ruby.h")
+
 # replace files
 replace = {
   'OCI8_CLIENT_VERSION' => oraconf.version,
@@ -120,14 +126,22 @@ replace = {
 # make ruby script before running create_makefile.
 replace_keyword(File.dirname(__FILE__) + '/../../lib/oci8.rb.in', '../../lib/oci8.rb', replace)
 
+so_basename = 'oci8lib_'
+if defined? RUBY_ENGINE and RUBY_ENGINE != 'ruby'
+  so_basename += RUBY_ENGINE
+end
+
 # Config::CONFIG["ruby_version"] indicates the ruby API version.
 #  1.8   - ruby 1.8.x
 #  1.9.1 - ruby 1.9.1 and 1.9.2
 #  1.9.x - ruby 1.9.x future version which will break the API compatibility
-so_basename = "oci8lib_" + Config::CONFIG["ruby_version"].gsub(/\W/, '')
+so_basename += Config::CONFIG["ruby_version"].gsub(/\W/, '')
 
 $defs << "-DInit_oci8lib=Init_#{so_basename}"
 $defs << "-Doci8lib=#{so_basename}"
+if defined? RUBY_ENGINE and RUBY_ENGINE == 'rbx'
+  $defs << "-DCHAR_IS_NOT_A_SHORTCUT_TO_ID"
+end
 
 create_header()
 

data/ext/oci8/lob.c

@@ -64,15 +64,59 @@ VALUE oci8_make_bfile(oci8_svcctx_t *svcctx, OCILobLocator *s)
     return oci8_make_lob(cOCI8BFILE, svcctx, s);
 }
 
+static void oci8_assign_lob(VALUE klass, oci8_svcctx_t *svcctx, VALUE lob, OCILobLocator **dest)
+{
+    oci8_base_t *base = oci8_get_handle(lob, klass);
+    oci_lc(OCILobLocatorAssign_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, base->hp.lob, dest));
+}
+
+void oci8_assign_clob(oci8_svcctx_t *svcctx, VALUE lob, OCILobLocator **dest)
+{
+    oci8_assign_lob(cOCI8CLOB, svcctx, lob, dest);
+}
+
+void oci8_assign_nclob(oci8_svcctx_t *svcctx, VALUE lob, OCILobLocator **dest)
+{
+    oci8_assign_lob(cOCI8NCLOB, svcctx, lob, dest);
+}
+
+void oci8_assign_blob(oci8_svcctx_t *svcctx, VALUE lob, OCILobLocator **dest)
+{
+    oci8_assign_lob(cOCI8BLOB, svcctx, lob, dest);
+}
+
+void oci8_assign_bfile(oci8_svcctx_t *svcctx, VALUE lob, OCILobLocator **dest)
+{
+    oci8_assign_lob(cOCI8BFILE, svcctx, lob, dest);
+}
+
 static void oci8_lob_mark(oci8_base_t *base)
 {
     oci8_lob_t *lob = (oci8_lob_t *)base;
     rb_gc_mark(lob->svc);
 }
 
+static VALUE free_temp_lob(oci8_lob_t *lob)
+{
+    oci8_svcctx_t *svcctx = oci8_get_svcctx(lob->svc);
+
+    OCILobFreeTemporary_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, lob->base.hp.lob);
+    return Qnil;
+}
+
 static void oci8_lob_free(oci8_base_t *base)
 {
     oci8_lob_t *lob = (oci8_lob_t *)base;
+    boolean is_temporary;
+
+    if (have_OCILobIsTemporary
+        && OCILobIsTemporary(oci8_envhp, oci8_errhp, lob->base.hp.lob, &is_temporary) == OCI_SUCCESS
+        && is_temporary) {
+        /* Exceptions in free_temp_lob() are ignored.
+         * oci8_lob_free() is called in GC. It must not raise an exception.
+         */
+        rb_rescue(free_temp_lob, (VALUE)base, NULL, 0);
+    }
     lob->svc = Qnil;
 }
 

data/ext/oci8/metadata.c

@@ -38,7 +38,7 @@ VALUE oci8_metadata_create(OCIParam *parmhp, VALUE svc, VALUE parent)
     VALUE klass;
     VALUE obj;
 
-    Check_Handle(parent, oci8_cOCIHandle, p);
+    p = oci8_get_handle(parent, oci8_cOCIHandle);
 
     oci_lc(OCIAttrGet(parmhp, OCI_DTYPE_PARAM, &ptype, &size, OCI_ATTR_PTYPE, oci8_errhp));
     klass = rb_hash_aref(ptype_to_class, INT2FIX(ptype));

data/ext/oci8/object.c

@@ -42,6 +42,10 @@ enum {
     ATTR_BINARY_FLOAT,
     ATTR_NAMED_TYPE,
     ATTR_NAMED_COLLECTION,
+    ATTR_CLOB,
+    ATTR_NCLOB,
+    ATTR_BLOB,
+    ATTR_BFILE,
 };
 
 static VALUE get_attribute(VALUE self, VALUE datatype, VALUE typeinfo, void *data, OCIInd *ind);
@@ -198,6 +202,14 @@ static VALUE get_attribute(VALUE self, VALUE datatype, VALUE typeinfo, void *dat
         rv = rb_funcall(tmp_obj, id_to_value, 0);
         oci8_unlink_from_parent(&obj->base);
         return rv;
+    case ATTR_CLOB:
+        return oci8_make_clob(oci8_get_svcctx(typeinfo), *(OCILobLocator**)data);
+    case ATTR_NCLOB:
+        return oci8_make_nclob(oci8_get_svcctx(typeinfo), *(OCILobLocator**)data);
+    case ATTR_BLOB:
+        return oci8_make_blob(oci8_get_svcctx(typeinfo), *(OCILobLocator**)data);
+    case ATTR_BFILE:
+        return oci8_make_bfile(oci8_get_svcctx(typeinfo), *(OCILobLocator**)data);
     default:
         rb_raise(rb_eRuntimeError, "not supported datatype");
     }
@@ -248,6 +260,25 @@ static VALUE oci8_named_type_set_attribute(VALUE self, VALUE datatype, VALUE typ
     return Qnil;
 }
 
+static VALUE oci8_named_type_null_p(VALUE self)
+{
+    void *data;
+    OCIInd *ind;
+
+    oci8_named_type_check_offset(self, INT2FIX(0), INT2FIX(0), sizeof(void*), &data, &ind);
+    return *ind ? Qtrue : Qfalse;
+}
+
+static VALUE oci8_named_type_set_null(VALUE self, VALUE val)
+{
+    void *data;
+    OCIInd *ind;
+
+    oci8_named_type_check_offset(self, INT2FIX(0), INT2FIX(0), sizeof(void*), &data, &ind);
+    *ind = RTEST(val) ? -1 : 0;
+    return val;
+}
+
 typedef struct {
     VALUE self;
     VALUE datatype;
@@ -335,6 +366,11 @@ static VALUE oci8_named_coll_set_coll_element(VALUE self, VALUE datatype, VALUE
         oci_lc(OCIObjectNew(oci8_envhp, oci8_errhp, svcctx->hp.svc, OCI_TYPECODE_NAMEDCOLLECTION, tdo->hp.tdo, NULL, OCI_DURATION_SESSION, TRUE, &cb_data.data.ptr));
         oci_lc(OCIObjectGetInd(oci8_envhp, oci8_errhp, cb_data.data.ptr, (dvoid**)&cb_data.indp));
         break;
+    case ATTR_CLOB:
+    case ATTR_NCLOB:
+    case ATTR_BLOB:
+    case ATTR_BFILE:
+        rb_raise(rb_eRuntimeError, "Could not set LOB objects to collection types yet.");
     default:
         rb_raise(rb_eRuntimeError, "not supported datatype");
     }
@@ -482,6 +518,18 @@ static void set_attribute(VALUE self, VALUE datatype, VALUE typeinfo, void *data
         rb_funcall(tmp_obj, id_set_attributes, 1, val);
         oci8_unlink_from_parent(&obj->base);
         break;
+    case ATTR_CLOB:
+        oci8_assign_clob(oci8_get_svcctx(typeinfo), val, (OCILobLocator **)data);
+        break;
+    case ATTR_NCLOB:
+        oci8_assign_nclob(oci8_get_svcctx(typeinfo), val, (OCILobLocator **)data);
+        break;
+    case ATTR_BLOB:
+        oci8_assign_blob(oci8_get_svcctx(typeinfo), val, (OCILobLocator **)data);
+        break;
+    case ATTR_BFILE:
+        oci8_assign_bfile(oci8_get_svcctx(typeinfo), val, (OCILobLocator **)data);
+        break;
     default:
         rb_raise(rb_eRuntimeError, "not supported datatype");
     }
@@ -578,6 +626,7 @@ static void bind_named_type_init_elem(oci8_bind_t *obind, VALUE svc)
 
         oci_lc(OCIObjectNew(oci8_envhp, oci8_errhp, svcctx->base.hp.svc, tc, tdo->hp.tdo, NULL, OCI_DURATION_SESSION, TRUE, (dvoid**)obj->instancep));
         oci_lc(OCIObjectGetInd(oci8_envhp, oci8_errhp, (dvoid*)*obj->instancep, (dvoid**)obj->null_structp));
+        *(OCIInd*)*obj->null_structp = -1;
     } while (++idx < obind->maxar_sz);
 }
 
@@ -615,6 +664,10 @@ void Init_oci_object(VALUE cOCI8)
     rb_define_const(cOCI8TDO, "ATTR_BINARY_FLOAT", INT2FIX(ATTR_BINARY_FLOAT));
     rb_define_const(cOCI8TDO, "ATTR_NAMED_TYPE", INT2FIX(ATTR_NAMED_TYPE));
     rb_define_const(cOCI8TDO, "ATTR_NAMED_COLLECTION", INT2FIX(ATTR_NAMED_COLLECTION));
+    rb_define_const(cOCI8TDO, "ATTR_CLOB", INT2FIX(ATTR_CLOB));
+    rb_define_const(cOCI8TDO, "ATTR_NCLOB", INT2FIX(ATTR_NCLOB));
+    rb_define_const(cOCI8TDO, "ATTR_BLOB", INT2FIX(ATTR_BLOB));
+    rb_define_const(cOCI8TDO, "ATTR_BFILE", INT2FIX(ATTR_BFILE));
 #define ALIGNMENT_OF(type) (size_t)&(((struct {char c; type t;}*)0)->t)
     rb_define_const(cOCI8TDO, "SIZE_OF_POINTER", INT2FIX(sizeof(void *)));
     rb_define_const(cOCI8TDO, "ALIGNMENT_OF_POINTER", INT2FIX(ALIGNMENT_OF(void *)));
@@ -633,6 +686,8 @@ void Init_oci_object(VALUE cOCI8)
     rb_define_method(cOCI8NamedType, "tdo", oci8_named_type_tdo, 0);
     rb_define_private_method(cOCI8NamedType, "get_attribute", oci8_named_type_get_attribute, 4);
     rb_define_private_method(cOCI8NamedType, "set_attribute", oci8_named_type_set_attribute, 5);
+    rb_define_method(cOCI8NamedType, "null?", oci8_named_type_null_p, 0);
+    rb_define_method(cOCI8NamedType, "null=", oci8_named_type_set_null, 1);
 
     /* OCI8::NamedCollection */
     cOCI8NamedCollection = oci8_define_class_under(cOCI8, "NamedCollection", &oci8_named_type_class);