ruby-oci8 2.0.1 → 2.0.2

data/ext/oci8/oraconf.rb

@@ -48,48 +48,69 @@ module MiniRegistry
     # copy the minimum code and reorganize it.
     ERROR_SUCCESS = 0
     ERROR_FILE_NOT_FOUND = 2
+    ERROR_NO_MORE_ITEMS = 259
 
     HKEY_LOCAL_MACHINE = 0x80000002
+    KEY_ENUMERATE_SUB_KEYS = 0x0008
+    KEY_QUERY_VALUE = 0x0001
     RegOpenKeyExA = Win32API.new('advapi32', 'RegOpenKeyExA', 'LPLLP', 'L')
+    RegEnumKeyExA = Win32API.new('advapi32', 'RegEnumKeyExA', 'LLPPPPPP', 'L')
     RegQueryValueExA = Win32API.new('advapi32','RegQueryValueExA','LPPPPP','L')
     RegCloseKey = Win32API.new('advapi32', 'RegCloseKey', 'L', 'L')
 
-    def get_reg_value(root, subkey, name)
-      result = [0].pack('L')
-      code = RegOpenKeyExA.call(root, subkey, 0, 0x20019, result)
+    def self.get_str_value(hKey, name)
+      lpcbData = [0].pack('L')
+      code = RegQueryValueExA.call(hKey, name, nil, nil, nil, lpcbData)
+      if code == ERROR_FILE_NOT_FOUND
+        return nil
+      elsif code != ERROR_SUCCESS
+        raise MiniRegistryError.new("Win32::RegQueryValueExA",code)
+      end
+      len = lpcbData.unpack('L')[0]
+      lpType = [0].pack('L')
+      lpData = "\0"*len
+      lpcbData = [len].pack('L')
+      code = RegQueryValueExA.call(hKey, name, nil, lpType, lpData, lpcbData)
+      if code != ERROR_SUCCESS
+        raise MiniRegistryError.new("Win32::RegQueryValueExA",code)
+      end
+      lpData.unpack('Z*')[0]
+    end
+
+    def self.enum_homes
+      phkResult = [0].pack('L')
+      code = RegOpenKeyExA.call(HKEY_LOCAL_MACHINE, 'SOFTWARE\ORACLE', 0, 0x20019, phkResult)
       if code != ERROR_SUCCESS
         raise MiniRegistryError.new("Win32::RegOpenKeyExA", code)
       end
-      hkey = result.unpack('L')[0]
-      begin
-        lpcbData = [0].pack('L')
-        code = RegQueryValueExA.call(hkey, name, nil, nil, nil, lpcbData)
-        if code == ERROR_FILE_NOT_FOUND
-          return nil
-        elsif code != ERROR_SUCCESS
-          raise MiniRegistryError.new("Win32::RegQueryValueExA",code)
+      hKey = phkResult.unpack('L')[0]
+      idx = 0
+      maxkeylen = 256
+      loop do
+        lpName = "\0" * maxkeylen
+        lpcName = [maxkeylen].pack('L')
+        code = RegEnumKeyExA.call(hKey, idx, lpName, lpcName, nil, nil, nil, nil);
+        break if code == ERROR_NO_MORE_ITEMS
+        if code != ERROR_SUCCESS
+          RegCloseKey.call(hKey)
+          raise MiniRegistryError.new("Win32::RegEnumKeyEx", code)
         end
-        len = lpcbData.unpack('L')[0]
-        lpType = "\0\0\0\0"
-        lpData = "\0"*len
-        lpcbData = [len].pack('L')
-        code = RegQueryValueExA.call(hkey, name, nil, lpType, lpData, lpcbData)
+        code = RegOpenKeyExA.call(hKey, lpName, 0, KEY_QUERY_VALUE, phkResult)
         if code != ERROR_SUCCESS
-          raise MiniRegistryError.new("Win32::RegQueryValueExA",code)
+          RegCloseKey.call(hKey)
+          raise MiniRegistryError.new("Win32::RegEnumKeyEx", code)
         end
-        lpData.unpack('Z*')[0]
-      ensure
-        RegCloseKey.call(hkey)
+        hSubkey = phkResult.unpack('L')[0]
+
+        name = get_str_value(hSubkey, 'ORACLE_HOME_NAME')
+        path = get_str_value(hSubkey, 'ORACLE_HOME')
+        yield name, path
+        RegCloseKey.call(hSubkey)
+        idx += 1
       end
+      RegCloseKey.call(hKey)
     end
-    def get_local_registry(subkey, name)
-      get_reg_value(HKEY_LOCAL_MACHINE, subkey, name)
-    end
-  else
-    # UNIX
-    def get_local_registry(subkey, name)
-      nil
-    end
+
   end
 end # module MiniRegistry
 
