ruby-oci8-master 2.0.7

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/ext/oci8/win32.c

@@ -0,0 +1,137 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+  win32.c - part of ruby-oci8
+
+  Copyright (C) 2009-2010 KUBO Takehiro <kubo@jiubao.org>
+*/
+#include "oci8.h"
+#ifdef __CYGWIN__
+/* boolean is defined as a macro in oratypes.h.
+ * It conflicts with the definition in windows.h.
+ */
+#undef boolean
+#endif
+#include <windows.h>
+
+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);
+}
+
+static VALUE dll_path(VALUE module)
+{
+    HMODULE hModule;
+    DWORD len;
+    char path[1024];
+
+    hModule = GetModuleHandle("OCI.DLL");
+    if (hModule == NULL) {
+        raise_error();
+    }
+    len = GetModuleFileName(hModule, path, sizeof(path));
+    if (len == 0) {
+        raise_error();
+    }
+    return rb_external_str_new_with_enc(path, len, rb_filesystem_encoding());
+}
+
+
+typedef struct {
+    HKEY hKey;
+    HKEY hSubKey;
+} enum_homes_arg_t;
+
+static VALUE enum_homes_real(enum_homes_arg_t *arg)
+{
+    LONG rv;
+    DWORD type;
+    DWORD idx;
+    char name[1024];
+    DWORD name_len;
+    FILETIME ft;
+
+    rv = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\ORACLE", 0, KEY_ENUMERATE_SUB_KEYS, &arg->hKey);
+    if (rv != ERROR_SUCCESS) {
+        return Qnil;
+    }
+    for (idx = 0; ; idx++) {
+        volatile VALUE oracle_home;
+        volatile VALUE nls_lang;
+
+        /* Get subkey name */
+        name_len = sizeof(name);
+        rv = RegEnumKeyEx(arg->hKey, idx, name, &name_len, NULL, NULL, NULL, &ft);
+        if (rv != ERROR_SUCCESS) {
+            break;
+        }
+        /* Open subkey */
+        if (arg->hSubKey != NULL) {
+            RegCloseKey(arg->hSubKey);
+            arg->hSubKey = NULL;
+        }
+        rv = RegOpenKeyEx(arg->hKey, name, 0, KEY_QUERY_VALUE, &arg->hSubKey);
+        if (rv != ERROR_SUCCESS) {
+            continue;
+        }
+        /* Get ORACLE_HOME */
+        name_len = sizeof(name);
+        rv = RegQueryValueEx(arg->hSubKey, "ORACLE_HOME", NULL, &type, TO_ORATEXT(name), &name_len);
+        if (rv != ERROR_SUCCESS || type != REG_SZ) {
+            continue;
+        }
+        oracle_home = rb_locale_str_new_cstr(name);
+        /* Get NLS_LANG */
+        name_len = sizeof(name);
+        rv = RegQueryValueEx(arg->hSubKey, "NLS_LANG", NULL, &type, TO_ORATEXT(name), &name_len);
+        if (rv != ERROR_SUCCESS || type != REG_SZ) {
+            continue;
+        }
+        nls_lang = rb_locale_str_new_cstr(name);
+        rb_yield_values(2, oracle_home, nls_lang);
+    }
+    return Qnil;
+}
+
+static VALUE enum_homes_ensure(enum_homes_arg_t *arg)
+{
+    if (arg->hKey != NULL) {
+        RegCloseKey(arg->hKey);
+        arg->hKey = NULL;
+    }
+    if (arg->hSubKey != NULL) {
+        RegCloseKey(arg->hSubKey);
+        arg->hSubKey = NULL;
+    }
+    return Qnil;
+}
+
+static VALUE enum_homes(VALUE module)
+{
+    enum_homes_arg_t arg;
+    arg.hKey = NULL;
+    arg.hSubKey = NULL;
+    return rb_ensure(enum_homes_real, (VALUE)&arg, enum_homes_ensure, (VALUE)&arg);
+}
+
+void Init_oci8_win32(VALUE cOCI8)
+{
+    VALUE mWin32Util = rb_define_module_under(cOCI8, "Win32Util");
+
+    rb_define_module_function(mWin32Util, "dll_path", dll_path, 0);
+    rb_define_module_function(mWin32Util, "enum_homes", enum_homes, 0);
+}

data/lib/.document

@@ -0,0 +1 @@
+oci8

data/lib/dbd/OCI8.rb

