ruby-oci8 1.0.2

data/ext/oci8/descriptor.c

@@ -0,0 +1,39 @@
+/*
+  descriptor.c - part of ruby-oci8
+
+  Copyright (C) 2002 KUBO Takehiro <kubo@jiubao.org>
+
+=begin
+== OCIDescriptor
+The abstract class of OCI descriptors.
+=end
+*/
+#include "oci8.h"
+
+/*
+=begin
+--- OCIDescriptor#attrGet(type)
+     :type
+       the type of attribute.
+     :return value
+       depends on argument ((|type|)).
+
+     See also ((<Attributes of Handles and Descriptors>)).
+=end
+*/
+
+/*
+=begin
+--- OCIDescriptor#free()
+     explicitly free the OCI's data structure associated with this object.
+     This call will not free ruby's object itself, which wrap the OCI's data structure.
+=end
+*/
+
+void Init_oci8_descriptor(void)
+{
+  rb_define_method(cOCIDescriptor, "attrGet", oci8_attr_get, 1);
+  rb_define_method(cOCIDescriptor, "attrSet", oci8_attr_set, 2);
+  rb_define_method(cOCIDescriptor, "free", oci8_handle_free, 0);
+  rb_define_singleton_method(cOCIDescriptor, "new", oci8_s_new, 0);
+}

data/ext/oci8/env.c

