Revert "Use array fetching when LOB colums are in a query and no object types are in the query."

This reverts commit a35c64d.

Author: akostadinov

ext/oci8/bind.c

@@ -633,20 +633,11 @@ 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(int argc, VALUE *argv, VALUE self)
+static VALUE oci8_bind_get_data(VALUE self)
 {
     oci8_bind_t *obind = TO_BIND(self);
-    VALUE index;
 
-    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) {
+    if (obind->maxar_sz == 0) {
         obind->curar_idx = 0;
         return rb_funcall(self, oci8_id_get, 0);
     } else {
@@ -817,7 +808,7 @@ 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, -1);
+    rb_define_private_method(cOCI8BindTypeBase, "get_data", oci8_bind_get_data, 0);
     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);

ext/oci8/stmt.c

@@ -15,8 +15,7 @@ static VALUE cOCIStmt;
 typedef struct {
     oci8_base_t base;
     VALUE svc;
-    char use_stmt_release;
-    char end_of_fetch;
+    int use_stmt_release;
 } oci8_stmt_t;
 
 static void oci8_stmt_mark(oci8_base_t *base)
@@ -261,15 +260,14 @@ 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);
     return self;
 }
 
 /*
- * @overload __fetch(connection, max_rows)
+ * @overload __fetch(connection)
  *
  *  Fetches one row and set the result to <code>@define_handles</code>.
  *  This is called by private methods of OCI8::Cursor.
@@ -279,18 +277,13 @@ static VALUE oci8_stmt_execute(VALUE self, VALUE iteration_count)
  *
  *  @private
  */
-static VALUE oci8_stmt_fetch(VALUE self, VALUE svc, VALUE max_rows)
+static VALUE oci8_stmt_fetch(VALUE self, VALUE svc)
 {
     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;
@@ -300,22 +293,16 @@ static VALUE oci8_stmt_fetch(VALUE self, VALUE svc, VALUE max_rows)
                 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, nrows, OCI_FETCH_NEXT, OCI_DEFAULT);
+    rv = OCIStmtFetch_nb(svcctx, stmt->base.hp.stmt, oci8_errhp, 1, OCI_FETCH_NEXT, OCI_DEFAULT);
     if (rv == OCI_NO_DATA) {
-        stmt->end_of_fetch = 1;
-    } else {
-        chker3(rv, &svcctx->base, stmt->base.hp.stmt);
+        return Qfalse;
     }
