ruby-oci8 2.0.3 → 2.0.4

data/ext/oci8/ocinumber.c

@@ -8,6 +8,7 @@
 #include "oci8.h"
 #include <orl.h>
 #include <errno.h>
+#include "oranumber_util.h"
 
 #ifndef RUBY_VM
 /* ruby 1.8 */
@@ -36,26 +37,6 @@ static OCINumber const_m1;   /*  -1 */
 static OCINumber const_PI2;  /* +PI/2 */
 static OCINumber const_mPI2; /* -PI/2 */
 
-#define SHRESHOLD_FMT_STR "00000000000000000000000000"
-#define SHRESHOLD_FMT (OraText*)SHRESHOLD_FMT_STR
-#define SHRESHOLD_FMT_LEN (sizeof(SHRESHOLD_FMT_STR) - 1)
-#define SHRESHOLD_VAL_STR "10000000000000000000000000"
-#define SHRESHOLD_VAL (OraText*)SHRESHOLD_VAL_STR
-#define SHRESHOLD_VAL_LEN (sizeof(SHRESHOLD_VAL_STR) - 1)
-static OCINumber const_shreshold;
-
-/* TODO: scale: -84 - 127 */
-#define NUMBER_FORMAT1_STR "FM9999999999999999999999990.9999999999999999999999999999999999999"
-#define NUMBER_FORMAT1 (OraText*)NUMBER_FORMAT1_STR
-#define NUMBER_FORMAT1_LEN (sizeof(NUMBER_FORMAT1_STR) - 1)
-#define NUMBER_FORMAT2_STR "FM99999999999999999999999999999999999990.999999999999999999999999"
-#define NUMBER_FORMAT2 (OraText*)NUMBER_FORMAT2_STR
-#define NUMBER_FORMAT2_LEN (sizeof(NUMBER_FORMAT2_STR) - 1)
-#define NUMBER_FORMAT2_DECIMAL                              (sizeof("999999999999999999999999") - 1)
-#define NUMBER_FORMAT_INT_STR "FM99999999999999999999999999999999999990"
-#define NUMBER_FORMAT_INT (OraText*)NUMBER_FORMAT_INT_STR
-#define NUMBER_FORMAT_INT_LEN (sizeof(NUMBER_FORMAT_INT_STR) - 1)
-
 #define _NUMBER(val) ((OCINumber *)DATA_PTR(val)) /* dangerous macro */
 
 #define RBOCI8_T_ORANUMBER (T_MASK + 1)
@@ -109,6 +90,7 @@ static int rboci8_type(VALUE obj)
 static VALUE onum_to_f(VALUE self);
 static VALUE onum_to_r(VALUE self);
 static VALUE onum_to_d(VALUE self);