@@ -0,0 +1,276 @@
+/*
+  env.c - part of ruby-oci8
+
+  Copyright (C) 2002 KUBO Takehiro <kubo@jiubao.org>
+
+=begin
+== OCIEnv
+The environment handle is the source of all OCI objects.
+Usually there is one instance per one application.
+
+super class: ((<OCIHandle>))
+
+correspond native OCI datatype: ((|OCIEnv|))
+=end
+*/
+#include "oci8.h"
+#include <util.h> /* ruby_setenv */
+
+RBOCI_NORETURN(static void oci8_raise_init_error(void));
+
+static void oci8_raise_init_error(void)
+{
+  VALUE msg = rb_str_new2("OCI Library Initialization Error");
+  VALUE exc = rb_funcall(eOCIError, oci8_id_new, 1, msg);
+  rb_ivar_set(exc, oci8_id_code, rb_ary_new3(1, INT2FIX(-1)));
+  rb_ivar_set(exc, oci8_id_message, rb_ary_new3(1, msg));
+  rb_exc_raise(exc);
+}
+
+static VALUE oci8_env_s_initialize(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE vmode;
+  ub4 mode;
+  sword rv;
+
+#ifndef WIN32
+  /* workaround code.
+   *
+   * Some instant clients set the environment variables
+   * ORA_NLS_PROFILE33, ORA_NLS10 and ORACLE_HOME if they aren't
+   * set. It causes problems on some platforms.
+   */
+  if (RTEST(rb_eval_string("RUBY_VERSION == \"1.8.4\""))) {
+    if (getenv("ORA_NLS_PROFILE33") == NULL) {
+      ruby_setenv("ORA_NLS_PROFILE33", "");
+    }
+    if (getenv("ORA_NLS10") == NULL) {
+      ruby_setenv("ORA_NLS10", "");
+    }
+    if (getenv("ORACLE_HOME") == NULL) {
+      ruby_setenv("ORACLE_HOME", ".");
+    }
+  }
+#endif /* WIN32 */
+
+  rb_scan_args(argc, argv, "01", &vmode);
+  Get_Int_With_Default(argc, 1, vmode, mode, OCI_DEFAULT); /* 1 */
+  
+  rv = OCIInitialize(mode, NULL, NULL, NULL, NULL);
+  return INT2FIX(rv);
+}
+
+static VALUE oci8_env_s_init(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE vmode;
+  ub4 mode;
+  OCIEnv *envhp = NULL;
+  OCIError *errhp;
+  oci8_handle_t *h;
+  sword rv;
+
+  rb_scan_args(argc, argv, "01", &vmode);
+  Get_Int_With_Default(argc, 1, vmode, mode, OCI_DEFAULT); /* 1 */
+  
+  rv = OCIEnvInit(&envhp, OCI_DEFAULT, 0, NULL);
+  if (envhp == NULL) {
+    oci8_raise_init_error();
+  }
+  if (rv != OCI_SUCCESS)
+    oci8_env_raise(envhp, rv);
+  rv = OCIHandleAlloc(envhp, (dvoid *)&errhp, OCI_HTYPE_ERROR, 0, NULL);
+  if (rv != OCI_SUCCESS)
+    oci8_env_raise(envhp, rv);
+  h = oci8_make_handle(OCI_HTYPE_ENV, envhp, errhp, NULL, 0);
+  return h->self;
+}
+
+/*
+=begin
+--- OCIEnv.create([mode])
+     create the environment handle. Don't call `new'.
+
+     :mode
+        ((|OCI_DEFAULT|)), ((|OCI_THREADED|)), ((|OCI_OBJECT|)), ((|OCI_SHARED|))
+        or these combination.
+        But I test only ((|OCI_DEFAULT|)). Default value is ((|OCI_DEFAULT|)).
+
+        ((|OCI_THREADED|)): if your application use native thread(not ruby's thread), use this.
+
+        ((|OCI_OBJECT|)): for OCI objects. But current implementation doesn't support OCI Object-Relational functions.
+        This is for ((*far future*)) extension, because my plan doesn't include `OCI object support'.
+
+        ((|OCI_SHARED|))(Oracle 8i or later): for ((<Shared Data Mode>)).
+
+     :return value
+        A instance of ((<OCIEnv>)).
+
+     correspond native OCI function: ((|OCIEnvCreate|)) (if ((|OCIEnvCreate|)) is not found, the combination of ((|OCIInitialize|)) and ((|OCIEnvInit|)).)
+=end
+*/
+#ifdef HAVE_OCIENVCREATE
+static VALUE oci8_env_s_create(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE vmode;
+  ub4 mode;
+  OCIEnv *envhp = NULL;
+  OCIError *errhp;
+  oci8_handle_t *h;
+  sword rv;
+
+  rb_scan_args(argc, argv, "01", &vmode);
+  Get_Int_With_Default(argc, 1, vmode, mode, OCI_DEFAULT); /* 1 */
+
+  rv = OCIEnvCreate(&envhp, mode, NULL, NULL, NULL, NULL, 0, NULL);
+  if (envhp == NULL) {
+    oci8_raise_init_error();
+  }
+  if (rv != OCI_SUCCESS)
+    oci8_env_raise(envhp, rv);
+  rv = OCIHandleAlloc(envhp, (dvoid *)&errhp, OCI_HTYPE_ERROR, 0, NULL);
+  if (rv != OCI_SUCCESS)
+    oci8_env_raise(envhp, rv);
+  h = oci8_make_handle(OCI_HTYPE_ENV, envhp, errhp, NULL, 0);
+  return h->self;
+}
+#endif
+
+/*
+=begin
+--- OCIEnv.terminate([mode])
+     :mode
+        ((|OCI_DEFAULT|)) only valid. Default value is ((|OCI__DEFAULT|)).
+
+     correspond native OCI function: ((|OCITerminate|))
+=end
+*/
+#ifdef HAVE_OCITERMINATE
+static VALUE oci8_env_s_terminate(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE vmode;
+  ub4 mode;
+
+  if (rb_scan_args(argc, argv, "01", &vmode) == 1) {
+    Check_Type(vmode, T_FIXNUM);
+    mode = FIX2INT(vmode);
+  } else {
+    mode = OCI_DEFAULT;
+  }
+
+  OCITerminate(mode);
+  return Qnil;
+}
+#endif
+
+/*
+=begin
+--- OCIEnv#alloc(handle)
+     create a new OCI handle.
+     :handle
+        The valid values are ((<OCISvcCtx>)), ((<OCIStmt>)),
+        ((<OCIServer>)), ((<OCISession>)), and ((<OCIDescribe>)).
+     :return value
+        A newly created handle.
+
+     correspond native OCI function: ((|OCIHandleAlloc|))
+=end
+*/
+typedef sword (*alloc_func_t)(CONST dvoid *, dvoid **, CONST ub4, CONST size_t, dvoid **);
+static VALUE oci8_handle_alloc(VALUE self, VALUE klass)
+{
+  sword rv;
+  dvoid *hp;
+  oci8_handle_t *envh;
+  oci8_handle_t *h;
+  int i;
+  struct {
+    VALUE *klass;
+    ub4 type;
+    alloc_func_t alloc_func;
+  } alloc_map[] = {
+    {&cOCISvcCtx,   OCI_HTYPE_SVCCTX,   (alloc_func_t)OCIHandleAlloc},
+    {&cOCIStmt,     OCI_HTYPE_STMT,     (alloc_func_t)OCIHandleAlloc},
+    {&cOCIServer,   OCI_HTYPE_SERVER,   (alloc_func_t)OCIHandleAlloc},
+    {&cOCISession,  OCI_HTYPE_SESSION,  (alloc_func_t)OCIHandleAlloc},
+    {&cOCIDescribe, OCI_HTYPE_DESCRIBE, (alloc_func_t)OCIHandleAlloc},
+    {&cOCILobLocator, OCI_DTYPE_LOB,    (alloc_func_t)OCIDescriptorAlloc},
+    {&cOCIFileLocator, OCI_DTYPE_FILE,  (alloc_func_t)OCIDescriptorAlloc},
+  };
+#define ALLOC_MAP_SIZE (sizeof(alloc_map) / sizeof(alloc_map[0]))
+
+  Get_Handle(self, envh);
+  for (i = 0;i < ALLOC_MAP_SIZE;i++) {
+    if (alloc_map[i].klass[0] == klass)
+      break;
+  }
+  if (i == ALLOC_MAP_SIZE) {
+    rb_raise(rb_eTypeError, "not valid handle type %s", rb_class2name(CLASS_OF(klass)));
+  }
+
+  rv = alloc_map[i].alloc_func(envh->hp, &hp, alloc_map[i].type, 0, NULL);
+  if (rv != OCI_SUCCESS)
+    oci8_env_raise(envh->hp, rv);
+  h = oci8_make_handle(alloc_map[i].type, hp, envh->errhp, envh, 0);
+  return h->self;
+}
+
+/*
+=begin
+--- OCIEnv#logon(username, password, dbname)
+     Logon to the Oracle server.
+
+     See ((<Simplified Logon>)) and ((<Explicit Attach and Begin Session>))
+
+     :username
+        the username.
+     :password
+        the user's password.
+     :dbname
+        the name of the database, or nil.
+     :return value
+        A instance of ((<OCISvcCtx>))
+     For example:
+       env = OCIEnv.create()
+       svc = env.logon("SCOTT", "TIGER", nil)
+         or
+       svc = env.logon("SCOTT", "TIGER", "ORCL.WORLD")
+
+     correspond native OCI function: ((|OCILogon|))
+=end
+*/
+static VALUE oci8_logon(VALUE self, VALUE username, VALUE password, VALUE dbname)
+{
+  oci8_handle_t *envh;
+  oci8_handle_t *svch;
+  OCISvcCtx *svchp;
+  oci8_string_t u, p, d;
+  VALUE obj;
+  sword rv;
+
+  Get_Handle(self, envh);
+  Get_String(username, u);
+  Get_String(password, p);
+  Get_String(dbname, d);
+  rv = OCILogon(envh->hp, envh->errhp, &svchp,
+		    u.ptr, u.len, p.ptr, p.len, d.ptr, d.len);
+  if (rv != OCI_SUCCESS) {
+    oci8_raise(envh->errhp, rv, NULL);
+  }
+  svch = oci8_make_handle(OCI_HTYPE_SVCCTX, svchp, envh->errhp, envh, 0);
+  obj = svch->self;
+  return obj;
+}
+
+void Init_oci8_env(void)
+{
+  rb_define_singleton_method(cOCIEnv, "initialise", oci8_env_s_initialize, -1);
+  rb_define_singleton_method(cOCIEnv, "init", oci8_env_s_init, -1);
+#ifdef HAVE_OCIENVCREATE
+  rb_define_singleton_method(cOCIEnv, "create", oci8_env_s_create, -1);
+#endif
+#ifdef HAVE_OCITERMINATE
+  rb_define_singleton_method(cOCIEnv, "terminate", oci8_env_s_terminate, -1);
+#endif
+  rb_define_method(cOCIEnv, "alloc", oci8_handle_alloc, 1);
+  rb_define_method(cOCIEnv, "logon", oci8_logon, 3);
+}