@@ -293,8 +314,6 @@ class MiniSOReader
 end
 
 class OraConf
-  include MiniRegistry
-
   attr_reader :cc_is_gcc
   attr_reader :version
   attr_reader :cflags
@@ -756,26 +775,10 @@ class OraConfFC < OraConf
       if oracle_home.nil?
         struct = Struct.new("OracleHome", :name, :path)
         oracle_homes = []
-        begin
-          last_home = get_local_registry("SOFTWARE\\ORACLE\\ALL_HOMES", 'LAST_HOME')
-          0.upto last_home.to_i do |id|
-             oracle_homes << "HOME#{id}"
-          end
-        rescue MiniRegistryError
-        end
-        oracle_homes << "KEY_XE"
-        oracle_homes << "KEY_XEClient"
-        oracle_homes.collect! do |home|
-          begin
-            name = get_local_registry("SOFTWARE\\ORACLE\\#{home}", 'ORACLE_HOME_NAME')
-            path = get_local_registry("SOFTWARE\\ORACLE\\#{home}", 'ORACLE_HOME')
-            path.chomp!("\\")
-            struct.new(name, path) if is_valid_home?(path)
-          rescue MiniRegistryError
-            nil
-          end
+        MiniRegistry.enum_homes do |name, path|
+          path.chomp!("\\") if path
+          oracle_homes << struct.new(name, path) if is_valid_home?(path)
         end
-        oracle_homes.compact!
         if oracle_homes.empty?
           raise <<EOS
 Set the environment variable ORACLE_HOME if Oracle Full Client.
@@ -945,21 +948,18 @@ EOS
         end
       end
 
-      # remove object files from libs.
-      objs = []
-      libs.gsub!(/\S+\.o\b/) do |obj|
-        objs << obj
-        ""
-      end
-      # change object files to an archive file to work around.
-      if objs.length > 0
-        Logging::open do
-          puts "change object files to an archive file."
-          command = Config::CONFIG["AR"] + " cru oracle_objs.a " + objs.join(" ")
-          puts command
-          system(command)
-          libs = "oracle_objs.a " + libs
+      # check whether object files are included.
+      if /\S+\.o\b/ =~ libs
+
+        # monkey patching!
+        Object.module_eval do
+          alias :orig_link_command :link_command
+          def link_command(ldflags, opt="", libpath=$DEFLIBPATH|$LIBPATH)
+            opt = "" if opt == $libs
+            orig_link_command(ldflags, opt, libpath)
+          end
         end
+
       end
       libs
     end # get_libs

data/ext/oci8/oradate.c

@@ -3,7 +3,7 @@
  *  oradate.c
  *
  * $Author: kubo $
- * $Date: 2009-01-04 01:58:01 +0900 (Sun, 04 Jan 2009) $
+ * $Date: 2009-05-17 22:07:16 +0900 (Sun, 17 May 2009) $
  *
  * Copyright (C) 2002-2008 KUBO Takehiro <kubo@jiubao.org>
  *

data/lib/dbd/OCI8.rb

@@ -402,6 +402,21 @@ class Statement < DBI::BaseStatement
   end
 end
 
+# DBI_STMT_NEW_ARGS is DBI::StatementHandle.new's arguments except +handle+.
+#
+# FYI: DBI::StatementHandle.new method signatures are follows:
+#   0.2.2: handle, fetchable=false, prepared=true
+#   0.4.0: handle, fetchable=false, prepared=true, convert_types=true
+#   0.4.1: handle, fetchable=false, prepared=true, convert_types=true, executed=false
+begin
+  DBI::StatementHandle.new(nil, false, true, true, true)
+  # dbi 0.4.1
+  DBI_STMT_NEW_ARGS = [true, true, true, true] # :nodoc:
+rescue ArgumentError
+  # dbi 0.4.0 or lower
+  DBI_STMT_NEW_ARGS = [true] # :nodoc:
+end
+
 if defined? ::OCI8::BindType::Base
   ##
   ## ruby-oci8 2.0 bind classes.
@@ -491,7 +506,7 @@ if defined? ::OCI8::BindType::Base
         val = super
         return nil if val.nil?
         stmt = DBI::DBD::OCI8::Statement.new(val)
-        DBI::StatementHandle.new(stmt, true, false)
+        DBI::StatementHandle.new(stmt, *DBI_STMT_NEW_ARGS)
       end
     end
   end # BindType
@@ -560,7 +575,7 @@ else
           return val if val.nil?
           cur = ::OCI8::Cursor.new(@env, @svc, @ctx, val)
           stmt = DBI::DBD::OCI8::Statement.new(cur)
-          DBI::StatementHandle.new(stmt, true, false)
+          DBI::StatementHandle.new(stmt, *DBI_STMT_NEW_ARGS)
         end
       end
     end

