ruby-oci8 1.0.7 → 2.0.0

data/ext/oci8/stmt.c

@@ -1,624 +1,804 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
-  stmt.c - part of ruby-oci8
-           implement the methods of OCIStmt.
+ * stmt.c - part of ruby-oci8
+ *         implement the methods of OCIStmt.
+ *
+ * Copyright (C) 2002-2007 KUBO Takehiro <kubo@jiubao.org>
+ *
+ */
+#include "oci8.h"
 
-  Copyright (C) 2002-2006 KUBO Takehiro <kubo@jiubao.org>
+static VALUE oci8_sym_select_stmt;
+static VALUE oci8_sym_update_stmt;
+static VALUE oci8_sym_delete_stmt;
+static VALUE oci8_sym_insert_stmt;
+static VALUE oci8_sym_create_stmt;
+static VALUE oci8_sym_drop_stmt;
+static VALUE oci8_sym_alter_stmt;
+static VALUE oci8_sym_begin_stmt;
+static VALUE oci8_sym_declare_stmt;
+static ID id_at_column_metadata;
+static ID id_at_actual_array_size;
+static ID id_at_max_array_size;
+static ID id_each_value;
+static ID id_at_names;
+static ID id_empty_p;
+static ID id_at_con;
+static ID id_clear;
+static ID id_set;
+
+VALUE cOCIStmt;
+
+typedef struct {
+    oci8_base_t base;
+    VALUE svc;
+    VALUE binds;
+    VALUE defns;
+} oci8_stmt_t;
+
+static void oci8_stmt_mark(oci8_base_t *base)
+{
+    oci8_stmt_t *stmt = (oci8_stmt_t *)base;
+    rb_gc_mark(stmt->svc);
+    rb_gc_mark(stmt->binds);
+    rb_gc_mark(stmt->defns);
+}
 
-=begin
-== OCIStmt
-Statemet handle identify a SQL or PL/SQL statement and its associated attributes.
+static void oci8_stmt_free(oci8_base_t *base)
+{
+    oci8_stmt_t *stmt = (oci8_stmt_t *)base;
+    stmt->svc = Qnil;
+    stmt->binds = Qnil;
+    stmt->defns = Qnil;
+}
 
-Information about SQL or PL/SQL's input/output variables is managed by the 
-((<bind handle|OCIBind>)). Fetched data of select statement is managed by the
-((<define handle|OCIDefine>)). 
+static oci8_base_class_t oci8_stmt_class = {
+    oci8_stmt_mark,
+    oci8_stmt_free,
+    sizeof(oci8_stmt_t),
+};
 
-super class: ((<OCIHandle>))
+static VALUE oci8_stmt_initialize(int argc, VALUE *argv, VALUE self)
+{
+    oci8_stmt_t *stmt = DATA_PTR(self);
+    VALUE svc;
+    VALUE sql;
+    sword rv;
+
+    rb_scan_args(argc, argv, "11", &svc, &sql);
+
+    oci8_check_pid_consistency(oci8_get_svcctx(svc));
+    if (argc > 1)
+        OCI8SafeStringValue(sql);
+
+    rv = OCIHandleAlloc(oci8_envhp, &stmt->base.hp.ptr, OCI_HTYPE_STMT, 0, NULL);
+    if (rv != OCI_SUCCESS)
+        oci8_env_raise(oci8_envhp, rv);
+    stmt->base.type = OCI_HTYPE_STMT;
+    stmt->svc = svc;
+    stmt->binds = rb_hash_new();
+    stmt->defns = rb_ary_new();
+    rb_ivar_set(stmt->base.self, id_at_column_metadata, rb_ary_new());
+    rb_ivar_set(stmt->base.self, id_at_names, Qnil);
+    rb_ivar_set(stmt->base.self, id_at_con, svc);
+    rb_ivar_set(stmt->base.self, id_at_max_array_size, Qnil);
+
+    if (argc > 1) {
+        rv = OCIStmtPrepare(stmt->base.hp.stmt, oci8_errhp, RSTRING_ORATEXT(sql), RSTRING_LEN(sql), OCI_NTV_SYNTAX, OCI_DEFAULT);
+        if (IS_OCI_ERROR(rv)) {
+            oci8_raise(oci8_errhp, rv, stmt->base.hp.stmt);
+        }
+    }
+    oci8_link_to_parent((oci8_base_t*)stmt, (oci8_base_t*)DATA_PTR(svc));
+    return Qnil;
+}
 
-correspond native OCI datatype: ((|OCIStmt|))
-=end
-*/
-#include "oci8.h"
+static VALUE oci8_define_by_pos(VALUE self, VALUE vposition, VALUE vbindobj)
+{
+    oci8_stmt_t *stmt = DATA_PTR(self);
+    ub4 position;
+    oci8_bind_t *obind;
+    const oci8_bind_class_t *bind_class;
+    sword status;
+    ub4 mode;
+
+    position = NUM2INT(vposition); /* 1 */
+    obind = oci8_get_bind(vbindobj); /* 2 */
+    if (obind->base.hp.dfn != NULL) {
+        oci8_base_free(&obind->base); /* TODO: OK? */
+    }
+    bind_class = (const oci8_bind_class_t *)obind->base.klass;
+    if (bind_class->out == NULL) {
+        mode = OCI_DEFAULT;
+    } else {
+        mode = OCI_DYNAMIC_FETCH;
+    }
+    status = OCIDefineByPos(stmt->base.hp.stmt, &obind->base.hp.dfn, oci8_errhp, position, obind->valuep, obind->value_sz, bind_class->dty, NIL_P(obind->tdo) ? obind->u.inds : NULL, NULL, 0, mode);
+    if (status != OCI_SUCCESS) {
+        oci8_raise(oci8_errhp, status, stmt->base.hp.ptr);
+    }
+    obind->base.type = OCI_HTYPE_DEFINE;
+    if (NIL_P(obind->tdo) && obind->maxar_sz > 0) {
+        oci_lc(OCIDefineArrayOfStruct(obind->base.hp.dfn, oci8_errhp, obind->alloc_sz, sizeof(sb2), 0, 0));
+    }
+    if (RTEST(obind->tdo)) {
+        oci8_base_t *tdo = DATA_PTR(obind->tdo);
+        oci_lc(OCIDefineObject(obind->base.hp.dfn, oci8_errhp, tdo->hp.tdo,
+                               obind->valuep, 0, obind->u.null_structs, 0));
+    }
+    if (position - 1 < RARRAY_LEN(stmt->defns)) {
+        VALUE old_value = RARRAY_PTR(stmt->defns)[position - 1];
+        if (!NIL_P(old_value)) {
+            oci8_base_free((oci8_base_t*)oci8_get_bind(old_value));
+        }
+    }
+    if (bind_class->csfrm != 0) {
+        oci_lc(OCIAttrSet(obind->base.hp.ptr, OCI_HTYPE_DEFINE, (void*)&bind_class->csfrm, 0, OCI_ATTR_CHARSET_FORM, oci8_errhp));
+    }
+    rb_ary_store(stmt->defns, position - 1, obind->base.self);
+    oci8_unlink_from_parent((oci8_base_t*)obind);
+    oci8_link_to_parent((oci8_base_t*)obind, (oci8_base_t*)stmt);
+    return obind->base.self;
+}
 
