ruby-staci 2.2.9

data/ext/oci8/ocihandle.c

@@ -0,0 +1,852 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * ocihandle.c
+ *
+ * Copyright (C) 2009-2015 Kubo Takehiro <kubo@jiubao.org>
+ *
+ * implement OCIHandle
+ *
+ */
+#include "oci8.h"
+
+#define TO_HANDLE(obj) ((oci8_base_t*)oci8_check_typeddata((obj), &oci8_handle_data_type, 1))
+
+#ifdef _MSC_VER
+#define MAGIC_NUMBER 0xDEAFBEAFDEAFBEAFui64;
+#else
+#define MAGIC_NUMBER 0xDEAFBEAFDEAFBEAFull;
+#endif
+
+static long check_data_range(VALUE val, long min, long max, const char *type)
+{
+    long lval = NUM2LONG(val);
+    if (lval < min || max < lval) {
+        rb_raise(rb_eRangeError, "integer %ld too %s to convert to `%s'",
+                 lval, lval < 0 ? "small" : "big", type);
+    }
+    return lval;
+}
+
+const oci8_handle_data_type_t oci8_handle_data_type = {
+    {
+        "OCIHandle",
+        {
+            NULL,
+            oci8_handle_cleanup,
+            oci8_handle_size,
+        },
+        NULL, NULL,
+#ifdef RUBY_TYPED_WB_PROTECTED
+        RUBY_TYPED_WB_PROTECTED,
+#endif
+    },
+    NULL,
+    sizeof(oci8_base_t),
+};
+
+static VALUE oci8_handle_initialize(VALUE self)
+{
+    rb_raise(rb_eNameError, "private method `new' called for %s:Class", rb_class2name(CLASS_OF(self)));
+}
+
+/*
+ *  Clears the object internal structure and its dependents.
+ *
+ *  @since 2.0.0
+ *  @private
+ */
+static VALUE oci8_handle_free(VALUE self)
+{
+    oci8_base_t *base = DATA_PTR(self);
+
+    oci8_base_free(base);
+    return self;
+}
+
+void oci8_handle_cleanup(void *ptr)
+{
+    oci8_base_t *base = (oci8_base_t *)ptr;
+    if (oci8_in_finalizer) {
+        /* Do nothing when the program exits.
+         * The first two words of memory addressed by VALUE datatype is
+         * changed in finalizer. If a ruby function which access it such
+         * as rb_obj_is_kind_of is called, it may cause SEGV.
+         */
+        return;
+    }
+    oci8_base_free(base);
+    xfree(base);
+}
+
+size_t oci8_handle_size(const void *ptr)
+{
+    const oci8_base_t *base = (const oci8_base_t *)ptr;
+    const oci8_bind_t *bind = (const oci8_bind_t *)ptr;
+    size_t size = base->data_type->size;
+
+    if (base->hp.ptr != NULL) {
+        size += 256; /* I don't know the real size. Use 256 for now. */
+    }
+    switch (base->type) {
+    case OCI_HTYPE_DEFINE:
+    case OCI_HTYPE_BIND:
+        size += bind->alloc_sz * (bind->maxar_sz ? bind->maxar_sz : 1);
+    }
+    return size;
+}
+
+static VALUE oci8_s_allocate(VALUE klass)
+{
+    return oci8_allocate_typeddata(klass, &oci8_handle_data_type);
+}
+
+VALUE oci8_allocate_typeddata(VALUE klass, const oci8_handle_data_type_t *data_type)
+{
+    oci8_base_t *base;
+    VALUE obj;
+
+    base = xmalloc(data_type->size);
+    memset(base, 0, data_type->size);
+
+    obj = TypedData_Wrap_Struct(klass, &data_type->rb_data_type, base);
+    base->self = obj;
+    base->data_type = data_type;
+    base->parent = NULL;
+    base->next = base;
+    base->prev = base;
+    base->children = NULL;
+    return obj;
+}
+
+enum datatype {
+    DATATYPE_UB1,
+    DATATYPE_UB2,
+    DATATYPE_UB4,
+    DATATYPE_UB8,
+    DATATYPE_SB1,
+    DATATYPE_SB2,
+    DATATYPE_SB4,
+    DATATYPE_SB8,
+    DATATYPE_BOOLEAN,
+    DATATYPE_STRING,
+    DATATYPE_BINARY,
+    DATATYPE_INTEGER,
+    DATATYPE_ORADATE,
+};
+
+static VALUE attr_get_common(int argc, VALUE *argv, VALUE self, enum datatype datatype)
+{
+    oci8_base_t *base = oci8_check_typeddata(self, &oci8_handle_data_type, 0);
+    VALUE attr_type;
+    VALUE strict;
+    VALUE args[6];
+    union {
+        ub1 ub1val;
+        ub2 ub2val;
+        ub4 ub4val;
+        ub8 ub8val;
+        sb1 sb1val;
+        sb2 sb2val;
+        sb4 sb4val;
+        sb8 sb8val;
+        boolean booleanval;
+        char *charptr;
+        ub1 *ub1ptr;
+    } v;
+    ub4 size = 0;
+    sword rv;
+
+    if (base->closed) {
+        /* Returns nil when the backtrace includes `inspect'.
+         * Otherwise, raises an exception.
+         * IMO, `inspect' should not raise an exception.
+         */
+        volatile VALUE backtrace = rb_funcall(rb_cObject, rb_intern("caller"), 0);
+        if (TYPE(backtrace) == T_ARRAY) {
+            int i;
+            for (i = 0; i < RARRAY_LEN(backtrace); i++) {
+                volatile VALUE elem = RARRAY_AREF(backtrace, i);
+                char *s = StringValueCStr(elem);
+                if (strstr(s, "inspect") != NULL) {
+                    return Qnil;
+                }
+            }
+        }
+        /* check again just to raise an exception. */
+        oci8_check_typeddata(self, &oci8_handle_data_type, 1);
+    }
+
+    v.ub8val = MAGIC_NUMBER;
+    rb_scan_args(argc, argv, "11", &attr_type, &strict);
+    if (argc == 1) {
+        strict = Qtrue;
+    }
+    Check_Type(attr_type, T_FIXNUM);
+    rv = OCIAttrGet(base->hp.ptr, base->type, &v, &size, FIX2INT(attr_type), oci8_errhp);
+    if (!RTEST(strict)) {
+        if (rv == OCI_ERROR && oci8_get_error_code(oci8_errhp) == 24328) {
+			/* ignore ORA-24328: illegal attribute value */
+            return Qnil;
+        }
+    }
+    chker2(rv, base);
+    switch (datatype) {
+        OCINumber onum;
+        static VALUE cOraDate = Qnil;
+    case DATATYPE_UB1:
+        return INT2FIX(v.ub1val);
+    case DATATYPE_UB2:
+        return INT2FIX(v.ub2val);
+    case DATATYPE_UB4:
+        return UINT2NUM(v.ub4val);
+    case DATATYPE_UB8:
+        return ULL2NUM(v.ub8val);
+    case DATATYPE_SB1:
+        return INT2FIX(v.sb1val);
+    case DATATYPE_SB2:
+        return INT2FIX(v.sb2val);
+    case DATATYPE_SB4:
+        return INT2NUM(v.sb4val);
+    case DATATYPE_SB8:
+        return LL2NUM(v.sb8val);
+    case DATATYPE_BOOLEAN:
+        return v.booleanval ? Qtrue : Qfalse;
+    case DATATYPE_STRING:
+        if (size == 0 && !RTEST(strict)) {
+            return Qnil;
+        }
+        return rb_external_str_new_with_enc(v.charptr, size, oci8_encoding);
+    case DATATYPE_BINARY:
+        return rb_tainted_str_new(v.charptr, size);
+    case DATATYPE_INTEGER:
+        if (size > sizeof(onum.OCINumberPart) - 1) {
+            rb_raise(rb_eRuntimeError, "Too long size %u", size);
+        }
+        memset(&onum, 0, sizeof(onum));
+        onum.OCINumberPart[0] = size;
+        memcpy(&onum.OCINumberPart[1], v.ub1ptr, size);
+        return oci8_make_integer(&onum, oci8_errhp);
+    case DATATYPE_ORADATE:
+        if (NIL_P(cOraDate))
+            cOraDate = rb_eval_string("OraDate");
+        args[0] = INT2FIX((v.ub1ptr[0] - 100) * 100 + (v.ub1ptr[1] - 100));
+        args[1] = INT2FIX(v.ub1ptr[2]);
+        args[2] = INT2FIX(v.ub1ptr[3]);
+        args[3] = INT2FIX(v.ub1ptr[4] - 1);
+        args[4] = INT2FIX(v.ub1ptr[5] - 1);
+        args[5] = INT2FIX(v.ub1ptr[6] - 1);
+        return rb_class_new_instance(6, args, cOraDate);
+    }
+    return Qnil;
+}
+
+/*
+ * @overload attr_get_ub1(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `ub1' datatype.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_ub1(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_UB1);
+}
+
+/*
+ * @overload attr_get_ub2(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `ub2' datatype.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_ub2(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_UB2);
+}
+
+/*
+ * @overload attr_get_ub4(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `ub4' datatype.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_ub4(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_UB4);
+}
+
+/*
+ * @overload attr_get_ub8(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `ub8' datatype.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_ub8(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_UB8);
+}
+
+/*
+ * @overload attr_get_sb1(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `sb1' datatype.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_sb1(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_SB1);
+}
+
+/*
+ * @overload attr_get_sb2(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `sb2' datatype.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_sb2(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_SB2);
+}
+
+/*
+ * @overload attr_get_sb4(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `sb4' datatype.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_sb4(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_SB4);
+}
+
+/*
+ * @overload attr_get_sb8(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `sb8' datatype.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_sb8(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_SB8);
+}
+
+/*
+ * @overload attr_get_boolean(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `boolean' datatype.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [true of false]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_boolean(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_BOOLEAN);
+}
+
+/*
+ * @overload attr_get_string(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `oratext *' datatype.
+ *  The return value is converted to Encoding.default_internal or
+ *  tagged with {STACI.encoding} when the ruby version is 1.9.
+ *
+ *  @note If the specified attr_type's datatype is not a
+ *    pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [String]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_string(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_STRING);
+}
+
+/*
+ * @overload attr_get_binary(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `ub1 *' datatype.
+ *  The return value is tagged with ASCII-8BIT when the ruby version is 1.9.
+ *
+ *  @note If the specified attr_type's datatype is not a
+ *    pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [String]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_binary(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_BINARY);
+}
+
+/*
+ * @overload attr_get_integer(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `ub1 *' datatype.
+ *  The return value is converted to Integer from internal Oracle NUMBER format.
+ *
+ *  @note If the specified attr_type's datatype is not a
+ *    pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [Integer]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_integer(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_INTEGER);
+}
+
+/*
+ * @overload attr_get_oradate(attr_type, strict = true)
+ *
+ *  Gets the value of an attribute as `ub1 *' datatype.
+ *  The return value is converted to OraDate.
+ *
+ *  @note If the specified attr_type's datatype is not a
+ *    pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Boolean] strict If false, "ORA-24328: illegal attribute value" is ignored.
+ *  @return [OraDate]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_get_oradate(int argc, VALUE *argv, VALUE self)
+{
+    return attr_get_common(argc, argv, self, DATATYPE_ORADATE);
+}
+
+/*
+ * @overload attr_set_ub1(attr_type, attr_value)
+ *
+ *  Sets the value of an attribute as `ub1' datatype.
+ *
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Integer] attr_value
+ *  @return [self]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_set_ub1(VALUE self, VALUE attr_type, VALUE val)
+{
+    oci8_base_t *base = TO_HANDLE(self);
+    ub1 value;
+
+    /* validate arguments */
+    Check_Type(attr_type, T_FIXNUM);
+    value = (ub1)check_data_range(val, 0, UCHAR_MAX, "ub1");
+    /* set attribute */
+    chker2(OCIAttrSet(base->hp.ptr, base->type, &value, sizeof(value), FIX2INT(attr_type), oci8_errhp), base);
+    return self;
+}
+
+/*
+ * @overload attr_set_ub2(attr_type, attr_value)
+ *
+ *  Sets the value of an attribute as `ub2' datatype.
+ *
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Integer] attr_value
+ *  @return [self]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_set_ub2(VALUE self, VALUE attr_type, VALUE val)
+{
+    oci8_base_t *base = TO_HANDLE(self);
+    ub2 value;
+
+    /* validate arguments */
+    Check_Type(attr_type, T_FIXNUM);
+    value = (ub2)check_data_range(val, 0, USHRT_MAX, "ub2");
+    /* set attribute */
+    chker2(OCIAttrSet(base->hp.ptr, base->type, &value, sizeof(value), FIX2INT(attr_type), oci8_errhp), base);
+    return self;
+}
+
+/*
+ * @overload attr_set_ub4(attr_type, attr_value)
+ *
+ *  Sets the value of an attribute as `ub4' datatype.
+ *
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Integer] attr_value
+ *  @return [self]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_set_ub4(VALUE self, VALUE attr_type, VALUE val)
+{
+    oci8_base_t *base = TO_HANDLE(self);
+    ub4 value;
+
+    /* validate arguments */
+    Check_Type(attr_type, T_FIXNUM);
+    value = NUM2UINT(val);
+    /* set attribute */
+    chker2(OCIAttrSet(base->hp.ptr, base->type, &value, sizeof(value), FIX2INT(attr_type), oci8_errhp), base);
+    return self;
+}
+
+/*
+ * @overload attr_set_ub8(attr_type, attr_value)
+ *
+ *  Sets the value of an attribute as `ub8' datatype.
+ *
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Integer] attr_value
+ *  @return [self]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_set_ub8(VALUE self, VALUE attr_type, VALUE val)
+{
+    oci8_base_t *base = TO_HANDLE(self);
+    ub8 value;
+
+    /* validate arguments */
+    Check_Type(attr_type, T_FIXNUM);
+    value = NUM2ULL(val);
+    /* set attribute */
+    chker2(OCIAttrSet(base->hp.ptr, base->type, &value, sizeof(value), FIX2INT(attr_type), oci8_errhp), base);
+    return self;
+}
+
+/*
+ * @overload attr_set_sb1(attr_type, attr_value)
+ *
+ *  Sets the value of an attribute as `sb1' datatype.
+ *
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Integer] attr_value
+ *  @return [self]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_set_sb1(VALUE self, VALUE attr_type, VALUE val)
+{
+    oci8_base_t *base = TO_HANDLE(self);
+    sb1 value;
+
+    /* validate arguments */
+    Check_Type(attr_type, T_FIXNUM);
+    value = (sb1)check_data_range(val, CHAR_MIN, CHAR_MAX, "sb1");
+    /* set attribute */
+    chker2(OCIAttrSet(base->hp.ptr, base->type, &value, sizeof(value), FIX2INT(attr_type), oci8_errhp), base);
+    return self;
+}
+
+/*
+ * @overload attr_set_sb2(attr_type, attr_value)
+ *
+ *  Sets the value of an attribute as `sb2' datatype.
+ *
+ *  @note If the specified attr_type's datatype is a
+ *   pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Integer] attr_value
+ *  @return [self]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_set_sb2(VALUE self, VALUE attr_type, VALUE val)
+{
+    oci8_base_t *base = TO_HANDLE(self);
+    sb2 value;
+
+    /* validate arguments */
+    Check_Type(attr_type, T_FIXNUM);
+    value = (sb2)check_data_range(val, SHRT_MIN, SHRT_MAX, "sb2");
+    /* set attribute */
+    chker2(OCIAttrSet(base->hp.ptr, base->type, &value, sizeof(value), FIX2INT(attr_type), oci8_errhp), base);
+    return self;
+}
+
+/*
+ * @overload attr_set_sb4(attr_type, attr_value)
+ *
+ *  Sets the value of an attribute as `sb4' datatype.
+ *
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Integer] attr_value
+ *  @return [self]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_set_sb4(VALUE self, VALUE attr_type, VALUE val)
+{
+    oci8_base_t *base = TO_HANDLE(self);
+    sb4 value;
+
+    /* validate arguments */
+    Check_Type(attr_type, T_FIXNUM);
+    value = NUM2INT(val);
+    /* set attribute */
+    chker2(OCIAttrSet(base->hp.ptr, base->type, &value, sizeof(value), FIX2INT(attr_type), oci8_errhp), base);
+    return self;
+}
+
+/*
+ * @overload attr_set_sb8(attr_type, attr_value)
+ *
+ *  Sets the value of an attribute as `sb8' datatype.
+ *
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Integer] attr_value
+ *  @return [self]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_set_sb8(VALUE self, VALUE attr_type, VALUE val)
+{
+    oci8_base_t *base = TO_HANDLE(self);
+    sb8 value;
+
+    /* validate arguments */
+    Check_Type(attr_type, T_FIXNUM);
+    value = NUM2LL(val);
+    /* set attribute */
+    chker2(OCIAttrSet(base->hp.ptr, base->type, &value, sizeof(value), FIX2INT(attr_type), oci8_errhp), base);
+    return self;
+}
+
+/*
+ * @overload attr_set_boolean(attr_type, attr_value)
+ *
+ *  Sets the value of an attribute as `boolean' datatype.
+ *
+ *  @note If the specified attr_type's datatype is a
+ *    pointer type, it causes a segmentation fault.
+ *
+ *  @param [Integer] attr_type
+ *  @param [true or false] attr_value
+ *  @return [self]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_set_boolean(VALUE self, VALUE attr_type, VALUE val)
+{
+    oci8_base_t *base = TO_HANDLE(self);
+    boolean value;
+
+    /* validate arguments */
+    Check_Type(attr_type, T_FIXNUM);
+    value = RTEST(val) ? TRUE : FALSE;
+    /* set attribute */
+    chker2(OCIAttrSet(base->hp.ptr, base->type, &value, sizeof(value), FIX2INT(attr_type), oci8_errhp), base);
+    return self;
+}
+
+/*
+ * @overload attr_set_string(attr_type, attr_value)
+ *
+ *  Sets the value of an attribute as `oratext *' datatype.
+ *  +attr_value+ is converted to {STACI.encoding} before it is set
+ *  when the ruby version is 1.9.
+ *
+ *  @param [Integer] attr_type
+ *  @param [String] attr_value
+ *  @return [self]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_set_string(VALUE self, VALUE attr_type, VALUE val)
+{
+    oci8_base_t *base = TO_HANDLE(self);
+
+    /* validate arguments */
+    Check_Type(attr_type, T_FIXNUM);
+    OCI8SafeStringValue(val);
+    /* set attribute */
+    chker2(OCIAttrSet(base->hp.ptr, base->type, RSTRING_PTR(val), RSTRING_LEN(val), FIX2INT(attr_type), oci8_errhp), base);
+    return self;
+}
+
+/*
+ * @overload attr_set_binary(attr_type, attr_value)
+ *
+ *  Sets the value of an attribute as `ub1 *' datatype.
+ *
+ *  @param [Integer] attr_type
+ *  @param [String] attr_value
+ *  @return [self]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_set_binary(VALUE self, VALUE attr_type, VALUE val)
+{
+    oci8_base_t *base = TO_HANDLE(self);
+
+    /* validate arguments */
+    Check_Type(attr_type, T_FIXNUM);
+    SafeStringValue(val);
+    /* set attribute */
+    chker2(OCIAttrSet(base->hp.ptr, base->type, RSTRING_PTR(val), RSTRING_LEN(val), FIX2INT(attr_type), oci8_errhp), base);
+    return self;
+}
+
+/*
+ * @overload attr_set_integer(attr_type, number)
+ *
+ *  Sets the value of an attribute as `ub1 *' datatype.
+ *  +number+ is converted to internal Oracle NUMBER format before
+ *  it is set.
+ *
+ *  @param [Integer] attr_type
+ *  @param [Numeric] number
+ *  @return [self]
+ *
+ *  @since 2.0.4
+ *  @private
+ */
+static VALUE attr_set_integer(VALUE self, VALUE attr_type, VALUE val)
+{
+    oci8_base_t *base = TO_HANDLE(self);
+    OCINumber value;
+
+    /* validate arguments */
+    Check_Type(attr_type, T_FIXNUM);
+    oci8_set_integer(&value, val, oci8_errhp);
+    /* set attribute */
+    chker2(OCIAttrSet(base->hp.ptr, base->type, &value, sizeof(value), FIX2INT(attr_type), oci8_errhp), base);
+    return self;
+}
+
+void Init_oci8_handle(void)
+{
+    /*
+     * OCIHandle is the abstract base class of OCI handles and
+     * OCI descriptors; opaque data types of Oracle Call Interface.
+     * Don't use constants and methods defined in the class.
+     *
+     * @since 2.0.0
+     */
+    oci8_cOCIHandle = rb_define_class("OCIHandle", rb_cObject);
+    rb_define_alloc_func(oci8_cOCIHandle, oci8_s_allocate);
+    rb_define_method_nodoc(oci8_cOCIHandle, "initialize", oci8_handle_initialize, 0);
+    rb_define_private_method(oci8_cOCIHandle, "free", oci8_handle_free, 0);
+
+    /* methods to get attributes */
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_ub1", attr_get_ub1, -1);
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_ub2", attr_get_ub2, -1);
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_ub4", attr_get_ub4, -1);
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_ub8", attr_get_ub8, -1);
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_sb1", attr_get_sb1, -1);
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_sb2", attr_get_sb2, -1);
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_sb4", attr_get_sb4, -1);
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_sb8", attr_get_sb8, -1);
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_boolean", attr_get_boolean, -1);
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_string", attr_get_string, -1);
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_binary", attr_get_binary, -1);
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_integer", attr_get_integer, -1);
+    rb_define_private_method(oci8_cOCIHandle, "attr_get_oradate", attr_get_oradate, -1);
+
+    /* methods to set attributes */
+    rb_define_private_method(oci8_cOCIHandle, "attr_set_ub1", attr_set_ub1, 2);
+    rb_define_private_method(oci8_cOCIHandle, "attr_set_ub2", attr_set_ub2, 2);
+    rb_define_private_method(oci8_cOCIHandle, "attr_set_ub4", attr_set_ub4, 2);
+    rb_define_private_method(oci8_cOCIHandle, "attr_set_ub8", attr_set_ub8, 2);
+    rb_define_private_method(oci8_cOCIHandle, "attr_set_sb1", attr_set_sb1, 2);
+    rb_define_private_method(oci8_cOCIHandle, "attr_set_sb2", attr_set_sb2, 2);
+    rb_define_private_method(oci8_cOCIHandle, "attr_set_sb4", attr_set_sb4, 2);
+    rb_define_private_method(oci8_cOCIHandle, "attr_set_sb8", attr_set_sb8, 2);
+    rb_define_private_method(oci8_cOCIHandle, "attr_set_boolean", attr_set_boolean, 2);
+    rb_define_private_method(oci8_cOCIHandle, "attr_set_string", attr_set_string, 2);
+    rb_define_private_method(oci8_cOCIHandle, "attr_set_binary", attr_set_binary, 2);
+    rb_define_private_method(oci8_cOCIHandle, "attr_set_integer", attr_set_integer, 2);
+}