ruby-staci 2.2.9

data/ext/oci8/stmt.c

@@ -0,0 +1,448 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * stmt.c - part of ruby-oci8
+ *         implement the methods of OCIStmt.
+ *
+ * Copyright (C) 2002-2015 Kubo Takehiro <kubo@jiubao.org>
+ *
+ */
+#include "oci8.h"
+
+static VALUE cOCIStmt;
+
+#define TO_STMT(obj) ((oci8_stmt_t *)oci8_check_typeddata((obj), &oci8_stmt_data_type, 1))
+
+typedef struct {
+    oci8_base_t base;
+    VALUE svc;
+    char use_stmt_release;
+    char end_of_fetch;
+} oci8_stmt_t;
+
+static void oci8_stmt_mark(oci8_base_t *base)
+{
+    oci8_stmt_t *stmt = (oci8_stmt_t *)base;
+    rb_gc_mark(stmt->svc);
+}
+
+static void oci8_stmt_free(oci8_base_t *base)
+{
+    oci8_stmt_t *stmt = (oci8_stmt_t *)base;
+    stmt->svc = Qnil;
+    if (stmt->use_stmt_release) {
+        ACIStmtRelease(base->hp.stmt, oci8_errhp, NULL, 0, ACI_DEFAULT);
+        base->type = 0;
+        base->closed = 1;
+        stmt->use_stmt_release = 0;
+    }
+}
+
+static const oci8_handle_data_type_t oci8_stmt_data_type = {
+    {
+        "STACI::Cursor",
+        {
+            (RUBY_DATA_FUNC)oci8_stmt_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_stmt_free,
+    sizeof(oci8_stmt_t),
+};
+
+static VALUE oci8_stmt_alloc(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &oci8_stmt_data_type);
+}
+
+/*
+ * @overload __initialize(connection, sql_statement)
+ *
+ *  @param [OCI8] connection
+ *  @param [String] sql_statement
+ *
+ *  @private
+ */
+static VALUE oci8_stmt_initialize(VALUE self, VALUE svc, VALUE sql)
+{
+    oci8_stmt_t *stmt = TO_STMT(self);
+    oci8_svcctx_t *svcctx;
+    sword rv;
+
+    svcctx = oci8_get_svcctx(svc);
+    oci8_check_pid_consistency(svcctx);
+    if (!NIL_P(sql)) {
+        OCI8SafeStringValue(sql);
+
+        rv = ACIStmtPrepare2(svcctx->base.hp.svc, &stmt->base.hp.stmt, oci8_errhp, RSTRING_ORATEXT(sql), RSTRING_LEN(sql), NULL, 0, ACI_NTV_SYNTAX, ACI_DEFAULT);
+        if (IS_OCI_ERROR(rv)) {
+            chker2(rv, &svcctx->base);
+        }
+        stmt->base.type = ACI_HTYPE_STMT;
+        stmt->use_stmt_release = 1;
+    } else {
+        rv = ACIHandleAlloc(oci8_envhp, &stmt->base.hp.ptr, ACI_HTYPE_STMT, 0, NULL);
+        if (rv != ACI_SUCCESS) {
+            oci8_env_raise(oci8_envhp, rv);
+        }
+        stmt->base.type = ACI_HTYPE_STMT;
+    }
+    RB_OBJ_WRITE(stmt->base.self, &stmt->svc, svc);
+
+    oci8_link_to_parent(&stmt->base, &svcctx->base);
+    return Qnil;
+}
+
+/*
+ * @overload __define(position, bindobj)
+ *
+ *  @param [Integer] position
+ *  @param [OCI8::BindType::Base] bindobj
+ *
+ *  @private
+ */
+static VALUE oci8_define_by_pos(VALUE self, VALUE vposition, VALUE vbindobj)
+{
+    oci8_stmt_t *stmt = TO_STMT(self);
+    ub4 position = NUM2INT(vposition);
+    oci8_bind_t *obind = TO_BIND(vbindobj);
+    const oci8_bind_data_type_t *data_type;
+    sword status;
+    void *valuep;
+    void *indp;
+    ub4 mode;
+
+    if (obind->base.hp.dfn != NULL) {
+        oci8_base_free(&obind->base); /* TODO: OK? */
+    }
+    data_type = (const oci8_bind_data_type_t *)obind->base.data_type;
+    if (obind->value_sz != SB4MAXVAL) {
+        valuep = obind->valuep;
+        indp = NIL_P(obind->tdo) ? obind->u.inds : NULL;
+        mode = ACI_DEFAULT;
+    } else {
+        valuep = NULL;
+        indp = NULL;
+        mode = ACI_DYNAMIC_FETCH;
+    }
+    status = ACIDefineByPos(stmt->base.hp.stmt, &obind->base.hp.dfn, oci8_errhp, position, valuep, obind->value_sz, data_type->dty, indp, NULL, 0, mode);
+    if (status != ACI_SUCCESS) {
+        chker3(status, &stmt->base, stmt->base.hp.ptr);
+    }
+    obind->base.type = ACI_HTYPE_DEFINE;
+    /* link to the parent as soon as possible to preserve deallocation order. */
+    oci8_unlink_from_parent((oci8_base_t*)obind);
+    oci8_link_to_parent((oci8_base_t*)obind, (oci8_base_t*)stmt);
+
+    if (NIL_P(obind->tdo) && obind->maxar_sz > 0) {
+        chker2(ACIDefineArrayOfStruct(obind->base.hp.dfn, oci8_errhp, obind->alloc_sz, sizeof(sb2), 0, 0), &stmt->base);
+    }
+    if (data_type->post_bind_hook != NULL) {
+        data_type->post_bind_hook(obind);
+    }
+    return obind->base.self;
+}
+
+/*
+ * @overload __bind(placeholder, bindobj)
+ *
+ *  @param [Integer, String or Symbol] placeholder
+ *  @param [STACI::BindType::Base] bindobj
+ *
+ *  @private
+ */
+static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
+{
+    oci8_stmt_t *stmt = TO_STMT(self);
+    char *placeholder_ptr = (char*)-1; /* initialize as an invalid value */
+    ub4 placeholder_len = 0;
+    ub4 position = 0;
+    oci8_bind_t *obind;
+    const oci8_bind_data_type_t *data_type;
+    sword status;
+    void *valuep;
+    void *indp;
+    ub4 mode;
+
+    if (NIL_P(vplaceholder)) { /* 1 */
+        placeholder_ptr = NULL;
+        placeholder_len = 0;
+    } else if (SYMBOL_P(vplaceholder)) {
+#ifdef HAVE_RB_SYM2STR
+        /* Don't use SYM2ID on ruby 2.2.0 or later.
+         * Symbols passed to SYM2ID are not GC'ed.
+         */
+        VALUE symval = rb_sym2str(vplaceholder);
+        const char *symname = RSTRING_PTR(symval);
+        size_t len = RSTRING_LEN(symval);
+#else
+        const char *symname = rb_id2name(SYM2ID(vplaceholder));
+        size_t len = strlen(symname);
+#endif
+        placeholder_ptr = ALLOCA_N(char, len + 1);
+        placeholder_len = len + 1;
+        placeholder_ptr[0] = ':';
+        memcpy(placeholder_ptr + 1, symname, len);
+    } else if (FIXNUM_P(vplaceholder)) {
+        position = NUM2INT(vplaceholder);
+    } else {
+        OCI8StringValue(vplaceholder);
+        placeholder_ptr = RSTRING_PTR(vplaceholder);
+        placeholder_len = RSTRING_LEN(vplaceholder);
+    }
+    obind = TO_BIND(vbindobj); /* 2 */
+    if (obind->base.hp.bnd != NULL) {
+        oci8_base_free(&obind->base); /* TODO: OK? */
+    }
+    data_type = (const oci8_bind_data_type_t *)obind->base.data_type;
+
+    if (obind->value_sz != SB4MAXVAL) {
+        valuep = obind->valuep;
+        indp = NIL_P(obind->tdo) ? obind->u.inds : NULL;
+        mode = ACI_DEFAULT;
+    } else {
+        valuep = NULL;
+        indp = NULL;
+        mode = ACI_DATA_AT_EXEC;
+    }
+    if (placeholder_ptr == (char*)-1) {
+        status = OCIBindByPos(stmt->base.hp.stmt, &obind->base.hp.bnd, oci8_errhp, position, valuep, obind->value_sz, data_type->dty, indp, NULL, 0, 0, 0, mode);
+    } else {
+        status = ACIBindByName(stmt->base.hp.stmt, &obind->base.hp.bnd, oci8_errhp, TO_ORATEXT(placeholder_ptr), placeholder_len, valuep, obind->value_sz, data_type->dty, indp, NULL, 0, 0, 0, mode);
+    }
+    if (status != ACI_SUCCESS) {
+        chker3(status, &stmt->base, stmt->base.hp.stmt);
+    }
+    obind->base.type = ACI_HTYPE_BIND;
+    /* link to the parent as soon as possible to preserve deallocation order. */
+    oci8_unlink_from_parent((oci8_base_t*)obind);
+    oci8_link_to_parent((oci8_base_t*)obind, (oci8_base_t*)stmt);
+
+    if (NIL_P(obind->tdo) && obind->maxar_sz > 0) {
+        chker2(ACIBindArrayOfStruct(obind->base.hp.bnd, oci8_errhp, obind->alloc_sz, sizeof(sb2), 0, 0),
+               &stmt->base);
+    }
+    if (data_type->post_bind_hook != NULL) {
+        data_type->post_bind_hook(obind);
+    }
+    return obind->base.self;
+}
+
+static sword oci8_call_stmt_execute(oci8_svcctx_t *svcctx, oci8_stmt_t *stmt, ub4 iters, ub4 mode)
+{
+    sword rv;
+
+    rv = ACIStmtExecute_nb(svcctx, svcctx->base.hp.svc, stmt->base.hp.stmt, oci8_errhp, iters, 0, NULL, NULL, mode);
+    if (rv == ACI_ERROR) {
+        if (oci8_get_error_code(oci8_errhp) == 1000) {
+            /* run GC to close unreferred cursors
+             * when ORA-01000 (maximum open cursors exceeded).
+             */
+            rb_gc();
+            rv = ACIStmtExecute_nb(svcctx, svcctx->base.hp.svc, stmt->base.hp.stmt, oci8_errhp, iters, 0, NULL, NULL, mode);
+        }
+    }
+    return rv;
+}
+
+/*
+ * @overload __execute(iteration_count)
+ *
+ *  @param [Integer] iteration_count
+ *
+ *  @private
+ */
+static VALUE oci8_stmt_execute(VALUE self, VALUE iteration_count)
+{
+    oci8_stmt_t *stmt = TO_STMT(self);
+    oci8_svcctx_t *svcctx = oci8_get_svcctx(stmt->svc);
+
+    stmt->end_of_fetch = 0;
+    chker3(oci8_call_stmt_execute(svcctx, stmt, NUM2UINT(iteration_count),
+                                  svcctx->is_autocommit ? ACI_COMMIT_ON_SUCCESS : ACI_DEFAULT),
+           &stmt->base, stmt->base.hp.stmt);
+    return self;
+}
+
+/*
+ * @overload __fetch(connection, max_rows)
+ *
+ *  Fetches one row and set the result to <code>@define_handles</code>.
+ *  This is called by private methods of STACI::Cursor.
+ *
+ *  @param [STACI] connection
+ *  @return [true or false] true on success and false when all rows are fetched.
+ *
+ *  @private
+ */
+static VALUE oci8_stmt_fetch(VALUE self, VALUE svc, VALUE max_rows)
+{
+    oci8_stmt_t *stmt = TO_STMT(self);
+    oci8_svcctx_t *svcctx = oci8_get_svcctx(svc);
+    sword rv;
+    oci8_bind_t *obind;
+    const oci8_bind_data_type_t *data_type;
+    ub4 nrows = NUM2UINT(max_rows);
+
+    if (stmt->end_of_fetch) {
+        return Qnil;
+    }
+
+    if (stmt->base.children != NULL) {
+        obind = (oci8_bind_t *)stmt->base.children;
+        do {
+            if (obind->base.type == ACI_HTYPE_DEFINE) {
+                data_type = (const oci8_bind_data_type_t *)obind->base.data_type;
+                if (data_type->pre_fetch_hook != NULL) {
+                    data_type->pre_fetch_hook(obind, stmt->svc);
+                }
+                if (nrows > 1 && nrows != obind->maxar_sz) {
+                    rb_raise(rb_eRuntimeError, "fetch size (%u) != define-handle size %u", nrows, obind->maxar_sz);
+                }
+            }
+            obind = (oci8_bind_t *)obind->base.next;
+        } while (obind != (oci8_bind_t*)stmt->base.children);
+    }
+    rv = ACIStmtFetch_nb(svcctx, stmt->base.hp.stmt, oci8_errhp, nrows, ACI_FETCH_NEXT, ACI_DEFAULT);
+    if (rv == ACI_NO_DATA) {
+        stmt->end_of_fetch = 1;
+    } else {
+        chker3(rv, &svcctx->base, stmt->base.hp.stmt);
+    }
+    chker2(ACIAttrGet(stmt->base.hp.stmt, ACI_HTYPE_STMT, &nrows, 0, ACI_ATTR_ROWS_FETCHED, oci8_errhp),
+           &svcctx->base);
+    return nrows ? UINT2NUM(nrows) : Qnil;
+}
+
+/*
+ * @overload __paramGet(pos)
+ *
+ *  Returns the definition of column specified by <i>pos</i>
+ *
+ *  @param [Integer] pos Column position which starts from one
+ *  @return [STACI::Metadata::Base]
+ *
+ *  @private
+ */
+static VALUE oci8_stmt_get_param(VALUE self, VALUE pos)
+{
+    oci8_stmt_t *stmt = TO_STMT(self);
+    ACIParam *parmhp = NULL;
+    sword rv;
+
+    Check_Type(pos, T_FIXNUM); /* 1 */
+    rv = ACIParamGet(stmt->base.hp.stmt, ACI_HTYPE_STMT, oci8_errhp, (dvoid *)&parmhp, FIX2INT(pos));
+    if (rv != ACI_SUCCESS) {
+        chker3(rv, &stmt->base, stmt->base.hp.stmt);
+    }
+    return oci8_metadata_create(parmhp, stmt->svc, self);
+}
+
+/*
+ *  Gets the rowid of the last inserted, updated or deleted row.
+ *  This cannot be used for select statements.
+ *
+ *  @example
+ *    cursor = conn.parse('INSERT INTO foo_table values(:1, :2)', 1, 2)
+ *    cursor.exec
+ *    cursor.rowid # => "AAAFlLAAEAAAAG9AAA", the inserted row's rowid
+ *
+ *  @return [String]
+ */
+static VALUE oci8_stmt_get_rowid(VALUE self)
+{
+    oci8_base_t *base = oci8_check_typeddata(self, &oci8_stmt_data_type, 1);
+    return oci8_get_rowid_attr(base, ACI_ATTR_ROWID, base->hp.stmt);
+}
+
+/*
+ * bind_stmt
+ */
+VALUE oci8_stmt_get(oci8_bind_t *obind, void *data, void *null_struct)
+{
+    oci8_hp_obj_t *oho = (oci8_hp_obj_t *)data;
+    rb_funcall(oho->obj, rb_intern("define_columns"), 0);
+    return oho->obj;
+}
+
+static void bind_stmt_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
+{
+    oci8_hp_obj_t *oho = (oci8_hp_obj_t *)data;
+    oci8_stmt_t *stmt = TO_STMT(val);
+    oho->hp = stmt->base.hp.ptr;
+    RB_OBJ_WRITE(obind->base.self, &oho->obj, val);
+}
+
+static void bind_stmt_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
+{
+    obind->value_sz = sizeof(void *);
+    obind->alloc_sz = sizeof(oci8_hp_obj_t);
+}
+
+static void bind_stmt_init_elem(oci8_bind_t *obind, VALUE svc)
+{
+    oci8_hp_obj_t *oho = (oci8_hp_obj_t *)obind->valuep;
+    oci8_base_t *h;
+    ub4 idx = 0;
+
+    do {
+        oho[idx].obj = rb_class_new_instance(1, &svc, cOCIStmt);
+        RB_OBJ_WRITTEN(obind->base.self, Qundef, oho[idx].obj);
+        h = DATA_PTR(oho[idx].obj);
+        oho[idx].hp = h->hp.ptr;
+    } while (++idx < obind->maxar_sz);
+}
+
+static const oci8_bind_data_type_t bind_stmt_data_type = {
+    {
+        {
+            "STACI::BindType::Cursor",
+            {
+                (RUBY_DATA_FUNC)oci8_bind_hp_obj_mark,
+                oci8_handle_cleanup,
+                oci8_handle_size,
+            },
+            &oci8_bind_data_type.rb_data_type, NULL,
+#ifdef RUBY_TYPED_WB_PROTECTED
+            RUBY_TYPED_WB_PROTECTED,
+#endif
+        },
+        oci8_bind_free,
+        sizeof(oci8_bind_t)
+    },
+    oci8_stmt_get,
+    bind_stmt_set,
+    bind_stmt_init,
+    bind_stmt_init_elem,
+    bind_stmt_init_elem,
+    SQLT_RSET
+};
+
+static VALUE bind_stmt_alloc(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &bind_stmt_data_type.base);
+}
+
+void Init_oci8_stmt(VALUE cOCI8)
+{
+#if 0
+    cOCIHandle = rb_define_class("ACIHandle", rb_cObject);
+    cOCI8 = rb_define_class("OCI8", cOCIHandle);
+    cOCIStmt = rb_define_class_under(cOCI8, "Cursor", cOCIHandle);
+#endif
+    cOCIStmt = oci8_define_class_under(cOCI8, "Cursor", &oci8_stmt_data_type, oci8_stmt_alloc);
+
+    rb_define_private_method(cOCIStmt, "__initialize", oci8_stmt_initialize, 2);
+    rb_define_private_method(cOCIStmt, "__define", oci8_define_by_pos, 2);
+    rb_define_private_method(cOCIStmt, "__bind", oci8_bind, 2);
+    rb_define_private_method(cOCIStmt, "__execute", oci8_stmt_execute, 1);
+    rb_define_private_method(cOCIStmt, "__fetch", oci8_stmt_fetch, 2);
+    rb_define_private_method(cOCIStmt, "__paramGet", oci8_stmt_get_param, 1);
+    rb_define_method(cOCIStmt, "rowid", oci8_stmt_get_rowid, 0);
+
+    oci8_define_bind_class("Cursor", &bind_stmt_data_type, bind_stmt_alloc);
+}