-static ID id_alloc;
+static VALUE oci8_bind(VALUE self, VALUE vplaceholder, VALUE vbindobj)
+{
+    oci8_stmt_t *stmt = DATA_PTR(self);
+    char *placeholder_ptr = (char*)-1; /* initialize as an invalid value */
+    ub4 placeholder_len = 0;
+    ub4 position = 0;
+    oci8_bind_t *obind;
+    const oci8_bind_class_t *bind_class;
+    sword status;
+    VALUE old_value;
+    void *indp;
+    ub4 *curelep;
+    ub4 mode;
+
+    if (NIL_P(vplaceholder)) { /* 1 */
+        placeholder_ptr = NULL;
+        placeholder_len = 0;
+    } else if (SYMBOL_P(vplaceholder)) {
+        const char *symname = rb_id2name(SYM2ID(vplaceholder));
+        size_t len = strlen(symname);
+        placeholder_ptr = ALLOCA_N(char, len + 1);
+        placeholder_len = len + 1;
+        placeholder_ptr[0] = ':';
+        memcpy(placeholder_ptr + 1, symname, len);
+    } else if (FIXNUM_P(vplaceholder)) {
+        position = NUM2INT(vplaceholder);
+    } else {
+        OCI8StringValue(vplaceholder);
+        placeholder_ptr = RSTRING_PTR(vplaceholder);
+        placeholder_len = RSTRING_LEN(vplaceholder);
+    }
+    obind = oci8_get_bind(vbindobj); /* 2 */
+    if (obind->base.hp.bnd != NULL) {
+        oci8_base_free(&obind->base); /* TODO: OK? */
+    }
+    bind_class = (const oci8_bind_class_t *)obind->base.klass;
+    if (bind_class->in != NULL || bind_class->out != NULL) {
+        mode = OCI_DATA_AT_EXEC;
+    } else {
+        mode = OCI_DEFAULT;
+    }
 
-static void check_bind_type(ub4 type, oci8_handle_t *stmth, VALUE vtype, VALUE vlength, oci8_bind_handle_t **bhp, ub2 *dty)
+    indp = NIL_P(obind->tdo) ? obind->u.inds : NULL;
+    if (obind->maxar_sz == 0) {
+        curelep = NULL;
+    } else {
+        curelep = &obind->curar_sz;
+    }
+    if (placeholder_ptr == (char*)-1) {
+        status = OCIBindByPos(stmt->base.hp.stmt, &obind->base.hp.bnd, oci8_errhp, position, obind->valuep, obind->value_sz, bind_class->dty, indp, NULL, 0, 0, 0, mode);
+    } else {
+        status = OCIBindByName(stmt->base.hp.stmt, &obind->base.hp.bnd, oci8_errhp, TO_ORATEXT(placeholder_ptr), placeholder_len, obind->valuep, obind->value_sz, bind_class->dty, indp, NULL, 0, 0, 0, mode);
+    }
+    if (status != OCI_SUCCESS) {
+        oci8_raise(oci8_errhp, status, stmt->base.hp.stmt);
+    }
+    obind->base.type = OCI_HTYPE_BIND;
+    if (NIL_P(obind->tdo) && obind->maxar_sz > 0) {
+        oci_lc(OCIBindArrayOfStruct(obind->base.hp.bnd, oci8_errhp, obind->alloc_sz, sizeof(sb2), 0, 0));
+    }
+    if (!NIL_P(obind->tdo)) {
+        oci8_base_t *tdo = DATA_PTR(obind->tdo);
+        oci_lc(OCIBindObject(obind->base.hp.bnd, oci8_errhp, tdo->hp.tdo,
+                             obind->valuep, 0, obind->u.null_structs, 0));
+    }
+    if (bind_class->csfrm != 0) {
+        oci_lc(OCIAttrSet(obind->base.hp.ptr, OCI_HTYPE_BIND, (void*)&bind_class->csfrm, 0, OCI_ATTR_CHARSET_FORM, oci8_errhp));
+    }
+    old_value = rb_hash_aref(stmt->binds, vplaceholder);
+    if (!NIL_P(old_value)) {
+        oci8_base_free((oci8_base_t*)oci8_get_bind(old_value));
+    }
+    rb_hash_aset(stmt->binds, vplaceholder, obind->base.self);
+    oci8_unlink_from_parent((oci8_base_t*)obind);
+    oci8_link_to_parent((oci8_base_t*)obind, (oci8_base_t*)stmt);
+    return obind->base.self;
+}
+
+static sword oci8_call_stmt_execute(oci8_svcctx_t *svcctx, oci8_stmt_t *stmt, ub4 iters, ub4 mode)
 {
-  enum oci8_bind_type bind_type;
-  oci8_bind_handle_t *bh;
-  sb4 value_sz;
-  VALUE klass = Qnil;
-
-  if (TYPE(vtype) == T_FIXNUM) {
-    switch (FIX2INT(vtype)) {
-    case SQLT_CHR: /* OCI_TYPECODE_VARCHAR */
-      bind_type = BIND_STRING;
-      *dty = SQLT_LVC;
-      if (NIL_P(vlength))
-	rb_raise(rb_eArgError, "the length of String is not specified.");
-      value_sz = NUM2INT(vlength) + 4;
-      if (value_sz < 5)
-        value_sz = 5; /* at least 5 bytes */
-      break;
-    case SQLT_LVB: /* OCI_TYPECODE_RAW */
-    case SQLT_BIN: /* OCI_TYPECODE_UNSIGNED8 */
-      bind_type = BIND_STRING;
-      *dty = SQLT_LVB;
-      if (NIL_P(vlength))
-	rb_raise(rb_eArgError, "the length of String is not specified.");
-      value_sz = NUM2INT(vlength) + 4;
-      if (value_sz < 5)
-        value_sz = 5; /* at least 5 bytes */
-      break;
-    case SQLT_DAT:
-      bind_type = BIND_ORA_DATE;
-      *dty = SQLT_DAT;
-      value_sz = sizeof(ora_date_t);
-      break;
-    case SQLT_CLOB: /* OCI_TYPECODE_CLOB */
-    case SQLT_BLOB: /* OCI_TYPECODE_BLOB */
-      bind_type = BIND_HANDLE;
-      *dty = FIX2INT(vtype);
-      value_sz = sizeof(bh->value.handle);
-      klass = cOCILobLocator;
-      break;
-    case SQLT_BFILE:
-    case SQLT_CFILE:
-      bind_type = BIND_HANDLE;
-      *dty = FIX2INT(vtype);
-      value_sz = sizeof(bh->value.handle);
-      klass = cOCIFileLocator;
-      break;
-    case SQLT_RDD:
-      bind_type = BIND_HANDLE;
-      *dty = SQLT_RDD;
-      value_sz = sizeof(bh->value.handle);
-      klass = cOCIRowid;
-      break;
-    case SQLT_RSET:
-      bind_type = BIND_HANDLE;
-      *dty = SQLT_RSET;
-      value_sz = sizeof(bh->value.handle);
-      klass = cOCIStmt;
-      break;
-#ifdef SQLT_IBDOUBLE
-    case SQLT_IBDOUBLE:
-      bind_type = BIND_FLOAT;
-      *dty = SQLT_BDOUBLE;
-      value_sz = sizeof(double);
-      break;
-#endif
-    default:
-      rb_raise(rb_eArgError, "Not supported type (%d)", FIX2INT(vtype));
-    }
-  } else if (vtype == rb_cFixnum) {
-    bind_type = BIND_FIXNUM;
-    *dty = SQLT_INT;
-    value_sz = sizeof(long);
-  } else if (vtype == rb_cInteger || vtype == rb_cBignum) {
-    bind_type = BIND_INTEGER_VIA_ORA_NUMBER;
-    *dty = SQLT_NUM;
-    value_sz = sizeof(ora_number_t);
-  } else if (vtype == rb_cTime) {
-    bind_type = BIND_TIME_VIA_ORA_DATE;
-    *dty = SQLT_DAT;
-    value_sz = sizeof(ora_date_t);
-  } else if (vtype == rb_cString) {
-    bind_type = BIND_STRING;
-    *dty = SQLT_LVC;
-    if (NIL_P(vlength))
-      rb_raise(rb_eArgError, "the length of String is not specified.");
-    value_sz = NUM2INT(vlength) + 4;
-    if (value_sz < 5)
-      value_sz = 5; /* at least 5 bytes */
-  } else if (vtype == rb_cFloat) {
-    bind_type = BIND_FLOAT;
-    *dty = SQLT_FLT;
-    value_sz = sizeof(double);
-  } else if (vtype == cOraDate) {
-    bind_type = BIND_ORA_DATE;
-    *dty = SQLT_DAT;
-    value_sz = sizeof(ora_date_t);
-  } else if (vtype == cOraNumber) {
-    bind_type = BIND_ORA_NUMBER;
-    *dty = SQLT_NUM;
-    value_sz = sizeof(ora_number_t);
-  } else {
-    if (SYMBOL_P(vtype)) {
-      rb_raise(rb_eArgError, "Not supported type (:%s)", rb_id2name(SYM2ID(vtype)));
+    sword rv;
+
+    rv = OCIStmtExecute_nb(svcctx, svcctx->base.hp.svc, stmt->base.hp.stmt, oci8_errhp, iters, 0, NULL, NULL, mode);
+    if (rv == OCI_ERROR) {
+        if (oci8_get_error_code(oci8_errhp) == 1000) {
+            /* run GC to close unreferred cursors
+             * when ORA-01000 (maximum open cursors exceeded).
+             */
+            rb_gc();
+            rv = OCIStmtExecute_nb(svcctx, svcctx->base.hp.svc, stmt->base.hp.stmt, oci8_errhp, iters, 0, NULL, NULL, mode);
+        }
+    }
+    return rv;
+}
+
+static VALUE oci8_stmt_execute(VALUE self, VALUE iteration_count)
+{
+    oci8_stmt_t *stmt = DATA_PTR(self);
+    oci8_svcctx_t *svcctx = oci8_get_svcctx(stmt->svc);
+    ub4 iters;
+    ub4 mode;
+    sword rv;
+
+    if (oci8_get_ub2_attr(&stmt->base, OCI_ATTR_STMT_TYPE) == INT2FIX(OCI_STMT_SELECT)) {
+        iters = 0;
+        mode = OCI_DEFAULT;
     } else {
-      rb_raise(rb_eArgError, "Not supported type (%s)", rb_class2name(vtype));
-    }
-  }
-  bh = (oci8_bind_handle_t *)oci8_make_handle(type, NULL, NULL, stmth, value_sz);
-  bh->bind_type = bind_type;
-  if (bind_type == BIND_HANDLE) {
-    if (NIL_P(vlength)) {
-      oci8_handle_t *envh;
-      for (envh = stmth; envh->type != OCI_HTYPE_ENV; envh = envh->parent);
-      vlength = rb_funcall(envh->self, id_alloc, 1, klass);
-    }
-    bh->value.handle.klass = klass;
-    oci8_set_value(bh, vlength);
-  }
-  *bhp = bh;
+        if(!NIL_P(iteration_count)) 
+            iters = NUM2INT(iteration_count);
+        else 
+            iters = 1;
+        mode = svcctx->is_autocommit ? OCI_COMMIT_ON_SUCCESS : OCI_DEFAULT;
+    }
+    rv = oci8_call_stmt_execute(svcctx, stmt, iters, mode);
+#ifdef USE_DYNAMIC_FETCH
+    while (rv == OCI_NEED_DATA) {
+        oci8_bind_t *obind;
+        const oci8_bind_class_t *bind_class;
+        /* get piece info. */
+        dvoid *hp;
+        ub4 type;
+        ub1 in_out;
+        ub4 iter;
+        ub4 idx;
+        ub1 piece;
+        /* set piece info. */
+        void *valuep;
+        ub4 *alenp;
+        void *indp;
+
+        oci_lc(OCIStmtGetPieceInfo(stmt->base.hp.ptr, oci8_errhp, &hp, &type, &in_out, &iter, &idx, &piece));
+        obind = (oci8_bind_t*)stmt->base.children;
+        do {
+            if (obind->base.hp.ptr == hp) {
+                if (type != OCI_HTYPE_BIND)
+                    rb_bug("ruby-oci8: expect OCI_HTYPE_BIND but %d", type);
+                bind_class = (const oci8_bind_class_t *)obind->base.klass;
+                switch (in_out) {
+                case OCI_PARAM_IN:
+                    if (bind_class->in == NULL)
+                        rb_bug("....");
+                    piece = bind_class->in(obind, idx, piece, &valuep, &alenp, &indp);
+                    break;
+                case OCI_PARAM_OUT:
+                    if (bind_class->out == NULL)
+                        rb_bug("....");
+                    bind_class->out(obind, idx, piece, &valuep, &alenp, &indp);
+                    break;
+                default:
+                    rb_bug("ruby-oci8: expect OCI_PARAM_IN or OCI_PARAM_OUT but %d", in_out);
+                }
+                oci_lc(OCIStmtSetPieceInfo(obind->base.hp.ptr, OCI_HTYPE_BIND, oci8_errhp, valuep, alenp, 0, indp, NULL));
+                break;
+            }
+            obind = (oci8_bind_t*)obind->base.next;
+        } while (obind != (oci8_bind_t*)stmt->base.children);
+        if (obind == (oci8_bind_t*)stmt) {
+            rb_bug("ruby-oci8: No bind handle is found.");
+        }
+        rv = oci8_call_stmt_execute(svcctx, stmt, iters, mode);
+    }
+#endif /* USE_DYNAMIC_FETCH */
+    if (IS_OCI_ERROR(rv)) {
+        oci8_raise(oci8_errhp, rv, stmt->base.hp.stmt);
+    }
+    return self;
+}
+
+static VALUE each_value(VALUE obj)
+{
+    return rb_funcall(obj, id_each_value, 0);
+}
+
+static VALUE clear_binds_iterator_proc(VALUE val, VALUE arg)
+{
+    if(!NIL_P(val)) {
+        oci8_base_free((oci8_base_t*)oci8_get_bind(val));
+    }
+    return Qnil;
 }
 
