ruby-oci8 2.2.4.1 → 2.2.11

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)
 {
@@ -148,7 +148,7 @@ int plthook_open_by_handle(plthook_t **plthook_out, void *hndl)
         RTLD_LAZY | RTLD_NOLOAD,
         RTLD_LAZY | RTLD_NOLOAD | RTLD_FIRST,
     };
-    int flag_idx;
+    size_t flag_idx;
 #define NUM_FLAGS (sizeof(flags) / sizeof(flags[0]))
 
     if (hndl == NULL) {
@@ -196,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__
@@ -320,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++) {
@@ -341,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++;
@@ -410,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/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;
 }
 
 /*
@@ -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

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/cursor.rb

@@ -25,7 +25,11 @@ class OCI8
       @names = nil
       @con = conn
       @max_array_size = nil
+      @fetch_array_size = nil
+      @rowbuf_size = 0
+      @rowbuf_index = 0
       __initialize(conn, sql) # Initialize the internal C structure.
+      self.prefetch_rows = conn.instance_variable_get(:@prefetch_rows)
     end
 
     # explicitly indicate the date type of fetched value. run this
@@ -38,7 +42,7 @@ class OCI8
     #   cursor.define(2, Time)       # fetch the second column as Time.
     #   cursor.exec()
     def define(pos, type, length = nil)
-      bindobj = make_bind_object(:type => type, :length => length)
+      bindobj = make_bind_object({:type => type, :length => length}, @fetch_array_size || 1)
       __define(pos, bindobj)
       if old = @define_handles[pos - 1]
         old.send(:free)
@@ -125,7 +129,10 @@ class OCI8
       case type
       when :select_stmt
         __execute(0)
-        define_columns()
+        define_columns() if @column_metadata.size == 0
+        @rowbuf_size = 0
+        @rowbuf_index = 0
+        @column_metadata.size
       else
         __execute(1)
         row_count
@@ -383,6 +390,7 @@ class OCI8
     # @param [Integer] rows The number of rows to be prefetched
     def prefetch_rows=(rows)
       attr_set_ub4(11, rows) # OCI_ATTR_PREFETCH_ROWS(11)
+      @prefetch_rows = rows
     end
 
     if OCI8::oracle_client_version >= ORAVER_12_1
@@ -467,7 +475,7 @@ class OCI8
 
     private
 
-    def make_bind_object(param)
+    def make_bind_object(param, fetch_array_size = nil)
       case param
       when Hash
         key = param[:type]
@@ -509,26 +517,38 @@ class OCI8
         OCI8::BindType::Mapping[key] = bindclass if bindclass
       end
       raise "unsupported datatype: #{key}" if bindclass.nil?
-      bindclass.create(@con, val, param, max_array_size)
+      bindclass.create(@con, val, param, fetch_array_size || max_array_size)
     end
 
+    @@use_array_fetch = false
+
     def define_columns
       # http://docs.oracle.com/cd/E11882_01/appdev.112/e10646/ociaahan.htm#sthref5494
       num_cols = attr_get_ub4(18) # OCI_ATTR_PARAM_COUNT(18)
-      1.upto(num_cols) do |i|
-        parm = __paramGet(i)
-        define_one_column(i, parm) unless @define_handles[i - 1]
-        @column_metadata[i - 1] = parm
+      @column_metadata = 1.upto(num_cols).collect do |i|
+        __paramGet(i)
+      end
+      if @define_handles.size == 0
+        use_array_fetch = @@use_array_fetch
+        @column_metadata.each do |md|
+          case md.data_type
+          when :clob, :blob, :bfile
+            # Rows prefetching doesn't work for CLOB, BLOB and BFILE.
+            # Use array fetching to get more than one row in a network round trip.
+            use_array_fetch = true
+          end
+        end
+        @fetch_array_size = @prefetch_rows if use_array_fetch
+      end
+      @column_metadata.each_with_index do |md, i|
+        define_one_column(i + 1, md) unless @define_handles[i]
       end
       num_cols
     end
 
     def define_one_column(pos, param)
-      bindobj = make_bind_object(param)
+      bindobj = make_bind_object(param, @fetch_array_size || 1)
       __define(pos, bindobj)
-      if old = @define_handles[pos - 1]
-        old.send(:free)
-      end
       @define_handles[pos - 1] = bindobj
     end
 
@@ -542,22 +562,33 @@ class OCI8
       end
     end
 
+    def fetch_row_internal
+      if @rowbuf_size && @rowbuf_size == @rowbuf_index
+        @rowbuf_size = __fetch(@con, @fetch_array_size || 1)
+        @rowbuf_index = 0
+      end
+      @rowbuf_size
+    end
+
     def fetch_one_row_as_array
-      if __fetch(@con)
-        @define_handles.collect do |handle|
-          handle.send(:get_data)
+      if fetch_row_internal
+        ret = @define_handles.collect do |handle|
+          handle.send(:get_data, @rowbuf_index)
         end
+        @rowbuf_index += 1
+        ret
       else
         nil
       end
     end
 
     def fetch_one_row_as_hash
-      if __fetch(@con)
+      if fetch_row_internal
         ret = {}
         get_col_names.each_with_index do |name, idx|
-          ret[name] = @define_handles[idx].send(:get_data)
+          ret[name] = @define_handles[idx].send(:get_data, @rowbuf_index)
         end
+        @rowbuf_index += 1
         ret
       else
         nil

data/lib/oci8/metadata.rb

@@ -1503,7 +1503,11 @@ class OCI8
         attr_get_sb1(OCI_ATTR_SCALE)
       end
 
-      # The datatype levels. This attribute always returns zero.
+      # The nest level.
+      #
+      # Oracle manual says that it always returns zero. However it returns
+      # the depth of {OCI8::ArgBase#arguments} calls when #arguments returns
+      # a non-empty array.
       def level
         attr_get_ub2(OCI_ATTR_LEVEL)
       end
@@ -1607,6 +1611,10 @@ class OCI8
 
       # The list of arguments at the next level (when the argument is
       # of a record or table type).
+      #
+      # This method returns an array containing type information when
+      # the type is a user-defined type and the Oracle server version
+      # is 12c or earlier. Otherwise, it returns an empty array.
       def arguments
         @arguments ||= list_arguments.to_a
       end

data/lib/oci8/object.rb

@@ -493,6 +493,16 @@ EOS
          Proc.new do |val| datetime_to_array(val, :date) end, # set_proc
          Proc.new do |val| array_to_time(val, :local) end, # get_proc
         ]
+      when :timestamp
+        [ATTR_TIMESTAMP, con, SIZE_OF_POINTER, 2, ALIGNMENT_OF_POINTER,
+         Proc.new do |val| datetime_to_array(val, :timestamp) end, # set_proc
+         Proc.new do |val| array_to_time(val, :local) end, # get_proc
+        ]
+      when :timestamp_tz
+        [ATTR_TIMESTAMP_TZ, con, SIZE_OF_POINTER, 2, ALIGNMENT_OF_POINTER,
+         Proc.new do |val| datetime_to_array(val, :timestamp_tz) end, # set_proc
+         Proc.new do |val| array_to_time(val, nil) end, # get_proc
+        ]
       when :binary_double
         [ATTR_BINARY_DOUBLE, nil, SIZE_OF_DOUBLE, 2, ALIGNMENT_OF_DOUBLE]
       when :binary_float

data/lib/oci8/oci8.rb

@@ -113,7 +113,7 @@ class OCI8
     if dbname.is_a? OCI8::ConnectionPool
       @pool = dbname # to prevent GC from freeing the connection pool.
       dbname = dbname.send(:pool_name)
-      attach_mode |= 0x0200 # OCI_CPOOL and OCI_LOGON2_CPOOL
+      attach_mode |= 0x0200 # OCI_CPOOL
     else
       tcp_connect_timeout = OCI8::properties[:tcp_connect_timeout]
       connect_timeout = OCI8::properties[:connect_timeout]
@@ -124,32 +124,27 @@ class OCI8
     end
     if stmt_cache_size
       # enable statement caching
-      attach_mode |= 0x0004 # OCI_STMT_CACHE and OCI_LOGON2_STMTCACHE
+      attach_mode |= 0x0004 # OCI_STMT_CACHE
     end
 
-    if true
-      # logon by the OCI function OCISessionBegin().
-      allocate_handles()
-      @session_handle.send(:attr_set_string, OCI_ATTR_USERNAME, username) if username
-      @session_handle.send(:attr_set_string, OCI_ATTR_PASSWORD, password) if password
-      if @@oracle_client_version >= ORAVER_11_1
-        # Sets the driver name displayed in V$SESSION_CONNECT_INFO.CLIENT_DRIVER
-        # if both the client and the server are Oracle 11g or upper.
-        # Only the first 8 chracters "ruby-oci" are displayed when the Oracle
-        # server version is lower than 12.0.1.2.
-        # 424: OCI_ATTR_DRIVER_NAME
-        @session_handle.send(:attr_set_string, 424, "ruby-oci8 : #{OCI8::VERSION}")
-      end
-      server_attach(dbname, attach_mode)
-      if OCI8.oracle_client_version >= OCI8::ORAVER_11_1
-        self.send_timeout = OCI8::properties[:send_timeout] if OCI8::properties[:send_timeout]
-        self.recv_timeout = OCI8::properties[:recv_timeout] if OCI8::properties[:recv_timeout]
-      end
-      session_begin(cred ? cred : OCI_CRED_RDBMS, auth_mode)
-    else
-      # logon by the OCI function OCILogon2().
-      logon2(username, password, dbname, attach_mode)
+    # logon by the OCI function OCISessionBegin().
+    allocate_handles()
+    @session_handle.send(:attr_set_string, OCI_ATTR_USERNAME, username) if username
+    @session_handle.send(:attr_set_string, OCI_ATTR_PASSWORD, password) if password
+    if @@oracle_client_version >= ORAVER_11_1
+      # Sets the driver name displayed in V$SESSION_CONNECT_INFO.CLIENT_DRIVER
+      # if both the client and the server are Oracle 11g or upper.
+      # Only the first 8 chracters "ruby-oci" are displayed when the Oracle
+      # server version is lower than 12.0.1.2.
+      # 424: OCI_ATTR_DRIVER_NAME
+      @session_handle.send(:attr_set_string, 424, "ruby-oci8 : #{OCI8::VERSION}")
     end
+    server_attach(dbname, attach_mode)
+    if OCI8.oracle_client_version >= OCI8::ORAVER_11_1
+      self.send_timeout = OCI8::properties[:send_timeout] if OCI8::properties[:send_timeout]
+      self.recv_timeout = OCI8::properties[:recv_timeout] if OCI8::properties[:recv_timeout]
+    end
+    session_begin(cred ? cred : OCI_CRED_RDBMS, auth_mode)
 
     if stmt_cache_size
       # set statement cache size
@@ -174,7 +169,6 @@ class OCI8
   # @private
   def parse_internal(sql)
     cursor = OCI8::Cursor.new(self, sql)
-    cursor.prefetch_rows = @prefetch_rows if @prefetch_rows
     cursor
   end
 
@@ -310,6 +304,7 @@ class OCI8
   # @return [Array] an array of first row.
   def select_one(sql, *bindvars)
     cursor = self.parse(sql)
+    cursor.prefetch_rows = 1
     begin
       cursor.exec(*bindvars)
       row = cursor.fetch
@@ -345,6 +340,12 @@ class OCI8
 
   # Returns the Oracle server version.
   #
+  # When the Oracle client version is 12c or earlier and
+  # the Oracle server version is 18c or later, this method
+  # doesn't return *full* version number such as '18.3.0.0.0'.
+  # It returns version number whose number components after
+  # the first dot are zeros such as '18.0.0.0.0'.
+  #
   # @see OCI8.oracle_client_version
   # @return [OCI8::OracleVersion]
   def oracle_server_version