ruby-oci8 2.2.0.2 → 2.2.12

data/ext/oci8/plthook_osx.c

@@ -73,10 +73,10 @@ struct plthook {
 };
 
 static int plthook_open_real(plthook_t **plthook_out, const struct mach_header *mh);
-static unsigned int get_bind_addr(plthook_t *plthook, const uint8_t *base, uint32_t lazy_bind_off, uint32_t lazy_bind_size, struct segment_command_ **segments, int addrdiff);
+static unsigned int get_bind_addr(plthook_t *plthook, const uint8_t *base, uint32_t lazy_bind_off, uint32_t lazy_bind_size, struct segment_command_ **segments, ptrdiff_t addrdiff);
 
 static void set_errmsg(const char *fmt, ...) __attribute__((__format__ (__printf__, 1, 2)));
-static void set_bind_addr(unsigned int *idx, plthook_t *plthook, const uint8_t *base, const char *sym_name, int seg_index, int seg_offset, struct segment_command_ **segments);
+static void set_bind_addr(unsigned int *idx, plthook_t *plthook, const uint8_t *base, const char *sym_name, int seg_index, uint64_t seg_offset, struct segment_command_ **segments);
 
 static uint64_t uleb128(const uint8_t **p)
 {
@@ -142,6 +142,37 @@ int plthook_open(plthook_t **plthook_out, const char *filename)
     return plthook_open_real(plthook_out, _dyld_get_image_header(idx));
 }
 