-static VALUE oci8_each_value(VALUE hash)
+static VALUE oci8_stmt_clear_binds(VALUE self)
 {
-  return rb_funcall(hash, rb_intern("each_value"), 0);
+    oci8_stmt_t *stmt = DATA_PTR(self);
+    
+    if(!RTEST(rb_funcall(stmt->binds, id_empty_p, 0)))
+    {
+        rb_iterate(each_value, stmt->binds, clear_binds_iterator_proc, Qnil);
+        rb_funcall(stmt->binds,id_clear,0);
+    }
+
+    return self;
+}
+
+static VALUE oci8_stmt_do_fetch(oci8_stmt_t *stmt, oci8_svcctx_t *svcctx)
+{
+    VALUE ary;
+    sword rv;
+    long idx;
+    oci8_bind_t *obind;
+    const oci8_bind_class_t *bind_class;
+
+    obind = (oci8_bind_t *)stmt->base.children;
+    do {
+        if (obind->base.type == OCI_HTYPE_DEFINE) {
+            bind_class = (const oci8_bind_class_t *)obind->base.klass;
+            if (bind_class->pre_fetch_hook != NULL) {
+                bind_class->pre_fetch_hook(obind, stmt->svc);
+            }
+        }
+        obind = (oci8_bind_t *)obind->base.next;
+    } while (obind != (oci8_bind_t*)stmt->base.children);
+    rv = OCIStmtFetch_nb(svcctx, stmt->base.hp.stmt, oci8_errhp, 1, OCI_FETCH_NEXT, OCI_DEFAULT);
+#ifdef USE_DYNAMIC_FETCH
+    while (rv == OCI_NEED_DATA) {
+        /* get piece info. */
+        dvoid *hp;
+        ub4 type;
+        ub1 in_out;
+        ub4 iter;
+        ub4 idx;
+        ub1 piece;
+        /* set piece info. */
+        void *valuep;
+        ub4 *alenp;
+        void *indp;
+
+        oci_lc(OCIStmtGetPieceInfo(stmt->base.hp.ptr, oci8_errhp, &hp, &type, &in_out, &iter, &idx, &piece));
+        obind = (oci8_bind_t *)stmt->base.children;
+        do {
+            if (obind->base.hp.ptr == hp) {
+                if (type != OCI_HTYPE_DEFINE)
+                    rb_bug("ruby-oci8: expect OCI_HTYPE_DEFINE but %d", type);
+                bind_class = (const oci8_bind_class_t *)obind->base.klass;
+                switch (in_out) {
+                case OCI_PARAM_OUT:
+                    if (bind_class->out == NULL)
+                        rb_bug("....");
+                    bind_class->out(obind, idx, piece, &valuep, &alenp, &indp);
+                    break;
+                default:
+                    rb_bug("ruby-oci8: expect OCI_PARAM_OUT but %d", in_out);
+                }
+                oci_lc(OCIStmtSetPieceInfo(obind->base.hp.ptr, OCI_HTYPE_DEFINE, oci8_errhp, valuep, alenp, 0, indp, NULL));
+                break;
+            }
+            obind = (oci8_bind_t *)obind->base.next;
+        } while (obind != (oci8_bind_t*)stmt->base.children);
+        if (obind == (oci8_bind_t*)stmt) {
+            rb_bug("ruby-oci8: No define handle is found.");
+        }
+        rv = OCIStmtFetch_nb(svcctx, stmt->base.hp.stmt, oci8_errhp, 1, OCI_FETCH_NEXT, OCI_DEFAULT);
+    }
+#endif /* USE_DYNAMIC_FETCH */
+    if (rv == OCI_NO_DATA) {
+        return Qnil;
+    }
+    if (IS_OCI_ERROR(rv)) {
+        oci8_raise(oci8_errhp, rv, stmt->base.hp.stmt);
+    }
+#ifdef USE_DYNAMIC_FETCH
+    obind = (oci8_bind_t *)stmt->base.children;
+    do {
+        /* set piece info. */
+        void *valuep;
+        ub4 *alenp;
+        void *indp;
+        ub1 piece = OCI_LAST_PIECE;
+
+        if (obind->base.type == OCI_HTYPE_DEFINE) {
+            bind_class = (const oci8_bind_class_t *)obind->base.klass;
+            if (bind_class->out != NULL) {
+                if (obind->maxar_sz == 0) {
+                    bind_class->out(obind, 0, piece, &valuep, &alenp, &indp);
+                } else {
+                    ub4 idx;
+                    for (idx = 0; idx < obind->curar_sz; idx++) {
+                        bind_class->out(obind, idx, piece, &valuep, &alenp, &indp);
+                    }
+                }
+            }
+        }
+        obind = (oci8_bind_t *)obind->base.next;
+    } while (obind != (oci8_bind_t*)stmt->base.children);
+#endif /* USE_DYNAMIC_FETCH */
+    ary = rb_ary_new2(RARRAY_LEN(stmt->defns));
+    for (idx = 0; idx < RARRAY_LEN(stmt->defns); idx++) {
+        rb_ary_store(ary, idx, rb_funcall(RARRAY_PTR(stmt->defns)[idx], oci8_id_get, 0));
+    }
+    return ary;
 }
 
 /*
-=begin
---- OCIStmt#prepare(stmt [, language [, mode]])
-     set and prepare SQL statement.
-
-     :stmt
-        SQL or PL/SQL statement
-     :language
-        ((|OCI_NTV_SYNTAX|)), ((|OCI_V7_SYNTAX|)), or ((|OCI_V8_SYNTAX|)).
-        Default value is ((|OCI_NTV_SYNTAX|))
-     :mode
-        ((|OCI_DEFAULT|)) or ((|OCI_NO_SHARING|)). Default value is ((|OCI_DEFAULT|)).
-
-        ((|OCI_NO_SHARING|)) disables ((<Shared Data Mode>)) for this statement.
-
-     correspond native OCI function: ((|OCIStmtPrepare|))
-=end
+ * Gets fetched data as array. This is available for select
+ * statement only.
+ *
+ * example:
+ *   conn = OCI8.new('scott', 'tiger')
+ *   cursor = conn.exec('SELECT * FROM emp')
+ *   while r = cursor.fetch()
+ *     puts r.join(',')
+ *   end
+ *   cursor.close
+ *   conn.logoff
  */
