ruby-oci8 2.0.1 → 2.0.2

data/lib/oci8/oci8.rb

@@ -1,5 +1,12 @@
-#   --*- ruby -*--
-# This is based on yoshidam's oracle.rb.
+#--
+# oci8.rb -- OCI8 and OCI8::Cursor
+#
+# Copyright (C) 2002-2009 KUBO Takehiro <kubo@jiubao.org>
+#
+# Original Copyright is:
+#   Oracle module for Ruby
+#   1998-2000 by yoshidam
+#++
 
 require 'date'
 
@@ -122,6 +129,20 @@ class OCI8
     end
   end # exec
 
+  # :call-seq:
+  #   select_one(sql, *bindvars) -> first_one_row
+  #
+  def select_one(sql, *bindvars)
+    cursor = self.parse(sql)
+    begin
+      cursor.exec(*bindvars)
+      row = cursor.fetch
+    ensure
+      cursor.close
+    end
+    return row
+  end
+
   def username
     @username || begin
       exec('select user from dual') do |row|
@@ -160,133 +181,6 @@ class OCI8
     @oracle_server_version
   end
 
-  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
-      def self.create(con, val, param, max_array_size)
-        case param
-        when Hash
-          # 1333 = ceil(4000 (max size of char) / 3 (NLS ratio of UTF8))
-          length = 1333 # 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
-          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
-          else
-            length = 100
-          end
-        end
-        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
-
   # The instance of this class corresponds to cursor in the term of
   # Oracle, which corresponds to java.sql.Statement of JDBC and statement
   # handle $sth of Perl/DBI.
@@ -655,144 +549,3 @@ class String
     OraNumber.new(self, format, nls_params)
   end
 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

data/test/test_all.rb

@@ -19,16 +19,25 @@ require "#{srcdir}/test_connstr"
 require "#{srcdir}/test_metadata"
 require "#{srcdir}/test_array_dml"
 require "#{srcdir}/test_rowid"
+require "#{srcdir}/test_appinfo"
 require "#{srcdir}/test_oracle_version"
 
+if OCI8.respond_to? :encoding
+  require "#{srcdir}/test_encoding"
+end
+
 # Ruby/DBI
 begin
   require 'dbi'
-  is_dbi_loaded = true
 rescue LoadError
-  is_dbi_loaded = false
+  begin
+    require 'rubygems'
+    require 'dbi'
+  rescue LoadError
+    dbi_not_found = true
+  end
 end
-if is_dbi_loaded
+unless dbi_not_found
   require "#{srcdir}/test_dbi"
   if $test_clob
     require "#{srcdir}/test_dbi_clob"

data/test/test_appinfo.rb

@@ -0,0 +1,29 @@
+require 'oci8'
+require 'test/unit'
+require File.dirname(__FILE__) + '/config'
+
+class TestAppInfo < Test::Unit::TestCase
+
+  def setup
+    @conn = get_oci8_connection
+  end
+
+  def test_set_client_identifier
+    # set client_id
+    client_id = "ruby-oci8:#{Process.pid()}"
+    @conn.client_identifier = client_id
+    assert_equal(client_id, @conn.select_one("SELECT SYS_CONTEXT('USERENV', 'CLIENT_IDENTIFIER') FROM DUAL")[0]);
+    # check the first character
+    assert_raise ArgumentError do
+      @conn.client_identifier = ':bad_identifier'
+    end
+
+    # clear client_id
+    @conn.client_identifier = nil
+    assert_nil(@conn.select_one("SELECT SYS_CONTEXT('USERENV', 'CLIENT_IDENTIFIER') FROM DUAL")[0]);
+  end
+
+  def teardown
+    @conn.logoff
+  end
+end

data/test/test_dbi.rb

@@ -252,7 +252,7 @@ EOS
 
     drop_table('test_table')
     @dbh.execute(<<-EOS)
