ruby-oci8 2.0.6 → 2.1.0

data/ext/oci8/thread_util.c

@@ -0,0 +1,85 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * thread_util.c - part of ruby-oci8
+ *
+ * Copyright (C) 2011 KUBO Takehiro <kubo@jiubao.org>
+ */
+#include "oci8.h"
+#include <errno.h>
+
+#ifdef USE_THREAD_LOCAL_ERRHP
+
+#ifndef WIN32
+#include <pthread.h>
+static pthread_attr_t detached_thread_attr;
+#endif
+
+typedef struct {
+    rb_blocking_function_t *func;
+    void *arg;
+} adapter_arg_t;
+
+void Init_oci8_thread_util(void)
+{
+#ifndef WIN32
+    pthread_attr_init(&detached_thread_attr);
+    pthread_attr_setdetachstate(&detached_thread_attr, PTHREAD_CREATE_DETACHED);
+#endif
+}
+
+#ifdef WIN32
+
+static void __cdecl adapter(void *arg)
+{
+    adapter_arg_t *aa = (adapter_arg_t *)arg;
+    aa->func(aa->arg);
+    free(aa);
+}
+
+int oci8_run_native_thread(rb_blocking_function_t func, void *arg)
+{
+    adapter_arg_t *aa = malloc(sizeof(adapter_arg_t));
+    if (aa == NULL) {
+        return ENOMEM;
+    }
+
+    aa->func = func;
+    aa->arg = arg;
+    if (_beginthread(adapter, 0, aa) == (uintptr_t)-1L) {
+        int err = errno;
+        free(aa);
+        return err;
+    }
+    return 0;
+}
+
+#else /* WIN32 */
+
+static void *adapter(void *arg)
+{
+    adapter_arg_t *aa = (adapter_arg_t *)arg;
+    aa->func(aa->arg);
+    free(aa);
+    return NULL;
+}
+
+int oci8_run_native_thread(rb_blocking_function_t func, void *arg)
+{
+    pthread_t thread;
+    adapter_arg_t *aa = malloc(sizeof(adapter_arg_t));
+    int rv;
+    if (aa == NULL) {
+        return ENOMEM;
+    }
+
+    aa->func = func;
+    aa->arg = arg;
+    rv = pthread_create(&thread, &detached_thread_attr, adapter, aa);
+    if (rv != 0) {
+        free(aa);
+    }
+    return rv;
+}
+#endif /* WIN32 */
+
+#endif /* USE_THREAD_LOCAL_ERRHP */

data/ext/oci8/thread_util.h

@@ -0,0 +1,30 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * thread_util.h - part of ruby-oci8
+ *
+ * Copyright (C) 2011 KUBO Takehiro <kubo@jiubao.org>
+ */
+#ifdef USE_THREAD_LOCAL_ERRHP
+
+/*
+ * Prepare to execute thread-related functions.
+ */
+void Init_oci8_thread_util(void);
+
+/*
+ * Run the func in a new native thread.
+ * Don't call any ruby functions in the func.
+ * The return value is errno.
+ */
+int oci8_run_native_thread(rb_blocking_function_t func, void *arg);
+
+#else
+
+/*
+ * For ruby 1.8 configured without --enable-pthread on Unix.
+ */
+
+#define Init_oci8_thread_util() do {} while (0)
+#define oci8_run_native_thread(func, arg) ((func)(arg), 0)
+
+#endif

data/lib/oci8.rb.in

@@ -6,16 +6,21 @@
 #  ruby -r oci8 -e 'OCI8.new("scott", "tiger", nil).exec("select * from emp") do |r| puts r.join(","); end'
 #  # select all data from emp and print them as CVS format.
 
+ENV['ORA_SDTZ'] = ENV['TZ'] unless ENV['ORA_SDTZ']
+
 if RUBY_PLATFORM =~ /cygwin/
   # Cygwin manages environment variables by itself.
   # They don't synchroize with Win32's ones.
   # This set some Oracle's environment variables to win32's enviroment.
   require 'Win32API'
   win32setenv = Win32API.new('Kernel32.dll', 'SetEnvironmentVariableA', 'PP', 'I')