-static VALUE oci8_stmt_prepare(int argc, VALUE *argv, VALUE self)
+static VALUE oci8_stmt_fetch(VALUE self)
+{
+    oci8_stmt_t *stmt = DATA_PTR(self);
+    oci8_svcctx_t *svcctx = oci8_get_svcctx(stmt->svc);
+
+    if (rb_block_given_p()) {
+        for (;;) {
+            VALUE rs = oci8_stmt_do_fetch(stmt, svcctx);
+            if (NIL_P(rs))
+                return self; /* NEED TO CHECK 0.1 behavior. */
+            rb_yield(rs);
+        }
+    } else {
+        return oci8_stmt_do_fetch(stmt, svcctx);
+    }
+}
+
+static VALUE oci8_stmt_get_param(VALUE self, VALUE pos)
 {
-  VALUE vsql, vlanguage, vmode;
-  oci8_handle_t *h;
-  oci8_string_t s;
-  ub4 language;
-  ub4 mode;
-  sword rv;
-  VALUE ary;
-  VALUE hash;
-  int i;
-
-  rb_scan_args(argc, argv, "12", &vsql, &vlanguage, &vmode);
-  Get_Handle(self, h); /* 0 */
-  Get_String(vsql, s); /* 1 */
-  Get_Int_With_Default(argc, 2, vlanguage, language, OCI_NTV_SYNTAX); /* 2 */
-  Get_Int_With_Default(argc, 3, vmode, mode, OCI_DEFAULT); /* 3 */
-
-  /* when a new statement is prepared, OCI implicitly free the previous 
-   * statement's define and bind handles. 
-   * But ruby's object don't know it. So free these handles in advance.
-   */
-  /* free define handles */
-  ary = rb_ivar_get(self, oci8_id_define_array);
-  if (ary != Qnil) {
-    for (i = 0;i < RARRAY_LEN(ary);i++) {
-      if (RARRAY_PTR(ary)[i] != Qnil)
-	oci8_handle_free(RARRAY_PTR(ary)[i]);
-    }
-    rb_ivar_set(self, oci8_id_define_array, Qnil);
-  }
-  /* free bind handles */
-  hash = rb_ivar_get(self, oci8_id_bind_hash);
-  if (hash != Qnil) {
-    rb_iterate(oci8_each_value, hash, oci8_handle_free, Qnil);
-    rb_ivar_set(self, oci8_id_bind_hash, Qnil);
-  }
-
-  rv = OCIStmtPrepare(h->hp, h->errhp, s.ptr, s.len, language, mode);
-  if (IS_OCI_ERROR(rv)) {
-    oci8_raise(h->errhp, rv, h->hp);
-  }
-  return self;
+    oci8_stmt_t *stmt = DATA_PTR(self);
+    OCIParam *parmhp = NULL;
+    sword rv;
+
+    Check_Type(pos, T_FIXNUM); /* 1 */
+    rv = OCIParamGet(stmt->base.hp.stmt, OCI_HTYPE_STMT, oci8_errhp, (dvoid *)&parmhp, FIX2INT(pos));
+    if (rv != OCI_SUCCESS) {
+        oci8_raise(oci8_errhp, rv, NULL);
+    }
+    return oci8_metadata_create(parmhp, stmt->svc, self);
 }
 
 /*
-=begin
---- OCIStmt#defineByPos(position, type [, length [, mode]])
-     define the datatype of fetched column.
-     You must define all column's datatype, before you fetch data.
-
-     :position
-        the position of the column. It starts from 1.
-     :type
-        the type of column. 
-        ((|String|)), ((|Fixnum|)), ((|Integer|)), ((|Float|)), ((|Time|)),
-        ((<OraDate>)), ((<OraNumber>)), or ((|OCI_TYPECODE_RAW|))
-     :length
-        When the 2nd argument is 
-        * ((|String|)) or ((|OCI_TYPECODE_RAW|)),
-          the max length of fetched data.
-        * otherwise,
-          its value is ignored.
-     :mode
-        ((|OCI_DEFAULT|)), or ((|OCI_DYNAMIC_FETCH|)). But now available value is 
-        ((|OCI_DEFAULT|)) only. Default value is ((|OCI_DEFAULT|))
-     :return value
-        newly created ((<define handle|OCIDefine>))
-
-     correspond native OCI function: ((|OCIDefineByPos|))
-=end
+ * gets the type of SQL statement as follows.
+ * * OCI8::STMT_SELECT
+ * * OCI8::STMT_UPDATE
+ * * OCI8::STMT_DELETE
+ * * OCI8::STMT_INSERT
+ * * OCI8::STMT_CREATE
+ * * OCI8::STMT_DROP
+ * * OCI8::STMT_ALTER
+ * * OCI8::STMT_BEGIN (PL/SQL block which starts with a BEGIN keyword)
+ * * OCI8::STMT_DECLARE (PL/SQL block which starts with a DECLARE keyword)
+ * * Other Fixnum value undocumented in Oracle manuals.
+ *
+ * <em>Changes between ruby-oci8 1.0 and 2.0.</em>
+ *
+ * [ruby-oci8 2.0] OCI8::STMT_* are Symbols. (:select_stmt, :update_stmt, etc.)
+ * [ruby-oci8 1.0] OCI8::STMT_* are Fixnums. (1, 2, 3, etc.)
  */