+static VALUE onum_to_d_real(OCINumber *num, OCIError *errhp);
 
 static VALUE onum_s_alloc(VALUE klass)
 {
@@ -135,14 +117,18 @@ VALUE oci8_make_integer(OCINumber *s, OCIError *errhp)
 {
     signed long sl;
     char buf[512];
-    ub4 buf_size = sizeof(buf);
+    sword rv;
 
     if (OCINumberToInt(errhp, s, sizeof(sl), OCI_NUMBER_SIGNED, &sl) == OCI_SUCCESS) {
         return LONG2NUM(sl);
     }
-    oci_lc(OCINumberToText(errhp, s, NUMBER_FORMAT2, NUMBER_FORMAT2_LEN,
-                           NULL, 0, &buf_size, TO_ORATEXT(buf)));
-    return rb_cstr2inum(buf, 10);
+    /* convert to Integer via String */
+    rv = oranumber_to_str(s, buf, sizeof(buf));
+    if (rv > 0) {
+        return rb_cstr2inum(buf, 10);
+    }
+    oranumber_dump(s, buf);
+    rb_raise(eOCIException, "Invalid internal number format: %s", buf);
 }
 
 VALUE oci8_make_float(OCINumber *s, OCIError *errhp)
@@ -164,29 +150,25 @@ static void set_oci_number_from_str(OCINumber *result, VALUE str, VALUE fmt, VAL
     StringValue(str);
     /* set from string. */
     if (NIL_P(fmt)) {
-        int i, cnt = 0;
-        for (i = RSTRING_LEN(str) - 1; i >= 0; i--) {
-            if (RSTRING_PTR(str)[i] != ' ')
-                cnt++;
-            if (RSTRING_PTR(str)[i] == '.') {
-                i = RSTRING_LEN(str) - i;
+        int rv = oranumber_from_str(result, RSTRING_PTR(str), RSTRING_LEN(str));
+        if (rv == ORANUMBER_SUCCESS) {
+            return; /* success */
+        } else {
+            const char *default_msg = NULL;
+            switch (rv) {
+            case ORANUMBER_INVALID_NUMBER:
+                default_msg = "invalid number";
+                break;
+            case ORANUMBER_NUMERIC_OVERFLOW:
+                default_msg = "numeric overflow";
                 break;
             }
+            oci8_raise_by_msgno(rv, default_msg);
         }
-        if (i == -1)
-            cnt = 0;
-        if (cnt <= NUMBER_FORMAT2_DECIMAL) {
-            fmt_ptr = NUMBER_FORMAT2;
-            fmt_len = NUMBER_FORMAT2_LEN;
-        } else {
-            fmt_ptr = NUMBER_FORMAT1;
-            fmt_len = NUMBER_FORMAT1_LEN;
-        }
-    } else {
-        StringValue(fmt);
-        fmt_ptr = RSTRING_ORATEXT(fmt);
-        fmt_len = RSTRING_LEN(fmt);
     }
+    StringValue(fmt);
+    fmt_ptr = RSTRING_ORATEXT(fmt);
+    fmt_len = RSTRING_LEN(fmt);
     if (NIL_P(nls_params)) {
         nls_params_ptr = NULL;
         nls_params_len = 0;
@@ -1053,30 +1035,16 @@ static VALUE onum_to_char(int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "02", &fmt /* nil */, &nls_params /* nil */);
     if (NIL_P(fmt)) {
-        OCINumber absval;
-        sword sign;
-        boolean is_int;
-
-        oci_lc(OCINumberIsInt(errhp, _NUMBER(self), &is_int));
-        if (is_int) {
-            fmt_ptr = NUMBER_FORMAT_INT;
-            fmt_len = NUMBER_FORMAT_INT_LEN;
-        } else {
-            oci_lc(OCINumberAbs(errhp, _NUMBER(self), &absval));
-            oci_lc(OCINumberCmp(errhp, &absval, &const_shreshold, &sign));
-            if (sign >= 0) {
-                fmt_ptr = NUMBER_FORMAT2;
-                fmt_len = NUMBER_FORMAT2_LEN;
-            } else {
-                fmt_ptr = NUMBER_FORMAT1;
-                fmt_len = NUMBER_FORMAT1_LEN;
-            }
+        rv = oranumber_to_str(_NUMBER(self), buf, sizeof(buf));
+        if (rv > 0) {
+            return rb_usascii_str_new(buf, rv);
         }
-    } else {
-        StringValue(fmt);
-        fmt_ptr = RSTRING_ORATEXT(fmt);
-        fmt_len = RSTRING_LEN(fmt);
+        oranumber_dump(_NUMBER(self), buf);
+        rb_raise(eOCIException, "Invalid internal number format: %s", buf);
     }
+    StringValue(fmt);
+    fmt_ptr = RSTRING_ORATEXT(fmt);
+    fmt_len = RSTRING_LEN(fmt);
     if (NIL_P(nls_params)) {
         nls_params_ptr = NULL;
         nls_params_len = 0;
@@ -1195,11 +1163,23 @@ static VALUE onum_to_r(VALUE self)
  */
 static VALUE onum_to_d(VALUE self)
 {
+    return onum_to_d_real(_NUMBER(self), oci8_errhp);
+}
+
+/* Converts to BigDecimal via number in scientific notation */
+static VALUE onum_to_d_real(OCINumber *num, OCIError *errhp)
+{
+    char buf[64];
+    ub4 buf_size = sizeof(buf);
+    const const char *fmt = "FM9.99999999999999999999999999999999999999EEEE";
+
     if (!cBigDecimal) {
         rb_require("bigdecimal");
         cBigDecimal = rb_const_get(rb_cObject, id_BigDecimal);
     }
-    return rb_funcall(rb_cObject, id_BigDecimal, 1, onum_to_s(self));
+    oci_lc(OCINumberToText(errhp, num, (const oratext *)fmt, strlen(fmt),
+                           NULL, 0, &buf_size, TO_ORATEXT(buf)));
+    return rb_funcall(rb_cObject, id_BigDecimal, 1, rb_usascii_str_new(buf, buf_size));
 }
 
 /*
@@ -1262,6 +1242,24 @@ static VALUE onum_shift(VALUE self, VALUE exp)
     return oci8_make_ocinumber(&result, errhp);
 }
 
+/*
+ *  call-seq:
+ *     onum.dump    -> string
+ *
+ *  Returns internal representation whose format is same with
+ *  the return value of Oracle SQL function DUMP().
+ *
+ *   OraNumber.new(100).dump  #=> "Typ=2 Len=2: 194,2"
+ *   OraNumber.new(123).dump  #=> "Typ=2 Len=3: 194,2,24"
+ *   OraNumber.new(0.1).dump  #=> "Typ=2 Len=2: 192,11"
+ */
+static VALUE onum_dump(VALUE self)
+{
+    char buf[ORANUMBER_DUMP_BUF_SIZ];
+    int rv = oranumber_dump(_NUMBER(self), buf);
+    return rb_usascii_str_new(buf, rv);
+}
+
 static VALUE onum_hash(VALUE self)
 {
     char *c  = DATA_PTR(self);
@@ -1297,7 +1295,7 @@ static VALUE onum_inspect(VALUE self)
  *
  *  Dump <i>onum</i> for marshaling.
  */
-static VALUE onum_dump(int argc, VALUE *argv, VALUE self)
+static VALUE onum__dump(int argc, VALUE *argv, VALUE self)
 {
     char *c  = DATA_PTR(self);
     int size = c[0] + 1;
@@ -1443,9 +1441,6 @@ Init_oci_number(VALUE cOCI8, OCIError *errhp)
     OCINumberDiv(errhp, &num1 /* PI */, &num2 /* 2 */, &const_PI2);
     /* set const_mPI2 */
     OCINumberNeg(errhp, &const_PI2 /* PI/2 */, &const_mPI2);
-    /* set const_shreshold */
-    OCINumberFromText(errhp, SHRESHOLD_VAL, SHRESHOLD_VAL_LEN, SHRESHOLD_FMT, SHRESHOLD_FMT_LEN,
-                      NULL, 0, &const_shreshold);
 
     /* PI */
     OCINumberSetPi(errhp, &num1);
@@ -1516,12 +1511,13 @@ Init_oci_number(VALUE cOCI8, OCIError *errhp)
     if (have_OCINumberShift) {
         rb_define_method(cOCINumber, "shift", onum_shift, 1);
     }
+    rb_define_method(cOCINumber, "dump", onum_dump, 0);
 
     rb_define_method_nodoc(cOCINumber, "hash", onum_hash, 0);
     rb_define_method_nodoc(cOCINumber, "inspect", onum_inspect, 0);
 
     /* methods for marshaling */
-    rb_define_method(cOCINumber, "_dump", onum_dump, -1);
+    rb_define_method(cOCINumber, "_dump", onum__dump, -1);
     rb_define_singleton_method(cOCINumber, "_load", onum_s_load, 1);
 
     oci8_define_bind_class("OraNumber", &bind_ocinumber_class);

data/ext/oci8/oradate.c

@@ -3,7 +3,7 @@
  *  oradate.c
  *
  * $Author: kubo $
- * $Date: 2009-10-21 22:50:01 +0900 (Wed, 21 Oct 2009) $
+ * $Date: 2009-01-04 01:58:01 +0900 (Sun, 04 Jan 2009) $
  *
  * Copyright (C) 2002-2008 KUBO Takehiro <kubo@jiubao.org>
  *

data/ext/oci8/oranumber_util.c

@@ -0,0 +1,315 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+#include <stdio.h>
+#include <string.h>
+#include "oranumber_util.h"
+
+int oranumber_to_str(const OCINumber *on, char *buf, int buflen)
+{
+    signed char exponent;
+    signed char mantissa[21]; /* terminated by a negative number */
+    int datalen = on->OCINumberPart[0];
+    int len = 0;
+    int idx;
+    int n;
+#define PUTC(chr) do { \
+    if (len < buflen) { \
+        buf[len++] = (chr); \
+    } else { \
+        return ORANUMBER_TOO_SHORT_BUFFER; \
+    } \
+} while(0)
+#define PUTEND() do { \
+    if (len < buflen) { \
+        buf[len] = '\0'; \
+    } else { \
+        return ORANUMBER_TOO_SHORT_BUFFER; \
+    } \
+} while(0)
+
+    if (datalen == 0) {
+        /* too short */
+        return -1;
+    }
+    if (datalen == 1) {
+        if (on->OCINumberPart[1] == 0x80) {
+            /* zero */
+            PUTC('0');
+            PUTEND();
+            return 1;
+        }
+        /* unexpected format */
+        return -1;
+    }
+    if (datalen > 21) {
+        /* too long */
+        return -1;
+    }
+    /* normalize exponent and mantissa */
+    if (on->OCINumberPart[1] >= 128) {
+        /* positive number */
+        exponent = on->OCINumberPart[1] - 193;
+        for (idx = 0; idx < on->OCINumberPart[0] - 1; idx++) {
+            mantissa[idx] = on->OCINumberPart[idx + 2] - 1;
+        }
+        mantissa[idx] = -1;
+    } else {
+        /* negative number */
+        exponent = 62 - on->OCINumberPart[1];
+        for (idx = 0; idx < on->OCINumberPart[0] - 1; idx++) {
+            mantissa[idx] = 101 - on->OCINumberPart[idx + 2];
+        }
+        mantissa[idx] = -1;
+        PUTC('-');
+    }
+    /* convert exponent and mantissa to human readable number */
+    idx = 0;
+    if (exponent-- >= 0) {
+        /* integer part */
+        n = mantissa[idx++];
+        if (n / 10 != 0) {
+            PUTC(n / 10 + '0');
+        }
+        PUTC(n % 10 + '0');
+        while (exponent-- >= 0) {
+            n = mantissa[idx++];
+            if (n < 0) {
+                do {
+                    PUTC('0');
+                    PUTC('0');
+                } while (exponent-- >= 0);
+                PUTEND();
+                return len;
+            }
+            PUTC(n / 10 + '0');
+            PUTC(n % 10 + '0');
+        }
+        if (mantissa[idx] < 0) {
+            PUTEND();
+            return len;
+        }
+    } else {
+        PUTC('0');
+    }
+    PUTC('.');
+    /* fractional number part */
+    while (++exponent < -1) {
+        PUTC('0');
+        PUTC('0');
+    }
+    while ((n = mantissa[idx++]) >= 0) {
+        PUTC(n / 10 + '0');
+        PUTC(n % 10 + '0');
+    }
+    if (buf[len - 1] == '0') {
+        len--;
+    }
+    PUTEND();
+    return len;
+}
+
+int oranumber_from_str(OCINumber *on, const char *buf, int buflen)
+{
+    const char *end;
+    int is_positive = 1;
+    char mantissa[41];
+    int dec_point;
+    long exponent = 0;
+    int idx = 0;
+    int i;
+
+    if (buflen < 0) {
+        end = buf + strlen(buf);
+    } else {
+        end = buf + buflen;
+    }
+
+    /* skip leading spaces */
+    while (buf < end && *buf == ' ') {
+        buf++;
+    }
+    if (buf == end) {
+        return ORANUMBER_INVALID_NUMBER;
+    }
+    /* read a sign mark */
+    if (*buf == '+') {
+        buf++;
+    } else if (*buf == '-') {
+        buf++;
+        is_positive = 0;
+    }
+    /* next should be number or a dot */
+    if ((*buf < '0' || '9' < *buf) && *buf != '.') {
+        return ORANUMBER_INVALID_NUMBER;
+    }
+    /* skip leading zeros */
+    while (buf < end) {
+        if (*buf == '0') {
+            buf++;
+        } else {
+            break;
+        }
+    }
+    /* read integer part */
+    while (buf < end) {
+        if ('0' <= *buf && *buf <= '9') {
+            if (idx < 41) {
+                mantissa[idx] = *buf - '0';
+            }
+            idx++;
+        } else if (*buf == '.' || *buf == 'E' || *buf == 'e' || *buf == ' ') {
+            break;
+        } else {
+            return ORANUMBER_INVALID_NUMBER;
+        }
+        buf++;
+    }
+    dec_point = idx;
+    /* read fractional part */
+    if (buf < end && *buf == '.') {
+        buf++;
+        if (idx == 0) {
+            /* skip leading zeros */
+            while (buf < end) {
+                if (*buf == '0') {
+                    dec_point--;
+                    buf++;
+                } else {
+                    break;
+                }
+            }
+        }
+        while (buf < end) {
+            if ('0' <= *buf && *buf <= '9') {
+                if (idx < 41) {
+                    mantissa[idx++] = *buf - '0';
+                }
+            } else if (*buf == 'E' || *buf == 'e' || *buf == ' ') {
+                break;
+            } else {
+                return ORANUMBER_INVALID_NUMBER;
+            }
+            buf++;
+        }
+    }
+    /* read exponent part */
+    if (buf < end && (*buf == 'E' || *buf == 'e')) {
+        int negate = 0;
+        buf++;
+        if (buf < end) {
+            if (*buf == '+') {
+                buf++;
+            } else if (*buf == '-') {
+                buf++;
+                negate = 1;
+            }
+        }
+        while (buf < end) {
+            if ('0' <= *buf && *buf <= '9') {
+                exponent *= 10;
+                exponent += *buf - '0';
+            } else if (*buf == ' ') {
+                break;
+            } else {
+                return ORANUMBER_INVALID_NUMBER;
+            }
+            buf++;
+        }
+        if (negate) {
+            exponent = -exponent;
+        }
+    }
+    /* skip trailing spaces */
+    while (buf < end && *buf == ' ') {
+        buf++;
+    }
+    /* final format check */
+    if (buf != end) {
+        return ORANUMBER_INVALID_NUMBER;
+    }
+    /* determine exponent */
+    exponent += dec_point - 1;
+    if (exponent % 2 == 0) {
+        memmove(mantissa + 1, mantissa, 40);
+        mantissa[0] = 0;
+        idx++;
+    }
+    /* round if needed */
+    if (idx > 40) {
+        idx = 40;
+        if (mantissa[40] >= 5) {
+            /* round up */
+            for (i = 39; i >= 0; i--) {
+                mantissa[i]++;
+                if (mantissa[i] == 10) {
+                    mantissa[i] = 0;
+                } else {
+                    break;
+                }
+            }
+            if (i == -1) {
+                /* all figures are rounded up. */
+                mantissa[0] = 0;
+                mantissa[1] = 1;
+                idx = 2;
+                exponent++;
+            }
+        }
+    }
+    /* shrink mantissa scale */
+    while (idx > 0 && mantissa[idx - 1] == 0) {
+        idx--;
+    }
+    /* check zero or underflow */
+    if (idx == 0 || exponent < -130) {
+        on->OCINumberPart[0] = 1;
+        on->OCINumberPart[1] = 0x80;
+        return ORANUMBER_SUCCESS;
+    }
+    /* check overflow */
+    if (exponent > 125) {
+        return ORANUMBER_NUMERIC_OVERFLOW;
+    }
+    /* change the base number from 10 to 100 */
+    if (idx % 2 == 1) {
+        mantissa[idx++] = 0;
+    }
+    idx /= 2;
+    for (i = 0; i < idx; i++) {
+        mantissa[i] = mantissa[i * 2] * 10 + mantissa[i * 2 + 1];
+    }
+    /* add negative value's terminator */
+    if (!is_positive && idx < 20) {
+        mantissa[idx++] = -1;
+    }
+    /* construct OCINumber */
+    on->OCINumberPart[0] = 1 + idx;
+    if (is_positive) {
+        on->OCINumberPart[1] = (exponent >> 1) + 193;
+        for (i = 0; i < idx; i++) {
+            on->OCINumberPart[i + 2] = mantissa[i] + 1;
+        }
+    } else {
+        on->OCINumberPart[1] = 62 - (exponent >> 1);
+        for (i = 0; i < idx; i++) {
+            on->OCINumberPart[i + 2] = 101 - mantissa[i];
+        }
+    }
+    return ORANUMBER_SUCCESS;
+}
+
+int oranumber_dump(const OCINumber *on, char *buf)
+{
+    int idx;
+    int len = on->OCINumberPart[0];
+    int offset;
+
+    offset = sprintf(buf, "Typ=2 Len=%u: ", len);
+    if (len > 21) {
+        len = 21;
+    }
+    for (idx = 1; idx <= len; idx++) {
+        offset += sprintf(buf + offset, "%hhu,", on->OCINumberPart[idx]);
+    }
+    buf[--offset] = '\0';
+    return offset;
+}