-  ['NLS_LANG', 'ORA_NLS10', 'ORA_NLS32', 'ORA_NLS33', 'ORACLE_BASE', 'ORACLE_HOME', 'ORACLE_SID', 'TNS_ADMIN', 'LOCAL'].each do |name|
+  ['NLS_LANG', 'TNS_ADMIN', 'LOCAL'].each do |name|
     val = ENV[name]
     win32setenv.call(name, val && val.dup)
   end
+  ENV.each do |name, val|
+    win32setenv.call(name, val && val.dup) if name =~ /^ORA/
+  end
 end
 
 so_basename = 'oci8lib_'
@@ -28,7 +33,7 @@ end
 #  191 - ruby 1.9.1 and 1.9.2
 #  19x - ruby 1.9.x future version which will break the API compatibility
 case RUBY_VERSION
-when /^1\.9/
+when /^1\.9/, /^2\.0/
   so_basename += '191'
 when /^1\.8/
   so_basename += '18'
@@ -37,14 +42,13 @@ else
 end
 require so_basename
 
-if OCI8.respond_to? :encoding
-  if defined? DEFAULT_OCI8_ENCODING
-    OCI8.encoding = DEFAULT_OCI8_ENCODING
-  else
-    load 'oci8/encoding-init.rb'
-  end
+if OCI8::VERSION != '@@OCI8_MODULE_VERSION@@'
+  require 'rbconfig'
+  so_name = so_basename + "." + Config::CONFIG['DLEXT']
+  raise "VERSION MISMATCH! #{so_name} version is #{OCI8::VERSION}, but oci8.rb version is @@OCI8_MODULE_VERSION@@."
 end
 
+require 'oci8/encoding-init.rb'
 require 'oci8/oracle_version.rb'
 
 class OCI8
@@ -77,17 +81,19 @@ class OCI8
   def self.oracle_client_version
     @@oracle_client_version
   end
+
+  # defined for backward compatibility.
+  CLIENT_VERSION = @@oracle_client_version.major.to_s +
+    @@oracle_client_version.minor.to_s +
+    @@oracle_client_version.update.to_s
 end
 
+require 'oci8/ocihandle.rb'
 require 'oci8/datetime.rb'
 require 'oci8/oci8.rb'
 require 'oci8/bindtype.rb'
 require 'oci8/metadata.rb'
 require 'oci8/compat.rb'
 require 'oci8/object.rb'
+require 'oci8/connection_pool.rb'
 require 'oci8/properties.rb'
-
-class OCI8
-  VERSION = '@@OCI8_MODULE_VERSION@@'
-  CLIENT_VERSION = '@@OCI8_CLIENT_VERSION@@'
-end

data/lib/oci8/.document

@@ -3,4 +3,6 @@ object.rb
 metadata.rb
 oracle_version.rb
 oci8.rb
+ocihandle.rb
+connection_pool.rb
 properties.rb

data/lib/oci8/bindtype.rb

@@ -1,7 +1,7 @@
 #--
 # bindtype.rb -- OCI8::BindType
 #
-# Copyright (C) 2009-2010 KUBO Takehiro <kubo@jiubao.org>
+# Copyright (C) 2009-2011 KUBO Takehiro <kubo@jiubao.org>
 #++
 
 class OCI8
@@ -105,45 +105,56 @@ class OCI8
       def self.create(con, val, param, max_array_size)
         case param
         when Hash
-          if param[:length]
-            # If length is passed explicitly, use it.
-            length = param[:length]
-          elsif val.is_a? String or (val.respond_to? :to_str and val = val.to_str)
-            if OCI8.respond_to? :encoding and OCI8.encoding != val.encoding
-              # If the string encoding is different with NLS_LANG character set,
-              # convert it to get the length.
-              val = val.encode(OCI8.encoding)
-            end
-            if val.respond_to? :bytesize
-              # ruby 1.8.7 or upper
-              length = val.bytesize
+          param[:length_semantics] = OCI8::properties[:length_semantics] unless param.has_key? :length_semantics
+          unless param[:length]
+            if val.respond_to? :to_str
+              val = val.to_str
+              if param[:length_semantics] == :char
+                # character semantics
+                param[:length] = val.size
+              else
+                # byte semantics
+                if OCI8.respond_to? :encoding and OCI8.encoding != val.encoding
+                  # If the string encoding is different with NLS_LANG character set,
+                  # convert it to get the length.
+                  val = val.encode(OCI8.encoding)
+                end
+                if val.respond_to? :bytesize
+                  # ruby 1.8.7 or upper
+                  param[:length] = val.bytesize
+                else
+                  # ruby 1.8.6 or lower
+                  param[:length] = val.size
+                end
+              end
             else