-static VALUE oci8_define_by_pos(int argc, VALUE *argv, VALUE self)
+static VALUE oci8_stmt_get_stmt_type(VALUE self)
 {
-  VALUE vposition;
-  VALUE vtype;
-  VALUE vlength;
-  VALUE vmode;
-  oci8_handle_t *h;
-  ub4 position;
-  oci8_bind_handle_t *bh;
-  ub2 dty;
-  ub4 mode;
-  dvoid *indp;
-  ub2 *rlenp;
-  dvoid *valuep;
-  OCIDefine *dfnhp = NULL;
-  sword status;
-  VALUE ary;
-  VALUE obj;
-
-  rb_scan_args(argc, argv, "22", &vposition, &vtype, &vlength, &vmode);
-  Get_Handle(self, h); /* 0 */
-  position = NUM2INT(vposition); /* 1 */
-  check_bind_type(OCI_HTYPE_DEFINE, h, vtype, vlength, &bh, &dty); /* 2, 3 */
-  Get_Int_With_Default(argc, 4, vmode, mode, OCI_DEFAULT); /* 4 */
-
-  if (mode & OCI_DYNAMIC_FETCH) {
-    indp = NULL;
-    rlenp = NULL;
-  } else {
-    indp = &(bh->ind);
-    rlenp = (bh->bind_type == BIND_STRING) ? NULL : &bh->rlen;
-  }
-  valuep = &bh->value;
-  status = OCIDefineByPos(h->hp, &dfnhp, h->errhp, position, valuep, bh->value_sz, dty, indp, rlenp, 0, mode);
-  if (status != OCI_SUCCESS) {
-    oci8_unlink((oci8_handle_t *)bh);
-    bh->type = 0;
-    oci8_raise(h->errhp, status, h->hp);
-  }
-  bh->type = OCI_HTYPE_DEFINE;
-  bh->hp = dfnhp;
-  bh->errhp = h->errhp;
-  obj = bh->self;
-  ary = rb_ivar_get(self, oci8_id_define_array);
-  if (ary == Qnil) {
-    ary = rb_ary_new();
-    rb_ivar_set(self, oci8_id_define_array, ary);
-  }
-  rb_ary_store(ary, position - 1, obj);
-  return obj;
+    VALUE stmt_type = oci8_get_ub2_attr(DATA_PTR(self), OCI_ATTR_STMT_TYPE);
+    switch (FIX2INT(stmt_type)) {
+    case OCI_STMT_SELECT:
+        return oci8_sym_select_stmt;
+    case OCI_STMT_UPDATE:
+        return oci8_sym_update_stmt;
+    case OCI_STMT_DELETE:
+        return oci8_sym_delete_stmt;
+    case OCI_STMT_INSERT:
+        return oci8_sym_insert_stmt;
+    case OCI_STMT_CREATE:
+        return oci8_sym_create_stmt;
+    case OCI_STMT_DROP:
+        return oci8_sym_drop_stmt;
+    case OCI_STMT_ALTER:
+        return oci8_sym_alter_stmt;
+    case OCI_STMT_BEGIN:
+        return oci8_sym_begin_stmt;
+    case OCI_STMT_DECLARE:
+        return oci8_sym_declare_stmt;
+    default:
+        return stmt_type;
+    }
 }
 
 /*
-=begin
---- OCIStmt#bindByPos(position, type [, length [, mode]])
-     define the datatype of the bind variable by posision.
-
-     :position
-        the position of the bind variable.
-     :type
-        the type of the bind variable.
-        ((|String|)), ((|Fixnum|)), ((|Integer|)), ((|Float|)), ((|Time|)),
-        ((<OraDate>)), ((<OraNumber>)), or ((|OCI_TYPECODE_RAW|))
-     :length
-        When the 2nd argument is 
-        * ((|String|)) or ((|OCI_TYPECODE_RAW|)),
-          the max length of fetched data.
-        * otherwise,
-          its value is ignored.
-     :mode
-        ((|OCI_DEFAULT|)), or ((|OCI_DATA_AT_EXEC|)). But now available value is 
-        ((|OCI_DEFAULT|)) only. Default value is ((|OCI_DEFAULT|))
-     :return value
-        newly created ((<bind handle|OCIBind>))
-
-     correspond native OCI function: ((|OCIBindByPos|))
-=end
+ * Returns the number of processed rows.
  */
