ruby-oci8 1.0.7 → 2.0.0

data/ext/oci8/bind.c

@@ -1,194 +1,502 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
-  define.c - part of ruby-oci8
+ * bind.c
+ *
+ * $Author: kubo $
+ * $Date: 2009-01-12 00:11:09 +0900 (Mon, 12 Jan 2009) $
+ *
+ * Copyright (C) 2002-2008 KUBO Takehiro <kubo@jiubao.org>
+ */
+#include "oci8.h"
+
+static ID id_bind_type;
+static ID id_set;
 
-  Copyright (C) 2002,2006 KUBO Takehiro <kubo@jiubao.org>
+static VALUE cOCI8BindTypeBase;
 
-=begin
-== OCIBind
-The bind handle, which is created by ((<OCIStmt#bindByPos>)) or ((<OCIStmt#bindByName>)).
+/*
+ * bind_string
+ */
+static VALUE bind_string_get(oci8_bind_t *obind, void *data, void *null_struct)
+{
+    oci8_vstr_t *vstr = (oci8_vstr_t *)data;
+    return rb_external_str_new_with_enc(vstr->buf, vstr->size, oci8_encoding);
+}
 
-super class: ((<OCIHandle>))
+static void bind_string_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
+{
+    oci8_vstr_t *vstr = (oci8_vstr_t *)data;
 
-correspond native OCI datatype: ((|OCIBind|))
-=end
-*/
-#include "oci8.h"
+    OCI8StringValue(val);
+    if (RSTRING_LEN(val) > obind->value_sz - sizeof(vstr->size)) {
+        rb_raise(rb_eArgError, "too long String to set. (%ld for %d)", RSTRING_LEN(val), obind->value_sz - (sb4)sizeof(vstr->size));
+    }
+    memcpy(vstr->buf, RSTRING_PTR(val), RSTRING_LEN(val));
+    vstr->size = RSTRING_LEN(val);
+}
+
+static void bind_string_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
+{
+    sb4 sz;
+    if (NIL_P(length)) {
+        if (NIL_P(val)) {
+            rb_raise(rb_eArgError, "value and length are both null.");
+        }
+        StringValue(val);
+        sz = RSTRING_LEN(val);
+    } else {
+        sz = NUM2INT(length);
+    }
+    if (sz <= 0) {
+        rb_raise(rb_eArgError, "invalid bind length %d", sz);
+    }
+    sz += sizeof(sb4);
+    obind->value_sz = sz;
+    obind->alloc_sz = (sz + (sizeof(sb4) - 1)) & ~(sizeof(sb4) - 1);
+}
+
+static const oci8_bind_class_t bind_string_class = {
+    {
+        NULL,
+        oci8_bind_free,
+        sizeof(oci8_bind_t)
+    },
+    bind_string_get,
+    bind_string_set,
+    bind_string_init,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    SQLT_LVC
+};
 
 /*
-=begin
---- OCIBind#get()
-     get the bind value, which set by OCI call.
+ * bind_raw
+ */
+static VALUE bind_raw_get(oci8_bind_t *obind, void *data, void *null_struct)
+{
+    oci8_vstr_t *vstr = (oci8_vstr_t *)data;
+    return rb_str_new(vstr->buf, vstr->size);
+}
 
-     :return value
-        the bind value. Its datatype is correspond to the 2nd argument of ((<OCIStmt#bindByPos>)) or ((<OCIStmt#bindByName>)).
+static const oci8_bind_class_t bind_raw_class = {
+    {
+        NULL,
+        oci8_bind_free,
+        sizeof(oci8_bind_t)
+    },
+    bind_raw_get,
+    bind_string_set,
+    bind_string_init,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    SQLT_LVB
+};
 
-     correspond native OCI function: nothing
-=end
-*/
-static VALUE oci8_get_data(VALUE self)
+#ifdef USE_DYNAMIC_FETCH /* don't use DYNAMIC_FETCH. It doesn't work well... */
+/*
+ * bind_long
+ */
+typedef struct {
+    VALUE obj;
+    ub4 alen;
+    char buf[1];
+} bind_long_t;
+#define bind_long_offset ((size_t)((bind_long_t*)0)->buf)
+
+static void bind_long_mark(oci8_base_t *base)
 {
-  oci8_bind_handle_t *defnhp;
-  VALUE obj;
+    oci8_bind_t *obind = (oci8_bind_t*)base;
+    ub4 idx = 0;
 
-  Data_Get_Struct(self, oci8_bind_handle_t, defnhp);
-  obj = oci8_get_value(defnhp);
-  return obj;
+    if (obind->valuep == NULL)
+        return;
+    do {
+        bind_long_t *bl = (bind_long_t *)((char*)obind->valuep + obind->alloc_sz * idx);
+        rb_gc_mark(bl->obj);
+    } while (++idx < obind->maxar_sz);
 }
 
-/*
-=begin
---- OCIBind#set(value)
-     get the bind value to pass Oracle via OCI call.
+static VALUE bind_long_get(oci8_bind_t *obind, void *data, void *null_struct)
+{
+    bind_long_t *bl = (bind_long_t *)data;
+    return RTEST(bl->obj) ? rb_str_dup(bl->obj) : Qnil;
+}
 
-     :value
-        the value to set the bind handle. Its datatype must be correspond to the 2nd argument of ((<OCIStmt#bindByPos>)) or ((<OCIStmt#bindByName>)).
+static void bind_long_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
+{
+    bind_long_t *bl = (bind_long_t *)data;
+    bl->obj = rb_str_dup(val);
+}
 
-     correspond native OCI function: nothing
-=end
-*/
-static VALUE oci8_set_data(VALUE self, VALUE val)
+static void bind_long_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
 {
-  oci8_bind_handle_t *hp;
+    sb4 sz = 0;
 
-  Data_Get_Struct(self, oci8_bind_handle_t, hp);
-  oci8_set_value(hp, val);
-  return self;
+    if (!NIL_P(length)) {
+        sz = NUM2INT(length);
+    }
+    if (sz < 4000) {
+        sz = 4000;
+    }
+    sz += bind_long_offset;
+    obind->value_sz = INT_MAX;
+    obind->alloc_sz = (sz + (sizeof(VALUE) - 1)) & ~(sizeof(VALUE) - 1);
 }
 
-void Init_oci8_bind(void)
+static void bind_long_init_elem(oci8_bind_t *obind, VALUE svc)
 {
-  rb_define_method(cOCIBind, "get", oci8_get_data, 0);
-  rb_define_method(cOCIBind, "set", oci8_set_data, 1);
+    ub4 idx = 0;
+
+    do {
+        bind_long_t *bl = (bind_long_t *)((char*)obind->valuep + obind->alloc_sz * idx);
+        bl->obj = Qnil;
+    } while (++idx < obind->maxar_sz);
 }
 
-VALUE oci8_get_value(oci8_bind_handle_t *hp)
+static ub1 bind_long_in(oci8_bind_t *obind, ub4 idx, ub1 piece, void **valuepp, ub4 **alenpp, void **indpp)
 {
-  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;
+    bind_long_t *bl = (bind_long_t *)((char*)obind->valuep + obind->alloc_sz * idx);
 
-  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:
+    *alenpp = &bl->alen;
+    *indpp = &obind->u.inds[idx];
+    if (NIL_P(bl->obj)) {
+        *valuepp = NULL;
+        bl->alen = 0;
+        obind->u.inds[idx] = -1;
+    } else {
+        StringValue(bl->obj);
+        *valuepp = RSTRING_PTR(bl->obj);
+        bl->alen = RSTRING_LEN(bl->obj);
+        obind->u.inds[idx] = 0;
+    }
+    return OCI_ONE_PIECE;
+}
+
+static void bind_long_out(oci8_bind_t *obind, ub4 idx, ub1 piece, void **valuepp, ub4 **alenpp, void **indpp)
+{
+    bind_long_t *bl = (bind_long_t *)((char*)obind->valuep + obind->alloc_sz * idx);
+
+    switch (piece) {
+    case OCI_NEXT_PIECE:
+    case OCI_LAST_PIECE:
+        if (bl->alen > 0) {
+            if (!RTEST(bl->obj)) {
+                bl->obj = rb_str_buf_new(bl->alen);
+            }
+            rb_str_buf_cat(bl->obj, bl->buf, bl->alen);
+        }
+        break;
+    default:
+        /* OCI_FIRST_PIECE is passed at the first call according to manuals.
+         * But OCI_ONE_PIECE is passed on Oracle 8 and 8i on Windows...
+         */
+        bl->obj = Qnil;
+    }
+    *valuepp = bl->buf;
+    *alenpp = &bl->alen;
+    *indpp = &obind->u.inds[idx];
+    bl->alen = obind->alloc_sz - bind_long_offset;
+    obind->u.inds[idx] = 0;
+}
+
+static const oci8_bind_class_t bind_long_class = {
+    {
+        bind_long_mark,
+        oci8_bind_free,
+        sizeof(oci8_bind_t)
+    },
+    bind_long_get,
+    bind_long_set,
+    bind_long_init,
+    bind_long_init_elem,
+    bind_long_in,
+    bind_long_out,
+    NULL,
+    SQLT_CHR
+};
+
+/*
+ * bind_long_raw
+ */
+static const oci8_bind_class_t bind_long_raw_class = {
+    {
+        bind_long_mark,
+        oci8_bind_free,
+        sizeof(oci8_bind_t)
+    },
+    bind_long_get,
+    bind_long_set,
+    bind_long_init,
+    bind_long_init_elem,
+    bind_long_in,
+    bind_long_out,
+    NULL,
+    SQLT_BIN
+};
+#endif /* USE_DYNAMIC_FETCH */
+
+/*
+ * bind_fixnum
+ */
+static VALUE bind_fixnum_get(oci8_bind_t *obind, void *data, void *null_struct)
+{
+    return LONG2NUM(*(long*)data);
+}
+
+static void bind_fixnum_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
+{
     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:
+    *(long*)data = FIX2LONG(val);
+}
+
+static void bind_fixnum_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
+{
+    obind->value_sz = sizeof(long);
+    obind->alloc_sz = sizeof(long);
+}
+
+static const oci8_bind_class_t bind_fixnum_class = {
+    {
+        NULL,
+        oci8_bind_free,
+        sizeof(oci8_bind_t)
+    },
+    bind_fixnum_get,
+    bind_fixnum_set,
+    bind_fixnum_init,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    SQLT_INT
+};
+
+/*
+ * bind_float
+ */
+static VALUE bind_float_get(oci8_bind_t *obind, void *data, void *null_struct)
+{
+    return rb_float_new(*(double*)data);
+}
+
+static void bind_float_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
+{
     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));
+    *(double*)data = RFLOAT_VALUE(val);
+}
+
+static void bind_float_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
+{
+    obind->value_sz = sizeof(double);
+    obind->alloc_sz = sizeof(double);
+}
+
+static const oci8_bind_class_t bind_float_class = {
+    {
+        NULL,
+        oci8_bind_free,
+        sizeof(oci8_bind_t)
+    },
+    bind_float_get,
+    bind_float_set,
+    bind_float_init,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    SQLT_FLT
+};
+
+#ifndef SQLT_BDOUBLE
+#define SQLT_BDOUBLE 22
+#endif
+static const oci8_bind_class_t bind_binary_double_class = {
+    {
+        NULL,
+        oci8_bind_free,
+        sizeof(oci8_bind_t)
+    },
+    bind_float_get,
+    bind_float_set,
+    bind_float_init,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    SQLT_BDOUBLE
+};
+
+static inline VALUE oci8_get_data_at(const oci8_bind_class_t *obc, oci8_bind_t *obind, ub4 idx)
+{
+    void **null_structp = NULL;
+
+    if (NIL_P(obind->tdo)) {
+        if (obind->u.inds[idx] != 0)
+            return Qnil;
+    } else {
+        null_structp = &obind->u.null_structs[idx];
+        if (*(OCIInd*)*null_structp != 0)
+            return Qnil;
+    }
+    return obc->get(obind, (void*)((size_t)obind->valuep + obind->alloc_sz * idx), null_structp);
+}
+
+static VALUE oci8_get_data(VALUE self)
+{
+    oci8_bind_t *obind = DATA_PTR(self);
+    const oci8_bind_class_t *obc = (const oci8_bind_class_t *)obind->base.klass;
+
+    if (obind->maxar_sz == 0) {
+        return oci8_get_data_at(obc, obind, 0);
+    } else {
+        volatile VALUE ary = rb_ary_new2(obind->curar_sz);
+        ub4 idx;
+
+        for (idx = 0; idx < obind->curar_sz; idx++) {
+            rb_ary_store(ary, idx, oci8_get_data_at(obc, obind, idx));
+        }
+        return ary;
+    }
+}
+
+static inline void oci8_set_data_at(const oci8_bind_class_t *obc, oci8_bind_t *obind, ub4 idx, VALUE val)
+{
+
+    if (NIL_P(val)) {
+        if (NIL_P(obind->tdo)) {
+            obind->u.inds[idx] = -1;
+        } else {
+            *(OCIInd*)obind->u.null_structs[idx] = -1;
+        }
+    } else {
+        void **null_structp = NULL;
+
+        if (NIL_P(obind->tdo)) {
+            null_structp = NULL;
+            obind->u.inds[idx] = 0;
+        } else {
+            null_structp = &obind->u.null_structs[idx];
+        }
+        obc->set(obind, (void*)((size_t)obind->valuep + obind->alloc_sz * idx), null_structp, val);
+    }
+}
+
+static VALUE oci8_set_data(VALUE self, VALUE val)
+{
+    oci8_bind_t *obind = DATA_PTR(self);
+    const oci8_bind_class_t *obc = (const oci8_bind_class_t *)obind->base.klass;
+
+    if (obind->maxar_sz == 0) {
+        oci8_set_data_at(obc, obind, 0, val);
+    } else {
+        ub4 size;
+        ub4 idx;
+        Check_Type(val, T_ARRAY);
+
+        size = RARRAY_LEN(val);
+        if (size > obind->maxar_sz) {
+            rb_raise(rb_eRuntimeError, "over the max array size");
+        }
+        for (idx = 0; idx < size; idx++) {
+            oci8_set_data_at(obc, obind, idx, RARRAY_PTR(val)[idx]);
+        }
+        obind->curar_sz = size;
+    }
+    return self;
+}
+
+static VALUE oci8_bind_initialize(VALUE self, VALUE svc, VALUE val, VALUE length, VALUE max_array_size)
+{
+    oci8_bind_t *obind = DATA_PTR(self);
+    const oci8_bind_class_t *bind_class = (const oci8_bind_class_t *)obind->base.klass;
+    ub4 cnt = 1;
+
+    obind->tdo = Qnil;
+    obind->maxar_sz = NIL_P(max_array_size) ? 0 : NUM2UINT(max_array_size);
+    obind->curar_sz = 0;
+    if (obind->maxar_sz > 0)
+        cnt = obind->maxar_sz;
+    bind_class->init(obind, svc, val, length);
+    if (obind->alloc_sz > 0) {
+        obind->valuep = xmalloc(obind->alloc_sz * cnt);
+        memset(obind->valuep, 0, obind->alloc_sz * cnt);
     } 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;
+        obind->valuep = NULL;
+    }
+    if (NIL_P(obind->tdo)) {
+        obind->u.inds = xmalloc(sizeof(sb2) * cnt);
+        memset(obind->u.inds, -1, sizeof(sb2) * cnt);
     } else {
-      rb_raise(rb_eTypeError, "invalid argument: %s (expect %s)", rb_obj_classname(val), rb_class2name(hp->value.handle.klass));
+        obind->u.null_structs = xmalloc(sizeof(void *) * cnt);
+        memset(obind->u.null_structs, 0, sizeof(void *) * cnt);
+    }
+    if (bind_class->init_elem != NULL) {
+        bind_class->init_elem(obind, svc);
+    }
+    if (!NIL_P(val)) {
+        rb_funcall(self, id_set, 1, val);
+    }
+    return Qnil;
+}
+
+void oci8_bind_free(oci8_base_t *base)
+{
+    oci8_bind_t *obind = (oci8_bind_t *)base;
+    if (obind->valuep != NULL) {
+        xfree(obind->valuep);
+        obind->valuep = NULL;
+    }
+    if (obind->u.inds != NULL) {
+        xfree(obind->u.inds);
+        obind->u.inds = NULL;
     }
-    break;
-  default:
-    rb_bug("unsupported data type: %d", hp->bind_type);
-  }
-  hp->ind = 0;
+}
+
+void oci8_bind_hp_obj_mark(oci8_base_t *base)
+{
+    oci8_bind_t *obind = (oci8_bind_t *)base;
+    oci8_hp_obj_t *oho = (oci8_hp_obj_t *)obind->valuep;
+
+    if (oho != NULL) {
+        ub4 idx = 0;
+
+        do {
+            rb_gc_mark(oho[idx].obj);
+        } while (++idx < obind->maxar_sz);
+    }
+}
+
+void Init_oci8_bind(VALUE klass)
+{
+    cOCI8BindTypeBase = klass;
+    id_bind_type = rb_intern("bind_type");
+    id_set = rb_intern("set");
+
+    rb_define_method(cOCI8BindTypeBase, "initialize", oci8_bind_initialize, 4);
+    rb_define_method(cOCI8BindTypeBase, "get", oci8_get_data, 0);
+    rb_define_method(cOCI8BindTypeBase, "set", oci8_set_data, 1);
+
+    /* register primitive data types. */
+    oci8_define_bind_class("String", &bind_string_class);
+    oci8_define_bind_class("RAW", &bind_raw_class);
+#ifdef USE_DYNAMIC_FETCH
+    oci8_define_bind_class("Long", &bind_long_class);
+    oci8_define_bind_class("LongRaw", &bind_long_raw_class);
+#endif /* USE_DYNAMIC_FETCH */
+    oci8_define_bind_class("Fixnum", &bind_fixnum_class);
+    oci8_define_bind_class("Float", &bind_float_class);
+    if (oracle_client_version >= ORAVER_10_1) {
+        oci8_define_bind_class("BinaryDouble", &bind_binary_double_class);
+    }
+}
+
+oci8_bind_t *oci8_get_bind(VALUE obj)
+{
+    oci8_base_t *base;
+    Check_Handle(obj, cOCI8BindTypeBase, base);
+    return (oci8_bind_t *)base;
 }