ruby-oci8 1.0.2

data/ext/oci8/bind.c

@@ -0,0 +1,194 @@
+/*
+  define.c - part of ruby-oci8
+
+  Copyright (C) 2002,2006 KUBO Takehiro <kubo@jiubao.org>
+
+=begin
+== OCIBind
+The bind handle, which is created by ((<OCIStmt#bindByPos>)) or ((<OCIStmt#bindByName>)).
+
+super class: ((<OCIHandle>))
+
+correspond native OCI datatype: ((|OCIBind|))
+=end
+*/
+#include "oci8.h"
+
+/*
+=begin
+--- OCIBind#get()
+     get the bind value, which set by OCI call.
+
+     :return value
+        the bind value. Its datatype is correspond to the 2nd argument of ((<OCIStmt#bindByPos>)) or ((<OCIStmt#bindByName>)).
+
+     correspond native OCI function: nothing
+=end
+*/
+static VALUE oci8_get_data(VALUE self)
+{
+  oci8_bind_handle_t *defnhp;
+  VALUE obj;
+
+  Data_Get_Struct(self, oci8_bind_handle_t, defnhp);
+  obj = oci8_get_value(defnhp);
+  return obj;
+}
+
+/*
+=begin
+--- OCIBind#set(value)
+     get the bind value to pass Oracle via OCI call.
+
+     :value
+        the value to set the bind handle. Its datatype must be correspond to the 2nd argument of ((<OCIStmt#bindByPos>)) or ((<OCIStmt#bindByName>)).
+
+     correspond native OCI function: nothing
+=end
+*/
+static VALUE oci8_set_data(VALUE self, VALUE val)
+{
+  oci8_bind_handle_t *hp;
+
+  Data_Get_Struct(self, oci8_bind_handle_t, hp);
+  oci8_set_value(hp, val);
+  return self;
+}
+
+void Init_oci8_bind(void)
+{
+  rb_define_method(cOCIBind, "get", oci8_get_data, 0);
+  rb_define_method(cOCIBind, "set", oci8_set_data, 1);
+}
+
+VALUE oci8_get_value(oci8_bind_handle_t *hp)
+{
+  ora_date_t *od;
+  ora_vnumber_t *ovn;
+  VALUE obj;
+  unsigned char buf[ORA_NUMBER_BUF_SIZE];
+  int year, month, day, hour, minute, second;
+  static ID id_local = (ID)-1;
+
+  if (hp->ind != 0)
+    return Qnil;
+  switch (hp->bind_type) {
+  case BIND_STRING:
+    return rb_str_new(hp->value.str.buf, hp->value.str.len);
+  case BIND_FIXNUM:
+    return LONG2NUM(hp->value.lng);
+  case BIND_INTEGER_VIA_ORA_NUMBER:
+    ora_number_to_str(buf, NULL, &(hp->value.on), hp->rlen);
+    return rb_cstr2inum(TO_CHARPTR(buf), 10);
+  case BIND_TIME_VIA_ORA_DATE:
+    oci8_get_ora_date(&(hp->value.od), &year, &month, &day, &hour, &minute, &second);
+    if (id_local == (ID)-1)
+      id_local = rb_intern("local");
+    return rb_funcall(rb_cTime, id_local, 6, INT2FIX(year), INT2FIX(month), INT2FIX(day), INT2FIX(hour), INT2FIX(minute), INT2FIX(second));
+  case BIND_FLOAT:
+  case BIND_BINARY_DOUBLE:
+    return rb_float_new(hp->value.dbl);
+  case BIND_ORA_DATE:
+    obj = Data_Make_Struct(cOraDate, ora_date_t, NULL, xfree, od);
+    memcpy(od, &(hp->value.od), sizeof(ora_date_t));
+    return obj;
+  case BIND_ORA_NUMBER:
+    obj = Data_Make_Struct(cOraNumber, ora_vnumber_t, NULL, xfree, ovn);
+    ovn->size = hp->rlen;
+    memcpy(&(ovn->num), &(hp->value.on), sizeof(ora_number_t));
+    return obj;
+  case BIND_HANDLE:
+    return hp->value.handle.v;
+  }
+  rb_bug("unsupported data type: %d", hp->bind_type);
+}
+
+void oci8_set_value(oci8_bind_handle_t *hp, VALUE val)
+{
+  ora_date_t *od;
+  ora_vnumber_t *ovn;
+  int year, mon, day, hour, min, sec;
+  static ID id_year = (ID)-1;
+  static ID id_mon = (ID)-1;
+  static ID id_day = (ID)-1;
+  static ID id_hour = (ID)-1;
+  static ID id_min = (ID)-1;
+  static ID id_sec = (ID)-1;
+
+  if (NIL_P(val)) {
+    hp->ind = -1;
+    return;
+  }
+  switch (hp->bind_type) {
+  case BIND_FIXNUM:
+    Check_Type(val, T_FIXNUM);
+    hp->value.lng = FIX2LONG(val);
+    break;
+  case BIND_STRING:
+    Check_Type(val, T_STRING);
+    if (hp->value_sz - 4 < RSTRING_LEN(val)) {
+      rb_raise(rb_eArgError, "Assigned string is too long. %ld (max %d)", RSTRING_LEN(val), hp->value_sz - 4);
+    }
+    memcpy(hp->value.str.buf, RSTRING_PTR(val), RSTRING_LEN(val));
+    hp->value.str.len = RSTRING_LEN(val);
+    break;
+  case BIND_TIME_VIA_ORA_DATE:
+    if (!rb_obj_is_instance_of(val, rb_cTime)) {
+      rb_raise(rb_eTypeError, "invalid argument (expect Time)");
+    }
+#define GET_TIME_OF_XXX(name) \
+    if (id_##name == (ID)-1) \
+      id_##name = rb_intern(#name); \
+    name = FIX2INT(rb_funcall(val, id_##name, 0))
+    GET_TIME_OF_XXX(year);
+    GET_TIME_OF_XXX(mon);
+    GET_TIME_OF_XXX(day);
+    GET_TIME_OF_XXX(hour);
+    GET_TIME_OF_XXX(min);
+    GET_TIME_OF_XXX(sec);
+    oci8_set_ora_date(&(hp->value.od), year, mon, day, hour, min, sec);
+    break;
+  case BIND_FLOAT:
+  case BIND_BINARY_DOUBLE:
+    Check_Type(val, T_FLOAT);
+    hp->value.dbl = RFLOAT(val)->value;
+    break;
+  case BIND_ORA_DATE:
+    if (!rb_obj_is_instance_of(val, cOraDate)) {
+      rb_raise(rb_eTypeError, "invalid argument (expect OraDate)");
+    }
+    Data_Get_Struct(val, ora_date_t, od);
+    memcpy(&(hp->value.od), od, sizeof(ora_date_t));
+    break;
+  case BIND_INTEGER_VIA_ORA_NUMBER:
+  case BIND_ORA_NUMBER:
+    if (rb_obj_is_instance_of(val, cOraNumber)) {
+      Data_Get_Struct(val, ora_vnumber_t, ovn);
+      hp->rlen = ovn->size;
+      memcpy(&(hp->value.on), &(ovn->num), sizeof(ora_number_t));
+    } else if (rb_obj_is_kind_of(val, rb_cNumeric)) {
+      ora_vnumber_t ovn;
+      if (set_oci_vnumber(&ovn, val, hp->errhp) == 0) {
+	rb_raise(rb_eTypeError, "could not bind value.");
+      }
+      hp->rlen = ovn.size;
+      memcpy(&(hp->value.on), &(ovn.num), sizeof(ora_number_t));
+    } else {
+      rb_raise(rb_eTypeError, "invalid argument (expect OraNumber)");
+    }
+    break;
+  case BIND_HANDLE:
+    if (rb_obj_is_kind_of(val, hp->value.handle.klass)) {
+      oci8_handle_t *h;
+      Get_Handle(val, h);
+      hp->value.handle.v = val;
+      hp->value.handle.hp = h->hp;
+    } else {
+      rb_raise(rb_eTypeError, "invalid argument: %s (expect %s)", rb_obj_classname(val), rb_class2name(hp->value.handle.klass));
+    }
+    break;
+  default:
+    rb_bug("unsupported data type: %d", hp->bind_type);
+  }
+  hp->ind = 0;
+}

data/ext/oci8/const.c

@@ -0,0 +1,165 @@
+/*
+  const.c - part of ruby-oci8
+
+  Copyright (C) 2002-2006 KUBO Takehiro <kubo@jiubao.org>
+
+  define constant values.
+*/
+#include "oci8.h"
+
+ID oci8_id_code;
+ID oci8_id_define_array;
+ID oci8_id_bind_hash;
+ID oci8_id_message;
+ID oci8_id_new;
+ID oci8_id_parse_error_offset;
+ID oci8_id_server;
+ID oci8_id_session;
+ID oci8_id_sql;
+
+struct oci8_names {
+  const char *name;
+  VALUE value;
+};
+typedef struct oci8_names oci8_names_t;
+#define ENTRY(name) {#name, INT2FIX(name)}
+
+static oci8_names_t oci8_typecode[] = {
+  ENTRY(OCI_TYPECODE_VARCHAR),          /* 1(SQLT_CHR) */
+  ENTRY(OCI_TYPECODE_NUMBER),           /* 2(SQLT_NUM) */
+  ENTRY(OCI_TYPECODE_DATE),             /* 12(SQLT_DAT) */
+  ENTRY(OCI_TYPECODE_UNSIGNED8),        /* 23(SQLT_BIN) */
+  ENTRY(OCI_TYPECODE_RAW),              /* 95(SQLT_LVB) */
+  ENTRY(OCI_TYPECODE_CHAR),             /* 96(SQLT_AFC) */
+#ifdef OCI_TYPECODE_BDOUBLE
+  ENTRY(OCI_TYPECODE_BDOUBLE),          /* 101(SQLT_IBDOUBLE) */
+#endif
+  ENTRY(OCI_TYPECODE_OBJECT),           /* 108(SQLT_NTY) */
+  ENTRY(OCI_TYPECODE_BLOB),             /* 113(SQLT_BLOB) */
+  ENTRY(OCI_TYPECODE_CLOB),             /* 112(SQLT_CLOB) */
+  ENTRY(OCI_TYPECODE_NAMEDCOLLECTION),  /* 122(SQLT_NCO) */
+  ENTRY(SQLT_RDD) /* 104 */
+};
+#define NUM_OF_OCI8_TYPECODE (sizeof(oci8_typecode) / sizeof(oci8_typecode[0]))
+
+static VALUE oci8_make_names(oci8_names_t *names, size_t size)
+{
+  volatile VALUE ary;
+  int i;
+
+  ary = rb_ary_new();
+  for (i = 0;i < size;i++)
+    rb_ary_store(ary, FIX2INT(names[i].value), rb_str_new2(names[i].name));
+  return ary;
+}
+
+void  Init_oci8_const(void)
+{
+  int i;
+
+  oci8_id_code = rb_intern("code");
+  oci8_id_define_array = rb_intern("define_array");
+  oci8_id_bind_hash = rb_intern("bind_hash");
+  oci8_id_message = rb_intern("message");
+  oci8_id_new = rb_intern("new");
+  oci8_id_parse_error_offset = rb_intern("parse_error_offset");
+  oci8_id_server = rb_intern("server");
+  oci8_id_session = rb_intern("session");
+  oci8_id_sql = rb_intern("sql");
+
+  rb_define_global_const("OCI_DEFAULT", INT2FIX(OCI_DEFAULT));
+  rb_define_global_const("OCI_OBJECT", INT2FIX(OCI_OBJECT));
+  rb_define_global_const("OCI_CRED_RDBMS", INT2FIX(OCI_CRED_RDBMS));
+  rb_define_global_const("OCI_CRED_EXT", INT2FIX(OCI_CRED_EXT));
+  rb_define_global_const("OCI_MIGRATE", INT2FIX(OCI_MIGRATE));
+  rb_define_global_const("OCI_SYSDBA", INT2FIX(OCI_SYSDBA));
+  rb_define_global_const("OCI_SYSOPER", INT2FIX(OCI_SYSOPER));
+  rb_define_global_const("OCI_PRELIM_AUTH", INT2FIX(OCI_PRELIM_AUTH));
+
+  /* OCIStmt#prepare */
+  rb_define_global_const("OCI_NTV_SYNTAX", INT2FIX(OCI_NTV_SYNTAX));
+  rb_define_global_const("OCI_V7_SYNTAX", INT2FIX(OCI_V7_SYNTAX));
+  rb_define_global_const("OCI_V8_SYNTAX", INT2FIX(OCI_V8_SYNTAX));
+
+  /* OCIStmt#execute */
+#ifdef OCI_BATCH_ERRORS
+  rb_define_global_const("OCI_BATCH_ERRORS", INT2FIX(OCI_BATCH_ERRORS));
+#endif
+  rb_define_global_const("OCI_COMMIT_ON_SUCCESS", INT2FIX(OCI_COMMIT_ON_SUCCESS));
+  rb_define_global_const("OCI_DESCRIBE_ONLY", INT2FIX(OCI_DESCRIBE_ONLY));
+  rb_define_global_const("OCI_EXACT_FETCH", INT2FIX(OCI_EXACT_FETCH));
+#ifdef OCI_PARSE_ONLY
+  rb_define_global_const("OCI_PARSE_ONLY", INT2FIX(OCI_PARSE_ONLY));
+#endif
+#ifdef OCI_STMT_SCROLLABLE_READONLY
+  rb_define_global_const("OCI_STMT_SCROLLABLE_READONLY", INT2FIX(OCI_STMT_SCROLLABLE_READONLY));
+#endif
+
+  rb_define_global_const("OCI_AUTH", INT2FIX(OCI_AUTH));
+#ifdef OCI_SHARED
+  rb_define_global_const("OCI_SHARED", INT2FIX(OCI_SHARED));
+#endif
+#ifdef OCI_CPOOL
+  rb_define_global_const("OCI_CPOOL", INT2FIX(OCI_CPOOL));
+#endif
+#ifdef OCI_NO_SHARING
+  rb_define_global_const("OCI_NO_SHARING", INT2FIX(OCI_NO_SHARING));
+#endif
+
+  rb_define_global_const("OCI_FETCH_NEXT", INT2FIX(OCI_FETCH_NEXT));
+
+  for (i = 0;i < oci8_attr_size;i++) {
+    rb_define_global_const(oci8_attr_list[i].name, INT2FIX(i));
+  }
+
+  /* TYPE CODE */
+  for (i = 0;i < NUM_OF_OCI8_TYPECODE;i++)
+    rb_define_global_const(oci8_typecode[i].name, oci8_typecode[i].value);
+  rb_define_global_const("OCI_TYPECODE_NAMES", oci8_make_names(oci8_typecode, NUM_OF_OCI8_TYPECODE));
+
+  /* OCI Parameter Types */
+  rb_define_global_const("OCI_PTYPE_UNK", INT2FIX(OCI_PTYPE_UNK));
+  rb_define_global_const("OCI_PTYPE_TABLE", INT2FIX(OCI_PTYPE_TABLE));
+  rb_define_global_const("OCI_PTYPE_VIEW", INT2FIX(OCI_PTYPE_VIEW));
+  rb_define_global_const("OCI_PTYPE_PROC", INT2FIX(OCI_PTYPE_PROC));
+  rb_define_global_const("OCI_PTYPE_FUNC", INT2FIX(OCI_PTYPE_FUNC));
+  rb_define_global_const("OCI_PTYPE_PKG", INT2FIX(OCI_PTYPE_PKG));
+  rb_define_global_const("OCI_PTYPE_TYPE", INT2FIX(OCI_PTYPE_TYPE));
+  rb_define_global_const("OCI_PTYPE_SYN", INT2FIX(OCI_PTYPE_SYN));
+  rb_define_global_const("OCI_PTYPE_SEQ", INT2FIX(OCI_PTYPE_SEQ));
+  rb_define_global_const("OCI_PTYPE_COL", INT2FIX(OCI_PTYPE_COL));
+  rb_define_global_const("OCI_PTYPE_ARG", INT2FIX(OCI_PTYPE_ARG));
+  rb_define_global_const("OCI_PTYPE_LIST", INT2FIX(OCI_PTYPE_LIST));
+  rb_define_global_const("OCI_PTYPE_TYPE_ATTR", INT2FIX(OCI_PTYPE_TYPE_ATTR));
+  rb_define_global_const("OCI_PTYPE_TYPE_COLL", INT2FIX(OCI_PTYPE_TYPE_COLL));
+  rb_define_global_const("OCI_PTYPE_TYPE_METHOD", INT2FIX(OCI_PTYPE_TYPE_METHOD));
+  rb_define_global_const("OCI_PTYPE_TYPE_ARG", INT2FIX(OCI_PTYPE_TYPE_ARG));
+  rb_define_global_const("OCI_PTYPE_TYPE_RESULT", INT2FIX(OCI_PTYPE_TYPE_RESULT));
+#ifdef OCI_PTYPE_SCHEMA
+  rb_define_global_const("OCI_PTYPE_SCHEMA", INT2FIX(OCI_PTYPE_SCHEMA));
+#endif
+#ifdef OCI_PTYPE_DATABASE
+  rb_define_global_const("OCI_PTYPE_DATABASE", INT2FIX(OCI_PTYPE_DATABASE));
+#endif
+
+  /* Bind and Define Options */
+  rb_define_global_const("OCI_DATA_AT_EXEC", INT2FIX(OCI_DATA_AT_EXEC));
+  rb_define_global_const("OCI_DYNAMIC_FETCH", INT2FIX(OCI_DYNAMIC_FETCH));
+
+  /* OCI Statement Types */
+  rb_define_global_const("OCI_STMT_SELECT", INT2FIX(OCI_STMT_SELECT));
+  rb_define_global_const("OCI_STMT_UPDATE", INT2FIX(OCI_STMT_UPDATE));
+  rb_define_global_const("OCI_STMT_DELETE", INT2FIX(OCI_STMT_DELETE));
+  rb_define_global_const("OCI_STMT_INSERT", INT2FIX(OCI_STMT_INSERT));
+  rb_define_global_const("OCI_STMT_CREATE", INT2FIX(OCI_STMT_CREATE));
+  rb_define_global_const("OCI_STMT_DROP", INT2FIX(OCI_STMT_DROP));
+  rb_define_global_const("OCI_STMT_ALTER", INT2FIX(OCI_STMT_ALTER));
+  rb_define_global_const("OCI_STMT_BEGIN", INT2FIX(OCI_STMT_BEGIN));
+  rb_define_global_const("OCI_STMT_DECLARE", INT2FIX(OCI_STMT_DECLARE));
+
+  /* Piece Definitions */
+  rb_define_global_const("OCI_ONE_PIECE", INT2FIX(OCI_ONE_PIECE));
+  rb_define_global_const("OCI_FIRST_PIECE", INT2FIX(OCI_FIRST_PIECE));
+  rb_define_global_const("OCI_NEXT_PIECE", INT2FIX(OCI_NEXT_PIECE));
+  rb_define_global_const("OCI_LAST_PIECE", INT2FIX(OCI_LAST_PIECE));
+}

data/ext/oci8/define.c

@@ -0,0 +1,53 @@
+/*
+  define.c - part of ruby-oci8
+
+  Copyright (C) 2002 KUBO Takehiro <kubo@jiubao.org>
+
+=begin
+== OCIDefine
+The define handle, which is created by ((<OCIStmt#defineByPos>)).
+
+The fetched data of select statements is got via this handle.
+
+super class: ((<OCIHandle>))
+
+correspond native OCI datatype: ((|OCIDefine|))
+=end
+*/
+#include "oci8.h"
+
+/*
+=begin
+--- OCIDefine#get()
+     get the selected date.
+
+     :return value
+        fetched data. Its datatype is correspond to the 2nd argument of ((<OCIStmt#defineByPos>)).
+
+     correspond native OCI function: nothing
+=end
+*/
+static VALUE oci8_get_data(VALUE self)
+{
+  oci8_bind_handle_t *defnhp;
+  VALUE obj;
+
+  Data_Get_Struct(self, oci8_bind_handle_t, defnhp);
+  obj = oci8_get_value(defnhp);
+  return obj;
+}
+
+static VALUE oci8_set_data(VALUE self, VALUE val)
+{
+  oci8_bind_handle_t *hp;
+
+  Data_Get_Struct(self, oci8_bind_handle_t, hp);
+  oci8_set_value(hp, val);
+  return self;
+}
+
+void Init_oci8_define(void)
+{
+  rb_define_method(cOCIDefine, "get", oci8_get_data, 0);
+  rb_define_method(cOCIDefine, "set", oci8_set_data, 1);
+}

data/ext/oci8/describe.c

@@ -0,0 +1,81 @@
+/*
+  describe.c - part of ruby-oci8
+
+  Copyright (C) 2002 KUBO Takehiro <kubo@jiubao.org>
+
+=begin
+== OCIDescribe
+The describe handle, which is used for the explicit describe.
+
+super class: ((<OCIHandle>))
+
+correspond native OCI datatype: ((|OCIDescribe|))
+
+For example:
+  dsc = env.alloc(OCIDescribe)
+  dsc.describeAny(svc, "EMP", OCI_PTYPE_TABLE)
+  parm = dsc.attrGet(OCI_ATTR_PARAM)
+  ...get various information from parm...
+
+TODO: more explanation and examples.
+
+=end
+*/
+#include "oci8.h"
+
+/*
+=begin
+--- OCIDescribe#describeAny(svc, name, type)
+     get various information of Oracle's schema objects: tables, views, synonyms, 
+     procedures, functions, packages, sequences, and types.
+
+     :svc
+        ((<service context handle|OCISvcCtx>)) in which the object to describe exists.
+     :name
+        name of object to describe.
+     :type
+        type of object to describe. 
+
+        * ((|OCI_PTYPE_TABLE|)), for tables
+        * ((|OCI_PTYPE_VIEW|)), for views
+        * ((|OCI_PTYPE_PROC|)), for procedures
+        * ((|OCI_PTYPE_FUNC|)), for functions
+        * ((|OCI_PTYPE_PKG|)), for packages
+        * ((|OCI_PTYPE_TYPE|)), for types
+        * ((|OCI_PTYPE_SYN|)), for synonyms
+        * ((|OCI_PTYPE_SEQ|)), for sequences
+        * ((|OCI_PTYPE_SCHEMA|)), for schemas
+        * ((|OCI_PTYPE_DATABASE|)), for databases
+        * ((|OCI_PTYPE_UNK|)), for unknown schema objects
+
+     correspond native OCI function: ((|OCIDescribeAny|))
+
+     ((*note*)): To use this method in Oracle 8.0.5 for Linux,
+     call OCIEnv.create with OCI_OBJECT or segmentation fault occurs.
+     This bug was fixed 8.0.6 or later.
+=end
+*/
+static VALUE oci8_describe_any(VALUE self, VALUE vdsc, VALUE vname, VALUE vtype)
+{
+  oci8_handle_t *h;
+  oci8_handle_t *svch;
+  oci8_string_t name;
+  ub1 type;
+  sword rv;
+
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(vdsc, OCISvcCtx, svch); /* 1 */
+  Get_String(vname, name); /* 2 */
+  type = FIX2INT(vtype); /* 3 */
+
+  rv = OCIDescribeAny(svch->hp, h->errhp, name.ptr, name.len, OCI_OTYPE_NAME, OCI_DEFAULT, type, h->hp);
+  if (rv != OCI_SUCCESS) {
+    oci8_raise(h->errhp, rv, NULL);
+  }
+  return self;
+}
+
+void Init_oci8_describe(void)
+{
+  rb_define_method(cOCIDescribe, "describeAny", oci8_describe_any, 3);
+}