-    chker2(OCIAttrGet(stmt->base.hp.stmt, OCI_HTYPE_STMT, &nrows, 0, OCI_ATTR_ROWS_FETCHED, oci8_errhp),
-           &svcctx->base);
-    return nrows ? UINT2NUM(nrows) : Qnil;
+    chker3(rv, &svcctx->base, stmt->base.hp.stmt);
+    return Qtrue;
 }
 
 /*
@@ -440,7 +427,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, 2);
+    rb_define_private_method(cOCIStmt, "__fetch", oci8_stmt_fetch, 1);
     rb_define_private_method(cOCIStmt, "__paramGet", oci8_stmt_get_param, 1);
     rb_define_method(cOCIStmt, "rowid", oci8_stmt_get_rowid, 0);
 

lib/oci8/cursor.rb

@@ -25,11 +25,7 @@ def initialize(conn, sql = nil)
       @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
@@ -42,7 +38,7 @@ def initialize(conn, sql = nil)
     #   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}, @fetch_array_size || 1)
+      bindobj = make_bind_object(:type => type, :length => length)
       __define(pos, bindobj)
       if old = @define_handles[pos - 1]
         old.send(:free)
@@ -130,8 +126,6 @@ def exec(*bindvars)
       when :select_stmt
         __execute(0)
         define_columns() if @column_metadata.size == 0
-        @rowbuf_size = 0
-        @rowbuf_index = 0
         @column_metadata.size
       else
         __execute(1)
@@ -390,7 +384,6 @@ def keys
     # @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
@@ -475,7 +468,7 @@ def type
 
     private
 
-    def make_bind_object(param, fetch_array_size = nil)
+    def make_bind_object(param)
       case param
       when Hash
         key = param[:type]
@@ -517,42 +510,22 @@ def make_bind_object(param, fetch_array_size = nil)
         OCI8::BindType::Mapping[key] = bindclass if bindclass
       end
       raise "unsupported datatype: #{key}" if bindclass.nil?
-      bindclass.create(@con, val, param, fetch_array_size || max_array_size)
+      bindclass.create(@con, val, param, 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)
-      @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
-          when :named_type
-            # Disable array fetching even when rows prefetching doesn't work.
-            # It causes SEGV now.
-            use_array_fetch = false
-            break
-          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]
+      1.upto(num_cols) do |i|
+        parm = __paramGet(i)
+        define_one_column(i, parm) unless @define_handles[i - 1]
+        @column_metadata[i - 1] = parm
       end
       num_cols
     end
 
     def define_one_column(pos, param)
-      bindobj = make_bind_object(param, @fetch_array_size || 1)
+      bindobj = make_bind_object(param)
       __define(pos, bindobj)
       @define_handles[pos - 1] = bindobj
     end
@@ -567,33 +540,22 @@ def bind_params(*bindvars)
       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_row_internal
-        ret = @define_handles.collect do |handle|
-          handle.send(:get_data, @rowbuf_index)
+      if __fetch(@con)
+        @define_handles.collect do |handle|
+          handle.send(:get_data)
         end
-        @rowbuf_index += 1
-        ret
       else
         nil
       end
     end
 
     def fetch_one_row_as_hash
-      if fetch_row_internal
+      if __fetch(@con)
         ret = {}
         get_col_names.each_with_index do |name, idx|
-          ret[name] = @define_handles[idx].send(:get_data, @rowbuf_index)
+          ret[name] = @define_handles[idx].send(:get_data)
         end
-        @rowbuf_index += 1
         ret
       else
         nil

lib/oci8/oci8.rb

@@ -169,6 +169,7 @@ def parse(sql)
   # @private
   def parse_internal(sql)
     cursor = OCI8::Cursor.new(self, sql)
+    cursor.prefetch_rows = @prefetch_rows if @prefetch_rows
     cursor
   end
 
@@ -304,7 +305,6 @@ def exec_internal(sql, *bindvars)
   # @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

test/test_oci8.rb

@@ -539,7 +539,6 @@ def test_last_error
     assert_nil(@conn.last_error)
     @conn.last_error = 'dummy'
     cursor = @conn.parse('select col1, max(col2) from (select 1 as col1, null as col2 from dual) group by col1')
-    cursor.prefetch_rows = 1
     assert_nil(@conn.last_error)
 
     # When an OCI function returns OCI_SUCCESS_WITH_INFO, OCI8#last_error is set.
@@ -600,25 +599,4 @@ def test_server_version
           end
     assert_equal(ver, @conn.oracle_server_version.to_s)
   end
-
-  def test_array_fetch
-    drop_table('test_table')
-    @conn.exec("CREATE TABLE test_table (id number, val clob)")
-    cursor = @conn.parse("INSERT INTO test_table VALUES (:1, :2)")
-    1.upto(10) do |i|
-      cursor.exec(i, ('a'.ord + i).chr * i)
-    end
-    cursor.close
-    cursor = @conn.parse("select * from test_table where id <= :1 order by id")
-    cursor.prefetch_rows = 4
-    [1, 6, 2, 7, 3, 8, 4, 9, 5, 10].each do |i|
-      cursor.exec(i)
-      1.upto(i) do |j|
-        row = cursor.fetch
-        assert_equal(j, row[0])
-        assert_equal(('a'.ord + j).chr * j, row[1].read)
-      end
-      assert_nil(cursor.fetch)
-    end
-  end
 end # TestOCI8