-              # ruby 1.8.6 or lower
-              length = val.size
+              param[:length] = @@minimum_bind_length
             end
           end
           # use the default value when :nchar is not set explicitly.
-          nchar = OCI8.properties[:bind_string_as_nchar] unless param.has_key?(:nchar)
+          param[:nchar] = OCI8.properties[:bind_string_as_nchar] unless param.has_key?(:nchar)
         when OCI8::Metadata::Base
           case param.data_type
           when :char, :varchar2
-            length = param.data_size
-            # character size may become large on character set conversion.
-            # The length of a Japanese half-width kana is one in Shift_JIS,
-            # two in EUC-JP, three in UTF-8.
-            length *= 3 unless param.char_used?
-            nchar = (param.charset_form == :nchar)
+            length_semantics = OCI8.properties[:length_semantics]
+            if length_semantics == :char
+              length = param.char_size
+            else
+              length = param.data_size * OCI8.nls_ratio
+            end
+            param = {
+              :length => length,
+              :length_semantics => length_semantics,
+              :nchar => (param.charset_form == :nchar),
+            }
           when :raw
             # HEX needs twice space.
-            length = param.data_size * 2
+            param = {:length => param.data_size * 2}
+          else
+            param = {:length => @@minimum_bind_length}
           end
         end
-        length = @@minimum_bind_length if length.nil? or length < @@minimum_bind_length
-        if nchar
-          OCI8::BindType::NCHAR.new(con, val, length, max_array_size)
-        else
-          OCI8::BindType::CHAR.new(con, val, length, max_array_size)
-        end
+        self.new(con, val, param, max_array_size)
       end
     end
 
@@ -151,28 +162,36 @@ class OCI8
       def self.create(con, val, param, max_array_size)
         case param
         when Hash
-          length = 400 # default length
-          if param[:length]
-            length = param[:length]
-          elsif val.respond_to? :to_str and val.to_str.size > length
-            length = val.to_str.size
+          unless param[:length]
+            if val.respond_to? :to_str
+              val = val.to_str
+              if val.respond_to? :bytesize
+                param[:length] = val.bytesize
+              else
+                param[:length] = val.size
+              end
+            else
+              param[:length] = 400
+            end
           end
         when OCI8::Metadata::Base
-          length = param.data_size
+          param = {:length => param.data_size}
         end
-        self.new(con, val, length, max_array_size)
+        self.new(con, val, param, max_array_size)
       end
     end
 
     class Long < OCI8::BindType::String
       def self.create(con, val, param, max_array_size)
-        super(con, val, {:length => con.long_read_len}, 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)
-        self.new(con, val, con.long_read_len, max_array_size)
+        param = {:length => con.long_read_len, :char_semantics => false}
+        self.new(con, val, param, max_array_size)
       end
     end
 
@@ -260,13 +279,11 @@ OCI8::BindType::Mapping[:bfile] = OCI8::BindType::BFILE
 # DATE          SQLT_DAT      7    0    0
 OCI8::BindType::Mapping[:date] = OCI8::BindType::Time
 
-if OCI8.oracle_client_version >= OCI8::ORAVER_9_0
-  OCI8::BindType::Mapping[:timestamp] = OCI8::BindType::Time
-  OCI8::BindType::Mapping[:timestamp_tz] = OCI8::BindType::Time
-  OCI8::BindType::Mapping[:timestamp_ltz] = OCI8::BindType::Time
-  OCI8::BindType::Mapping[:interval_ym] = OCI8::BindType::IntervalYM
-  OCI8::BindType::Mapping[:interval_ds] = OCI8::BindType::IntervalDS
-end
+OCI8::BindType::Mapping[:timestamp] = OCI8::BindType::Time
+OCI8::BindType::Mapping[:timestamp_tz] = OCI8::BindType::Time
+OCI8::BindType::Mapping[:timestamp_ltz] = OCI8::BindType::Time
+OCI8::BindType::Mapping[:interval_ym] = OCI8::BindType::IntervalYM
+OCI8::BindType::Mapping[:interval_ds] = OCI8::BindType::IntervalDS
 
 # datatype        type     size prec scale
 # -------------------------------------------------

