ruby-oci8 1.0.2

data/ext/oci8/extconf.rb

@@ -0,0 +1,118 @@
+raise <<EOS if RUBY_VERSION.index("1.9") == 0
+---------------------------------------------------
+error message:
+ruby-oci8 1.0 is not supported by ruby #{RUBY_VERSION}.
+Use ruby-oci8 2.0 in SVN trunk.
+---------------------------------------------------
+EOS
+
+begin
+  require 'mkmf'
+rescue LoadError
+  if /linux/ =~ RUBY_PLATFORM
+    raise <<EOS
+You need to install a ruby development package ruby-devel, ruby-dev or so.
+EOS
+  end
+  raise
+end
+
+require File.dirname(__FILE__) + '/oraconf'
+
+RUBY_OCI8_VERSION = open("#{File.dirname(__FILE__)}/../../VERSION") {|f| f.read}.chomp
+
+oraconf = OraConf.get()
+
+def replace_keyword(source, target, replace)
+  puts "creating #{target} from #{source}"
+  open(source, "rb") { |f|
+    buf = f.read
+    replace.each do |key, value|
+      buf.gsub!('@@' + key + '@@', value)
+    end
+    open(target, "wb") {|fw|
+      fw.write buf
+    }
+  }        
+end
+
+$objs = ["oci8.o", "handle.o", "const.o", "env.o", "error.o", "svcctx.o",
+         "server.o", "session.o", "stmt.o", "define.o", "bind.o",
+         "describe.o", "descriptor.o", "param.o", "lob.o",
+         "oradate.o", "oranumber.o", "ocinumber.o", "attr.o"]
+
+$CFLAGS += oraconf.cflags
+$libs += oraconf.libs
+
+# OCIEnvCreate
+#   8.0.5  - NG
+#   9.0.1  - OK
+have_func("OCIEnvCreate")
+
+# OCITerminate
+#   8.0.5  - NG
+#   9.0.1  - OK
+have_func("OCITerminate")
+
+# OCIServerRelease
+#   8.1.5  - NG
+#   8.1.7  - OK
+#have_func("OCIServerRelease")
+
+# OCILobOpen
+#   8.0.5  - NG
+#   9.0.1  - OK
+have_func("OCILobOpen")
+
+# OCILobClose
+#   8.0.5  - NG
+#   9.0.1  - OK
+have_func("OCILobClose")
+
+# OCILobCreateTemporary
+#   8.0.5  - NG
+#   8.1.5  - OK
+have_func("OCILobCreateTemporary")
+
+have_func("OCILobGetChunkSize")
+have_func("OCILobLocatorAssign")
+
+$defs.push("-DHAVE_OCIRESET") unless /80./ =~ oraconf.version
+
+# Checking gcc or not
+if oraconf.cc_is_gcc
+  $CFLAGS += " -Wall"
+end
+
+# replace files
+replace = {
+  'OCI8_CLIENT_VERSION' => oraconf.version,
+  'OCI8_MODULE_VERSION' => RUBY_OCI8_VERSION
+}
+
+# make ruby script before running create_makefile.
+replace_keyword(File.dirname(__FILE__) + '/../../lib/oci8.rb.in', '../../lib/oci8.rb', replace)
+
+create_header()
+$defs = []
+
+# make dependency file
+open("depend", "w") do |f|
+  f.puts("Makefile: extconf.rb oraconf.rb")
+  f.puts("\t$(RUBY) extconf.rb")
+  $objs.each do |obj|
+    f.puts("#{obj}: $(srcdir)/#{obj.sub(/\.o$/, ".c")} $(srcdir)/oci8.h Makefile")
+  end
+end
+
+
+create_makefile("oci8lib")
+
+# append version info to extconf.h
+open("extconf.h", "a") do |f|
+  replace.each do |key, value|
+    f.puts("#define #{key} \"#{value}\"")
+  end
+end
+
+exit 0

data/ext/oci8/handle.c

