ruby-staci 2.2.9

data/ext/oci8/connection_pool.c

@@ -0,0 +1,216 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * connection_pool.c - part of ruby-oci8
+ *
+ * Copyright (C) 2010-2014 Kubo Takehiro <kubo@jiubao.org>
+ *
+ */
+#include "oci8.h"
+
+static VALUE cOCIConnectionPool;
+
+#define TO_CPOOL(obj) ((oci8_cpool_t *)oci8_check_typeddata((obj), &oci8_cpool_data_type, 1))
+
+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 void *cpool_free_thread(void *arg)
+{
+    OCIConnectionPoolDestroy((OCICPool *)arg, oci8_errhp, OCI_DEFAULT);
+    OCIHandleFree(arg, OCI_HTYPE_CPOOL);
+    return NULL;
+}
+
+static void oci8_cpool_free(oci8_base_t *base)
+{
+    oci8_run_native_thread(cpool_free_thread, base->hp.poolhp);
+    base->type = 0;
+    base->closed = 1;
+    base->hp.ptr = NULL;
+}
+
+static const oci8_handle_data_type_t oci8_cpool_data_type = {
+    {
+        "STACI::ConnectionPool",
+        {
+            (RUBY_DATA_FUNC)oci8_cpool_mark,
+            oci8_handle_cleanup,
+            oci8_handle_size,
+        },
+        &oci8_handle_data_type.rb_data_type, NULL,
+#ifdef RUBY_TYPED_WB_PROTECTED
+        RUBY_TYPED_WB_PROTECTED,
+#endif
+    },
+    oci8_cpool_free,
+    sizeof(oci8_cpool_t),
+};
+
+static VALUE oci8_cpool_alloc(VALUE klass)
+{
+    VALUE self = oci8_allocate_typeddata(klass, &oci8_cpool_data_type);
+    oci8_cpool_t *cpool = (oci8_cpool_t *)RTYPEDDATA_DATA(self);
+
+    cpool->pool_name = Qnil;
+    return self;
+}
+
+/*
+ * call-seq:
+ *   STACI::ConnectionPool.new(conn_min, conn_max, conn_incr, username = nil, password = nil, dbname = nil) -> connection pool
+ *   STACI::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 = TO_CPOOL(self);
+    OraText *pool_name = NULL;
+    sb4 pool_name_len = 0;
+    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);
+    RB_OBJ_WRITE(cpool->base.self, &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 = TO_CPOOL(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
+ *
+ * Retruns the pool name.
+ *
+ * @private
+ */
+static VALUE oci8_cpool_pool_name(VALUE self)
+{
+    oci8_cpool_t *cpool = TO_CPOOL(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("STACI", cOCIHandle);
+    cOCIConnectionPool = rb_define_class_under(cOCI8, "ConnectionPool", cOCIHandle);
+#endif
+
+    cOCIConnectionPool = oci8_define_class_under(cOCI8, "ConnectionPool", &oci8_cpool_data_type, oci8_cpool_alloc);
+
+    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,196 @@
+/* -*- 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;
+
+rb_encoding *oci8_encoding;
+
+/*
+ * call-seq:
+ *   charset_id2name(charset_id) -> charset_name
+ *
+ * Returns the Oracle character set name from the specified
+ * character set ID if it is valid. Otherwise, +nil+ is returned.
+ *
+ * @param [Integer] charset_id  Oracle character set id
+ * @return [String]             Oracle character set name or nil
+ * @since 2.2.0
+ */
+VALUE oci8_s_charset_id2name(VALUE klass, VALUE csid)
+{
+    char buf[OCI_NLS_MAXBUFSZ];
+    sword rv;
+
+    Check_Type(csid, T_FIXNUM);
+    rv = OCINlsCharSetIdToName(oci8_envhp, TO_ORATEXT(buf), sizeof(buf), (ub2)FIX2INT(csid));
+    if (rv != OCI_SUCCESS) {
+        return Qnil;
+    }
+    return rb_usascii_str_new_cstr(buf);
+}
+
+/*
+ * call-seq:
+ *   charset_name2id(charset_name) -> charset_id
+ *
+ * Returns the Oracle character set ID for the specified Oracle
+ * character set name if it is valid. Othewise, +nil+ is returned.
+ *
+ * @param [String] charset_name   Oracle character set name
+ * @return [Integer]              Oracle character set id or nil
+ * @since 2.2.0
+ */
+static VALUE oci8_s_charset_name2id(VALUE klass, VALUE name)
+{
+    ub2 rv;
+
+    rv = OCINlsCharSetNameToId(oci8_envhp, TO_ORATEXT(StringValueCStr(name)));
+    if (rv == 0) {
+        return Qnil;
+    }
+    return INT2FIX(rv);
+}
+
+/*
+ * call-seq:
+ *   STACI.nls_ratio -> integer
+ *
+ * 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.
+ *
+ * @return [Integer] NLS ratio
+ * @since 2.1.0
+ * @private
+ */
+static VALUE oci8_get_nls_ratio(VALUE klass)
+{
+    return INT2NUM(oci8_nls_ratio);
+}
+
+/*
+ * call-seq:
+ *    STACI.encoding -> enc
+ *
+ * Returns the Oracle client encoding.
+ *
+ * When string data, such as SQL statements and bind variables,
+ * are passed to Oracle, they are converted to +STACI.encoding+
+ * in advance.
+ *
+ * @example
+ *   # When STACI.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 +STACI.encoding+ if +Encoding.default_internal+ is +nil+.
+ * If it isn't +nil+, they are converted from +STACI.encoding+
+ * to +Encoding.default_internal+.
+ *
+ * If +STACI.encoding+ is ASCII-8BIT, no encoding conversions
+ * are done.
+ *
+ * @return [Encoding]
+ * @since 2.0.0 and ruby 1.9
+ * @private
+ * @see STACI.client_charset_name
+ */
+static VALUE oci8_get_encoding(VALUE klass)
+{
+    return rb_enc_from_encoding(oci8_encoding);
+}
+
+/*
+ * call-seq:
+ *   STACI.encoding = enc or nil
+ *
+ * Sets Oracle client encoding. You must not use this method.
+ * You should set the environment variable NLS_LANG properly to
+ * change +STACI.encoding+.
+ *
+ * @param [Encoding]  enc
+ * @since 2.0.0 and ruby 1.9
+ * @private
+ */
+static VALUE oci8_set_encoding(VALUE klass, VALUE encoding)
+{
+    if (NIL_P(encoding)) {
+        oci8_encoding = NULL;
+        oci8_nls_ratio = 1;
+    } else {
+        oci8_encoding = rb_to_encoding(encoding);
+        oci8_nls_ratio = rb_enc_mbmaxlen(oci8_encoding);
+    }
+    return encoding;
+}
+
+/*
+ * call-seq:
+ *   charset_name2id(charset_name) -> charset_id
+ *
+ * Returns the Oracle character set ID for the specified Oracle
+ * character set name if it is valid. Othewise, +nil+ is returned.
+ *
+ * @param [String] charset_name   Oracle character set name
+ * @return [Integer]              Oracle character set id or nil
+ * @since 2.0.0
+ * @deprecated Use {STACI.charset_name2id} instead.
+ */
+static VALUE oci8_charset_name2id(VALUE svc, VALUE name)
+{
+    rb_warning("Use STACI.charset_name2id instead of STACI#charset_name2id.");
+    return oci8_s_charset_name2id(Qnil, name);
+}
+
+/*
+ * call-seq:
+ *   charset_id2name(charset_id) -> charset_name
+ *
+ * Returns the Oracle character set name from the specified
+ * character set ID if it is valid. Otherwise, +nil+ is returned.
+ *
+ * @param [Integer] charset_id  Oracle character set id
+ * @return [String]             Oracle character set name or nil
+ * @since 2.0.0
+ * @deprecated Use {STACI.charset_id2name} instead.
+ */
+static VALUE oci8_charset_id2name(VALUE svc, VALUE name)
+{
+    rb_warning("Use STACI.charset_id2name instead of STACI#charset_id2name.");
+    return oci8_s_charset_id2name(Qnil, name);
+}
+
+
+void Init_oci8_encoding(VALUE cOCI8)
+{
+#if 0
+    oci8_cOCIHandle = rb_define_class("OCIHandle", rb_cObject);
+    cOCI8 = rb_define_class("STACI", oci8_cOCIHandle);
+#endif
+
+    rb_define_singleton_method(cOCI8, "charset_name2id", oci8_s_charset_name2id, 1);
+    rb_define_singleton_method(cOCI8, "charset_id2name", oci8_s_charset_id2name, 1);
+    rb_define_singleton_method(cOCI8, "nls_ratio", oci8_get_nls_ratio, 0);
+    rb_define_singleton_method(cOCI8, "encoding", oci8_get_encoding, 0);
+    rb_define_singleton_method(cOCI8, "encoding=", oci8_set_encoding, 1);
+    rb_define_method(cOCI8, "charset_name2id", oci8_charset_name2id, 1);
+    rb_define_method(cOCI8, "charset_id2name", oci8_charset_id2name, 1);
+}

data/ext/oci8/env.c

@@ -0,0 +1,139 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * env.c - part of ruby-oci8
+ *
+ * Copyright (C) 2002-2011 KUBO Takehiro <kubo@jiubao.org>
+ */
+#include "oci8.h"
+#include <ruby/util.h>
+#include <aci.h>
+
+ub4 oci8_env_mode = OCI_OBJECT | OCI_THREADED;
+
+OCIEnv *oci8_global_envhp;
+
+OCIEnv *oci8_make_envhp(void)
+{
+    sword rv;
+    OCIEnv *envhp = NULL;
+
+    rv = OCIEnvCreate(&envhp, oci8_env_mode, NULL, NULL, NULL, NULL, 0, NULL);
+    if (rv != OCI_SUCCESS) {
+        if (envhp != NULL) {
+            oci8_env_free_and_raise(envhp, rv);
+        } else {
+            oci8_raise_init_error();
+        }
+    }
+    oci8_global_envhp = envhp;
+    return oci8_global_envhp;
+}
+
+/*
+ * Setup thread-local oci8_errhp.
+ */
+
+oci8_tls_key_t oci8_tls_key; /* native thread key */
+
+/* This function is called on the native thread termination
+ * if the thread local errhp is not null.
+ */
+static void oci8_free_errhp(void *errhp)
+{
+    OCIHandleFree(errhp, OCI_HTYPE_ERROR);
+}
+
+#ifdef _WIN32
+static int dllmain_is_called;
+
+__declspec(dllexport)
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
+{
+    void *errhp;
+
+    switch (fdwReason) {
+    case DLL_PROCESS_ATTACH:
+        dllmain_is_called = 1;
+        break;
+    case DLL_THREAD_ATTACH:
+        /* do nothing */
+        break;
+    case DLL_THREAD_DETACH:
+        errhp = oci8_tls_get(oci8_tls_key);
+        if (errhp != NULL) {
+            oci8_free_errhp(errhp);
+        }
+        break;
+    case DLL_PROCESS_DETACH:
+        /* do nothing */
+        break;
+    }
+    return TRUE;
+}
+#endif
+
+ACIError *oci8_make_errhp(void)
+{
+    ACIError *errhp;
+    sword rv;
+
+    /* create a new errhp. */
+    rv = OCIHandleAlloc(oci8_envhp, (dvoid *)&errhp, OCI_HTYPE_ERROR, 0, NULL);
+    if (rv != OCI_SUCCESS) {
+        oci8_env_raise(oci8_envhp, rv);
+    }
+    /* Set the errhp to the thread local storage.
+     * It is freed by oci8_free_errhp().
+     */
+    oci8_tls_set(oci8_tls_key, (void*)errhp);
+    return errhp;
+}
+
+void Init_oci8_env(void)
+{
+    int error;
+
+    /* workaround code.
+     *
+     * When ORACLE_HOME ends with '/' and the Oracle client is
+     * an instant client lower than 10.2.0.3, OCIEvnCreate()
+     * doesn't work even though the combination of OCIInitialize()
+     * and OCIEnvInit() works fine. Delete the last slash for
+     * a workaround.
+     */
+    if (oracle_client_version < ORAVERNUM(10, 2, 0, 3, 0)) {
+#ifdef _WIN32
+#define DIR_SEP '\\'
+#else
+#define DIR_SEP '/'
+#endif
+        char *home = getenv("ORACLE_HOME");
+        if (home != NULL) {
+            size_t homelen = strlen(home);
+            if (homelen > 0 && home[homelen - 1] == DIR_SEP) {
+                home = ruby_strdup(home);
+                home[homelen - 1] = '\0';
+                ruby_setenv("ORACLE_HOME", home);
+                xfree(home);
+            }
+        }
+    }
+
+#if defined(_WIN32)
+    if (!dllmain_is_called) {
+        /* sanity check */
+        rb_raise(rb_eRuntimeError, "DllMain is not unexpectedly called. This causes resource leaks.");
+    }
+    oci8_tls_key = TlsAlloc();
+    if (oci8_tls_key == 0xFFFFFFFF) {
+        error = GetLastError();
+    } else {
+        error = 0;
+    }
+#else
+    error = pthread_key_create(&oci8_tls_key, oci8_free_errhp);
+#endif
+    if (error != 0) {
+        rb_raise(rb_eRuntimeError, "Cannot create thread local key (errno = %d)", error);
+    }
+}