data/lib/oci8/connection_pool.rb

@@ -0,0 +1,118 @@
+#--
+# connection_pool.rb -- OCI8::ConnectionPool
+#
+# Copyright (C) 2010 KUBO Takehiro <kubo@jiubao.org>
+#++
+
+class OCI8
+
+  # Connection pooling is the use of a group (the pool) of reusable
+  # physical connections by several sessions to balance loads.
+  # See: {Oracle Call Interface Manual}[http://docs.oracle.com/cd/E11882_01/appdev.112/e10646/oci09adv.htm#sthref1479]
+  #
+  # This is equivalent to Oracle JDBC Driver {OCI Connection Pooling}[http://docs.oracle.com/cd/E11882_01/java.112/e16548/ociconpl.htm#JJDBC28789].
+  #
+  # Usage:
+  #   # Create a connection pool.
+  #   # 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.
+  #   # Pass the connection pool to the third argument.
+  #   conn1 = OCI8.new(username, password, cpool)
+  #   
+  #   # Get another session.
+  #   conn2 = OCI8.new(username, password, cpool)
+  #
+  class ConnectionPool
+
+    # call-seq:
+    #   timeout -> integer
+    #
+    # Connections idle for more than this time value (in seconds) are
+    # terminated, to maintain an optimum number of open
+    # connections. If it is zero, the connections are never timed out.
+    # The default value is zero.
+    #
+    # <b>Note:</b> Shrinkage of the pool only occurs when there is a network
+    # round trip. If there are no operations, then the connections
+    # stay alive.
+    def timeout
+      attr_get_ub4(OCI_ATTR_CONN_TIMEOUT)
+    end
+
+    # call-seq:
+    #   timeout = integer
+    #
+    # Changes the timeout in seconds to terminate idle connections.
+    def timeout=(val)
+      attr_set_ub4(OCI_ATTR_CONN_TIMEOUT, val)
+    end
+
+    # call-seq:
+    #   nowait? -> true or false
+    #
+    # If true, an error is thrown when all the connections in the pool
+    # are busy and the number of connections has already reached the
+    # maximum. Otherwise the call waits till it gets a connection.
+    # The default value is false.
+    def nowait?
+      attr_get_ub1(OCI_ATTR_CONN_NOWAIT) != 0
+    end
+
+    # call-seq:
+    #   nowait = true or false
+    #
+    # Changes the behavior when all the connections in the pool
+    # are busy and the number of connections has already reached the
+    # maximum.
+    def nowait=(val)
+      attr_set_ub1(OCI_ATTR_CONN_NOWAIT, val ? 1 : 0)
+    end
+
+    # call-seq:
+    #   busy_count -> integer
+    #
+    # Returns the number of busy physical connections.
+    def busy_count
+      attr_get_ub4(OCI_ATTR_CONN_BUSY_COUNT)
+    end
+
+    # call-seq:
+    #   open_count -> integer
+    #
+    # Returns the number of open physical connections.
+    def open_count
+      attr_get_ub4(OCI_ATTR_CONN_OPEN_COUNT)
+    end
+
+    # call-seq:
+    #   min -> integer
+    #
+    # Returns the number of minimum physical connections.
+    def min
+      attr_get_ub4(OCI_ATTR_CONN_MIN)
+    end
+
+    # call-seq:
+    #   max -> integer
+    #
+    # Returns the number of maximum physical connections.
+    def max
+      attr_get_ub4(OCI_ATTR_CONN_MAX)
+    end
+
+    # call-seq:
+    #   incr -> integer
+    #
+    # Returns the connection increment parameter.
+    def incr
+      attr_get_ub4(OCI_ATTR_CONN_INCR)
+    end
+
+    # 
+    def destroy
+      free
+    end
+  end
+end