data/lib/oci8.rb.in

@@ -71,6 +71,7 @@ end
 
 require 'oci8/datetime.rb'
 require 'oci8/oci8.rb'
+require 'oci8/bindtype.rb'
 require 'oci8/metadata.rb'
 require 'oci8/compat.rb'
 require 'oci8/object.rb'

data/lib/oci8/bindtype.rb

@@ -0,0 +1,295 @@
+#--
+# bindtype.rb -- OCI8::BindType
+#
+# Copyright (C) 2009 KUBO Takehiro <kubo@jiubao.org>
+#++
+
+class OCI8
+  module BindType
+    Mapping = {}
+
+    class Base
+      def self.create(con, val, param, max_array_size)
+        self.new(con, val, param, max_array_size)
+      end
+    end
+
+    # get/set Date
+    class Date < OCI8::BindType::OraDate
+      def set(val)
+        super(val && ::OraDate.new(val.year, val.mon, val.mday))
+      end
+      def get()
+        (val = super()) && val.to_date
+      end
+    end
+
+    # get/set Number (for OCI8::SQLT_NUM)
+    class Number
+      def self.create(con, val, param, max_array_size)
+        if param.is_a? OCI8::Metadata::Base
+          precision = param.precision
+          scale = param.scale
+        end
+        if scale == -127
+          if precision == 0
+            # NUMBER declared without its scale and precision. (Oracle 9.2.0.3 or above)
+            klass = OCI8::BindType::Mapping[:number_no_prec_setting]
+          else
+            # FLOAT or FLOAT(p)
+            klass = OCI8::BindType::Float
+          end
+        elsif scale == 0
+          if precision == 0
+            # NUMBER whose scale and precision is unknown
+            # or
+            # NUMBER declared without its scale and precision. (Oracle 9.2.0.2 or below)
+            klass = OCI8::BindType::Mapping[:number_unknown_prec]
+          else
+            # NUMBER(p, 0)
+            klass = OCI8::BindType::Integer
+          end
+        else
+          # NUMBER(p, s)
+          if precision < 15 # the precision of double.
+            klass = OCI8::BindType::Float
+          else
+            # use BigDecimal instead?
+            klass = OCI8::BindType::OraNumber
+          end
+        end
+        klass.new(con, val, nil, max_array_size)
+      end
+    end
+
+    class String
+      # 1333 <= ceil(4000 / 3). 4000 is max size of char. 3 is NLS ratio of UTF-8.
+      @@minimum_bind_length = 1333
+
+      def self.minimum_bind_length
+        @@minimum_bind_length
+      end
+
+      def self.minimum_bind_length=(val)
+        @@minimum_bind_length = val
+      end
+
+      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
+            else
+              # ruby 1.8.6 or lower
+              length = val.size
+            end
+          end
+        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?
+          when :raw
+            # HEX needs twice space.
+            length = param.data_size * 2
+          end
+        end
+        length = @@minimum_bind_length if length.nil? or length < @@minimum_bind_length
+        self.new(con, val, length, max_array_size)
+      end
+    end
+
+    class RAW
+      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
+          end
+        when OCI8::Metadata::Base
+          length = param.data_size
+        end
+        self.new(con, val, length, max_array_size)
+      end
+    end
+
+    class Long < OCI8::BindType::String
+      def self.create(con, val, param, max_array_size)
+        self.new(con, val, con.long_read_len, 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)
+      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
+          OCI8::BindType::NCLOB.new(con, val, nil, max_array_size)
+        else
+          OCI8::BindType::CLOB.new(con, val, nil, max_array_size)
+        end
+      end
+    end
+  end # BindType
+end
+
+# bind or explicitly define
+OCI8::BindType::Mapping[String]       = OCI8::BindType::String
+OCI8::BindType::Mapping[OraNumber]    = OCI8::BindType::OraNumber
+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
+OCI8::BindType::Mapping[OraDate]      = OCI8::BindType::OraDate
+OCI8::BindType::Mapping[Time]         = OCI8::BindType::Time
+OCI8::BindType::Mapping[Date]         = OCI8::BindType::Date
+OCI8::BindType::Mapping[DateTime]     = OCI8::BindType::DateTime
+OCI8::BindType::Mapping[OCI8::CLOB]   = OCI8::BindType::CLOB
+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
+
+# implicitly define
+
+# datatype        type     size prec scale
+# -------------------------------------------------
+# CHAR(1)       SQLT_AFC      1    0    0
+# CHAR(10)      SQLT_AFC     10    0    0
+OCI8::BindType::Mapping[:char] = OCI8::BindType::String
+
+# datatype        type     size prec scale
+# -------------------------------------------------
+# VARCHAR(1)    SQLT_CHR      1    0    0
+# VARCHAR(10)   SQLT_CHR     10    0    0
+# VARCHAR2(1)   SQLT_CHR      1    0    0
+# VARCHAR2(10)  SQLT_CHR     10    0    0
+OCI8::BindType::Mapping[:varchar2] = OCI8::BindType::String
+
+# datatype        type     size prec scale
+# -------------------------------------------------
+# RAW(1)        SQLT_BIN      1    0    0
+# RAW(10)       SQLT_BIN     10    0    0
+OCI8::BindType::Mapping[:raw] = OCI8::BindType::RAW
+
+# datatype        type     size prec scale
+# -------------------------------------------------
+# LONG          SQLT_LNG      0    0    0
+OCI8::BindType::Mapping[:long] = OCI8::BindType::Long
+
+# datatype        type     size prec scale
+# -------------------------------------------------
+# LONG RAW      SQLT_LBI      0    0    0
+OCI8::BindType::Mapping[:long_raw] = OCI8::BindType::LongRaw
+
+# datatype        type     size prec scale
+# -------------------------------------------------
+# CLOB          SQLT_CLOB  4000    0    0
+OCI8::BindType::Mapping[:clob] = OCI8::BindType::CLOB
+OCI8::BindType::Mapping[:nclob] = OCI8::BindType::NCLOB
+
+# datatype        type     size prec scale
+# -------------------------------------------------
+# BLOB          SQLT_BLOB  4000    0    0
+OCI8::BindType::Mapping[:blob] = OCI8::BindType::BLOB
+
+# datatype        type     size prec scale
+# -------------------------------------------------
+# BFILE         SQLT_BFILE 4000    0    0
+OCI8::BindType::Mapping[:bfile] = OCI8::BindType::BFILE
+
+# datatype        type     size prec scale
+# -------------------------------------------------
+# 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
+
+# datatype        type     size prec scale
+# -------------------------------------------------
+# ROWID         SQLT_RDD      4    0    0
+OCI8::BindType::Mapping[:rowid] = OCI8::BindType::String
+
+# datatype           type     size prec scale
+# -----------------------------------------------------
+# FLOAT            SQLT_NUM     22  126 -127
+# FLOAT(1)         SQLT_NUM     22    1 -127
+# FLOAT(126)       SQLT_NUM     22  126 -127
+# DOUBLE PRECISION SQLT_NUM     22  126 -127
+# REAL             SQLT_NUM     22   63 -127
+# NUMBER           SQLT_NUM     22    0    0
+# NUMBER(1)        SQLT_NUM     22    1    0
+# NUMBER(38)       SQLT_NUM     22   38    0
+# NUMBER(1, 0)     SQLT_NUM     22    1    0
+# NUMBER(38, 0)    SQLT_NUM     22   38    0
+# NUMERIC          SQLT_NUM     22   38    0
+# INT              SQLT_NUM     22   38    0
+# INTEGER          SQLT_NUM     22   38    0
+# SMALLINT         SQLT_NUM     22   38    0
+OCI8::BindType::Mapping[:number] = OCI8::BindType::Number
+
+# mapping for calculated number values.
+#
+# for example:
+#   select col1 * 1.1 from tab1;
+#
+# For Oracle 9.2.0.2 or below, this is also used for NUMBER
+# datatypes that have no explicit setting of their precision
+# and scale.
+#
+# The default mapping is Float for ruby-oci8 1.0. It is OraNumber
+# for ruby-oci8 2.0.
+OCI8::BindType::Mapping[:number_unknown_prec] = OCI8::BindType::OraNumber
+
+# mapping for number without precision and scale.
+#
+# for example:
+#   create table tab1 (col1 number);
+#   select col1 from tab1;
+#
+# note: This is available only on Oracle 9.2.0.3 or above.
+# see:  Oracle 9.2.0.x Patch Set Notes.
+#
+# The default mapping is Float for ruby-oci8 1.0. It is OraNumber
+# for ruby-oci8 2.0.
+OCI8::BindType::Mapping[:number_no_prec_setting] = OCI8::BindType::OraNumber
+
+if defined? OCI8::BindType::BinaryDouble
+  OCI8::BindType::Mapping[:binary_float] = OCI8::BindType::BinaryDouble
+  OCI8::BindType::Mapping[:binary_double] = OCI8::BindType::BinaryDouble
+else
+  OCI8::BindType::Mapping[:binary_float] = OCI8::BindType::Float
+  OCI8::BindType::Mapping[:binary_double] = OCI8::BindType::Float
+end
+
+# Cursor
+OCI8::BindType::Mapping[:cursor] = OCI8::BindType::Cursor
+
+# XMLType (This mapping will be changed before release.)
+OCI8::BindType::Mapping[:xmltype] = OCI8::BindType::Long