-CREATE TABLE test_table (#{i = 0; coldef.collect do |c| i += 1; "C#{i} " + c[1] + (c[8] ? ' PRIMARY KEY' : ''); end.join(',')})
+CREATE TABLE test_table (#{n = 0; coldef.collect do |c| n += 1; "C#{n} " + c[1] + (c[8] ? ' PRIMARY KEY' : ''); end.join(',')})
 STORAGE (
    INITIAL 100k
    NEXT 100k

data/test/test_encoding.rb

@@ -0,0 +1,100 @@
+require 'oci8'
+require 'test/unit'
+require File.dirname(__FILE__) + '/config'
+
+class TestEncoding < Test::Unit::TestCase
+  def setup
+    @conn = get_oci8_connection
+  end
+
+  def test_select
+    drop_table('test_table')
+    @conn.exec(<<EOS)
+CREATE TABLE test_table
+  (C CHAR(10),
+   V VARCHAR2(10),
+   R RAW(10),
+   LR LONG RAW,
+   CL CLOB,
+   NCL NCLOB,
+   BL BLOB)
+STORAGE (
+   INITIAL 4k
+   NEXT 4k
+   MINEXTENTS 1
+   MAXEXTENTS UNLIMITED
+   PCTINCREASE 0)
+EOS
+    ascii_8bit = Encoding.find('ASCII-8BIT')
+    @conn.exec(<<EOS)
+INSERT INTO test_table VALUES ('abcd', 'abcd', 'abcd', 'abcd', 'abcd', 'abcd', 'abcd')
+EOS
+    @conn.exec("SELECT * FROM test_table") do |row|
+      assert_equal('abcd      ', row[0], 'CHAR(10)')
+      assert_equal(OCI8.encoding, row[0].encoding);
+      assert_equal('abcd', row[1], 'VARCHAR2(10)')
+      assert_equal(OCI8.encoding, row[1].encoding);
+      assert_equal("\xab\xcd", row[2], 'RAW(10)')
+      assert_equal(ascii_8bit, row[2].encoding);
+      assert_equal("\xab\xcd", row[3], 'LONG RAW')
+      assert_equal(ascii_8bit, row[3].encoding);
+      assert_equal('abcd', (data = row[4].read), 'CLOB')
+      assert_equal(OCI8.encoding, data.encoding);
+      assert_equal('abcd', (data = row[5].read), 'NCLOB')
+      assert_equal(OCI8.encoding, data.encoding);
+      assert_equal("\xab\xcd", (data = row[6].read), 'BLOB')
+      assert_equal(ascii_8bit, data.encoding);
+
+      if OCI8.encoding.name == "UTF-8"
+        utf_8 = "\u00A1\u00A2\u00A3\u00A4\u00A5\u00A6\u00A7\u00A8\u00A9"
+        iso_8859_1 = utf_8.encode("ISO-8859-1")
+        # CLOB
+        lob = row[4]
+        lob.rewind
+        lob.write(iso_8859_1) # converted to OCI8.encoding(UTF-8)
+        lob.rewind
+        assert_equal(utf_8, lob.read)
+        # NCLOB
+        lob = row[5]
+        lob.rewind
+        lob.write(iso_8859_1) # converted to OCI8.encoding(UTF-8)
+        lob.rewind
+        assert_equal(utf_8, lob.read)
+        # BLOB
+        lob = row[6]
+        lob.rewind
+        lob.write(iso_8859_1) # written without encoding conversion
+        lob.rewind
+        assert_equal(iso_8859_1.force_encoding('ASCII-8BIT'), lob.read)
+      end
+    end
+    drop_table('test_table')
+  end
+
+  if OCI8.encoding.name == "UTF-8"
+    def test_bind_string_with_code_conversion
+      drop_table('test_table')
+      @conn.exec(<<EOS)
+CREATE TABLE test_table
+  (V VARCHAR2(3000))
+STORAGE (
+   INITIAL 4k
+   NEXT 4k
+   MINEXTENTS 1
+   MAXEXTENTS UNLIMITED
+   PCTINCREASE 0)
+EOS
+      utf_8 = "\u00A1" * 1500 # 3000 byte
+      iso_8859_1 = utf_8.encode("ISO-8859-1") # 1500 byte
+      @conn.exec("INSERT INTO test_table VALUES (:1)", iso_8859_1)
+      @conn.exec("SELECT * FROM test_table") do |row|
+        assert_equal(utf_8, row[0])
+      end
+      drop_table('test_table')
+    end
+  end
+
+  def teardown
+    @conn.logoff
+  end
+end