data/ext/oci8/error.c

@@ -0,0 +1,234 @@
+/*
+  error.c - part of ruby-oci8
+
+  Copyright (C) 2002 KUBO Takehiro <kubo@jiubao.org>
+
+=begin
+== OCIError
+=end
+*/
+#include "oci8.h"
+
+static ID oci8_id_caller;
+static ID oci8_id_set_backtrace;
+
+RBOCI_NORETURN(static void oci8_raise2(dvoid *errhp, sword status, ub4 type, OCIStmt *stmthp, const char *file, int line));
+
+static void oci8_raise2(dvoid *errhp, sword status, ub4 type, OCIStmt *stmthp, const char *file, int line)
+{
+  VALUE vcodes = Qnil;
+  VALUE vmessages = Qnil;
+  VALUE exc;
+  char errmsg[1024];
+  sb4 errcode;
+  ub4 recodeno;
+  VALUE msg;
+#ifdef OCI_ATTR_PARSE_ERROR_OFFSET
+  VALUE vparse_error_offset = Qnil;
+#endif
+#ifdef OCI_ATTR_STATEMENT
+  VALUE vsql = Qnil;
+#endif
+  int i;
+  int rv;
+  VALUE backtrace;
+#if defined(_WIN32) || defined(WIN32)
+  char *p = strrchr(file, '\\');
+  if (p != NULL)
+    file = p + 1;
+#endif
+
+  switch (status) {
+  case OCI_ERROR:
+  case OCI_SUCCESS_WITH_INFO:
+    vcodes = rb_ary_new();
+    vmessages = rb_ary_new();
+    for (recodeno = 1;;recodeno++) {
+      /* get error string */
+      rv = OCIErrorGet(errhp, recodeno, NULL, &errcode, TO_ORATEXT(errmsg), sizeof(errmsg), type);
+      if (rv != OCI_SUCCESS) {
+        break;
+      }
+      /* chop error string */
+      for (i = strlen(errmsg) - 1;i >= 0;i--) {
+	if (errmsg[i] == '\n' || errmsg[i] == '\r') {
+	  errmsg[i] = '\0';
+	} else {
+	  break;
+	}
+      }
+      rb_ary_push(vcodes, INT2FIX(errcode));
+      rb_ary_push(vmessages, rb_str_new2(errmsg));
+    }
+    if (RARRAY_LEN(vmessages) > 0) {
+      msg = RARRAY_PTR(vmessages)[0];
+    } else {
+      msg = rb_str_new2("ERROR");
+    }
+    if (status == OCI_ERROR) {
+      exc = eOCIError;
+    } else {
+      exc = eOCISuccessWithInfo;
+    }
+    break;
+  case OCI_NO_DATA:
+    exc = eOCINoData;
+    msg = rb_str_new2("No Data");
+    break;
+  case OCI_INVALID_HANDLE:
+    exc = eOCIInvalidHandle;
+    msg = rb_str_new2("Invalid Handle");
+    break;
+  case OCI_NEED_DATA:
+    exc = eOCINeedData;
+    msg = rb_str_new2("Need Data");
+    break;
+  case OCI_STILL_EXECUTING:
+    exc = eOCIStillExecuting;
+    msg = rb_str_new2("Still Executing");
+    break;
+  case OCI_CONTINUE:
+    exc = eOCIContinue;
+    msg = rb_str_new2("Continue");
+    break;
+  default:
+    sprintf(errmsg, "Unknown error (%d)", status);
+    exc = rb_eStandardError;
+    msg = rb_str_new2(errmsg);
+  }
+  exc = rb_funcall(exc, oci8_id_new, 1, msg);
+  if (!NIL_P(vcodes)) {
+    rb_ivar_set(exc, oci8_id_code, vcodes);
+  }
+  if (!NIL_P(vmessages)) {
+    rb_ivar_set(exc, oci8_id_message, vmessages);
+  }
+#ifdef OCI_ATTR_PARSE_ERROR_OFFSET
+  if (!NIL_P(vparse_error_offset)) {
+    rb_ivar_set(exc, oci8_id_parse_error_offset, vparse_error_offset);
+  }
+#endif
+#ifdef OCI_ATTR_STATEMENT
+  if (!NIL_P(vsql)) {
+    rb_ivar_set(exc, oci8_id_sql, vsql);
+  }
+#endif
+  /*
+   * make error line in C code.
+   */
+  backtrace = rb_funcall(rb_cObject, rb_intern("caller"), 0);
+  sprintf(errmsg, "%s:%d:in oci8lib.so", file, line);
+  rb_ary_unshift(backtrace, rb_str_new2(errmsg));
+  rb_funcall(exc, rb_intern("set_backtrace"), 1, backtrace);
+  rb_exc_raise(exc);
+}
+
+static VALUE oci8_error_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE msg;
+  VALUE code;
+
+  rb_scan_args(argc, argv, "02", &msg, &code);
+  rb_call_super(argc > 1 ? 1 : argc, argv);
+  if (!NIL_P(code)) {
+    rb_ivar_set(self, oci8_id_code, rb_ary_new3(1, code));
+  }
+  return Qnil;
+}
+
+
+/*
+=begin
+--- OCIError#code()
+=end
+*/
+static VALUE oci8_error_code(VALUE self)
+{
+  VALUE ary = rb_ivar_get(self, oci8_id_code);
+  if (NIL_P(ary)) {
+    return Qnil;
+  }
+  Check_Type(ary, T_ARRAY);
+  if (RARRAY_LEN(ary) == 0) {
+    return Qnil;
+  }
+  return RARRAY_PTR(ary)[0];
+}
+
+/*
+=begin
+--- OCIError#codes()
+=end
+*/
+static VALUE oci8_error_code_array(VALUE self)
+{
+  return rb_ivar_get(self, oci8_id_code);
+}
+
+/*
+=begin
+--- OCIError#message()
+=end
+*/
+
+/*
+=begin
+--- OCIError#messages()
+=end
+*/
+static VALUE oci8_error_message_array(VALUE self)
+{
+  return rb_ivar_get(self, oci8_id_message);
+}
+
+#ifdef OCI_ATTR_PARSE_ERROR_OFFSET
+/*
+=begin
+--- OCIError#parseErrorOffset()
+=end
+*/
+static VALUE oci8_error_parse_error_offset(VALUE self)
+{
+  return rb_ivar_get(self, oci8_id_parse_error_offset);
+}
+#endif
+
+#ifdef OCI_ATTR_STATEMENT
+/*
+=begin
+--- OCIError#sql()
+     (Oracle 8.1.6 or later)
+=end
+*/
+static VALUE oci8_error_sql(VALUE self)
+{
+  return rb_ivar_get(self, oci8_id_sql);
+}
+#endif
+
+void Init_oci8_error(void)
+{
+  oci8_id_caller = rb_intern("caller");
+  oci8_id_set_backtrace = rb_intern("set_backtrace");
+
+  rb_define_method(eOCIError, "initialize", oci8_error_initialize, -1);
+  rb_define_method(eOCIError, "code", oci8_error_code, 0);
+  rb_define_method(eOCIError, "codes", oci8_error_code_array, 0);
+  rb_define_method(eOCIError, "messages", oci8_error_message_array, 0);
+#ifdef OCI_ATTR_PARSE_ERROR_OFFSET
+  rb_define_method(eOCIError, "parseErrorOffset", oci8_error_parse_error_offset, 0);
+#endif
+#ifdef OCI_ATTR_STATEMENT
+  rb_define_method(eOCIError, "sql", oci8_error_sql, 0);
+#endif
+}
+
+void oci8_do_raise(OCIError *errhp, sword status, OCIStmt *stmthp, const char *file, int line)
+{
+  oci8_raise2(errhp, status, OCI_HTYPE_ERROR, stmthp, file, line);
+}
+
+void oci8_do_env_raise(OCIEnv *envhp, sword status, const char *file, int line)
+{
+  oci8_raise2(envhp, status, OCI_HTYPE_ENV, NULL, file, line);
+}