-static VALUE oci8_bind_by_pos(int argc, VALUE *argv, VALUE self)
+static VALUE oci8_stmt_get_row_count(VALUE self)
 {
-  VALUE vposition;
-  VALUE vtype;
-  VALUE vlength;
-  VALUE vmode;
-  oci8_handle_t *h;
-  ub4 position;
-  oci8_bind_handle_t *bh;
-  ub2 dty;
-  ub4 mode;
-  dvoid *indp;
-  ub2 *rlenp;
-  dvoid *valuep;
-  OCIBind *bindhp = NULL;
-  sword status;
-  VALUE hash;
-  VALUE obj;
-
-  rb_scan_args(argc, argv, "22", &vposition, &vtype, &vlength, &vmode);
-  Get_Handle(self, h); /* 0 */
-  position = NUM2INT(vposition); /* 1 */
-  check_bind_type(OCI_HTYPE_BIND, h, vtype, vlength, &bh, &dty); /* 2, 3 */
-  Get_Int_With_Default(argc, 4, vmode, mode, OCI_DEFAULT); /* 4 */
-
-  if (mode & OCI_DATA_AT_EXEC) {
-    indp = NULL;
-    rlenp = NULL;
-  } else {
-    indp = &(bh->ind);
-    rlenp = (bh->bind_type == BIND_STRING) ? NULL : &bh->rlen;
-  }
-  valuep = &bh->value;
-  status = OCIBindByPos(h->hp, &bindhp, h->errhp, position, valuep, bh->value_sz, dty, indp, rlenp, 0, 0, 0, mode);
-  if (status != OCI_SUCCESS) {
-    oci8_unlink((oci8_handle_t *)bh);
-    bh->type = 0;
-    oci8_raise(h->errhp, status, h->hp);
-  }
-  bh->type = OCI_HTYPE_BIND;
-  bh->hp = bindhp;
-  bh->errhp = h->errhp;
-  obj = bh->self;
-  hash = rb_ivar_get(self, oci8_id_bind_hash);
-  if (hash == Qnil) {
-    hash = rb_hash_new();
-    rb_ivar_set(self, oci8_id_bind_hash, hash);
-  }
-  rb_hash_aset(hash, vposition, obj);
-  return obj;
+    return oci8_get_ub4_attr(DATA_PTR(self), OCI_ATTR_ROW_COUNT);
 }
 
 /*
-=begin
---- OCIStmt#bindByName(name, type [, length [, mode]])
-     define the datatype of the bind variable by name.
-
-     :name
-        the name of the bind variable including colon.
-     :type
-        the type of the bind variable.
-        ((|String|)), ((|Fixnum|)), ((|Integer|)), ((|Float|)), ((|Time|)),
-        ((<OraDate>)), ((<OraNumber>)), or ((|OCI_TYPECODE_RAW|))
-     :length
-        When the 2nd argument is 
-        * ((|String|)) or ((|OCI_TYPECODE_RAW|)),
-          the max length of fetched data.
-        * otherwise,
-          its value is ignored.
-     :mode
-        ((|OCI_DEFAULT|)), or ((|OCI_DATA_AT_EXEC|)). But now available value is 
-        ((|OCI_DEFAULT|)) only. Default value is ((|OCI_DEFAULT|))
-     :return value
-        newly created ((<bind handle|OCIBind>))
-
-     for example
-       stmt = env.alloc(OCIStmt)
-       stmt.prepare("SELECT * FROM EMP
-                      WHERE ename = :ENAME
-                        AND sal > :SAL
-                        AND hiredate >= :HIREDATE")
-       b_ename = stmt.bindByName(":ENAME", String, 10)
-       b_sal = stmt.bindByName(":SAL", Fixnum)
-       b_hiredate = stmt.bindByName(":HIREDATE", OraDate)
-
-     correspond native OCI function: ((|OCIBindByName|))
-=end
+ * Get the rowid of the last inserted/updated/deleted row.
+ * This cannot be used for select statements.
+ *
+ * example:
+ *   cursor = conn.parse('INSERT INTO foo_table values(:1, :2)', 1, 2)
+ *   cursor.exec
+ *   cursor.rowid # => the inserted row's rowid
+ *
+ * <em>Changes between ruby-oci8 1.0.3 and 1.0.4.</em>
+ *
+ * [ruby-oci8 1.0.4 or upper] The return value is a String.
+ * [ruby-oci8 1.0.3 or lower] It returns an OCIRowid object.
  */
