ruby-oci8 2.2.0.2 → 2.2.12

data/ext/oci8/lob.c

@@ -26,8 +26,6 @@ static VALUE seek_end;
 
 enum state {
     S_NO_OPEN_CLOSE,
-    S_OPEN,
-    S_CLOSE,
     S_BFILE_CLOSE,
     S_BFILE_OPEN,
 };
@@ -266,28 +264,6 @@ static ub8 oci8_lob_get_length(oci8_lob_t *lob)
     return len;
 }
 
-static void lob_open(oci8_lob_t *lob)
-{
-    if (lob->state == S_CLOSE) {
-        oci8_svcctx_t *svcctx = check_svcctx(lob);
-
-        chker2(OCILobOpen_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, lob->base.hp.lob, OCI_DEFAULT),
-               &svcctx->base);
-        lob->state = S_OPEN;
-    }
-}
-
-static void lob_close(oci8_lob_t *lob)
-{
-    if (lob->state == S_OPEN) {
-        oci8_svcctx_t *svcctx = check_svcctx(lob);
-
-        chker2(OCILobClose_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, lob->base.hp.lob),
-               &svcctx->base);
-        lob->state = S_CLOSE;
-    }
-}
-
 static void bfile_close(oci8_lob_t *lob)
 {
     if (lob->state == S_BFILE_OPEN) {
@@ -368,7 +344,6 @@ static void bfile_close(oci8_lob_t *lob)
 static VALUE oci8_lob_close(VALUE self)
 {
     oci8_lob_t *lob = TO_LOB(self);
-    lob_close(lob);
     oci8_base_free(&lob->base);
     return self;
 }
@@ -591,7 +566,6 @@ static VALUE oci8_lob_truncate(VALUE self, VALUE len)
     oci8_lob_t *lob = TO_LOB(self);
     oci8_svcctx_t *svcctx = check_svcctx(lob);
 
-    lob_open(lob);
     chker2(OCILobTrim2_nb(svcctx, svcctx->base.hp.svc, oci8_errhp, lob->base.hp.lob, NUM2ULL(len)),
            &svcctx->base);
     return self;
@@ -665,10 +639,9 @@ static VALUE oci8_lob_read(int argc, VALUE *argv, VALUE self)
 {
     oci8_lob_t *lob = TO_LOB(self);
     oci8_svcctx_t *svcctx = check_svcctx(lob);
-    ub8 lob_length;
-    ub8 read_len;
     ub8 pos = lob->pos;
-    long strbufsiz;
+    long strbufsiz = 512;
+    ub8 sz;
     ub8 byte_amt;
     ub8 char_amt;
     sword rv;
@@ -678,36 +651,21 @@ static VALUE oci8_lob_read(int argc, VALUE *argv, VALUE self)
     ub1 piece = OCI_FIRST_PIECE;
 
     rb_scan_args(argc, argv, "01", &size);
-    lob_length = oci8_lob_get_length(lob);
-    if (lob_length == 0 && NIL_P(size)) {
-        return rb_usascii_str_new("", 0);
-    }
-    if (lob_length <= pos) /* EOF */
-        return Qnil;
     if (NIL_P(size)) {
-        read_len = lob_length - pos;
+        sz = UB4MAXVAL;
     } else {
-        ub8 sz = NUM2ULL(size);
-        read_len = MIN(sz, lob_length - pos);
+        sz = NUM2ULL(size);
+    }
+    if (lob->state == S_BFILE_CLOSE) {
+        open_bfile(svcctx, lob, errhp);
     }
+read_more_data:
     if (lob->lobtype == OCI_TEMP_CLOB) {
         byte_amt = 0;
-        char_amt = read_len;
-        if (oci8_nls_ratio == 1) {
-            strbufsiz = MIN(read_len, ULONG_MAX);
-        } else {
-            strbufsiz = MIN(read_len + read_len / 8, ULONG_MAX);
-        }
-        if (strbufsiz <= 10) {
-            strbufsiz = 10;
-        }
+        char_amt = sz;
     } else {
-        byte_amt = read_len;
+        byte_amt = sz;
         char_amt = 0;
-        strbufsiz = MIN(read_len, ULONG_MAX);
-    }
-    if (lob->state == S_BFILE_CLOSE) {
-        open_bfile(svcctx, lob, errhp);
     }
     do {
         VALUE strbuf = rb_str_buf_new(strbufsiz);
@@ -737,23 +695,30 @@ static VALUE oci8_lob_read(int argc, VALUE *argv, VALUE self)
         }
         rb_str_set_len(strbuf, byte_amt);
         rb_ary_push(v, strbuf);
+        if (strbufsiz < 128 * 1024 * 1024) {
+            strbufsiz *= 2;
+        }
     } while (rv == OCI_NEED_DATA);
 
-    if (pos >= lob_length) {
-        lob_close(lob);
-        bfile_close(lob);
+    if (NIL_P(size) && pos - lob->pos == sz) {
+        lob->pos = pos;
+        piece = OCI_FIRST_PIECE;
+        goto read_more_data;
     }
     lob->pos = pos;
     switch (RARRAY_LEN(v)) {
     case 0:
-        return Qnil;
+        if (NIL_P(size) && pos == 0) {
+            return rb_usascii_str_new("", 0);
+        } else {
+            return Qnil;
+        }
     case 1:
         v = RARRAY_AREF(v, 0);
         break;
     default:
         v = rb_ary_join(v, Qnil);
     }
-    OBJ_TAINT(v);
     if (lob->lobtype == OCI_TEMP_CLOB) {
         /* set encoding */
         rb_enc_associate(v, oci8_encoding);
@@ -781,7 +746,6 @@ static VALUE oci8_lob_write(VALUE self, VALUE data)
     ub8 byte_amt;
     ub8 char_amt;
 
-    lob_open(lob);
     if (TYPE(data) != T_STRING) {
         str = rb_obj_as_string(data);
     } else {
@@ -801,48 +765,40 @@ static VALUE oci8_lob_write(VALUE self, VALUE data)
     RB_GC_GUARD(str);
     if (lob->lobtype == OCI_TEMP_CLOB) {
         lob->pos += char_amt;
-        return UINT2NUM(char_amt);
+        return ULL2NUM(char_amt);
     } else {
         lob->pos += byte_amt;
-        return UINT2NUM(byte_amt);
+        return ULL2NUM(byte_amt);
     }
 }
 
 /*
- *  @deprecated I'm not sure that this is what the name indicates.
+ *  @deprecated LOB#sync had not worked by mistake. Do nothing now.
  *  @private
  */
 static VALUE oci8_lob_get_sync(VALUE self)
 {
-    oci8_lob_t *lob = TO_LOB(self);
-    return (lob->state == S_NO_OPEN_CLOSE) ? Qtrue : Qfalse;
+    rb_warning("LOB#sync had not worked by mistake. Do nothing now.");
+    return Qfalse;
 }
 
 /*
- *  @deprecated I'm not sure that this is what the name indicates.
+ *  @deprecated LOB#sync had not worked by mistake. Do nothing now.
  *  @private
  */
 static VALUE oci8_lob_set_sync(VALUE self, VALUE b)
 {
-    oci8_lob_t *lob = TO_LOB(self);
-    if (RTEST(b)) {
-        lob_close(lob);
-        lob->state = S_NO_OPEN_CLOSE;
-    } else {
-        if (lob->state == S_NO_OPEN_CLOSE)
-            lob->state = S_CLOSE;
-    }
+    rb_warning("LOB#sync had not worked by mistake. Do nothing now.");
     return b;
 }
 
 /*
- *  @deprecated I'm not sure that this is what the name indicates.
+ *  @deprecated LOB#flush had not worked by mistake. Do nothing now.
  *  @private
  */
 static VALUE oci8_lob_flush(VALUE self)
 {
-    oci8_lob_t *lob = TO_LOB(self);
-    lob_close(lob);
+    rb_warning("LOB#flush had not worked by mistake. Do nothing now.");
     return self;
 }
 

data/ext/oci8/metadata.c

@@ -2,7 +2,7 @@
 /*
  * metadata.c
  *
- * Copyright (C) 2006-2015 Kubo Takehiro <kubo@jiubao.org>
+ * Copyright (C) 2006-2016 Kubo Takehiro <kubo@jiubao.org>
  *
  * implement private methods of classes in OCI8::Metadata module.
  *
@@ -145,7 +145,7 @@ static VALUE metadata_is_implicit_p(VALUE self)
     return md->is_implicit ? Qtrue : Qfalse;
 }
 
-static VALUE oci8_do_describe(VALUE self, void *objptr, ub4 objlen, ub1 objtype, VALUE klass, VALUE check_public)
+VALUE oci8_do_describe(VALUE self, void *objptr, ub4 objlen, ub1 objtype, VALUE klass, VALUE check_public)
 {
     oci8_svcctx_t *svcctx = oci8_get_svcctx(self);
     OCIParam *parmhp;
@@ -195,7 +195,7 @@ static VALUE oci8_do_describe(VALUE self, void *objptr, ub4 objlen, ub1 objtype,
 static VALUE oci8_describe(VALUE self, VALUE name, VALUE klass, VALUE check_public)
 {
     char *str;
-    size_t idx, len;
+    int idx, len;
     VALUE metadata;
     VALUE obj_link = Qnil;
 
@@ -204,7 +204,7 @@ static VALUE oci8_describe(VALUE self, VALUE name, VALUE klass, VALUE check_publ
         rb_raise(rb_eArgError, "empty string is set.");
     }
     str = RSTRING_PTR(name);
-    len = RSTRING_LEN(name);
+    len = RSTRING_LENINT(name);
     for (idx = 0; idx < len; idx++) {
         if (str[idx] == '@') {
             obj_link = rb_enc_str_new(str + idx + 1, len - idx - 1, oci8_encoding);
@@ -259,10 +259,10 @@ void Init_oci8_metadata(VALUE cOCI8)
 {
     mOCI8Metadata = rb_define_module_under(cOCI8, "Metadata");
     cOCI8MetadataBase = oci8_define_class_under(mOCI8Metadata, "Base", &oci8_metadata_base_data_type, oci8_metadata_alloc);
-    ptype_to_class = rb_hash_new();
-    class_to_ptype = rb_hash_new();
     rb_global_variable(&ptype_to_class);
     rb_global_variable(&class_to_ptype);
+    ptype_to_class = rb_hash_new();
+    class_to_ptype = rb_hash_new();
     id_at_obj_link = rb_intern("@obj_link");
 
     rb_define_singleton_method(cOCI8MetadataBase, "register_ptype", metadata_s_register_ptype, 1);
@@ -274,4 +274,6 @@ void Init_oci8_metadata(VALUE cOCI8)
     rb_define_private_method(cOCI8, "__describe", oci8_describe, 3);
     rb_define_private_method(cOCI8MetadataBase, "__type_metadata", metadata_get_type_metadata, 1);
     rb_define_method(cOCI8MetadataBase, "tdo_id", metadata_get_tdo_id, 0);
+
+    rb_define_class_under(mOCI8Metadata, "Type", cOCI8MetadataBase);
 }

data/ext/oci8/object.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- * Copyright (C) 2002-2014 Kubo Takehiro <kubo@jiubao.org>
+ * Copyright (C) 2002-2016 Kubo Takehiro <kubo@jiubao.org>
  */
 
 /*
@@ -20,8 +20,11 @@ static VALUE cOCI8TDO;
 static VALUE cOCI8NamedType;
 static VALUE cOCI8NamedCollection;
 static VALUE cOCI8BindNamedType;
+static VALUE cOCI8MetadataType;
 static ID id_to_value;
 static ID id_set_attributes;
+static ID id_get_tdo_by_metadata;
+static ID id_at_is_final_type;
 
 #define TO_TDO(obj) ((oci8_base_t *)oci8_check_typeddata((obj), &oci8_tdo_data_type, 1))
 #define CHECK_TDO(obj) ((void)oci8_check_typeddata((obj), &oci8_tdo_data_type, 1))
@@ -41,6 +44,8 @@ enum {
     ATTR_FLOAT,
     ATTR_INTEGER,
     ATTR_OCIDATE,
+    ATTR_TIMESTAMP,
+    ATTR_TIMESTAMP_TZ,
     ATTR_BINARY_DOUBLE,
     ATTR_BINARY_FLOAT,
     ATTR_NAMED_TYPE,
@@ -137,10 +142,49 @@ static VALUE oci8_named_type_initialize(VALUE self)
     return Qnil;
 }
 
+typedef struct get_tdo_by_instance_arg {
+    VALUE svc;
+    void *instance;
+    void *typeref;
+} get_tdo_by_instance_arg_t;
+
+static VALUE get_tdo_by_instance(VALUE data)
+{
+    get_tdo_by_instance_arg_t *arg = (get_tdo_by_instance_arg_t *)data;
+    VALUE metadata;
+
+    chkerr(OCIObjectGetTypeRef(oci8_envhp, oci8_errhp, arg->instance, arg->typeref));
+    metadata = oci8_do_describe(arg->svc, arg->typeref, 0, OCI_OTYPE_REF, cOCI8MetadataType, Qfalse);
+    return rb_funcall(arg->svc, id_get_tdo_by_metadata, 1, metadata);
+}
+
 static VALUE oci8_named_type_tdo(VALUE self)
 {
     oci8_named_type_t *obj = DATA_PTR(self);
-    return obj->tdo;
+    VALUE tdo = obj->tdo;
+
+    if (!RTEST(rb_ivar_get(tdo, id_at_is_final_type))) {
+        /* The type of the instance may be a subtype. */
+        oci8_base_t *svcctx;
+        get_tdo_by_instance_arg_t arg;
+        int state = 0;
+
+        /* search svcctx */
+        svcctx = DATA_PTR(obj->tdo);
+        while (svcctx->type != OCI_HTYPE_SVCCTX) {
+            svcctx = svcctx->parent;
+        }
+
+        arg.svc = svcctx->self;
+        arg.instance = *obj->instancep;
+        chkerr(OCIObjectNew(oci8_envhp, oci8_errhp, svcctx->hp.svc, OCI_TYPECODE_REF, NULL, NULL, OCI_DURATION_DEFAULT, TRUE, &arg.typeref));
+        tdo = rb_protect(get_tdo_by_instance, (VALUE)&arg, &state);
+        chkerr(OCIObjectFree(oci8_envhp, oci8_errhp, arg.typeref, OCI_OBJECTFREE_FORCE));
+        if (state != 0) {
+            rb_jump_tag(state);
+        }
+    }
+    return tdo;
 }
 
 static void oci8_named_type_check_offset(VALUE self, VALUE val_offset, VALUE ind_offset, size_t val_size, void **instancep, OCIInd **indp)
@@ -193,6 +237,10 @@ static VALUE get_attribute(VALUE self, VALUE datatype, VALUE typeinfo, void *dat
         return oci8_make_integer((OCINumber *)data, oci8_errhp);
     case ATTR_OCIDATE:
         return oci8_make_ocidate((OCIDate *)data);
+    case ATTR_TIMESTAMP:
+        return oci8_make_ocitimestamp(*(OCIDateTime**)data, FALSE);
+    case ATTR_TIMESTAMP_TZ:
+        return oci8_make_ocitimestamp(*(OCIDateTime**)data, TRUE);
     case ATTR_BINARY_DOUBLE:
         return rb_float_new(*(double*)data);
     case ATTR_BINARY_FLOAT:
@@ -371,6 +419,18 @@ static VALUE oci8_named_coll_set_coll_element(VALUE self, VALUE datatype, VALUE
     case ATTR_OCIDATE:
         cb_data.indp = &cb_data.ind;
         break;
+    case ATTR_TIMESTAMP:
+        chker2(OCIObjectNew(oci8_envhp, oci8_errhp, svcctx->hp.svc, OCI_TYPECODE_TIMESTAMP, NULL, NULL, OCI_DURATION_SESSION, TRUE, &cb_data.data.ptr),
+               svcctx);
+        chker2(OCIObjectGetInd(oci8_envhp, oci8_errhp, cb_data.data.ptr, (dvoid**)&cb_data.indp),
+               svcctx);
+        break;
+    case ATTR_TIMESTAMP_TZ:
+        chker2(OCIObjectNew(oci8_envhp, oci8_errhp, svcctx->hp.svc, OCI_TYPECODE_TIMESTAMP_TZ, NULL, NULL, OCI_DURATION_SESSION, TRUE, &cb_data.data.ptr),
+               svcctx);
+        chker2(OCIObjectGetInd(oci8_envhp, oci8_errhp, cb_data.data.ptr, (dvoid**)&cb_data.indp),
+               svcctx);
+        break;
     case ATTR_BINARY_DOUBLE:
         cb_data.data.dbl = 0.0;
         cb_data.indp = &cb_data.ind;
@@ -425,7 +485,7 @@ static VALUE set_coll_element_func(set_coll_element_cb_data_t *cb_data)
 
     chkerr(OCICollSize(oci8_envhp, oci8_errhp, coll, &size));
     if (RARRAY_LEN(val) < size) {
-        chkerr(OCICollTrim(oci8_envhp, oci8_errhp, size - RARRAY_LEN(val), coll));
+        chkerr(OCICollTrim(oci8_envhp, oci8_errhp, (sb4)(size - RARRAY_LEN(val)), coll));
     }
     for (idx = 0; idx < RARRAY_LEN(val); idx++) {
         switch (FIX2INT(datatype)) {
@@ -465,6 +525,8 @@ static VALUE set_coll_element_ensure(set_coll_element_cb_data_t *cb_data)
     switch (FIX2INT(datatype)) {
     case ATTR_STRING:
     case ATTR_RAW:
+    case ATTR_TIMESTAMP:
+    case ATTR_TIMESTAMP_TZ:
     case ATTR_NAMED_TYPE:
     case ATTR_NAMED_COLLECTION:
         if (cb_data->data.ptr != NULL) {
@@ -497,13 +559,13 @@ static void set_attribute(VALUE self, VALUE datatype, VALUE typeinfo, void *data
     case ATTR_STRING:
         OCI8StringValue(val);
         chkerr(OCIStringAssignText(oci8_envhp, oci8_errhp,
-                                   RSTRING_ORATEXT(val), RSTRING_LEN(val),
+                                   RSTRING_ORATEXT(val), RSTRING_LENINT(val),
                                    (OCIString **)data));
         break;
     case ATTR_RAW:
         StringValue(val);
         chkerr(OCIRawAssignBytes(oci8_envhp, oci8_errhp,
-                                 RSTRING_ORATEXT(val), RSTRING_LEN(val),
+                                 RSTRING_ORATEXT(val), RSTRING_LENINT(val),
                                  (OCIRaw **)data));
         break;
     case ATTR_OCINUMBER:
@@ -516,6 +578,12 @@ static void set_attribute(VALUE self, VALUE datatype, VALUE typeinfo, void *data
     case ATTR_OCIDATE:
         oci8_set_ocidate((OCIDate*)data, val);
         break;
+    case ATTR_TIMESTAMP:
+        oci8_set_ocitimestamp_tz(*(OCIDateTime **)data, val, Qnil);
+        break;
+    case ATTR_TIMESTAMP_TZ:
+        oci8_set_ocitimestamp_tz(*(OCIDateTime **)data, val, Qnil);
+        break;
     case ATTR_BINARY_DOUBLE:
         *(double*)data = NUM2DBL(val);
         break;
@@ -612,45 +680,57 @@ static VALUE oci8_named_collection_alloc(VALUE klass)
     return oci8_allocate_typeddata(klass, &oci8_named_collection_data_type);
 }
 
+typedef struct {
+    oci8_bind_t bind;
+    VALUE *obj;
+} bind_named_type_t;
+
 static void bind_named_type_mark(oci8_base_t *base)
 {
-    oci8_bind_t *obind = (oci8_bind_t *)base;
-    oci8_hp_obj_t *oho = (oci8_hp_obj_t *)obind->valuep;
+    bind_named_type_t *bnt = (bind_named_type_t *)base;
 
-    if (oho != NULL) {
+    if (bnt->obj != NULL) {
         ub4 idx = 0;
 
         do {
-            rb_gc_mark(oho[idx].obj);
-        } while (++idx < obind->maxar_sz);
+            rb_gc_mark(bnt->obj[idx]);
+        } while (++idx < bnt->bind.maxar_sz);
     }
-    rb_gc_mark(obind->tdo);
+    rb_gc_mark(bnt->bind.tdo);
 }
 
 static void bind_named_type_free(oci8_base_t *base)
 {
-    oci8_bind_t *obind = (oci8_bind_t *)base;
-    oci8_hp_obj_t *oho = (oci8_hp_obj_t *)obind->valuep;
+    bind_named_type_t *bnt = (bind_named_type_t *)base;
+    void **hp = (void **)bnt->bind.valuep;
 
-    if (oho != NULL) {
+    if (hp != NULL) {
         ub4 idx = 0;
 
         do {
-            if (oho[idx].hp != NULL) {
-                OCIObjectFree(oci8_envhp, oci8_errhp, oho[idx].hp, OCI_DEFAULT);
-                oho[idx].hp = NULL;
+            if (hp[idx] != NULL) {
+                OCIObjectFree(oci8_envhp, oci8_errhp, hp[idx], OCI_DEFAULT);
+                hp[idx] = NULL;
             }
-        } while (++idx < obind->maxar_sz);
+        } while (++idx < bnt->bind.maxar_sz);
+    }
+    if (bnt->obj != NULL) {
+        xfree(bnt->obj);
+        bnt->obj = NULL;
     }
     oci8_bind_free(base);
 }
 
 static VALUE bind_named_type_get(oci8_bind_t *obind, void *data, void *null_struct)
 {
-    oci8_hp_obj_t *oho = (oci8_hp_obj_t *)data;
-    return oho->obj;
+    bind_named_type_t *bnt = (bind_named_type_t *)obind;
+    ub4 idx = obind->curar_idx;
+
+    return bnt->obj[idx];
 }
 
+NORETURN(static void bind_named_type_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val));
+
 static void bind_named_type_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
 {
     rb_raise(rb_eRuntimeError, "not supported");
@@ -658,10 +738,12 @@ static void bind_named_type_set(oci8_bind_t *obind, void *data, void **null_stru
 
 static void bind_named_type_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
 {
+    bind_named_type_t *bnt = (bind_named_type_t *)obind;
     VALUE tdo_obj = length;
 
     obind->value_sz = sizeof(void*);
-    obind->alloc_sz = sizeof(oci8_hp_obj_t);
+    obind->alloc_sz = sizeof(void*);
+    bnt->obj = xcalloc(sizeof(VALUE), obind->maxar_sz ? obind->maxar_sz : 1);
 
     CHECK_TDO(tdo_obj);
     RB_OBJ_WRITE(obind->base.self, &obind->tdo, tdo_obj);
@@ -669,7 +751,8 @@ static void bind_named_type_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE
 
 static void bind_named_type_init_elem(oci8_bind_t *obind, VALUE svc)
 {
-    oci8_hp_obj_t *oho = (oci8_hp_obj_t *)obind->valuep;
+    bind_named_type_t *bnt = (bind_named_type_t *)obind;
+    void **hp = (void **)obind->valuep;
     oci8_base_t *tdo = DATA_PTR(obind->tdo);
     OCITypeCode tc = OCITypeTypeCode(oci8_envhp, oci8_errhp, tdo->hp.tdo);
     VALUE klass = Qnil;
@@ -687,14 +770,14 @@ static void bind_named_type_init_elem(oci8_bind_t *obind, VALUE svc)
     }
     svcctx = oci8_get_svcctx(svc);
     do {
-        oho[idx].obj = rb_class_new_instance(0, NULL, klass);
-        RB_OBJ_WRITTEN(obind->base.self, Qundef, oho[idx].obj);
-        obj = DATA_PTR(oho[idx].obj);
-        RB_OBJ_WRITE(oho[idx].obj, &obj->tdo, obind->tdo);
-        obj->instancep = (char**)&oho[idx].hp;
+        bnt->obj[idx] = rb_class_new_instance(0, NULL, klass);
+        RB_OBJ_WRITTEN(obind->base.self, Qundef, bnt->obj[idx]);
+        obj = DATA_PTR(bnt->obj[idx]);
+        RB_OBJ_WRITE(bnt->obj[idx], &obj->tdo, obind->tdo);
+        obj->instancep = (char**)&hp[idx];
         obj->null_structp = (char**)&obind->u.null_structs[idx];
         oci8_link_to_parent(&obj->base, &obind->base);
-        RB_OBJ_WRITTEN(oho[idx].obj, Qundef, obind->base.self);
+        RB_OBJ_WRITTEN(bnt->obj[idx], Qundef, obind->base.self);
 
         chker2(OCIObjectNew(oci8_envhp, oci8_errhp, svcctx->base.hp.svc, tc, tdo->hp.tdo, NULL, OCI_DURATION_SESSION, TRUE, (dvoid**)obj->instancep),
                &svcctx->base);
@@ -736,7 +819,7 @@ static const oci8_bind_data_type_t bind_named_type_data_type = {
 #endif
         },
         bind_named_type_free,
-        sizeof(oci8_bind_t)
+        sizeof(bind_named_type_t)
     },
     bind_named_type_get,
     bind_named_type_set,
@@ -754,8 +837,11 @@ static VALUE bind_named_type_alloc(VALUE klass)
 
 void Init_oci_object(VALUE cOCI8)
 {
+    cOCI8MetadataType = rb_eval_string("OCI8::Metadata::Type");
     id_to_value = rb_intern("to_value");
     id_set_attributes = rb_intern("attributes=");
+    id_get_tdo_by_metadata = rb_intern("get_tdo_by_metadata");
+    id_at_is_final_type = rb_intern("@is_final_type");
 
     /* OCI8::TDO */
     cOCI8TDO = oci8_define_class_under(cOCI8, "TDO", &oci8_tdo_data_type, oci8_tdo_alloc);
@@ -773,6 +859,10 @@ void Init_oci_object(VALUE cOCI8)
     /* @private */
     rb_define_const(cOCI8TDO, "ATTR_OCIDATE", INT2FIX(ATTR_OCIDATE));
     /* @private */
+    rb_define_const(cOCI8TDO, "ATTR_TIMESTAMP", INT2FIX(ATTR_TIMESTAMP));
+    /* @private */
+    rb_define_const(cOCI8TDO, "ATTR_TIMESTAMP_TZ", INT2FIX(ATTR_TIMESTAMP_TZ));
+    /* @private */
     rb_define_const(cOCI8TDO, "ATTR_BINARY_DOUBLE", INT2FIX(ATTR_BINARY_DOUBLE));
     /* @private */
     rb_define_const(cOCI8TDO, "ATTR_BINARY_FLOAT", INT2FIX(ATTR_BINARY_FLOAT));