@@ -0,0 +1,262 @@
+/*
+  handle.c - part of ruby-oci8
+
+  Copyright (C) 2002-2006 KUBO Takehiro <kubo@jiubao.org>
+
+=begin
+== OCIHandle
+This is the abstract super class of OCI Handles.
+See ((<Class Hierarchy>)).
+=end
+*/
+#include "oci8.h"
+
+static void oci8_handle_do_free(oci8_handle_t *h)
+{
+  int i;
+  if (h->type == 0) {
+    return;
+  }
+  /* free its children recursively.*/
+  for (i = 0;i < h->size;i++) {
+    if (h->children[i] != NULL)
+      oci8_handle_do_free(h->children[i]);
+  }
+  xfree(h->children);
+  /* unlink from parent */
+  oci8_unlink(h);
+  /* do free */
+  if (h->hp != NULL) {
+    if (h->type >= OCI_DTYPE_FIRST)
+      OCIDescriptorFree(h->hp, h->type);
+    else
+      OCIHandleFree(h->hp, h->type);
+  }
+  h->type = 0;
+  return;
+}
+
+/*
+=begin
+--- OCIHandle#attrSet(type, value)
+     :type
+       the type of attribute to be set.
+       See ((<Attributes of Handles and Descriptors>)).
+     :value
+       depends on ((|type|)).
+
+     correspond native OCI function: ((|OCIAttrSet|))
+=end
+*/
+
+
+/*
+=begin
+--- OCIHandle#attrGet(type)
+     :type
+       the type of attribute.
+       See also ((<Attributes of Handles and Descriptors>)).
+     :return value
+       depends on ((|type|)).
+
+     correspond native OCI function: ((|OCIAttrGet|))
+=end
+*/
+
+
+/*
+=begin
+--- OCIHandle#free()
+     explicitly free the OCI's data structure.
+
+     correspond native OCI function: ((|OCIHandleFree|))
+=end
+*/
+VALUE oci8_handle_free(VALUE self)
+{
+  oci8_handle_t *h;
+
+  Get_Handle(self, h);
+  oci8_handle_do_free(h);
+  return self;
+}
+
+void  Init_oci8_handle(void)
+{
+  rb_define_method(cOCIHandle, "free", oci8_handle_free, 0);
+  rb_define_method(cOCIHandle, "attrSet", oci8_attr_set, 2);
+  rb_define_method(cOCIHandle, "attrGet", oci8_attr_get, 1);
+  rb_define_singleton_method(cOCIHandle, "new", oci8_s_new, 0);
+}
+
+void oci8_handle_cleanup(oci8_handle_t *h)
+{
+  oci8_handle_do_free(h);
+  xfree(h);
+}
+
+VALUE oci8_s_new(VALUE self)
+{
+  rb_raise(rb_eNameError, "private method `new' called for %s:Class", rb_class2name(self));
+}
+
+
+static void oci8_handle_mark(oci8_handle_t *h)
+{
+  oci8_bind_handle_t *bh;
+  int i;
+
+  switch (h->type) {
+  case OCI_HTYPE_SVCCTX:
+    for (i = 0;i < h->size;i++) {
+      if (h->children[i] != NULL) {
+	if (h->children[i]->type == OCI_HTYPE_SERVER || h->children[i]->type == OCI_HTYPE_SESSION) {
+	  rb_gc_mark(h->children[i]->self);
+	}
+      }
+    }
+    break;
+  case OCI_HTYPE_STMT:
+    for (i = 0;i < h->size;i++) {
+      if (h->children[i] != NULL) {
+	if (h->children[i]->type == OCI_HTYPE_BIND || h->children[i]->type == OCI_HTYPE_DEFINE) {
+	  rb_gc_mark(h->children[i]->self);
+	}
+      }
+    }
+    break;
+  case OCI_HTYPE_DEFINE:
+  case OCI_HTYPE_BIND:
+    bh = (oci8_bind_handle_t *)h;
+    if (bh->bind_type == BIND_HANDLE)
+      rb_gc_mark(bh->value.handle.v);
+    break;
+  }
+  if (h->parent != NULL) {
+    rb_gc_mark(h->parent->self);
+  }
+}
+
+oci8_handle_t *oci8_make_handle(ub4 type, dvoid *hp, OCIError *errhp, oci8_handle_t *parenth, sb4 value_sz)
+{
+  VALUE obj;
+  oci8_handle_t *h;
+  oci8_bind_handle_t *bh;
+
+  switch (type) {
+  case OCI_HTYPE_ENV:
+    obj = Data_Make_Struct(cOCIEnv, oci8_handle_t, oci8_handle_mark, oci8_handle_cleanup, h);
+    break;
+  case OCI_HTYPE_SVCCTX:
+    obj = Data_Make_Struct(cOCISvcCtx, oci8_handle_t, oci8_handle_mark, oci8_handle_cleanup, h);
+    break;
+  case OCI_HTYPE_STMT:
+    obj = Data_Make_Struct(cOCIStmt, oci8_handle_t, oci8_handle_mark, oci8_handle_cleanup, h);
+    rb_ivar_set(obj, oci8_id_define_array, Qnil);
+    rb_ivar_set(obj, oci8_id_bind_hash, Qnil);
+    break;
+  case OCI_HTYPE_SERVER:
+    obj = Data_Make_Struct(cOCIServer, oci8_handle_t, oci8_handle_mark, oci8_handle_cleanup, h);
+    break;
+  case OCI_HTYPE_SESSION:
+    obj = Data_Make_Struct(cOCISession, oci8_handle_t, oci8_handle_mark, oci8_handle_cleanup, h);
+    break;
+  case OCI_HTYPE_DESCRIBE:
+    obj = Data_Make_Struct(cOCIDescribe, oci8_handle_t, oci8_handle_mark, oci8_handle_cleanup, h);
+    break;
+  case OCI_DTYPE_LOB:
+    obj = Data_Make_Struct(cOCILobLocator, oci8_handle_t, oci8_handle_mark, oci8_handle_cleanup, h);
+#ifndef OCI8_USE_CALLBACK_LOB_READ
+    h->u.lob_locator.char_width = 1;
+#endif
+    break;
+  case OCI_DTYPE_FILE:
+    obj = Data_Make_Struct(cOCIFileLocator, oci8_handle_t, oci8_handle_mark, oci8_handle_cleanup, h);
+#ifndef OCI8_USE_CALLBACK_LOB_READ
+    h->u.lob_locator.char_width = 1;
+#endif
+    break;
+  case OCI_DTYPE_ROWID:
+    obj = Data_Make_Struct(cOCIRowid, oci8_handle_t, oci8_handle_mark, oci8_handle_cleanup, h);
+    break;
+  case OCI_DTYPE_PARAM:
+    obj = Data_Make_Struct(cOCIParam, oci8_handle_t, oci8_handle_mark, oci8_handle_cleanup, h);
+    h->u.param.is_implicit = 0;
+    break;
+  case OCI_HTYPE_BIND:
+    bh = xmalloc(sizeof(oci8_bind_handle_t) - sizeof(bh->value) + value_sz);
+    memset(bh, 0, sizeof(oci8_bind_handle_t) - sizeof(bh->value) + value_sz);
+    obj = Data_Wrap_Struct(cOCIBind, oci8_handle_mark, oci8_handle_cleanup, bh);
+    bh->bind_type = 0;
+    bh->ind = -1;
+    bh->rlen = value_sz;
+    bh->value_sz = value_sz;
+    h = (oci8_handle_t *)bh;
+    break;
+  case OCI_HTYPE_DEFINE:
+    bh = xmalloc(sizeof(oci8_bind_handle_t) - sizeof(bh->value) + value_sz);
+    memset(bh, 0, sizeof(oci8_bind_handle_t) - sizeof(bh->value) + value_sz);
+    obj = Data_Wrap_Struct(cOCIDefine, oci8_handle_mark, oci8_handle_cleanup, bh);
+    bh->bind_type = 0;
+    bh->ind = -1;
+    bh->rlen = value_sz;
+    bh->value_sz = value_sz;
+    h = (oci8_handle_t *)bh;
+    break;
+  default:
+    rb_bug("unsupported type %d in oci8_make_handle()", type);
+  }
+  h->type = type;
+  h->hp = hp;
+  h->errhp = errhp;
+  h->self = obj;
+  h->parent = NULL;
+  h->size = 0;
+  h->children = NULL;
+  oci8_link(parenth, h);
+  return h;
+}
+
+#define CHILDREN_ARRAY_GROW_SIZE 16
+
+void oci8_link(oci8_handle_t *parent, oci8_handle_t *child)
+{
+  int i;
+  int new_size;
+
+  if (parent == NULL)
+    return;
+  oci8_unlink(child);
+  child->parent = parent;
+
+  for (i = 0;i < parent->size;i++) {
+    if (parent->children[i] == NULL) {
+      parent->children[i] = child;
+      return;
+    }
+  }
+  new_size = parent->size + CHILDREN_ARRAY_GROW_SIZE;
+  parent->children = xrealloc(parent->children, sizeof(oci8_handle_t *) * new_size);
+  parent->children[parent->size] = child;
+  for (i = parent->size + 1;i < new_size;i++) {
+    parent->children[i] = NULL;
+  }
+  parent->size = new_size;
+  return;
+}
+
+void oci8_unlink(oci8_handle_t *self)
+{
+  oci8_handle_t *parent = self->parent;
+  int i;
+
+  if (self->parent == NULL)
+    return;
+  for (i = 0;i < parent->size;i++) {
+    if (parent->children[i] == self) {
+      parent->children[i] = NULL;
+      self->parent = NULL;
+      return;
+    }
+  }
+}

