ruby-oci8-master 2.0.7

data/ext/oci8/connection_pool.c

@@ -0,0 +1,199 @@
+/* -*- 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_base_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.
+ *
+ * <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

@@ -0,0 +1,289 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * encoding.c - part of ruby-oci8
+ *
+ * Copyright (C) 2008-2010 KUBO Takehiro <kubo@jiubao.org>
+ *
+ */
+#include "oci8.h"
+
+#ifndef OCI_NLS_MAXBUFSZ
+#define OCI_NLS_MAXBUFSZ 100
+#endif
+
+/* NLS ratio, maximum number of bytes per one chracter */
+int oci8_nls_ratio = 1;
+
+/* Oracle charset id -> Oracle charset name */
+static VALUE csid2name;
+
+/* Oracle charset name -> Oracle charset id */
+static ID id_upcase;
+static VALUE csname2id;
+static VALUE oci8_charset_name2id(VALUE svc, VALUE name);
+#ifdef HAVE_TYPE_RB_ENCODING
+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);
+
+    if (!NIL_P(name)) {
+        return name;
+    }
+    Check_Type(csid, T_FIXNUM);
+    if (have_OCINlsCharSetIdToName) {
+        /* Oracle 9iR2 or upper */
+        char buf[OCI_NLS_MAXBUFSZ];
+        sword rv;
+
+        rv = OCINlsCharSetIdToName(oci8_envhp, TO_ORATEXT(buf), sizeof(buf), (ub2)FIX2INT(csid));
+        if (rv != OCI_SUCCESS) {
+            return Qnil;
+        }
+        name = rb_usascii_str_new_cstr(buf);
+    } else {
+        /* Oracle 9iR1 or lower */
+        oci8_exec_sql_var_t bind_vars[2];
+        char buf[OCI_NLS_MAXBUFSZ];
+        ub2 buflen = 0;
+        int ival = FIX2INT(csid);
+
+        /* :name */
+        bind_vars[0].valuep = buf;
+        bind_vars[0].value_sz = OCI_NLS_MAXBUFSZ;
+        bind_vars[0].dty = SQLT_CHR;
+        bind_vars[0].indp = NULL;
+        bind_vars[0].alenp = &buflen;
+        /* :csid */
+        bind_vars[1].valuep = &ival;
+        bind_vars[1].value_sz = sizeof(int);
+        bind_vars[1].dty = SQLT_INT;
+        bind_vars[1].indp = NULL;
+        bind_vars[1].alenp = NULL;
+
+        /* convert chaset id to charset name by querying Oracle server. */
+        oci8_exec_sql(oci8_get_svcctx(svc), "BEGIN :name := nls_charset_name(:csid); END;", 0, NULL, 2, bind_vars, 1);
+        if (buflen == 0) {
+            return Qnil;
+        }
+        name = rb_usascii_str_new(buf, buflen);
+    }
+    OBJ_FREEZE(name);
+    rb_hash_aset(csid2name, csid, name);
+    rb_hash_aset(csname2id, name, 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;
+
+    name = rb_funcall(name, id_upcase, 0);
+    csid = rb_hash_aref(csname2id, StringValue(name));
+    if (!NIL_P(csid)) {
+        return csid;
+    }
+    if (have_OCINlsCharSetNameToId) {
+        /* Oracle 9iR2 or upper */
+        ub2 rv;
+
+        rv = OCINlsCharSetNameToId(oci8_envhp, RSTRING_ORATEXT(name));
+        if (rv == 0) {
+            return Qnil;
+        }
+        csid = INT2FIX(rv);
+    } else {
+        /* Oracle 9iR1 or lower */
+        oci8_exec_sql_var_t bind_vars[2];
+        int ival;
+        sb2 ind = 0; /* null indicator */
+
+        /* :csid */
+        bind_vars[0].valuep = &ival;
+        bind_vars[0].value_sz = sizeof(int);
+        bind_vars[0].dty = SQLT_INT;
+        bind_vars[0].indp = &ind;
+        bind_vars[0].alenp = NULL;
+        /* :name */
+        bind_vars[1].valuep = RSTRING_PTR(name);
+        bind_vars[1].value_sz = RSTRING_LEN(name);
+        bind_vars[1].dty = SQLT_CHR;
+        bind_vars[1].indp = NULL;
+        bind_vars[1].alenp = NULL;
+
+        /* convert chaset name to charset id by querying Oracle server. */
+        oci8_exec_sql(oci8_get_svcctx(svc), "BEGIN :csid := nls_charset_id(:name); END;", 0, NULL, 2, bind_vars, 1);
+        if (ind) {
+            return Qnil;
+        }
+        csid = INT2FIX(ival);
+    }
+    rb_hash_aset(csid2name, csid, name);
+    rb_hash_aset(csname2id, name, csid);
+    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
+ *
+ * <b>(new in 2.0.0 and ruby 1.9)</b>
+ *
+ * Returns the 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.
+ *
+ *   # 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.
+ *
+ *
+ * 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)
+{
+    return rb_enc_from_encoding(oci8_encoding);
+}
+
+/*
+ * call-seq:
+ *   OCI8.encoding = enc or nil
+ *
+ * <b>(new in 2.0.0 and ruby 1.9)</b>
+ *
+ * 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)
+{
+    if (NIL_P(encoding)) {
+        oci8_encoding = NULL;
+    } else {
+        oci8_encoding = rb_to_encoding(encoding);
+    }
+    return encoding;
+}
+#endif
+
+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);
+
+    id_upcase = rb_intern("upcase");
+    csname2id = rb_hash_new();
+    rb_global_variable(&csname2id);
+
+    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);
+#endif
+}