-static VALUE oci8_bind_by_name(int argc, VALUE *argv, VALUE self)
+static VALUE oci8_stmt_get_rowid(VALUE self)
+{
+    return oci8_get_rowid_attr(DATA_PTR(self), OCI_ATTR_ROWID);
+}
+
+static VALUE oci8_stmt_get_param_count(VALUE self)
 {
-  VALUE vplaceholder;
-  VALUE vtype;
-  VALUE vlength;
-  VALUE vmode;
-  oci8_handle_t *h;
-  oci8_string_t placeholder;
-  oci8_bind_handle_t *bh;
-  ub2 dty;
-  ub4 mode;
-  dvoid *indp;
-  ub2 *rlenp;
-  dvoid *valuep;
-  OCIBind *bindhp = NULL;
-  sword status;
-  VALUE hash;
-  VALUE obj;
-
-  rb_scan_args(argc, argv, "22", &vplaceholder, &vtype, &vlength, &vmode);
-  Get_Handle(self, h); /* 0 */
-  Get_String(vplaceholder, placeholder); /* 1 */
-  check_bind_type(OCI_HTYPE_BIND, h, vtype, vlength, &bh, &dty); /* 2, 3 */
-  Get_Int_With_Default(argc, 4, vmode, mode, OCI_DEFAULT); /* 4 */
-
-  if (mode & OCI_DATA_AT_EXEC) {
-    indp = NULL;
-    rlenp = NULL;
-  } else {
-    indp = &(bh->ind);
-    rlenp = (bh->bind_type == BIND_STRING) ? NULL : &bh->rlen;
-  }
-  valuep = &bh->value;
-  status = OCIBindByName(h->hp, &bindhp, h->errhp, placeholder.ptr, placeholder.len, valuep, bh->value_sz, dty, indp, rlenp, 0, 0, 0, mode);
-  if (status != OCI_SUCCESS) {
-    oci8_unlink((oci8_handle_t *)bh);
-    bh->type = 0;
-    oci8_raise(h->errhp, status, h->hp);
-  }
-  bh->type = OCI_HTYPE_BIND;
-  bh->hp = bindhp;
-  bh->errhp = h->errhp;
-  obj = bh->self;
-  hash = rb_ivar_get(self, oci8_id_bind_hash);
-  if (hash == Qnil) {
-    hash = rb_hash_new();
-    rb_ivar_set(self, oci8_id_bind_hash, hash);
-  }
-  rb_hash_aset(hash, vplaceholder, obj);
-  return obj;
+    return oci8_get_ub4_attr(DATA_PTR(self), OCI_ATTR_PARAM_COUNT);
 }
 
 /*
-=begin
---- OCIStmt#execute(svc [, iters [, mode]])
-     execute statement at the ((<service context handle|OCISvcCtx>)).
-
-     :svc
-        ((<service context handle|OCISvcCtx>))
-     :iters
-        the number of iterations to execute.
-
-        For select statement, if there are columns which is not defined
-        by ((<OCIStmt#defineByPos>)) and this value is positive, it 
-        raises exception. If zero, no exception. In any case you must define
-        all columns before you call ((<OCIStmt#fetch>)).
-
-        For non-select statement, use positive value.
-
-        Default value is 0 for select statement, 1 for non-select statement.
-
-        note: Current implemantation doesn't support array fetch and batch mode, so
-        valid value is 0 or 1.
-     :mode
-        ((|OCI_DEFAULT|)), ((|OCI_BATCH_ERRORS|)), ((|OCI_COMMIT_ON_SUCCESS|)),
-        ((|OCI_DESCRIBE_ONLY|)), ((|OCI_EXACT_FETCH|)), ((|OCI_PARSE_ONLY|)), 
-        any combinations of previous values, or ((|OCI_STMT_SCROLLABLE_READONLY|)).
-        Default value is ((|OCI_DEFAULT|)).
-
-        ((|OCI_BATCH_ERRORS|)) and ((|OCI_STMT_SCROLLABLE_READONLY|)) are not
-        supported by current implementation.
-
-     correspond native OCI function: ((|OCIStmtExecute|))
-=end
-*/
-static VALUE oci8_stmt_execute(int argc, VALUE *argv, VALUE self)
+ * call-seq:
+ *   [key]
+ *
+ * Gets the value of the bind variable.
+ *
+ * In case of binding explicitly, use same key with that of
+ * OCI8::Cursor#bind_param. A placeholder can be bound by
+ * name or position. If you bind by name, use that name. If you bind
+ * by position, use the position.
+ *
+ * example:
+ *   cursor = conn.parse("BEGIN :out := 'BAR'; END;")
+ *   cursor.bind_param(':out', 'FOO') # bind by name
+ *   p cursor[':out'] # => 'FOO'
+ *   p cursor[1] # => nil
+ *   cursor.exec()
+ *   p cursor[':out'] # => 'BAR'
+ *   p cursor[1] # => nil
+ *
+ * example:
+ *   cursor = conn.parse("BEGIN :out := 'BAR'; END;")
+ *   cursor.bind_param(1, 'FOO') # bind by position
+ *   p cursor[':out'] # => nil
+ *   p cursor[1] # => 'FOO'
+ *   cursor.exec()
+ *   p cursor[':out'] # => nil
+ *   p cursor[1] # => 'BAR'
+ *
+ * In case of binding by OCI8#exec or OCI8::Cursor#exec,
+ * get the value by position, which starts from 1.
+ *
+ * example:
+ *   cursor = conn.exec("BEGIN :out := 'BAR'; END;", 'FOO')
+ *   # 1st bind variable is bound as String with width 3. Its initial value is 'FOO'
+ *   # After execute, the value become 'BAR'.
+ *   p cursor[1] # => 'BAR'
+ */
+static VALUE oci8_stmt_aref(VALUE self, VALUE key)
 {
-  VALUE vsvc;
-  VALUE viters;
-  VALUE vmode;
-  oci8_handle_t *h;
-  oci8_handle_t *svch;
-  ub4 mode;
-  ub4 iters;
-  ub2 stmt_type;
-  sword rv;
-
-  rb_scan_args(argc, argv, "12", &vsvc, &viters, &vmode);
-  Get_Handle(self, h); /* 0 */
-  Check_Handle(vsvc, OCISvcCtx, svch); /* 1 */
-  if (argc >= 2) {
-    iters = NUM2UINT(viters); /* 2 */
-  } else {
-    rv = OCIAttrGet(h->hp, OCI_HTYPE_STMT, &stmt_type, 0, OCI_ATTR_STMT_TYPE, h->errhp);
-    if (rv != OCI_SUCCESS) {
-      oci8_raise(h->errhp, rv, h->hp);
+    oci8_stmt_t *stmt = DATA_PTR(self);
+    VALUE obj = rb_hash_aref(stmt->binds, key);
+    if (NIL_P(obj)) {
+        return Qnil;
     }
-    if (stmt_type == OCI_STMT_SELECT) {
-      /* for select statement, default value 0. */
-      iters = 0;
-    } else {
-      /* for non-select statement, default value 0. */
-      iters = 1;
-    }
-  }
-  Get_Int_With_Default(argc, 3, vmode, mode, OCI_DEFAULT); /* 3 */
-
-  if (iters > 1) {
-    rb_raise(rb_eArgError, "current implementation doesn't support array fatch or batch mode");
-  }
-
-  rv = OCIStmtExecute(svch->hp, h->hp, h->errhp, iters, 0, NULL, NULL, mode);
-  if (rv == OCI_ERROR) {
-    sb4 errcode;
-    OCIErrorGet(h->errhp, 1, NULL, &errcode, NULL, 0, OCI_HTYPE_ERROR);
-    if (errcode == 1000) {
-      /* run GC to close unreferred cursors when ORA-01000 (maximum open cursors exceeded). */
-      rb_gc();
-      rv = OCIStmtExecute(svch->hp, h->hp, h->errhp, iters, 0, NULL, NULL, mode);
-    }
-  }
-  if (IS_OCI_ERROR(rv)) {
-    oci8_raise(h->errhp, rv, h->hp);
-  }
-  return self;
+    return rb_funcall(obj, oci8_id_get, 0);
 }
 
 /*
-=begin
---- OCIStmt#fetch([nrows [, orientation [, mode]]])
-     fetch data from select statement.
-     fetched data are stored to previously defined ((<define handle|OCIDefine>)).
+ * call-seq:
+ *   [key] = val
+ *
+ * Sets the value to the bind variable. The way to specify the
+ * +key+ is same with OCI8::Cursor#[]. This is available
+ * to replace the value and execute many times.
+ *
+ * example1:
+ *   cursor = conn.parse("INSERT INTO test(col1) VALUES(:1)")
+ *   cursor.bind_params(1, nil, String, 3)
+ *   ['FOO', 'BAR', 'BAZ'].each do |key|
+ *     cursor[1] = key
+ *     cursor.exec
+ *   end
+ *   cursor.close()
+ *
+ * example2:
+ *   ['FOO', 'BAR', 'BAZ'].each do |key|
+ *     conn.exec("INSERT INTO test(col1) VALUES(:1)", key)
+ *   end
+ *
+ * Both example's results are same. But the former will use less resources.
+ */
+static VALUE oci8_stmt_aset(VALUE self, VALUE key, VALUE val)
+{
+    long max_array_size;
+    long actual_array_size;
+    long bind_array_size;
+
+    oci8_stmt_t *stmt = DATA_PTR(self);
+    VALUE obj = rb_hash_aref(stmt->binds, key);
+    if (NIL_P(obj)) {
+        return Qnil; /* ?? MUST BE ERROR? */
+    }
 
-     :nrows
-        number of rows to fetch. If zero, cancel the cursor.
-        The default value is 1.
+    if(TYPE(val) == T_ARRAY) {
+        max_array_size = NUM2INT(rb_ivar_get(self, id_at_max_array_size));
+        actual_array_size = NUM2INT(rb_ivar_get(self, id_at_actual_array_size));
+        bind_array_size = RARRAY_LEN(val);
 
-        Because array fetch is not supported, valid value is 0 or 1.
+        if(actual_array_size > 0 && bind_array_size != actual_array_size) {
+            rb_raise(rb_eRuntimeError, "all binding arrays hould be the same size");        
+        }
+        if(bind_array_size <= max_array_size && actual_array_size == 0) {
+            rb_ivar_set(self, id_at_actual_array_size, INT2NUM(bind_array_size));
+        }
+    }     
 
-     :orientation
-        orientation to fetch. ((|OCI_FETCH_NEXT|)) only valid.
-        The default value is ((|OCI_FETCH_NEXT|)).
+    return rb_funcall(obj, oci8_id_set, 1, val);
+}
 
-     :mode
-        ((|OCI_DEFULT|)) only valid. 
-        The default value is ((|OCI_DEFAULT|)).
+/*
+ * call-seq:
+ *   keys -> an Array
+ *
+ * Returns the keys of bind variables as array.
+ */
+static VALUE oci8_stmt_keys(VALUE self)
+{
+    oci8_stmt_t *stmt = DATA_PTR(self);
+    return rb_funcall(stmt->binds, oci8_id_keys, 0);
+}
 
-     :return value
-        array of define handles, which are defined previously,
-        or nil when end of data.
+static VALUE oci8_stmt_defined_p(VALUE self, VALUE pos)
+{
+    oci8_stmt_t *stmt = DATA_PTR(self);
+    long position = NUM2INT(pos);
+
+    if (position - 1 < RARRAY_LEN(stmt->defns)) {
+        VALUE value = RARRAY_PTR(stmt->defns)[position - 1];
+        if (!NIL_P(value)) {
+            return Qtrue;
+        }
+    }
+    return Qfalse;
+}
 
-     correspond native OCI function: ((|OCIStmtFetch|))
-=end
-*/
-static VALUE oci8_stmt_fetch(int argc, VALUE *argv, VALUE self)
+/*
+ * call-seq:
+ *   prefetch_rows = aFixnum
+ *
+ * Set number of rows to be prefetched.
+ * This can reduce the number of network round trips when fetching
+ * many rows. The default value is one.
+ *
+ * FYI: Rails oracle adaptor uses 100 by default.
+ */
+static VALUE oci8_stmt_set_prefetch_rows(VALUE self, VALUE rows)
 {
-  VALUE vnrows;
-  VALUE vorientation;
-  VALUE vmode;
-  oci8_handle_t *h;
-  ub4 nrows;
-  ub2 orientation;
-  ub4 mode;
-  sword rv;
-
-  rb_scan_args(argc, argv, "03", &vnrows, &vorientation, &vmode);
-  Get_Handle(self, h); /* 0 */
-  Get_Int_With_Default(argc, 1, vnrows, nrows, 1); /* 1 */
-  Get_Int_With_Default(argc, 2, vorientation, orientation, OCI_FETCH_NEXT); /* 2 */
-  Get_Int_With_Default(argc, 3, vmode, mode, OCI_DEFAULT); /* 3 */
-
-  rv = OCIStmtFetch(h->hp, h->errhp, nrows, orientation, mode);
-  if (rv == OCI_NO_DATA) {
-    return Qnil;
-  }
-  if (IS_OCI_ERROR(rv)) {
-    oci8_raise(h->errhp, rv, h->hp);
-  }
-  return rb_ivar_get(self, oci8_id_define_array);
-}  
+    oci8_stmt_t *stmt = DATA_PTR(self);
+    ub4 num = NUM2UINT(rows);
+
+    oci_lc(OCIAttrSet(stmt->base.hp.ptr, OCI_HTYPE_STMT, &num, 0, OCI_ATTR_PREFETCH_ROWS, oci8_errhp));
+    return Qfalse;
+}
 
 /*
-implemented in param.c
-=begin
---- OCIStmt#paramGet(position)
-     get column information of executed select statement.
-     See ((<Select a table whose column types are unknown.>))
-
-     :posision
-        the position of the column to get parameter. It starts from 1.
-     :return value
-        newly created ((<read-only parameter descriptor|OCIParam>))
-        
-     correspond native OCI function: ((|OCIParamGet|))
-=end
-*/
-
-void Init_oci8_stmt(void)
+ * bind_stmt
+ */
+VALUE oci8_stmt_get(oci8_bind_t *obind, void *data, void *null_struct)
 {
-  id_alloc = rb_intern("alloc");
-  rb_define_method(cOCIStmt, "prepare", oci8_stmt_prepare, -1);
-  rb_define_method(cOCIStmt, "defineByPos", oci8_define_by_pos, -1);
-  rb_define_method(cOCIStmt, "bindByPos", oci8_bind_by_pos, -1);
-  rb_define_method(cOCIStmt, "bindByName", oci8_bind_by_name, -1);
-  rb_define_method(cOCIStmt, "execute", oci8_stmt_execute, -1);
-  rb_define_method(cOCIStmt, "fetch", oci8_stmt_fetch, -1);
-  rb_define_method(cOCIStmt, "paramGet", oci8_param_get, 1);
+    oci8_hp_obj_t *oho = (oci8_hp_obj_t *)data;
+    rb_funcall(oho->obj, rb_intern("define_columns"), 0);
+    return oho->obj;
+}
+
+static void bind_stmt_set(oci8_bind_t *obind, void *data, void **null_structp, VALUE val)
+{
+    oci8_hp_obj_t *oho = (oci8_hp_obj_t *)data;
+    oci8_base_t *h;
+    if (!rb_obj_is_instance_of(val, cOCIStmt))
+        rb_raise(rb_eArgError, "Invalid argument: %s (expect OCIStmt)", rb_class2name(CLASS_OF(val)));
+    h = DATA_PTR(val);
+    oho->hp = h->hp.ptr;
+    oho->obj = val;
+}
+
+static void bind_stmt_init(oci8_bind_t *obind, VALUE svc, VALUE val, VALUE length)
+{
+    obind->value_sz = sizeof(void *);
+    obind->alloc_sz = sizeof(oci8_hp_obj_t);
+}
+
+static void bind_stmt_init_elem(oci8_bind_t *obind, VALUE svc)
+{
+    oci8_hp_obj_t *oho = (oci8_hp_obj_t *)obind->valuep;
+    oci8_base_t *h;
+    ub4 idx = 0;
+
+    do {
+        oho[idx].obj = rb_funcall(cOCIStmt, oci8_id_new, 1, svc);
+        h = DATA_PTR(oho[idx].obj);
+        oho[idx].hp = h->hp.ptr;
+    } while (++idx < obind->maxar_sz);
+}
+
+static const oci8_bind_class_t bind_stmt_class = {
+    {
+        oci8_bind_hp_obj_mark,
+        oci8_bind_free,
+        sizeof(oci8_bind_t)
+    },
+    oci8_stmt_get,
+    bind_stmt_set,
+    bind_stmt_init,
+    bind_stmt_init_elem,
+    NULL,
+    NULL,
+    bind_stmt_init_elem,
+    SQLT_RSET
+};
+
+void Init_oci8_stmt(VALUE cOCI8)
+{
+#if 0
+    cOCIHandle = rb_define_class("OCIHandle", rb_cObject);
+    cOCI8 = rb_define_class("OCI8", cOCIHandle);
+    cOCIStmt = rb_define_class_under(cOCI8, "Cursor", cOCIHandle);
+#endif
+    cOCIStmt = oci8_define_class_under(cOCI8, "Cursor", &oci8_stmt_class);
+
+    oci8_sym_select_stmt = ID2SYM(rb_intern("select_stmt"));
+    oci8_sym_update_stmt = ID2SYM(rb_intern("update_stmt"));
+    oci8_sym_delete_stmt = ID2SYM(rb_intern("delete_stmt"));
+    oci8_sym_insert_stmt = ID2SYM(rb_intern("insert_stmt"));
+    oci8_sym_create_stmt = ID2SYM(rb_intern("create_stmt"));
+    oci8_sym_drop_stmt = ID2SYM(rb_intern("drop_stmt"));
+    oci8_sym_alter_stmt = ID2SYM(rb_intern("alter_stmt"));
+    oci8_sym_begin_stmt = ID2SYM(rb_intern("begin_stmt"));
+    oci8_sym_declare_stmt = ID2SYM(rb_intern("declare_stmt"));
+    id_at_column_metadata = rb_intern("@column_metadata");
+    id_at_actual_array_size = rb_intern("@actual_array_size");
+    id_at_max_array_size = rb_intern("@max_array_size");
+    id_each_value = rb_intern("each_value");
+    id_at_names = rb_intern("@names");
+    id_at_con = rb_intern("@con");
+    id_empty_p = rb_intern("empty?");
+    id_clear = rb_intern("clear");
+    id_set = rb_intern("set");
+
+    rb_define_private_method(cOCIStmt, "initialize", oci8_stmt_initialize, -1);
+    rb_define_private_method(cOCIStmt, "__define", oci8_define_by_pos, 2);
+    rb_define_private_method(cOCIStmt, "__bind", oci8_bind, 2);
+    rb_define_private_method(cOCIStmt, "__execute", oci8_stmt_execute, 1);
+    rb_define_private_method(cOCIStmt, "__clearBinds", oci8_stmt_clear_binds, 0);
+    rb_define_method(cOCIStmt, "fetch", oci8_stmt_fetch, 0);
+    rb_define_private_method(cOCIStmt, "__paramGet", oci8_stmt_get_param, 1);
+    rb_define_method(cOCIStmt, "type", oci8_stmt_get_stmt_type, 0);
+    rb_define_method(cOCIStmt, "row_count", oci8_stmt_get_row_count, 0);
+    rb_define_method(cOCIStmt, "rowid", oci8_stmt_get_rowid, 0);
+    rb_define_private_method(cOCIStmt, "__param_count", oci8_stmt_get_param_count, 0);
+    rb_define_method(cOCIStmt, "[]", oci8_stmt_aref, 1);
+    rb_define_method(cOCIStmt, "[]=", oci8_stmt_aset, 2);
+    rb_define_method(cOCIStmt, "keys", oci8_stmt_keys, 0);
+    rb_define_private_method(cOCIStmt, "__defined?", oci8_stmt_defined_p, 1);
+    rb_define_method(cOCIStmt, "prefetch_rows=", oci8_stmt_set_prefetch_rows, 1);
+
+    oci8_define_bind_class("Cursor", &bind_stmt_class);
 }