data/ext/oci8/lob.c

@@ -0,0 +1,386 @@
+#include "oci8.h"
+
+static VALUE sym_file_readonly;
+
+#ifndef OCI8_USE_CALLBACK_LOB_READ
+static VALUE oci8_lob_set_char_width(VALUE self, VALUE vsize)
+{
+  oci8_handle_t *h;
+  int size;
+
+  Get_Handle(self, h); /* 0 */
+  size = NUM2INT(vsize); /* 1 */
+
+  if (size <= 0)
+    rb_raise(rb_eArgError, "size must be more than one.");
+  h->u.lob_locator.char_width = size;
+  return vsize;
+}
+#endif
+
+static VALUE oci8_lob_is_initialized_p(VALUE self, VALUE venv)
+{
+  oci8_handle_t *h;
+  oci8_handle_t *envh;
+  boolean is_initialized;
+  sword rv;
+
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(venv, OCIEnv, envh); /* 1 */
+
+  rv = OCILobLocatorIsInit(envh->hp, h->errhp, h->hp, &is_initialized);
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+  return is_initialized ? Qtrue : Qfalse;
+}
+
+
+/*
+=begin
+--- OCILobLocator#GetLength()
+     get the length of LOB.
+     counts by bytes for BLOB, by charactors for CLOB.
+=end
+ */
+static VALUE oci8_lob_get_length(VALUE self, VALUE vsvc)
+{
+  oci8_handle_t *h;
+  oci8_handle_t *svch;
+  ub4 len;
+  sword rv;
+
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(vsvc, OCISvcCtx, svch); /* 1 */
+
+  rv = OCILobGetLength(svch->hp, h->errhp, h->hp, &len);
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+  return INT2FIX(len);
+}
+
+#ifdef HAVE_OCILOBGETCHUNKSIZE
+static VALUE oci8_lob_get_chunk_size(VALUE self, VALUE vsvc)
+{
+  oci8_handle_t *h;
+  oci8_handle_t *svch;
+  ub4 len;
+  sword rv;
+
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(vsvc, OCISvcCtx, svch); /* 1 */
+
+  rv = OCILobGetChunkSize(svch->hp, h->errhp, h->hp, &len);
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+  return INT2FIX(len);
+}
+#endif
+
+#ifdef OCI8_USE_CALLBACK_LOB_READ
+static sb4 oci8_callback_lob_read(dvoid *ctxp, CONST dvoid *bufp, ub4 len, ub1 piece)
+{
+  VALUE v = *((VALUE *)ctxp);
+
+  if (v == Qnil)
+    v = rb_str_new(bufp, len);
+  else
+    v = rb_str_cat(v, bufp, len);
+
+  *((VALUE *)ctxp) = v;
+  return OCI_CONTINUE;
+}
+#endif
+
+static VALUE oci8_lob_read(int argc, VALUE *argv, VALUE self)
+{
+  VALUE vsvc, voffset, vamt, vcsid, vcsfrm;
+  oci8_handle_t *h;
+  oci8_handle_t *svch;
+  ub4 offset;
+  ub2 csid;
+  ub1 csfrm;
+  ub4 amt;
+  sword rv;
+  char buf[4096];
+#ifndef OCI8_USE_CALLBACK_LOB_READ
+  size_t buf_size_in_char;
+#endif
+  VALUE v = Qnil;
+
+  rb_scan_args(argc, argv, "32", &vsvc, &voffset, &vamt, &vcsid, &vcsfrm);
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(vsvc, OCISvcCtx, svch); /* 1 */
+  offset = NUM2INT(voffset); /* 2 */
+  amt = NUM2INT(vamt); /* 3 */
+  csid = NIL_P(vcsid) ? 0 : NUM2INT(vcsid); /* 4 */
+  csfrm = NIL_P(vcsfrm) ? SQLCS_IMPLICIT : NUM2INT(vcsfrm); /* 5 */
+
+#ifdef OCI8_USE_CALLBACK_LOB_READ
+  /* This raises ORA-24812, when the size of readed data is two or
+   * three times longer than the size of buf. I couldn't fix it. Thus
+   * I use polling way instead of callback method.
+   */
+  rv = OCILobRead(svch->hp, h->errhp, h->hp, &amt, offset, buf, sizeof(buf), &v, oci8_callback_lob_read, csid, csfrm);
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+#else
+  /* Disadvantage of polling way in contrast with callback method is
+   * that it sets 'amt' the number of characters readed, when charset
+   * is fixed size. For single byte charset or variable size charset,
+   * it cause no problem because the unit of 'amt' is byte. But for
+   * fixed size multibyte charset, how can I know the size of a
+   * character from system? Therefore who want to use fixed size
+   * multibyte charset must set the size explicitly.
+   *
+   * Umm, if I could use callback method, I have no need to care about
+   * it.
+   */
+  buf_size_in_char = sizeof(buf) / h->u.lob_locator.char_width;
+  do {
+    rv = OCILobRead(svch->hp, h->errhp, h->hp, &amt, offset, buf, sizeof(buf), NULL, NULL, csid, csfrm);
+    if (rv != OCI_SUCCESS && rv != OCI_NEED_DATA)
+      oci8_raise(h->errhp, rv, NULL);
+    if (amt == 0)
+      break;
+    /* for fixed size charset, amt is the number of characters stored in buf. */
+    if (amt > buf_size_in_char)
+      rb_raise(eOCIException, "Too large buffer fetched or you set too large size of a character.");
+    amt *= h->u.lob_locator.char_width;
+    if (v == Qnil)
+      v = rb_str_new(buf, amt);
+    else
+      v = rb_str_cat(v, buf, amt);
+  } while (rv == OCI_NEED_DATA);
+#endif
+  return v;
+}
+
+static VALUE oci8_lob_write(int argc, VALUE *argv, VALUE self)
+{
+  VALUE vsvc, voffset, vbuf, vcsid, vcsfrm;
+  oci8_handle_t *h;
+  oci8_handle_t *svch;
+  oci8_string_t buf;
+  ub4 offset;
+  ub2 csid;
+  ub1 csfrm;
+  ub4 amt;
+  sword rv;
+
+  rb_scan_args(argc, argv, "32", &vsvc, &voffset, &vbuf, &vcsid, &vcsfrm);
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(vsvc, OCISvcCtx, svch); /* 1 */
+  offset = NUM2INT(voffset); /* 2 */
+  Get_String(vbuf, buf); /* 3 */
+  csid = NIL_P(vcsid) ? 0 : NUM2INT(vcsid); /* 4 */
+  csfrm = NIL_P(vcsfrm) ? SQLCS_IMPLICIT : NUM2INT(vcsfrm); /* 5 */
+
+  amt = buf.len;
+  rv = OCILobWrite(svch->hp, h->errhp, h->hp, &amt, offset, buf.ptr, buf.len, OCI_ONE_PIECE, NULL, NULL, csid, csfrm);
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+  return INT2FIX(amt);
+}
+
+static VALUE oci8_lob_trim(VALUE self, VALUE vsvc, VALUE len)
+{
+  oci8_handle_t *h;
+  oci8_handle_t *svch;
+  sword rv;
+
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(vsvc, OCISvcCtx, svch); /* 1 */
+
+  rv = OCILobTrim(svch->hp, h->errhp, h->hp, NUM2INT(len));
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+  return self;
+}
+
+static VALUE oci8_lob_clone(VALUE self, VALUE vsvc)
+{
+  oci8_handle_t *h;
+  oci8_handle_t *svch;
+  oci8_handle_t *envh;
+  oci8_handle_t *newh;
+  OCILobLocator *hp;
+  sword rv;
+
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(vsvc, OCISvcCtx, svch); /* 1 */
+
+  /* get environment handle */
+  for (envh = h; envh->type != OCI_HTYPE_ENV; envh = envh->parent);
+  rv = OCIDescriptorAlloc(envh->hp, (void *)&hp, h->type, 0, NULL);
+  if (rv != OCI_SUCCESS) {
+    oci8_env_raise(envh->hp, rv);
+  }
+#ifdef HAVE_OCILOBLOCATORASSIGN
+  /* Oracle 8.1 or upper */
+  rv = OCILobLocatorAssign(svch->hp, h->errhp, h->hp, &hp);
+#else
+  /* Oracle 8.0 */
+  rv = OCILobAssign(envh->hp, h->errhp, h->hp, &hp);
+#endif
+  if (rv != OCI_SUCCESS) {
+    OCIDescriptorFree(hp, h->type);
+    oci8_raise(h->errhp, rv, NULL);
+  }
+  newh = oci8_make_handle(h->type, hp, h->errhp, h->parent, 0);
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+  return newh->self;
+}
+
+#ifdef HAVE_OCILOBOPEN
+static VALUE oci8_lob_open(int argc, VALUE *argv, VALUE self)
+{
+  VALUE vsvc;
+  VALUE vmode = Qnil;
+  oci8_handle_t *h;
+  oci8_handle_t *svch;
+  ub1 mode;
+  sword rv;
+
+  rb_scan_args(argc, argv, "11", &vsvc, &vmode);
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(vsvc, OCISvcCtx, svch); /* 1 */
+  if (vmode == Qnil)
+    mode = OCI_DEFAULT;
+  else if (vmode == sym_file_readonly)
+    mode = OCI_FILE_READONLY;
+  else
+    rb_raise(rb_eArgError, "expect nil or :file_readonly");
+  rv = OCILobOpen(svch->hp, h->errhp, h->hp, mode);
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+  return self;
+}
+#endif
+
+#ifdef HAVE_OCILOBCLOSE
+static VALUE oci8_lob_close(VALUE self, VALUE vsvc)
+{
+  oci8_handle_t *h;
+  oci8_handle_t *svch;
+  sword rv;
+
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(vsvc, OCISvcCtx, svch); /* 1 */
+  
+  rv = OCILobClose(svch->hp, h->errhp, h->hp);
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+  return self;
+}
+#endif
+
+static VALUE oci8_lobfile_name(VALUE self, VALUE venv)
+{
+  oci8_handle_t *h;
+  oci8_handle_t *envh;
+  char dir_alias[31];
+  ub2 d_length = sizeof(dir_alias);
+  char filename[256];
+  ub2 f_length = sizeof(filename);
+  sword rv;
+
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(venv, OCIEnv, envh); /* 1 */
+
+  rv = OCILobFileGetName(envh->hp, h->errhp, h->hp, (OraText*)dir_alias, &d_length, (OraText*)filename, &f_length);
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+  return rb_ary_new3(2, rb_str_new(dir_alias, d_length), rb_str_new(filename, f_length));
+}
+
+static VALUE oci8_lobfile_set_name(VALUE self, VALUE venv, VALUE vdir, VALUE vfile)
+{
+  oci8_handle_t *h;
+  oci8_handle_t *envh;
+  sword rv;
+
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(venv, OCIEnv, envh); /* 1 */
+  StringValue(vdir); /* 2 */
+  StringValue(vfile); /* 3 */
+
+  rv = OCILobFileSetName(envh->hp, h->errhp, (OCILobLocator **)&h->hp,
+			 RSTRING_ORATEXT(vdir), RSTRING_LEN(vdir),
+			 RSTRING_ORATEXT(vfile), RSTRING_LEN(vfile));
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+  return self;
+}
+
+static VALUE oci8_lobfile_exist_p(VALUE self, VALUE vsvc)
+{
+  oci8_handle_t *h;
+  oci8_handle_t *svch;
+  boolean flag;
+  sword rv;
+
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(vsvc, OCISvcCtx, svch); /* 1 */
+
+  rv = OCILobFileExists(svch->hp, h->errhp, h->hp, &flag);
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+  return flag ? Qtrue : Qfalse;
+}
+
+static VALUE oci8_lob_create_temporary(VALUE self, VALUE vsvc, VALUE vcsid, VALUE vcsfrm, VALUE vlobtype, VALUE vcache, VALUE vduration)
+{
+#ifdef HAVE_OCILOBCREATETEMPORARY
+  oci8_handle_t *h;
+  oci8_handle_t *svch;
+  ub2 csid;
+  ub1 csfrm;
+  ub1 lobtype;
+  boolean cache;
+  OCIDuration duration;
+  sword rv;
+
+  Get_Handle(self, h); /* 0 */
+  Check_Handle(vsvc, OCISvcCtx, svch); /* 1 */
+  csid = NIL_P(vcsid) ? 0 : NUM2INT(vcsid); /* 2 */
+  csfrm = NIL_P(vcsfrm) ? SQLCS_IMPLICIT : NUM2INT(vcsfrm); /* 3 */
+  lobtype = NUM2INT(vlobtype); /* 4 */
+  cache = RTEST(vcache) ? TRUE : FALSE; /* 5 */
+  duration = NIL_P(vduration) ? OCI_DURATION_SESSION : NUM2INT(vduration); /* 6 */
+
+  rv = OCILobCreateTemporary(svch->hp, h->errhp, h->hp, csid, csfrm, lobtype, cache, duration);
+  if (rv != OCI_SUCCESS)
+    oci8_raise(h->errhp, rv, NULL);
+  return self;
+#else
+  rb_notimplement();
+#endif
+}
+
+void Init_oci8_lob(void)
+{
+  sym_file_readonly = ID2SYM(rb_intern("file_readonly"));
+#ifndef OCI8_USE_CALLBACK_LOB_READ
+  rb_define_method(cOCILobLocator, "char_width=", oci8_lob_set_char_width, 1);
+#endif
+  rb_define_method(cOCILobLocator, "is_initialized?", oci8_lob_is_initialized_p, 1);
+  rb_define_method(cOCILobLocator, "getLength", oci8_lob_get_length, 1);
+#ifdef HAVE_OCILOBGETCHUNKSIZE
+  rb_define_method(cOCILobLocator, "getChunkSize", oci8_lob_get_chunk_size, 1);
+#endif
+  rb_define_method(cOCILobLocator, "read", oci8_lob_read, -1);
+  rb_define_method(cOCILobLocator, "write", oci8_lob_write, -1);
+  rb_define_method(cOCILobLocator, "trim", oci8_lob_trim, 2);
+  rb_define_method(cOCILobLocator, "clone", oci8_lob_clone, 1);
+#ifdef HAVE_OCILOBOPEN
+  rb_define_method(cOCILobLocator, "open", oci8_lob_open, -1);
+#endif
+#ifdef HAVE_OCILOBCLOSE
+  rb_define_method(cOCILobLocator, "close", oci8_lob_close, 1);
+#endif
+  rb_define_method(cOCIFileLocator, "name", oci8_lobfile_name, 1);
+  rb_define_method(cOCIFileLocator, "set_name", oci8_lobfile_set_name, 3);
+  rb_define_method(cOCIFileLocator, "exists?", oci8_lobfile_exist_p, 1);
+  rb_define_method(cOCILobLocator, "create_temporary", oci8_lob_create_temporary, 6);
+}