ruby-oci8 2.0.6 → 2.1.0

data/ext/oci8/connection_pool.c

@@ -0,0 +1,201 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * connection_pool.c - part of ruby-oci8
+ *
+ * Copyright (C) 2010 KUBO Takehiro <kubo@jiubao.org>
+ *
+ */
+#include "oci8.h"
+
+static VALUE cOCIConnectionPool;
+
+typedef struct {
+    oci8_base_t base;
+    VALUE pool_name;
+} oci8_cpool_t;
+
+static void oci8_cpool_mark(oci8_base_t *base)
+{
+    oci8_cpool_t *cpool = (oci8_cpool_t *)base;
+
+    rb_gc_mark(cpool->pool_name);
+}
+
+static VALUE cpool_free_thread(void *arg)
+{
+    OCIConnectionPoolDestroy((OCICPool *)arg, oci8_errhp, OCI_DEFAULT);
+    OCIHandleFree(arg, OCI_HTYPE_CPOOL);
+    return 0;
+}
+
+static void oci8_cpool_free(oci8_base_t *base)
+{
+    oci8_run_native_thread(cpool_free_thread, base->hp.poolhp);
+    base->type = 0;
+    base->hp.ptr = NULL;
+}
+
+static void oci8_cpool_init(oci8_base_t *base)
+{
+    oci8_cpool_t *cpool = (oci8_cpool_t *)base;
+
+    cpool->pool_name = Qnil;
+}
+
+static oci8_base_vtable_t oci8_cpool_vtable = {
+    oci8_cpool_mark,
+    oci8_cpool_free,
+    sizeof(oci8_cpool_t),
+    oci8_cpool_init,
+};
+
+/*
+ * call-seq:
+ *   OCI8::ConnectionPool.new(conn_min, conn_max, conn_incr, username = nil, password = nil, dbname = nil) -> connection pool
+ *   OCI8::ConnectionPool.new(conn_min, conn_max, conn_incr, connect_string) -> connection pool
+ *
+ * Creates a connection pool.
+ *
+ * <i>conn_min</i> specifies the minimum number of connections in the
+ * connection pool. Valid values are 0 and higher.
+ *
+ * <i>conn_max</i> specifies the maximum number of connections that
+ * can be opened to the database. Once this value is reached, no more
+ * connections are opened. Valid values are 1 and higher.
+ * Note that this limits the number of concurent SQL executions, not
+ * the number of concurrent sessions.
+ *
+ * <i>conn_incr</i> allows the application to set the next increment
+ * for connections to be opened to the database if the current number
+ * of connections are less than <i>conn_max</i>. Valid values are 0
+ * and higher.
+ *
+ * <i>username</i> and <i>password</i> are required to establish an
+ * implicit primary session. When both are nil, external
+ * authentication is used.
+ *
+ * <i>dbname</i> specifies the database server to connect to.
+ *
+ * If the number of arguments is four, <i>username</i>,
+ * <i>password</i> and <i>dbname</i> are extracted from the fourth
+ * argument <i>connect_string</i>. The syntax is "username/password" or
+ * "username/password@dbname".
+ */
+static VALUE oci8_cpool_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE conn_min;
+    VALUE conn_max;
+    VALUE conn_incr;
+    VALUE username;
+    VALUE password;
+    VALUE dbname;
+    oci8_cpool_t *cpool = DATA_PTR(self);
+    OraText *pool_name;
+    sb4 pool_name_len;
+    sword rv;
+
+    /* check arguments */
+    rb_scan_args(argc, argv, "42", &conn_min, &conn_max, &conn_incr,
+                 &username, &password, &dbname);
+    Check_Type(conn_min, T_FIXNUM);
+    Check_Type(conn_max, T_FIXNUM);
+    Check_Type(conn_incr, T_FIXNUM);
+    if (argc == 4) {
+        VALUE mode;
+        VALUE conn_str = username;
+
+        OCI8SafeStringValue(conn_str);
+        oci8_do_parse_connect_string(conn_str, &username, &password, &dbname, &mode);
+        if (!NIL_P(mode)) {
+            rb_raise(rb_eArgError, "invalid connect string \"%s\": Connection pooling doesn't support sysdba and sysoper privileges.", RSTRING_PTR(conn_str));
+        }
+    } else {
+        if (!NIL_P(username)) {
+            OCI8SafeStringValue(username);
+        }
+        if (!NIL_P(password)) {
+            OCI8SafeStringValue(password);
+        }
+        if (!NIL_P(dbname)) {
+            OCI8SafeStringValue(dbname);
+        }
+    }
+
+    rv = OCIHandleAlloc(oci8_envhp, &cpool->base.hp.ptr, OCI_HTYPE_CPOOL, 0, NULL);
+    if (rv != OCI_SUCCESS)
+        oci8_env_raise(oci8_envhp, rv);
+    cpool->base.type = OCI_HTYPE_CPOOL;
+
+    chker2(OCIConnectionPoolCreate(oci8_envhp, oci8_errhp, cpool->base.hp.poolhp,
+                                   &pool_name, &pool_name_len,
+                                   NIL_P(dbname) ? NULL : RSTRING_ORATEXT(dbname),
+                                   NIL_P(dbname) ? 0 : RSTRING_LEN(dbname),
+                                   FIX2UINT(conn_min), FIX2UINT(conn_max),
+                                   FIX2UINT(conn_incr),
+                                   NIL_P(username) ? NULL : RSTRING_ORATEXT(username),
+                                   NIL_P(username) ? 0 : RSTRING_LEN(username),
+                                   NIL_P(password) ? NULL : RSTRING_ORATEXT(password),
+                                   NIL_P(password) ? 0 : RSTRING_LEN(password),
+                                   OCI_DEFAULT),
+           &cpool->base);
+    cpool->pool_name = rb_str_new(TO_CHARPTR(pool_name), pool_name_len);
+    rb_str_freeze(cpool->pool_name);
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   reinitialize(min, max, incr)
+ *
+ * Changes the the number of minimum connections, the number of
+ * maximum connections and the connection increment parameter.
+ */
+static VALUE oci8_cpool_reinitialize(VALUE self, VALUE conn_min, VALUE conn_max, VALUE conn_incr)
+{
+    oci8_cpool_t *cpool = DATA_PTR(self);
+    OraText *pool_name;
+    sb4 pool_name_len;
+
+    /* check arguments */
+    Check_Type(conn_min, T_FIXNUM);
+    Check_Type(conn_max, T_FIXNUM);
+    Check_Type(conn_incr, T_FIXNUM);
+
+    chker2(OCIConnectionPoolCreate(oci8_envhp, oci8_errhp, cpool->base.hp.poolhp,
+                                   &pool_name, &pool_name_len, NULL, 0, 
+                                   FIX2UINT(conn_min), FIX2UINT(conn_max),
+                                   FIX2UINT(conn_incr),
+                                   NULL, 0, NULL, 0, OCI_CPOOL_REINITIALIZE),
+           &cpool->base);
+    return self;
+}
+
+/*
+ * call-seq:
+ *   pool_name -> string
+ *
+ * <b>internal use only</b>
+ *
+ * Retruns the pool name.
+ */
+static VALUE oci8_cpool_pool_name(VALUE self)
+{
+    oci8_cpool_t *cpool = DATA_PTR(self);
+
+    return cpool->pool_name;
+}
+
+void Init_oci8_connection_pool(VALUE cOCI8)
+{
+#if 0
+    cOCIHandle = rb_define_class("OCIHandle", rb_cObject);
+    cOCI8 = rb_define_class("OCI8", cOCIHandle);
+    cOCIConnectionPool = rb_define_class_under(cOCI8, "ConnectionPool", cOCIHandle);
+#endif
+
+    cOCIConnectionPool = oci8_define_class_under(cOCI8, "ConnectionPool", &oci8_cpool_vtable);
+
+    rb_define_private_method(cOCIConnectionPool, "initialize", oci8_cpool_initialize, -1);
+    rb_define_method(cOCIConnectionPool, "reinitialize", oci8_cpool_reinitialize, 3);
+    rb_define_private_method(cOCIConnectionPool, "pool_name", oci8_cpool_pool_name, 0);
+}