data/ext/oci8/thread_util.c

@@ -0,0 +1,81 @@
+/* -*- 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>
+
+#ifndef WIN32
+#include <pthread.h>
+static pthread_attr_t detached_thread_attr;
+#endif
+
+typedef struct {
+    void *(*func)(void *);
+    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(void *(*func)(void*), 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(void *(*func)(void *), 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 */

data/ext/oci8/thread_util.h

@@ -0,0 +1,18 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * thread_util.h - part of ruby-oci8
+ *
+ * Copyright (C) 2011 KUBO Takehiro <kubo@jiubao.org>
+ */
+
+/*
+ * 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(void *(*func)(void *), void *arg);

data/ext/oci8/util.c

@@ -0,0 +1,71 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+  util.c - part of ruby-oci8
+
+  Copyright (C) 2015 Kubo Takehiro <kubo@jiubao.org>
+*/
+#if defined __linux && !defined(_GNU_SOURCE)
+#define _GNU_SOURCE 1
+#endif
+#include "oci8.h"
+#ifdef HAVE_DLADDR
+#include <dlfcn.h>
+#endif
+#ifdef __CYGWIN__
+#undef boolean
+#include <windows.h>
+#endif
+
+const char *oci8_dll_path(void)
+{
+#if defined _WIN32 || defined __CYGWIN__
+    HMODULE hMod = GetModuleHandleA("ACI.DLL");
+    static char buf[MAX_PATH];
+    if (hMod != NULL) {
+        if (GetModuleFileName(hMod, buf, sizeof(buf))) {
+            return buf;
+        }
+    }
+#elif defined HAVE_DLADDR && defined RTLD_DEFAULT
+    void *addr = dlsym(RTLD_DEFAULT, "ACIEnvCreate");
+    Dl_info info;
+    if (addr != NULL && dladdr(addr, &info)) {
+        return info.dli_fname;
+    }
+#elif defined HAVE_DLMODINFO && defined HAVE_DLGETNAME && defined RTLD_DEFAULT
+    void *addr = dlsym(RTLD_DEFAULT, "ACIEnvCreate");
+    if (addr != NULL) {
+        struct load_module_desc desc;
+        if (dlmodinfo((uint64_t)addr, &desc, sizeof(desc), NULL, 0, 0) != 0) {
+            return dlgetname(&desc, sizeof(desc), NULL, 0, 0);
+        }
+    }
+#endif
+    return NULL;
+}
+
+/*
+ *  Returns the full path of Oracle client library used by the current process.
+ *
+ *  @return [String]
+ */
+static VALUE dll_path(VALUE module)
+{
+    const char *path = oci8_dll_path();
+    if (path == NULL) {
+        return Qnil;
+    }
+    return rb_external_str_new_with_enc(path, strlen(path), rb_filesystem_encoding());
+}
+
+void Init_oci8_util(VALUE cOCI8)
+{
+#if 0
+    /* for yard */
+    cOCIHandle = rb_define_class("OCIHandle", rb_cObject);
+    cOCI8 = rb_define_class("STACI", cOCIHandle);
+#endif
+    VALUE mUtil = rb_define_module_under(cOCI8, "Util");
+
+    rb_define_module_function(mUtil, "dll_path", dll_path, 0);
+}