+int plthook_open_by_handle(plthook_t **plthook_out, void *hndl)
+{
+    int flags[] = {
+        RTLD_LAZY | RTLD_NOLOAD,
+        RTLD_LAZY | RTLD_NOLOAD | RTLD_FIRST,
+    };
+    size_t flag_idx;
+#define NUM_FLAGS (sizeof(flags) / sizeof(flags[0]))
+
+    if (hndl == NULL) {
+        set_errmsg("NULL handle");
+        return PLTHOOK_FILE_NOT_FOUND;
+    }
+    for (flag_idx = 0; flag_idx < NUM_FLAGS; flag_idx++) {
+        const char *image_name = NULL;
+        uint32_t idx = 0;
+
+        do {
+            void *handle = dlopen(image_name, flags[flag_idx]);
+            if (handle != NULL) {
+                dlclose(handle);
+                if (handle == hndl) {
+                    return plthook_open_real(plthook_out, _dyld_get_image_header(idx));
+                }
+            }
+        } while ((image_name = _dyld_get_image_name(++idx)) != NULL);
+    }
+    set_errmsg("Cannot find the image correspond to handle %p", hndl);
+    return PLTHOOK_FILE_NOT_FOUND;
+}
+
 int plthook_open_by_address(plthook_t **plthook_out, void *address)
 {
     Dl_info dlinfo;
@@ -165,8 +196,8 @@ static int plthook_open_real(plthook_t **plthook_out, const struct mach_header *
     struct segment_command_ *segments[NUM_SEGMENTS];
     int segment_idx = 0;
     unsigned int nbind;
-    int addrdiff = 0;
-    int i;
+    ptrdiff_t addrdiff = 0;
+    uint32_t i;
 
     memset(segments, 0, sizeof(segments));
 #ifdef __LP64__
@@ -289,14 +320,14 @@ static int plthook_open_real(plthook_t **plthook_out, const struct mach_header *
     return 0;
 }
 
-static unsigned int get_bind_addr(plthook_t *plthook, const uint8_t *base, uint32_t lazy_bind_off, uint32_t lazy_bind_size, struct segment_command_ **segments, int addrdiff)
+static unsigned int get_bind_addr(plthook_t *plthook, const uint8_t *base, uint32_t lazy_bind_off, uint32_t lazy_bind_size, struct segment_command_ **segments, ptrdiff_t addrdiff)
 {
     const uint8_t *ptr = base + lazy_bind_off + addrdiff;
     const uint8_t *end = ptr + lazy_bind_size;
     const char *sym_name;
     int seg_index = 0;
     uint64_t seg_offset = 0;
-    int count, skip;
+    uint64_t count, skip;
     unsigned int idx;
     DEBUG_BIND("get_bind_addr(%p, 0x%x, 0x%x", base, lazy_bind_off, lazy_bind_size);
     for (idx = 0; segments[idx] != NULL; idx++) {
@@ -310,7 +341,7 @@ static unsigned int get_bind_addr(plthook_t *plthook, const uint8_t *base, uint3
         uint8_t imm = *ptr & BIND_IMMEDIATE_MASK;
         uint64_t ulebval;
         int64_t slebval;
-        int i;
+        uint64_t i;
 
         DEBUG_BIND("0x%02x: ", *ptr);
         ptr++;
@@ -379,10 +410,10 @@ static unsigned int get_bind_addr(plthook_t *plthook, const uint8_t *base, uint3
     return idx;
 }
 
-static void set_bind_addr(unsigned int *idx, plthook_t *plthook, const uint8_t *base, const char *sym_name, int seg_index, int seg_offset, struct segment_command_ **segments)
+static void set_bind_addr(unsigned int *idx, plthook_t *plthook, const uint8_t *base, const char *sym_name, int seg_index, uint64_t seg_offset, struct segment_command_ **segments)
 {
     if (plthook != NULL) {
-        uint32_t vmaddr = segments[seg_index]->vmaddr;
+        uint64_t vmaddr = segments[seg_index]->vmaddr;
         plthook->entries[*idx].name = sym_name;
         plthook->entries[*idx].addr = (void**)(base + vmaddr + seg_offset);
     }

data/ext/oci8/plthook_win32.c

@@ -51,12 +51,18 @@
 #define __attribute__(arg)
 #endif
 
-#ifdef _WIN64
+#if defined _LP64 /* data model: I32/LP64 */
+#define SIZE_T_FMT "lu"
+#elif defined _WIN64  /* data model: IL32/P64 */
 #define SIZE_T_FMT "I64u"
 #else
 #define SIZE_T_FMT "u"
 #endif
 
+#ifdef __CYGWIN__
+#define stricmp strcasecmp
+#endif
+
 typedef struct {
     const char *mod_name;
     const char *name;
@@ -87,6 +93,15 @@ int plthook_open(plthook_t **plthook_out, const char *filename)
     return plthook_open_real(plthook_out, hMod);
 }
 
+int plthook_open_by_handle(plthook_t **plthook_out, void *hndl)
+{
+    if (hndl == NULL) {
+        set_errmsg("NULL handle");
+        return PLTHOOK_FILE_NOT_FOUND;
+    }
+    return plthook_open_real(plthook_out, (HMODULE)hndl);
+}
+
 int plthook_open_by_address(plthook_t **plthook_out, void *address)
 {
     HMODULE hMod;

data/ext/oci8/stmt.c

@@ -15,7 +15,8 @@ static VALUE cOCIStmt;
 typedef struct {
     oci8_base_t base;
     VALUE svc;
-    int use_stmt_release;
+    char use_stmt_release;
+    char end_of_fetch;
 } oci8_stmt_t;
 
 static void oci8_stmt_mark(oci8_base_t *base)
@@ -77,7 +78,7 @@ static VALUE oci8_stmt_initialize(VALUE self, VALUE svc, VALUE sql)
     if (!NIL_P(sql)) {
         OCI8SafeStringValue(sql);
 
-        rv = OCIStmtPrepare2(svcctx->base.hp.svc, &stmt->base.hp.stmt, oci8_errhp, RSTRING_ORATEXT(sql), RSTRING_LEN(sql), NULL, 0, OCI_NTV_SYNTAX, OCI_DEFAULT);
+        rv = OCIStmtPrepare2(svcctx->base.hp.svc, &stmt->base.hp.stmt, oci8_errhp, RSTRING_ORATEXT(sql), RSTRING_LENINT(sql), NULL, 0, OCI_NTV_SYNTAX, OCI_DEFAULT);
         if (IS_OCI_ERROR(rv)) {
             chker2(rv, &svcctx->base);
         }
@@ -111,12 +112,24 @@ static VALUE oci8_define_by_pos(VALUE self, VALUE vposition, VALUE vbindobj)
     oci8_bind_t *obind = TO_BIND(vbindobj);
     const oci8_bind_data_type_t *data_type;
     sword status;
+    void *valuep;
+    void *indp;
+    ub4 mode;
 
     if (obind->base.hp.dfn != NULL) {
         oci8_base_free(&obind->base); /* TODO: OK? */
     }
     data_type = (const oci8_bind_data_type_t *)obind->base.data_type;
-    status = OCIDefineByPos(stmt->base.hp.stmt, &obind->base.hp.dfn, oci8_errhp, position, obind->valuep, obind->value_sz, data_type->dty, NIL_P(obind->tdo) ? obind->u.inds : NULL, NULL, 0, OCI_DEFAULT);
+    if (obind->value_sz != SB4MAXVAL) {
+        valuep = obind->valuep;
+        indp = NIL_P(obind->tdo) ? obind->u.inds : NULL;
+        mode = OCI_DEFAULT;
+    } else {
+        valuep = NULL;
+        indp = NULL;
+        mode = OCI_DYNAMIC_FETCH;
+    }
+    status = OCIDefineByPos(stmt->base.hp.stmt, &obind->base.hp.dfn, oci8_errhp, position, valuep, obind->value_sz, data_type->dty, indp, NULL, 0, mode);
     if (status != OCI_SUCCESS) {
         chker3(status, &stmt->base, stmt->base.hp.ptr);
     }
@@ -151,7 +164,9 @@ static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
     oci8_bind_t *obind;
     const oci8_bind_data_type_t *data_type;
     sword status;
+    void *valuep;
     void *indp;
+    ub4 mode;
 
     if (NIL_P(vplaceholder)) { /* 1 */
         placeholder_ptr = NULL;
@@ -163,10 +178,10 @@ static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
          */
         VALUE symval = rb_sym2str(vplaceholder);
         const char *symname = RSTRING_PTR(symval);
-        size_t len = RSTRING_LEN(symval);
+        ub4 len = RSTRING_LENINT(symval);
 #else
         const char *symname = rb_id2name(SYM2ID(vplaceholder));
-        size_t len = strlen(symname);
+        ub4 len = (ub4)strlen(symname);
 #endif
         placeholder_ptr = ALLOCA_N(char, len + 1);
         placeholder_len = len + 1;
@@ -177,7 +192,7 @@ static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
     } else {
         OCI8StringValue(vplaceholder);
         placeholder_ptr = RSTRING_PTR(vplaceholder);
-        placeholder_len = RSTRING_LEN(vplaceholder);
+        placeholder_len = RSTRING_LENINT(vplaceholder);
     }
     obind = TO_BIND(vbindobj); /* 2 */
     if (obind->base.hp.bnd != NULL) {
@@ -185,11 +200,19 @@ static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
     }
     data_type = (const oci8_bind_data_type_t *)obind->base.data_type;
 
-    indp = NIL_P(obind->tdo) ? obind->u.inds : NULL;
+    if (obind->value_sz != SB4MAXVAL) {
+        valuep = obind->valuep;
+        indp = NIL_P(obind->tdo) ? obind->u.inds : NULL;
+        mode = OCI_DEFAULT;
+    } else {
+        valuep = NULL;
+        indp = NULL;
+        mode = OCI_DATA_AT_EXEC;
+    }
     if (placeholder_ptr == (char*)-1) {
-        status = OCIBindByPos(stmt->base.hp.stmt, &obind->base.hp.bnd, oci8_errhp, position, obind->valuep, obind->value_sz, data_type->dty, indp, NULL, 0, 0, 0, OCI_DEFAULT);
+        status = OCIBindByPos(stmt->base.hp.stmt, &obind->base.hp.bnd, oci8_errhp, position, valuep, obind->value_sz, data_type->dty, indp, NULL, 0, 0, 0, mode);
     } else {
-        status = OCIBindByName(stmt->base.hp.stmt, &obind->base.hp.bnd, oci8_errhp, TO_ORATEXT(placeholder_ptr), placeholder_len, obind->valuep, obind->value_sz, data_type->dty, indp, NULL, 0, 0, 0, OCI_DEFAULT);
+        status = OCIBindByName(stmt->base.hp.stmt, &obind->base.hp.bnd, oci8_errhp, TO_ORATEXT(placeholder_ptr), placeholder_len, valuep, obind->value_sz, data_type->dty, indp, NULL, 0, 0, 0, mode);
     }
     if (status != OCI_SUCCESS) {
         chker3(status, &stmt->base, stmt->base.hp.stmt);
@@ -238,6 +261,7 @@ static VALUE oci8_stmt_execute(VALUE self, VALUE iteration_count)
     oci8_stmt_t *stmt = TO_STMT(self);
     oci8_svcctx_t *svcctx = oci8_get_svcctx(stmt->svc);
 
+    stmt->end_of_fetch = 0;
     chker3(oci8_call_stmt_execute(svcctx, stmt, NUM2UINT(iteration_count),
                                   svcctx->is_autocommit ? OCI_COMMIT_ON_SUCCESS : OCI_DEFAULT),
            &stmt->base, stmt->base.hp.stmt);
@@ -245,7 +269,7 @@ static VALUE oci8_stmt_execute(VALUE self, VALUE iteration_count)
 }
 
 /*
- * @overload __fetch(connection)
+ * @overload __fetch(connection, max_rows)
  *
  *  Fetches one row and set the result to <code>@define_handles</code>.
  *  This is called by private methods of OCI8::Cursor.
@@ -255,13 +279,18 @@ static VALUE oci8_stmt_execute(VALUE self, VALUE iteration_count)
  *
  *  @private
  */
-static VALUE oci8_stmt_fetch(VALUE self, VALUE svc)
+static VALUE oci8_stmt_fetch(VALUE self, VALUE svc, VALUE max_rows)
 {
     oci8_stmt_t *stmt = TO_STMT(self);
     oci8_svcctx_t *svcctx = oci8_get_svcctx(svc);
     sword rv;
     oci8_bind_t *obind;
     const oci8_bind_data_type_t *data_type;
+    ub4 nrows = NUM2UINT(max_rows);
+
+    if (stmt->end_of_fetch) {
+        return Qnil;
+    }
 
     if (stmt->base.children != NULL) {
         obind = (oci8_bind_t *)stmt->base.children;
@@ -271,16 +300,22 @@ static VALUE oci8_stmt_fetch(VALUE self, VALUE svc)
                 if (data_type->pre_fetch_hook != NULL) {
                     data_type->pre_fetch_hook(obind, stmt->svc);
                 }
+                if (nrows > 1 && nrows != obind->maxar_sz) {
+                    rb_raise(rb_eRuntimeError, "fetch size (%u) != define-handle size %u", nrows, obind->maxar_sz);
+                }
             }
             obind = (oci8_bind_t *)obind->base.next;
         } while (obind != (oci8_bind_t*)stmt->base.children);
     }
-    rv = OCIStmtFetch_nb(svcctx, stmt->base.hp.stmt, oci8_errhp, 1, OCI_FETCH_NEXT, OCI_DEFAULT);
+    rv = OCIStmtFetch_nb(svcctx, stmt->base.hp.stmt, oci8_errhp, nrows, OCI_FETCH_NEXT, OCI_DEFAULT);
     if (rv == OCI_NO_DATA) {
-        return Qfalse;
+        stmt->end_of_fetch = 1;
+    } else {
+        chker3(rv, &svcctx->base, stmt->base.hp.stmt);
     }
-    chker3(rv, &svcctx->base, stmt->base.hp.stmt);
-    return Qtrue;
+    chker2(OCIAttrGet(stmt->base.hp.stmt, OCI_HTYPE_STMT, &nrows, 0, OCI_ATTR_ROWS_FETCHED, oci8_errhp),
+           &svcctx->base);
+    return nrows ? UINT2NUM(nrows) : Qnil;
 }
 
 /*
@@ -288,7 +323,7 @@ static VALUE oci8_stmt_fetch(VALUE self, VALUE svc)
  *
  *  Returns the definition of column specified by <i>pos</i>
  *
- *  @param [Fixnum] pos Column position which starts from one
+ *  @param [Integer] pos Column position which starts from one
  *  @return [OCI8::Metadata::Base]
  *
  *  @private
@@ -405,7 +440,7 @@ void Init_oci8_stmt(VALUE cOCI8)
     rb_define_private_method(cOCIStmt, "__define", oci8_define_by_pos, 2);
     rb_define_private_method(cOCIStmt, "__bind", oci8_bind, 2);
     rb_define_private_method(cOCIStmt, "__execute", oci8_stmt_execute, 1);
-    rb_define_private_method(cOCIStmt, "__fetch", oci8_stmt_fetch, 1);
+    rb_define_private_method(cOCIStmt, "__fetch", oci8_stmt_fetch, 2);
     rb_define_private_method(cOCIStmt, "__paramGet", oci8_stmt_get_param, 1);
     rb_define_method(cOCIStmt, "rowid", oci8_stmt_get_rowid, 0);
 

data/ext/oci8/win32.c

@@ -21,33 +21,14 @@
  *  @private
  */
 
-NORETURN(static void raise_error(void));
-
-static void raise_error(void)
-{
-    char msg[1024];
-    int err = GetLastError();
-    char *p;
-
-    sprintf(msg, "%d: ", err);
-    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-                  NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                  msg + strlen(msg), sizeof(msg) - strlen(msg), NULL);
-    for (p = msg; *p != '\0'; p++) {
-        if (*p == '\n' || *p == '\r') {
-            *p = ' ';
-        }
-    }
-    rb_raise(rb_eRuntimeError, "%s", msg);
-}
-
 typedef struct {
     HKEY hKey;
     HKEY hSubKey;
 } enum_homes_arg_t;
 
-static VALUE enum_homes_real(enum_homes_arg_t *arg)
+static VALUE enum_homes_real(VALUE varg)
 {
+    enum_homes_arg_t *arg = (enum_homes_arg_t *)varg;
     LONG rv;
     DWORD type;
     DWORD idx;
@@ -97,8 +78,9 @@ static VALUE enum_homes_real(enum_homes_arg_t *arg)
     return Qnil;
 }
 
-static VALUE enum_homes_ensure(enum_homes_arg_t *arg)
+static VALUE enum_homes_ensure(VALUE varg)
 {
+    enum_homes_arg_t *arg = (enum_homes_arg_t *)varg;
     if (arg->hKey != NULL) {
         RegCloseKey(arg->hKey);
         arg->hKey = NULL;

data/lib/oci8/bindtype.rb

@@ -49,7 +49,7 @@ class OCI8
 
     class BasicNumberType < OCI8::BindType::OraNumber
       def get()
-        (val = super()) && (val.has_decimal_part? ? val.to_f : val.to_i)
+        (val = super()) && (val.has_fractional_part? ? val.to_f : val.to_i)
       end
     end
 
@@ -172,20 +172,6 @@ class OCI8
       end
     end
 
-    class Long < OCI8::BindType::String
-      def self.create(con, val, param, max_array_size)
-        param = {:length => con.long_read_len, :char_semantics => true}
-        super(con, val, param, max_array_size)
-      end
-    end
-
-    class LongRaw < OCI8::BindType::RAW
-      def self.create(con, val, param, max_array_size)
-        param = {:length => con.long_read_len, :char_semantics => false}
-        self.new(con, val, param, max_array_size)
-      end
-    end
-
     class CLOB
       def self.create(con, val, param, max_array_size)
         if param.is_a? OCI8::Metadata::Base and param.charset_form == :nchar
@@ -203,10 +189,13 @@ OCI8::BindType::Mapping[String]       = OCI8::BindType::String
 OCI8::BindType::Mapping[OraNumber]    = OCI8::BindType::OraNumber
 OCI8::BindType::Mapping['BigDecimal'] = OCI8::BindType::BigDecimal
 OCI8::BindType::Mapping['Rational']   = OCI8::BindType::Rational
-OCI8::BindType::Mapping[Fixnum]       = OCI8::BindType::Integer
 OCI8::BindType::Mapping[Float]        = OCI8::BindType::Float
 OCI8::BindType::Mapping[Integer]      = OCI8::BindType::Integer
-OCI8::BindType::Mapping[Bignum]       = OCI8::BindType::Integer
+unless 0.class == Integer
+  # ruby before integer unification
+  OCI8::BindType::Mapping[Fixnum]     = OCI8::BindType::Integer
+  OCI8::BindType::Mapping[Bignum]     = OCI8::BindType::Integer
+end
 OCI8::BindType::Mapping[OraDate]      = OCI8::BindType::OraDate
 OCI8::BindType::Mapping[Time]         = OCI8::BindType::Time
 OCI8::BindType::Mapping[Date]         = OCI8::BindType::Date
@@ -216,6 +205,10 @@ OCI8::BindType::Mapping[OCI8::NCLOB]  = OCI8::BindType::NCLOB
 OCI8::BindType::Mapping[OCI8::BLOB]   = OCI8::BindType::BLOB
 OCI8::BindType::Mapping[OCI8::BFILE]  = OCI8::BindType::BFILE
 OCI8::BindType::Mapping[OCI8::Cursor] = OCI8::BindType::Cursor
+if defined? OCI8::BindType::Boolean
+  OCI8::BindType::Mapping[TrueClass] = OCI8::BindType::Boolean
+  OCI8::BindType::Mapping[FalseClass] = OCI8::BindType::Boolean
+end
 
 # implicitly define
 

data/lib/oci8/check_load_error.rb

@@ -4,32 +4,79 @@ class OCI8
   module Util
 
     case RUBY_PLATFORM
-    when /mswin32|cygwin|mingw32|bccwin32/
+    when /mswin32|cygwin|mingw/
+
+      require 'fiddle/import'
+      require 'fiddle/types'
+
+      extend Fiddle::Importer
+      dlload 'kernel32.dll'
+      include Fiddle::BasicTypes
+      include Fiddle::Win32Types
+
+      typealias "HANDLE", "void*"
+      typealias "HMODULE", "void*"
+      extern "DWORD GetModuleFileNameA(HMODULE, LPSTR, DWORD)"
+      extern "UINT GetSystemDirectoryA(LPCSTR, UINT)"
+      extern "UINT GetWindowsDirectoryA(LPCSTR, UINT)"
+      extern "HMODULE LoadLibraryExA(LPCSTR, HANDLE, DWORD)"
+      extern "BOOL FreeLibrary(HMODULE)"
 
-      require 'Win32API'
       MAX_PATH = 260
-      GetModuleFileNameA = Win32API.new('kernel32', 'GetModuleFileNameA', 'PPL', 'L')
-      GetSystemDirectoryA = Win32API.new('kernel32', 'GetSystemDirectoryA', 'PL', 'L')
-      GetWindowsDirectoryA = Win32API.new('kernel32', 'GetWindowsDirectoryA', 'PL', 'L')
+      DONT_RESOLVE_DLL_REFERENCES = 0x00000001
 
       def self.check_os_specific_load_error(exc)
         case exc.message
-        when /^193: / # "193: %1 is not a valid Win32 application." in English
+        when /^OCI\.DLL: 193\(/, /^193: / # "OCI.DLL: 193(%1 is not a valid Win32 application.)" in English
           check_win32_pe_arch(exc.message.split(' - ')[1], "ruby-oci8")
           dll_load_path_list.each do |path|
             check_win32_pe_arch(File.join(path, '\OCI.DLL'), "Oracle client")
           end
+        when /^OCI.DLL: 126\(/, /^126: / # "OCI.DLL: 126(The specified module could not be found.)" in English
+          oci_dll_files = dll_load_path_list.inject([]) do |files, path|
+            file = File.join(path, '\OCI.DLL')
+            files << file if File.exist?(file)
+            files
+          end
+          if oci_dll_files.empty?
+            raise LoadError, "Cannot find OCI.DLL in PATH."
+          end
+          if oci_dll_files.none? {|file| open(file, 'rb') {true} rescue false}
+            raise LoadError, "OCI.DLL in PATH isn't readable."
+          end
+          first_error = nil
+          oci_dll_files.each do |file|
+            begin
+              check_win32_pe_arch(file, "Oracle client")
+              valid_arch = true
+            rescue LoadError
+              first_error ||= $!
+              valid_arch = false
+            end
+            if valid_arch
+              handle = LoadLibraryExA(file, nil, DONT_RESOLVE_DLL_REFERENCES)
+              unless handle.null?
+                FreeLibrary(handle)
+                raise LoadError, <<EOS
+Cannot find DLLs depended by #{file}.
+See http://www.rubydoc.info/github/kubo/ruby-oci8/file/docs/install-instant-client.md#Windows
+EOS
+              end
+              break
+            end
+          end
+          raise first_error if first_error
         end
       end # self.check_os_specific_load_error
 
       def self.dll_load_path_list
         buf = "\0" * MAX_PATH
         paths = []
-        paths << buf[0, GetModuleFileNameA.call(nil, buf, MAX_PATH)].force_encoding("locale").gsub(/\\[^\\]*$/, '')
-        paths << buf[0, GetSystemDirectoryA.call(buf, MAX_PATH)].force_encoding("locale")
-        paths << buf[0, GetWindowsDirectoryA.call(buf, MAX_PATH)].force_encoding("locale")
+        paths << buf[0, GetModuleFileNameA(nil, buf, MAX_PATH)].force_encoding("locale").gsub(/\\[^\\]*$/, '')
+        paths << buf[0, GetSystemDirectoryA(buf, MAX_PATH)].force_encoding("locale")
+        paths << buf[0, GetWindowsDirectoryA(buf, MAX_PATH)].force_encoding("locale")
         paths << "."
-        paths + ENV['PATH'].split(';')
+        paths + (ENV['PATH'].split(';').reject {|path| path.empty?})
       end # self.dll_load_path_list
 
       def self.check_win32_pe_arch(filename, package)

data/lib/oci8/compat.rb

@@ -70,7 +70,7 @@ class OCI8
   constants.each do |name|
     next if name.to_s.index("SQLT_") != 0
     val = const_get name.intern
-    if val.is_a? Fixnum
+    if val.is_a? Integer
       SQLT_NAMES[val] = name
     end
   end
@@ -79,6 +79,10 @@ class OCI8
   alias autocommit autocommit?
 
   class Cursor
+    # @!visibility private
+    # dirty hack to suppress "warning: constant ::Fixnum is deprecated"
+    Fixnum = (0.class == ::Integer) ? ::Integer : ::Fixnum
+
     def self.select_number_as=(val)
       if val == Fixnum
         @@bind_unknown_number = OCI8::BindType::Fixnum

data/lib/oci8/connection_pool.rb

@@ -13,17 +13,88 @@ class OCI8
   #
   # This is equivalent to Oracle JDBC Driver {OCI Connection Pooling}[http://docs.oracle.com/cd/E11882_01/java.112/e16548/ociconpl.htm#JJDBC28789].
   #
-  # Usage:
+  # Note that this is different with generally called connection pooling.
+  # Generally connection pooling caches connections in a pool.
+  # When an application needs a new connection, a connection is got from
+  # the pool. So that the amount of time to establish a connection is
+  # reduced. However connection pooling in ruby-oci8 is different with
+  # above.
+  #
+  # One Oracle connection is devided into two layers: One is physical
+  # connection such as TCP/IP. The other is logical connection which
+  # is used by an application. The connection pooling in ruby-oci8
+  # caches physical connections in a pool, not logical connections.
+  # When an application needs a new connection, a logical connection
+  # is created via a physical connection, which needs time to
+  # establish a connection unlike generally called connection pooling.
+  # When an application sends a query via a logical connection, a
+  # physical connection is got from the pool. The physical connection
+  # returns to the pool automatically when the query finishes.
+  # As long as logical connections are used sequentially, only one
+  # physical connection is used. When an application sends
+  # queries at a time, it needs more than one physical connection
+  # because one physical connection cannot transmit more then one
+  # query at a time.
+  #
+  # Example:
   #   # Create a connection pool.
+  #   # The number of initial physical connections: 1
+  #   # The number of maximum physical connections: 5
+  #   # the connection increment parameter: 2
   #   # username and password are required to establish an implicit primary session.
   #   cpool = OCI8::ConnectionPool.new(1, 5, 2, username, password, database)
   #   
-  #   # Get a session from the pool.
+  #   #   The number of physical connections: 1
+  #   #   The number of logical connections: 0
+  #   
+  #   # Create a session.
   #   # Pass the connection pool to the third argument.
   #   conn1 = OCI8.new(username, password, cpool)
   #   
-  #   # Get another session.
+  #   # One logical connection was created.
+  #   #   The number of physical connections: 1
+  #   #   The number of logical connections: 1
+  #   
+  #   # Create another session.
   #   conn2 = OCI8.new(username, password, cpool)
+  #   
+  #   # Another logical connection was created.
+  #   #   The number of physical connections: 1
+  #   #   The number of logical connections: 2
+  #   
+  #   # Use conn1 and conn2 sequentially
+  #   conn1.exec('...')
+  #   conn2.exec('...')
+  #   
+  #   # Both logical connections use one physical connection.
+  #   #   The number of physical connections: 1
+  #   #   The number of logical connections: 2
+  #   
+  #   thr1 = Thread.new do
+  #      conn1.exec('...')
+  #   end
+  #   thr2 = Thread.new do
+  #      conn2.exec('...')
+  #   end
+  #   thr1.join
+  #   thr2.join
+  #   
+  #   # Logical connections cannot use one physical connection at a time.
+  #   # So that the number of physical connections is incremented.
+  #   #   The number of physical connections: 3
+  #   #   The number of logical connections: 2
+  #   
+  #   conn1.logoff
+  #
+  #   # One logical connection was closed.
+  #   #   The number of physical connections: 3
+  #   #   The number of logical connections: 1
+  #   
+  #   conn2.logoff
+  #   
+  #   # All logical connections were closed.
+  #   #   The number of physical connections: 3
+  #   #   The number of logical connections: 0
   #
   class ConnectionPool