data/ext/oci8/encoding.c

@@ -2,7 +2,7 @@
 /*
  * encoding.c - part of ruby-oci8
  *
- * Copyright (C) 2008 KUBO Takehiro <kubo@jiubao.org>
+ * Copyright (C) 2008-2010 KUBO Takehiro <kubo@jiubao.org>
  *
  */
 #include "oci8.h"
@@ -11,15 +11,8 @@
 #define OCI_NLS_MAXBUFSZ 100
 #endif
 
-/* type of callback function's argument */
-typedef struct {
-    oci8_svcctx_t *svcctx;
-    OCIStmt *stmtp;
-    union {
-        VALUE name;
-        int csid;
-    } u;
-} cb_arg_t;
+/* NLS ratio, maximum number of bytes per one chracter */
+int oci8_nls_ratio = 1;
 
 /* Oracle charset id -> Oracle charset name */
 static VALUE csid2name;
@@ -32,6 +25,30 @@ static VALUE oci8_charset_name2id(VALUE svc, VALUE name);
 rb_encoding *oci8_encoding;
 #endif
 
+
+/*
+ * call-seq:
+ *   charset_id2name(charset_id) -> charset_name
+ *
+ * <b>(new in 2.0.0)</b>
+ *
+ * Returns the Oracle character set name from the specified
+ * character set ID if it is valid. Otherwise, +nil+ is returned.
+ *
+ * === Oracle 9iR2 client or upper
+ *
+ * It is done by using the mapping table stored in the client side.
+ *
+ * === Oracle 9iR1 client or lower
+ *
+ * It executes the following PL/SQL block internally to use
+ * the mapping table stored in the server side.
+ *
+ *   BEGIN
+ *     :name := nls_charset_name(:csid);
+ *   END;
+ *
+ */
 VALUE oci8_charset_id2name(VALUE svc, VALUE csid)
 {
     VALUE name = rb_hash_aref(csid2name, csid);
@@ -83,6 +100,29 @@ VALUE oci8_charset_id2name(VALUE svc, VALUE csid)
     return name;
 }
 