@@ -0,0 +1,591 @@
+#
+# DBD::OCI8
+#
+# Copyright (c) 2002-2007 KUBO Takehiro <kubo@jiubao.org>
+#
+# copied some code from DBD::Oracle.
+# DBD::Oracle's copyright is as follows:
+# --------------------- begin -------------------
+#
+# Copyright (c) 2001, 2002, 2003, 2004 Michael Neumann <mneumann@ntecs.de>
+# 
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions 
+# are met:
+# 1. Redistributions of source code must retain the above copyright 
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright 
+#    notice, this list of conditions and the following disclaimer in the 
+#    documentation and/or other materials provided with the distribution.
+# 3. The name of the author may not be used to endorse or promote products
+#    derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+# THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# --------------------- end -------------------
+
+require 'oci8'
+
+module DBI # :nodoc:
+module DBD # :nodoc:
+module OCI8
+
+VERSION          = "0.1"
+USED_DBD_VERSION = "0.4"
+
+def self.driver_name
+  "OCI8"
+end
+
+# type converstion handler to bind values. (ruby-dbi 0.4)
+if DBI.const_defined?(:TypeUtil)
+  DBI::TypeUtil.register_conversion("OCI8") do |obj|
+    case obj
+    when ::TrueClass
+      ['1', false]
+    when ::FalseClass
+      ['0', false]
+    else
+      [obj, false]
+    end
+  end
+end
+
+# no type converstion is required for result set. (ruby-dbi 0.4)
+class NoTypeConversion
+  def self.parse(obj)
+    obj
+  end
+end
+
+module Util
+
+  ERROR_MAP = {
+    1 => DBI::IntegrityError, # unique constraint violated
+    900 => DBI::ProgrammingError, # invalid SQL statement
+    904 => DBI::ProgrammingError, # invalid identifier
+    905 => DBI::ProgrammingError, # missing keyword
+    923 => DBI::ProgrammingError, # FROM keyword not found where expected 
+    936 => DBI::ProgrammingError, # missing expression
+    942 => DBI::ProgrammingError, # table or view does not exist
+    2290 => DBI::IntegrityError, # check constraint violated
+    2291 => DBI::IntegrityError, # parent key not found
+    2292 => DBI::IntegrityError, # child record found
+    2293 => DBI::IntegrityError, # check constraint violated
+  }
+
+  def raise_dbierror(err) # :nodoc:
+    if err.is_a? OCIError
+      exc = ERROR_MAP[err.code] || DBI::DatabaseError
+      raise exc.new(err.message, err.code)
+    else
+      raise DBI::DatabaseError.new(err.message, -1)
+    end
+  rescue DBI::DatabaseError => exc
+    exc.set_backtrace(err.backtrace)
+    raise
+  end
+
+  def column_metadata_to_column_info(col)
+    sql_type, type_name, precision, scale =
+      case col.data_type
+      when :char
+        [SQL_CHAR, col.charset_form == :nchar ? "NCHAR" : "CHAR", col.data_size, nil]
+      when :varchar2
+        [SQL_VARCHAR, col.charset_form == :nchar ? "NVARCHAR2" : "VARCHAR2", col.data_size, nil]
+      when :raw
+        [SQL_VARBINARY, "RAW", col.data_size, nil]
+      when :long
+        [SQL_LONGVARCHAR, "LONG", 4000, nil]
+      when :long_raw
+        [SQL_LONGVARBINARY, "LONG RAW", 4000, nil]
+      when :clob
+        [SQL_CLOB, col.charset_form == :nchar ? "NCLOB" : "CLOB", 4000, nil]
+      when :blob
+        [SQL_BLOB, "BLOB", 4000, nil]
+      when :bfile
+        [SQL_BLOB, "BFILE", 4000, nil]
+      when :number
+        if col.scale == -127 && col.precision != 0
+          # To convert from binary to decimal precision, multiply n by 0.30103.
+          [SQL_FLOAT, "FLOAT", (col.precision * 0.30103).ceil , nil]
+        elsif col.precision == 0
+          # NUMBER or calculated value (eg. col * 1.2).
+          [SQL_NUMERIC, "NUMBER", 38, nil]
+        else
+          [SQL_NUMERIC, "NUMBER", col.precision, col.scale]
+        end
+      when :binary_float
+        # (23 * 0.30103).ceil => 7
+        [SQL_FLOAT, "BINARY_FLOAT", 7, nil]
+      when :binary_double
+        # (52 * 0.30103).ceil => 16
+        [SQL_DOUBLE, "BINARY_DOUBLE", 16, nil]
+      when :date
+        # yyyy-mm-dd hh:mi:ss
+        [SQL_DATE, "DATE", 19, nil]
+      when :timestamp
+        # yyyy-mm-dd hh:mi:ss.SSSS
+        [SQL_TIMESTAMP, "TIMESTAMP", 20 + col.fsprecision, nil]
+      when :timestamp_tz
+        # yyyy-mm-dd hh:mi:ss.SSSS +HH:MM
+        [SQL_TIMESTAMP, "TIMESTAMP WITH TIME ZONE", 27 + col.fsprecision, nil]
+      when :timestamp_ltz
+        # yyyy-mm-dd hh:mi:ss.SSSS
+        [SQL_TIMESTAMP, "TIMESTAMP WITH LOCAL TIME ZONE", 20 + col.fsprecision, nil]
+      when :interval_ym
+        # yyyy-mm
+        [SQL_OTHER, 'INTERVAL YEAR TO MONTH', col.lfprecision + 3, nil]
+      when :interval_ds
+        # dd hh:mi:ss.SSSSS
+        [SQL_OTHER, 'INTERVAL DAY TO SECOND', col.lfprecision + 10 + col.fsprecision, nil]
+      else
+        [SQL_OTHER, col.data_type.to_s, nil, nil]
+      end
+    {'name' => col.name,
+      'sql_type' => sql_type,
+      'type_name' => type_name,
+      'nullable' => col.nullable?,
+      'precision' => precision,
+      'scale' => scale,
+      'dbi_type' => NoTypeConversion,
+    }
+  end
+  private :column_metadata_to_column_info
+end
+
+class Driver < DBI::BaseDriver # :nodoc:
+  include Util
+
+  def initialize
+    super(USED_DBD_VERSION)
+  end
+
+  # external OS authentication
+  # (contributed by Dan Fitch)
+  def default_user
+    [nil, nil]
+  end
+
+  def connect( dbname, user, auth, attr )
+    handle = ::OCI8.new(user, auth, dbname, attr['Privilege'])
+    handle.non_blocking = true if attr['NonBlocking']
+    return Database.new(handle, attr)
+  rescue OCIException => err
+    raise_dbierror(err)
+  end
+end
+
+class Database < DBI::BaseDatabase
+  include Util
+
+  def disconnect
+    @handle.logoff
+  rescue OCIException => err
+    raise_dbierror(err)
+  end
+
+  def prepare( statement )
+    # convert ?-style parameters to :1, :2 etc.
+    prep_statement = DBI::SQL::PreparedStatement.new(DummyQuoter.new, statement)
+    if prep_statement.unbound.size > 0
+      arr = (1..(prep_statement.unbound.size)).collect{|i| ":#{i}"}
+      statement = prep_statement.bind( arr ) 
+    end
+    cursor = @handle.parse(statement)
+    Statement.new(cursor)
+  rescue OCIException => err
+    raise_dbierror(err)
+  end
+
+  def ping
+    @handle.exec("BEGIN NULL; END;")
+    true
+  rescue
+    false
+  end
+
+  def commit
+    @handle.commit()
+  rescue OCIException => err
+    raise_dbierror(err)
+  end
+
+  def rollback
+    @handle.rollback()
+  rescue OCIException => err
+    raise_dbierror(err)
+  end
+
+  def tables
+    stmt = execute("SELECT object_name FROM user_objects where object_type in ('TABLE', 'VIEW')")
+    rows = stmt.fetch_all || []
+    stmt.finish
+    rows.collect {|row| row[0]} 
+  end
+
+  # SQLs are copied from DBD::Oracle.
+  def columns(table)
+    tab = @handle.describe_table(table)
+    cols = tab.columns
+    cols.collect! do |col|
+      column_metadata_to_column_info(col)
+    end
+
+    dbh = DBI::DatabaseHandle.new(self)
+
+    primaries = {}
+    dbh.select_all(<<EOS, tab.obj_schema, tab.obj_name) do |row|
+select column_name
+  from all_cons_columns a, all_constraints b
+ where a.owner = b.owner
+   and a.constraint_name = b.constraint_name
+   and a.table_name = b.table_name
+   and b.constraint_type = 'P'
+   and b.owner = :1
+   and b.table_name = :2
+EOS
+      primaries[row[0]] = true
+    end
+
+    indices = {}
+    uniques = {}
+    dbh.select_all(<<EOS, tab.obj_schema, tab.obj_name) do |row|
+select a.column_name, a.index_name, b.uniqueness
+  from all_ind_columns a, all_indexes b
+ where a.index_name = b.index_name
+   and a.index_owner = b.owner
+   and a.table_owner = :1
+   and a.table_name = :2
+EOS
+      col_name, index_name, uniqueness = row
+      indices[col_name] = true
+      uniques[col_name] = true if uniqueness == 'UNIQUE'
+    end
+
+    dbh.select_all(<<EOS, tab.obj_schema, tab.obj_name).collect do |row|
+select column_id, column_name, data_default
+  from all_tab_columns
+ where owner = :1
+   and table_name = :2
+EOS
+      col_id, col_name, default = row
+
+      col = cols[col_id.to_i - 1]
+      col_name = col['name']
+
+      if default && default[0] == ?'
+        default = default[1..-2].gsub(/''/, "'")
+      end
+
+      col['indexed']   = indices[col_name]   || false
+      col['primary']   = primaries[col_name] || false
+      col['unique']    = uniques[col_name]   || false
+      col['default']   = default
+      col
+    end
+  rescue OCIException => err
+    raise_dbierror(err)
+  end
+
+  def [](attr)
+    case attr
+    when 'AutoCommit'
+      @handle.autocommit?
+    end
+  end
+
+  def []=(attr, value)
+    case attr
+    when 'AutoCommit'
+      @handle.autocommit = value
+    end
+  end
+
+  private
+
+  class DummyQuoter # :nodoc:
+    # dummy to substitute ?-style parameter markers by :1 :2 etc.
+    def quote(str)
+      str
+    end
+  end
+end
+
+class Statement < DBI::BaseStatement
+  include Util
+
+  def initialize(cursor)
+    @cursor = cursor
+  end
+
+  def bind_param( param, value, attribs)
+    if attribs.nil? || attribs['type'].nil?
+      if value.nil?
+	@cursor.bind_param(param, nil, String, 1)
+      else
+	@cursor.bind_param(param, value)
+      end
+    else
+      case attribs['type']
+      when SQL_BINARY
+	type = OCI_TYPECODE_RAW
+      else
+	type = attribs['type']
+      end
+      @cursor.bind_param(param, value, type)
+    end
+  rescue OCIException => err
+    raise_dbierror(err)
+  end
+
+  def execute
+    @cursor.exec
+  rescue OCIException => err
+    raise_dbierror(err)
+  end
+
+  def finish
+    @cursor.close
+  rescue OCIException => err
+    raise_dbierror(err)
+  end
+
+  def fetch
+    @cursor.fetch
+  rescue OCIException => err
+    raise_dbierror(err)
+  end
+
+  def column_info
+    # minimum implementation.
+    @cursor.column_metadata.collect do |md|
+      col = column_metadata_to_column_info(md)
+      col['indexed']   = nil
+      col['primary']   = nil
+      col['unique']    = nil
+      col['default']   = nil
+      col
+    end
+  rescue OCIException => err
+    raise_dbierror(err)
+  end
+
+  def rows
+    @cursor.row_count
+  rescue OCIException => err
+    raise_dbierror(err)
+  end
+
+  def __rowid
+    @cursor.rowid
+  end
+
+  def __define(pos, type, length = nil)
+    @cursor.define(pos, type, length)
+    self
+  end
+
+  def __bind_value(param)
+    @cursor[param]
+  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.
+  ##
+
+  module BindType # :nodoc:
+
+    # helper class to define/bind DBI::Date.
+    class DBIDate < ::OCI8::BindType::OraDate
+      def set(val)
+        # convert val to an OraDate,
+        # then set it to the bind handle.
+        super(val && OraDate.new(val.year, val.month, val.day))
+      end
+      def get()
+        # get an Oradate from the bind handle,
+        # then convert it to a DBI::Date.
+        val = super()
+        return nil if val.nil?
+        DBI::Date.new(val.year, val.month, val.day)
+      end
+    end
+
+    # helper class to define/bind DBI::Timestamp.
+    #
+    # To fetch all Oracle's DATE columns as DBI::Timestamp:
+    #    ::OCI8::BindType::Mapping[OCI8::SQLT_DAT] = ::DBI::DBD::OCI8::BindType::DBITimestamp
+    #
+    class DBITimestamp < ::OCI8::BindType::OraDate
+      def set(val)
+        # convert val to an OraDate,
+        # then set it to the bind handle.
+        super(val && OraDate.new(val.year, val.month, val.day,
+                                 val.respond_to?(:hour) ? val.hour : 0,
+                                 val.respond_to?(:min) ? val.min : 0,
+                                 val.respond_to?(:sec) ? val.sec : 0))
+      end
+      def get()
+        # get an Oradate from the bind handle,
+        # then convert it to a DBI::Timestamp.
+        val = super()
+        return nil if val.nil?
+        DBI::Timestamp.new(val.year, val.month, val.day, val.hour, val.minute, val.second)
+      end
+    end
+
+    # helper class to bind ref cursor as DBI::StatementHandle.
+    #
+    #   # Create package
+    #   dbh.execute(<<EOS)
+    #   create or replace package test_pkg is
+    #     type ref_cursor is ref cursor;
+    #     procedure tab_table(csr out ref_cursor);
+    #   end;
+    #   EOS
+    #
+    #   # Create package body
+    #   dbh.execute(<<EOS)
+    #   create or replace package body test_pkg is
+    #     procedure tab_table(csr out ref_cursor) is
+    #     begin
+    #       open csr for select * from tab;
+    #     end;
+    #   end;
+    #   EOS
+    #
+    #   # Execute test_pkg.tab_table.
+    #   # The first parameter is bound as DBI::StatementHandle.
+    #   plsql = dbh.execute("begin test_pkg.tab_table(?); end;", DBI::StatementHandle)
+    #
+    #   # Get the first parameter, which is a DBI::StatementHandle.
+    #   sth = plsql.func(:bind_value, 1)
+    #
+    #   # fetch column data.
+    #   sth.fetch_all
+    #
+    class DBIStatementHandle < ::OCI8::BindType::Cursor
+      def set(val)
+        if val.is_a? DBI::StatementHandle
+          # get OCI8::Cursor
+          val = val.instance_eval do @handle end
+          val = val.instance_eval do @cursor end
+        end
+        super(val)
+      end
+      def get()
+        val = super
+        return nil if val.nil?
+        stmt = DBI::DBD::OCI8::Statement.new(val)
+        DBI::StatementHandle.new(stmt, *DBI_STMT_NEW_ARGS)
+      end
+    end
+  end # BindType
+
+else
+  ##
+  ## ruby-oci8 1.0 bind classes.
+  ##
+
+  module BindType # :nodoc:
+    DBIDate = Object.new
+    class << DBIDate
+      def fix_type(env, val, length, precision, scale)
+        # bind as an OraDate
+        [::OCI8::SQLT_DAT, val, nil]
+      end
+      def decorate(b)
+        def b.set(val)
+          # convert val to an OraDate,
+          # then set it to the bind handle.
+          super(val && OraDate.new(val.year, val.month, val.day))
+        end
+        def b.get()
+          # get an Oradate from the bind handle,
+          # then convert it to a DBI::Date.
+          (val = super()) && DBI::Date.new(val.year, val.month, val.day)
+        end
+      end
+    end
+
+    DBITimestamp = Object.new
+    class << DBITimestamp
+      def fix_type(env, val, length, precision, scale)
+        # bind as an OraDate
+        [::OCI8::SQLT_DAT, val, nil]
+      end
+      def decorate(b)
+        def b.set(val)
+          # convert val to an OraDate,
+          # then set it to the bind handle.
+          super(val && OraDate.new(val.year, val.month, val.day,
+                                   val.respond_to?(:hour) ? val.hour : 0,
+                                   val.respond_to?(:min) ? val.min : 0,
+                                   val.respond_to?(:sec) ? val.sec : 0))
+        end
+        def b.get()
+          # get an Oradate from the bind handle,
+          # then convert it to a DBI::Timestamp.
+          (val = super()) && DBI::Timestamp.new(val.year, val.month, val.day, val.hour, val.minute, val.second)
+        end
+      end
+    end
+
+    DBIStatementHandle = Object.new
+    class << DBIStatementHandle
+      def fix_type(env, val, length, precision, scale)
+        raise NotImplementedError unless val.nil?
+        [::OCI8::SQLT_RSET, nil, env.alloc(OCIStmt)]
+      end
+      def decorate(b)
+        def b.set(val)
+          raise NotImplementedError
+        end
+        def b.get()
+          val = super
+          return val if val.nil?
+          cur = ::OCI8::Cursor.new(@env, @svc, @ctx, val)
+          stmt = DBI::DBD::OCI8::Statement.new(cur)
+          DBI::StatementHandle.new(stmt, *DBI_STMT_NEW_ARGS)
+        end
+      end
+    end
+  end # BindType
+end
+
+::OCI8::BindType::Mapping[DBI::Date] = BindType::DBIDate
+::OCI8::BindType::Mapping[DBI::Timestamp] = BindType::DBITimestamp
+::OCI8::BindType::Mapping[DBI::StatementHandle] = BindType::DBIStatementHandle
+
+end # module OCI8
+end # module DBD
+end # module DBI