+/*
+ * call-seq:
+ *   charset_name2id(charset_name) -> charset_id
+ *
+ * <b>(new in 2.0.0)</b>
+ *
+ * Returns the Oracle character set ID for the specified Oracle
+ * character set name if it is valid. Othewise, +nil+ is returned.
+ *
+ * === Oracle 9iR2 client or upper
+ *
+ * It is done by using the mapping table stored in the client side.
+ *
+ * === Oracle 9iR1 client or lower
+ *
+ * It executes the following PL/SQL block internally to use
+ * the mapping table stored in the server side.
+ *
+ *   BEGIN
+ *     :csid := nls_charset_id(:name);
+ *   END;
+ *
+ */
 static VALUE oci8_charset_name2id(VALUE svc, VALUE name)
 {
     VALUE csid;
@@ -132,27 +172,72 @@ static VALUE oci8_charset_name2id(VALUE svc, VALUE name)
     return csid;
 }
 
+/*
+ * call-seq:
+ *   OCI8.nls_ratio -> integer
+ *
+ * <b>(new in 2.1.0)</b>
+ *
+ * Gets NLS ratio, maximum number of bytes per one character of the
+ * current NLS chracter set. It is a factor to calculate the
+ * internal buffer size of a string bind variable whose nls length
+ * semantics is char.
+ */
+static VALUE oci8_get_nls_ratio(VALUE klass)
+{
+    return INT2NUM(oci8_nls_ratio);
+}
+
+/*
+ * call-seq:
+ *   OCI8.nls_ratio = integer
+ *
+ * <b>(new in 2.1.0)</b>
+ *
+ * Sets NLS ratio, maximum number of bytes per one character of the
+ * current NLS chracter set. It is initialized in 'oci8/encoding-init.rb'
+ * when oci8 is required. You have no need to set it explicitly.
+ */
+static VALUE oci8_set_nls_ratio(VALUE klass, VALUE val)
+{
+    int v = NUM2INT(val);
+    if (v <= 0) {
+        rb_raise(rb_eRangeError, "expected a positive integer but %d", v);
+    }
+    oci8_nls_ratio = v;
+    return val;
+}
+
 #ifdef HAVE_TYPE_RB_ENCODING
 
 /*
  * call-seq:
- *   OCI8.encoding -> enc
+ *    OCI8.encoding -> enc
+ *
+ * <b>(new in 2.0.0 and ruby 1.9)</b>
  *
- * (new in ruby 1.9)
+ * Returns the Oracle client encoding.
  *
- * Returns Oracle client encoding.
+ * When string data, such as SQL statements and bind variables,
+ * are passed to Oracle, they are converted to +OCI8.encoding+
+ * in advance.
  *
- * String values passed to Oracle, such as SQL statements,
- * bind values etc., are converted from their encoding to
- * the Oracle client encoding.
+ *   # When OCI8.encoding is ISO-8859-1,
+ *   conn.exec('insert into country_code values(:1, :2, :3)',
+ *             'AT', 'Austria', "\u00d6sterreichs")
+ *   # "\u00d6sterreichs" is 'Österreichs' encoded by UTF-8.
+ *   # It is converted to ISO-8859-1 before it is passed to
+ *   # the Oracle C API.
  *
- * If <code>Encoding.default_internal</code> is nil,
- * string values got from Oracle are tagged by
- * <code>OCI8.encoding</code>. If not nil, they are
- * converted from <code>OCI8.encoding</code> to
- * <code>Encoding.default_internal</code> by default.
  *
- * If it is 'ASCII-8BIT', no encoding conversions are done.
+ * When string data, such as fetched values and bind variable
+ * for output, are retrieved from Oracle, they are encoded
+ * by +OCI8.encoding+ if +Encoding.default_internal+ is +nil+.
+ * If it isn't +nil+, they are converted from +OCI8.encoding+
+ * to +Encoding.default_internal+.
+ *
+ * If +OCI8.encoding+ is ASCII-8BIT, no encoding conversions
+ * are done.
  */
 static VALUE oci8_get_encoding(VALUE klass)
 {
@@ -163,9 +248,11 @@ static VALUE oci8_get_encoding(VALUE klass)
  * call-seq:
  *   OCI8.encoding = enc or nil
  *
- * (new in ruby 1.9)
+ * <b>(new in 2.0.0 and ruby 1.9)</b>
  *
- * Sets Oracle client encoding.
+ * Sets Oracle client encoding. You must not use this method.
+ * You should set the environment variable NLS_LANG properly to
+ * change +OCI8.encoding+.
  */
 static VALUE oci8_set_encoding(VALUE klass, VALUE encoding)
 {
@@ -180,6 +267,10 @@ static VALUE oci8_set_encoding(VALUE klass, VALUE encoding)
 
 void Init_oci8_encoding(VALUE cOCI8)
 {
+#if 0
+    oci8_cOCIHandle = rb_define_class("OCIHandle", rb_cObject);
+    cOCI8 = rb_define_class("OCI8", oci8_cOCIHandle);
+#endif
     csid2name = rb_hash_new();
     rb_global_variable(&csid2name);
 
@@ -189,6 +280,8 @@ void Init_oci8_encoding(VALUE cOCI8)
 
     rb_define_method(cOCI8, "charset_name2id", oci8_charset_name2id, 1);
     rb_define_method(cOCI8, "charset_id2name", oci8_charset_id2name, 1);
+    rb_define_singleton_method(cOCI8, "nls_ratio", oci8_get_nls_ratio, 0);
+    rb_define_singleton_method(cOCI8, "nls_ratio=", oci8_set_nls_ratio, 1);
 #ifdef HAVE_TYPE_RB_ENCODING
     rb_define_singleton_method(cOCI8, "encoding", oci8_get_encoding, 0);
     rb_define_singleton_method(cOCI8, "encoding=", oci8_set_encoding, 1);

data/ext/oci8/env.c

@@ -12,11 +12,7 @@
 #include <util.h>
 #endif
 
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
 ub4 oci8_env_mode = OCI_OBJECT | OCI_THREADED;
-#else
-ub4 oci8_env_mode = OCI_OBJECT;
-#endif
 
 OCIEnv *oci8_global_envhp;
 
@@ -31,9 +27,9 @@ OCIEnv *oci8_make_envhp(void)
     return oci8_global_envhp;
 }
 
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+#ifdef USE_THREAD_LOCAL_ERRHP
 /*
- * oci8_errhp is a thread local object in ruby 1.9.
+ * Setup thread-local oci8_errhp.
  */
 
 oci8_tls_key_t oci8_tls_key; /* native thread key */
@@ -93,7 +89,7 @@ OCIError *oci8_make_errhp(void)
 }
 #else
 /*
- * oci8_errhp is global in ruby 1.8.
+ * oci8_errhp is global in ruby 1.8 configured without --enable-pthread on Unix.
  */
 OCIError *oci8_global_errhp;
 
@@ -110,7 +106,7 @@ OCIError *oci8_make_errhp(void)
 
 void Init_oci8_env(void)
 {
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+#ifdef USE_THREAD_LOCAL_ERRHP
     int error;
 #endif
 
@@ -160,8 +156,7 @@ void Init_oci8_env(void)
         }
     }
 
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
-/* ruby 1.9 */
+#ifdef USE_THREAD_LOCAL_ERRHP
 #if defined(_WIN32)
     if (!dllmain_is_called) {
         /* sanity check */