Class: OraNumber

Inherits:
Numeric show all
Includes:
Comparable
Defined in:
ext/oci8/ocinumber.c,
lib/oci8/oci8.rb,
ext/oci8/ocinumber.c

Overview

OraNumber is a ruby representation of Oracle NUMBER data type. without precision and scale designators.

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(expr = nil, fmt = nil, nlsparam = nil) ⇒ Object

Creates a value of OraNumber from expr. The expr can be a Numeric value or a String value. If it is a String value, optional fmt and nlsparam is used as Oracle SQL function TO_NUMBER does.

Examples:

# Numeric expr
OraNumber.new(123456.789)   # -> 123456.789
# String expr
OraNumber.new('123456.789') # => #<OraNumber:123456.789>
# String expr with fmt
OraNumber.new('123,456.789', '999,999,999.999') # => #<OraNumber:123456.789>
# String expr with fmt and nlsparam
OraNumber.new('123.456,789', '999G999G999D999', "NLS_NUMERIC_CHARACTERS = ',.'") # => #<OraNumber:123456.789>

Parameters:



782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
 
# File 'ext/oci8/ocinumber.c', line 782

static VALUE onum_initialize(int argc, VALUE *argv, VALUE self)
{
    OCIError *errhp = oci8_errhp;
    VALUE val;
    VALUE fmt;
    VALUE nls_params;

    if (rb_scan_args(argc, argv, "03", &val /* 0 */, &fmt /* nil */, &nls_params /* nil */) == 0) {
        OCINumberSetZero(errhp, _NUMBER(self));
    } else if (RTEST(rb_obj_is_kind_of(val, rb_cNumeric))) {
        set_oci_number_from_num(_NUMBER(self), val, 1, errhp);
    } else {
        set_oci_number_from_str(_NUMBER(self), val, fmt, nls_params, errhp);
    }
    return Qnil;
}

Class Method Details

._load(bytes) ⇒ OraNumber

Restores a byte stream serialized by #_dump. This method is called by Marshal.load() to deserialize a byte stream created by Marshal.dump().

Parameters:

  • bytes (String) —

    a byte stream

Returns:



1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
 
# File 'ext/oci8/ocinumber.c', line 1613

static VALUE
onum_s_load(VALUE klass, VALUE str)
{
    unsigned char *c;
    size_t size;
    OCINumber num;

    Check_Type(str, T_STRING);
    c = RSTRING_ORATEXT(str);
    size = RSTRING_LEN(str);
    if (size == 0 || size != c[0] + 1u || size > sizeof(num)) {
        rb_raise(rb_eTypeError, "marshaled OCI::Number format differ");
    }
    memset(&num, 0, sizeof(num));
    memcpy(&num, c, size);
    return oci8_make_ocinumber(&num, oci8_errhp);
}

Instance Method Details

#%(other) ⇒ OraNumber

Returns the modulo after division of self by other.

Examples:

OraNumber(13) % 5 # => #<OraNumber:3>

Parameters:

Returns:

Raises:

  • (ZeroDivisionError) —

    when other is zero.



1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
 
# File 'ext/oci8/ocinumber.c', line 1050

static VALUE onum_mod(VALUE lhs, VALUE rhs)
{
    OCIError *errhp = oci8_errhp;
    OCINumber n;
    OCINumber r;
    boolean is_zero;

    /* change to OCINumber */
    if (!set_oci_number_from_num(&n, rhs, 0, errhp))
        return rb_num_coerce_bin(lhs, rhs, '%');
    /* check whether argument is not zero. */
    chkerr(OCINumberIsZero(errhp, &n, &is_zero));
    if (is_zero)
        rb_num_zerodiv();
    /* modulo */
    chkerr(OCINumberMod(errhp, _NUMBER(lhs), &n, &r));
    return oci8_make_ocinumber(&r, errhp);
}

#*(other) ⇒ Numeric

Returns the product of self and other. When other’s class is Integer, it returns an OraNumber value. Otherwise, it returns a value same with other’s class.

Examples:

OraNumber(2) * 3   # => #<OraNumber:6>
OraNumber(2) * 1.5 # => 3.0 (Float)

Parameters:

Returns:



961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
 
# File 'ext/oci8/ocinumber.c', line 961

static VALUE onum_mul(VALUE lhs, VALUE rhs)
{
    OCIError *errhp = oci8_errhp;
    OCINumber n;
    OCINumber r;

    switch (rboci8_type(rhs)) {
    case T_FIXNUM:
    case T_BIGNUM:
        if (set_oci_number_from_num(&n, rhs, 0, errhp)) {
            chkerr(OCINumberMul(errhp, _NUMBER(lhs), &n, &r));
            return oci8_make_ocinumber(&r, errhp);
        }
        break;
    case RBOCI8_T_ORANUMBER:
        chkerr(OCINumberMul(errhp, _NUMBER(lhs), _NUMBER(rhs), &r));
        return oci8_make_ocinumber(&r, errhp);
    case T_FLOAT:
        return rb_funcall(onum_to_f(lhs), oci8_id_mul_op, 1, rhs);
    case T_RATIONAL:
        return rb_funcall(onum_to_r(lhs), oci8_id_mul_op, 1, rhs);
    case RBOCI8_T_BIGDECIMAL:
        return rb_funcall(onum_to_d(lhs), oci8_id_mul_op, 1, rhs);
    }
    return rb_num_coerce_bin(lhs, rhs, oci8_id_mul_op);
}

#**(other) ⇒ OraNumber

Raises self to the power of other.

Examples:

OraNumber(2) ** 2   # => #<OraNumber:4>
OraNumber(2) ** 2.5 # => #<OraNumber:5.65685424949238019520675489683879231435>

Parameters:

Returns:



1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
 
# File 'ext/oci8/ocinumber.c', line 1081

static VALUE onum_power(VALUE lhs, VALUE rhs)
{
    OCIError *errhp = oci8_errhp;
    OCINumber n;
    OCINumber r;

    if (FIXNUM_P(rhs)) {
        chkerr(OCINumberIntPower(errhp, _NUMBER(lhs), FIX2INT(rhs), &r));
    } else {
        /* change to OCINumber */
        if (!set_oci_number_from_num(&n, rhs, 0, errhp))
            return rb_num_coerce_bin(lhs, rhs, id_power);
        chkerr(OCINumberPower(errhp, _NUMBER(lhs), &n, &r));
    }
    return oci8_make_ocinumber(&r, errhp);
}

#+(other) ⇒ Numeric

Returns the sum of self and other. When other’s class is Integer, it returns an OraNumber value. Otherwise, it returns a value same with other’s class.

Examples:

OraNumber(2) + 3   # => #<OraNumber:5>
OraNumber(2) + 1.5 # => 3.5 (Float)

Parameters:

Returns:



879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
 
# File 'ext/oci8/ocinumber.c', line 879

static VALUE onum_add(VALUE lhs, VALUE rhs)
{
    OCIError *errhp = oci8_errhp;
    OCINumber n;
    OCINumber r;

    switch (rboci8_type(rhs)) {
    case T_FIXNUM:
    case T_BIGNUM:
        if (set_oci_number_from_num(&n, rhs, 0, errhp)) {
            chkerr(OCINumberAdd(errhp, _NUMBER(lhs), &n, &r));
            return oci8_make_ocinumber(&r, errhp);
        }
        break;
    case RBOCI8_T_ORANUMBER:
        chkerr(OCINumberAdd(errhp, _NUMBER(lhs), _NUMBER(rhs), &r));
        return oci8_make_ocinumber(&r, errhp);
    case T_FLOAT:
        return rb_funcall(onum_to_f(lhs), oci8_id_add_op, 1, rhs);
    case T_RATIONAL:
        return rb_funcall(onum_to_r(lhs), oci8_id_add_op, 1, rhs);
    case RBOCI8_T_BIGDECIMAL:
        return rb_funcall(onum_to_d(lhs), oci8_id_add_op, 1, rhs);
    }
    return rb_num_coerce_bin(lhs, rhs, oci8_id_add_op);
}

#-(other) ⇒ Numeric

Returns the difference of self and other. When other’s class is Integer, it returns an OraNumber value. Otherwise, it returns a value same with other’s class.

Examples:

OraNumber(2) - 3   # => #<OraNumber:-1>
OraNumber(2) - 1.5 # => 0.5 (Float)

Parameters:

Returns:



920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
 
# File 'ext/oci8/ocinumber.c', line 920

static VALUE onum_sub(VALUE lhs, VALUE rhs)
{
    OCIError *errhp = oci8_errhp;
    OCINumber n;
    OCINumber r;

    switch (rboci8_type(rhs)) {
    case T_FIXNUM:
    case T_BIGNUM:
        if (set_oci_number_from_num(&n, rhs, 0, errhp)) {
            chkerr(OCINumberSub(errhp, _NUMBER(lhs), &n, &r));
            return oci8_make_ocinumber(&r, errhp);
        }
        break;
    case RBOCI8_T_ORANUMBER:
        chkerr(OCINumberSub(errhp, _NUMBER(lhs), _NUMBER(rhs), &r));
        return oci8_make_ocinumber(&r, errhp);
    case T_FLOAT:
        return rb_funcall(onum_to_f(lhs), oci8_id_sub_op, 1, rhs);
    case T_RATIONAL:
        return rb_funcall(onum_to_r(lhs), oci8_id_sub_op, 1, rhs);
    case RBOCI8_T_BIGDECIMAL:
        return rb_funcall(onum_to_d(lhs), oci8_id_sub_op, 1, rhs);
    }
    return rb_num_coerce_bin(lhs, rhs, oci8_id_sub_op);
}

#-@ ⇒ OraNumber

Returns a negated value of self

Examples:

-OraNumber(2)  # =>  #<OraNumber:-2>

Returns:



856
857
858
859
860
861
862
863
 
# File 'ext/oci8/ocinumber.c', line 856

static VALUE onum_neg(VALUE self)
{
    OCIError *errhp = oci8_errhp;
    OCINumber r;

    chkerr(OCINumberNeg(errhp, _NUMBER(self), &r));
    return oci8_make_ocinumber(&r, errhp);
}

#/(other) ⇒ Numeric

Returns the result of dividing self by other. When other’s class is Integer, it returns an OraNumber value. Otherwise, it returns a value same with other’s class.

Examples:

OraNumber(2) / 3   # => #<OraNumber:0.6666666666666666666666666666666666666667>
OraNumber(2) / 1.5 # => 1.3333333333333333 (Float)

Parameters:

Returns:



1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
 
# File 'ext/oci8/ocinumber.c', line 1002

static VALUE onum_div(VALUE lhs, VALUE rhs)
{
    OCIError *errhp = oci8_errhp;
    OCINumber n;
    OCINumber r;
    boolean is_zero;

    switch (rboci8_type(rhs)) {
    case T_FIXNUM:
        if (rhs == INT2FIX(0)) {
            rb_num_zerodiv();
        }
    case T_BIGNUM:
        if (set_oci_number_from_num(&n, rhs, 0, errhp)) {
            chkerr(OCINumberDiv(errhp, _NUMBER(lhs), &n, &r));
            return oci8_make_ocinumber(&r, errhp);
        }
        break;
    case RBOCI8_T_ORANUMBER:
        chkerr(OCINumberIsZero(errhp, _NUMBER(rhs), &is_zero));
        if (is_zero) {
            rb_num_zerodiv();
        }
        chkerr(OCINumberDiv(errhp, _NUMBER(lhs), _NUMBER(rhs), &r));
        return oci8_make_ocinumber(&r, errhp);
    case T_FLOAT:
        return rb_funcall(onum_to_f(lhs), oci8_id_div_op, 1, rhs);
    case T_RATIONAL:
        return rb_funcall(onum_to_r(lhs), oci8_id_div_op, 1, rhs);
    case RBOCI8_T_BIGDECIMAL:
        return rb_funcall(onum_to_d(lhs), oci8_id_div_op, 1, rhs);
    }
    return rb_num_coerce_bin(lhs, rhs, oci8_id_div_op);
}

#<=>(other) ⇒ -1, 0 or +1

Returns -1, 0, or +1 depending on whether self is less than, equal to, or greater than other. This is the basis for the tests in Comparable.

Examples:

OraNumber(5) <=> 3   # => 1
OraNumber(4) <=> 4   # => 0
OraNumber(2) <=> 2.5 # => 1

Parameters:

Returns:

  • (-1, 0 or +1) 


1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
 
# File 'ext/oci8/ocinumber.c', line 1113

static VALUE onum_cmp(VALUE lhs, VALUE rhs)
{
    OCIError *errhp = oci8_errhp;
    OCINumber n;
    sword r;

    /* change to OCINumber */
    if (!set_oci_number_from_num(&n, rhs, 0, errhp))
        return rb_num_coerce_cmp(lhs, rhs, id_cmp);
    /* compare */
    chkerr(OCINumberCmp(errhp, _NUMBER(lhs), &n, &r));
    if (r > 0) {
        return INT2FIX(1);
    } else if (r == 0) {
        return INT2FIX(0);
    } else {
        return INT2FIX(-1);
    }
}

#_dump ⇒ String

Serializes self. This method is called by Marshal.dump().

Returns:

See Also:



1593
1594
1595
1596
1597
1598
1599
1600
1601
 
# File 'ext/oci8/ocinumber.c', line 1593

static VALUE onum__dump(int argc, VALUE *argv, VALUE self)
{
    char *c  = RTYPEDDATA_DATA(self);
    int size = c[0] + 1;
    VALUE dummy;

    rb_scan_args(argc, argv, "01", &dummy);
    return rb_str_new(c, size);
}

#abs ⇒ OraNumber

Returns the absolute value of self.

Returns:



1497
1498
1499
1500
1501
1502
1503
1504
 
# File 'ext/oci8/ocinumber.c', line 1497

static VALUE onum_abs(VALUE self)
{
    OCIError *errhp = oci8_errhp;
    OCINumber result;

    chkerr(OCINumberAbs(errhp, _NUMBER(self), &result));
    return oci8_make_ocinumber(&result, errhp);
}

#ceil ⇒ Integer

Returns the smallest Integer greater than or equal to self.

Examples:

OraNumber(11.1).ceil  # => 12
OraNumber(25.8).ceil  # => 26
OraNumber(-25.8).ceil # => -25

Returns:

  • (Integer) 


1166
1167
1168
1169
1170
1171
1172
1173
 
# File 'ext/oci8/ocinumber.c', line 1166

static VALUE onum_ceil(VALUE self)
{
    OCIError *errhp = oci8_errhp;
    OCINumber r;

    chkerr(OCINumberCeil(errhp, _NUMBER(self), &r));
    return oci8_make_integer(&r, errhp);
}

#dump ⇒ String

Returns internal representation whose format is same with the return value of Oracle SQL function DUMP.

Examples:

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"

Returns:

Since:

  • 2.0.4



1542
1543
1544
1545
1546
1547
 
# File 'ext/oci8/ocinumber.c', line 1542

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);
}

#floor ⇒ Integer

Returns the largest Integer less than or equal to self.

Examples:

OraNumber(11.1).floor  # => 11
OraNumber(25.8).floor  # => 25
OraNumber(-25.8).floor # => -26

Returns:

  • (Integer) 


1145
1146
1147
1148
1149
1150
1151
1152
 
# File 'ext/oci8/ocinumber.c', line 1145

static VALUE onum_floor(VALUE self)
{
    OCIError *errhp = oci8_errhp;
    OCINumber r;

    chkerr(OCINumberFloor(errhp, _NUMBER(self), &r));
    return oci8_make_integer(&r, errhp);
}

#has_fractional_part? ⇒ Boolean

Returns true if self has a fractional part.

Examples:

OraNumber(10).has_fractional_part?   # => false
OraNumber(10.1).has_fractional_part? # => true

Since:

  • 2.2.5

Returns:

  • (Boolean) 


1454
1455
1456
1457
1458
1459
1460
1461
 
# File 'ext/oci8/ocinumber.c', line 1454

static VALUE onum_has_fractional_part_p(VALUE self)
{
    OCIError *errhp = oci8_errhp;
    boolean result;

    chkerr(OCINumberIsInt(errhp, _NUMBER(self), &result));
    return result ? Qfalse : Qtrue;
}

#initialize_copy(obj) ⇒ Object

Replaces self with obj. Object#clone and Object#dup call this method to copy data unknown by the ruby interpreter.

Parameters:



809
810
811
812
813
814
815
816
817
 
# File 'ext/oci8/ocinumber.c', line 809

static VALUE onum_initialize_copy(VALUE lhs, VALUE rhs)
{
    if (!RTEST(rb_obj_is_instance_of(rhs, CLASS_OF(lhs)))) {
        rb_raise(rb_eTypeError, "invalid type: expected %s but %s",
                 rb_class2name(CLASS_OF(lhs)), rb_class2name(CLASS_OF(rhs)));
    }
    chkerr(OCINumberAssign(oci8_errhp, _NUMBER(rhs), _NUMBER(lhs)));
    return lhs;
}

#round ⇒ Integer #round(decplace) ⇒ OraNumber

Overloads:

  • #round ⇒ Integer

    Rounds self to the nearest Integer.

    Examples:

    OraNumber(1.49).round     # => 1
OraNumber(1.5).round      # => 2
OraNumber(-1.49).round    # => -1
OraNumber(-1.5).round     # => -2

    Returns:

    • (Integer)
  • #round(decplace) ⇒ OraNumber

    Rounds onum to a specified decimal place decplace.

    Examples:

    OraNumber(123.456).round(2)   # => #<OraNumber:123.46>
OraNumber(123.456).round(1)   # => #<OraNumber:123.5>
OraNumber(123.456).round(0)   # => #<OraNumber:123>
OraNumber(123.456).round(-1)  # => #<OraNumber:120>

    Parameters:

    • decplace (Integer)

    Returns:



1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
 
# File 'ext/oci8/ocinumber.c', line 1201

static VALUE onum_round(int argc, VALUE *argv, VALUE self)
{
    OCIError *errhp = oci8_errhp;
    VALUE decplace;
    OCINumber r;

    rb_scan_args(argc, argv, "01", &decplace /* 0 */);
    chkerr(OCINumberRound(errhp, _NUMBER(self), NIL_P(decplace) ? 0 : NUM2INT(decplace), &r));
    if (argc == 0) {
        return oci8_make_integer(&r, errhp);
    } else {
        return oci8_make_ocinumber(&r, errhp);
    }
}

#round_prec(digits) ⇒ OraNumber

Rounds self to a specified number of decimal digits. This method is available on Oracle 8.1 client or upper.

Examples:

OraNumber(1.234).round_prec(2) # => #<OraNumber:1.2>
OraNumber(12.34).round_prec(2) # => #<OraNumber:12>
OraNumber(123.4).round_prec(2) # => #<OraNumber:120>

Parameters:

  • digits (Integer)

Returns:



1261
1262
1263
1264
1265
1266
1267
1268
 
# File 'ext/oci8/ocinumber.c', line 1261

static VALUE onum_round_prec(VALUE self, VALUE ndigs)
{
    OCIError *errhp = oci8_errhp;
    OCINumber r;

    chkerr(OCINumberPrec(errhp, _NUMBER(self), NUM2INT(ndigs), &r));
    return oci8_make_ocinumber(&r, errhp);
}

#shift(ndigits) ⇒ OraNumber

Returns self shifted by ndigits This method is available on Oracle 8.1 client or upper.

Examples:

OraNumber(123).shift(3)  # => #<OraNumber:123000>
OraNumber(123).shift(-3) # => #<OraNumber:0.123>

Parameters:

  • ndigits (Integer)

Returns:



1519
1520
1521
1522
1523
1524
1525
1526
 
# File 'ext/oci8/ocinumber.c', line 1519

static VALUE onum_shift(VALUE self, VALUE exp)
{
    OCIError *errhp = oci8_errhp;
    OCINumber result;

    chkerr(OCINumberShift(errhp, _NUMBER(self), NUM2INT(exp), &result));
    return oci8_make_ocinumber(&result, errhp);
}

#onum.to_char(fmt = nil, nlsparam = nil) ⇒ String

Returns a string containing a representation of self. fmt and nlsparam are used as Oracle SQL function TO_CHAR(number) does.

Examples:

OraNumber(123456.789).to_char('FM999,999,999.999')  # => "123,456.789"
OraNumber(123456.789).to_char('FM999G999G999D999',  "NLS_NUMERIC_CHARACTERS = ',.'") # => "123.456,789"

Parameters:

  • fmt (String) (defaults to: nil)
  • nlsparam (String) (defaults to: nil)

Returns:



1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
 
# File 'ext/oci8/ocinumber.c', line 1286

static VALUE onum_to_char(int argc, VALUE *argv, VALUE self)
{
    OCIError *errhp = oci8_errhp;
    VALUE fmt;
    VALUE nls_params;
    char buf[512];
    ub4 buf_size = sizeof(buf);
    oratext *fmt_ptr;
    oratext *nls_params_ptr;
    ub4 fmt_len;
    ub4 nls_params_len;
    sword rv;

    rb_scan_args(argc, argv, "02", &fmt /* nil */, &nls_params /* nil */);
    if (NIL_P(fmt)) {
        rv = oranumber_to_str(_NUMBER(self), buf, sizeof(buf));
        if (rv > 0) {
            return rb_usascii_str_new(buf, rv);
        }
        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;
    } else {
        StringValue(nls_params);
        nls_params_ptr = RSTRING_ORATEXT(nls_params);
        nls_params_len = RSTRING_LEN(nls_params);
    }
    rv = OCINumberToText(errhp, _NUMBER(self),
                         fmt_ptr, fmt_len, nls_params_ptr, nls_params_len,
                         &buf_size, TO_ORATEXT(buf));
    if (rv == OCI_ERROR) {
        sb4 errcode;
        OCIErrorGet(errhp, 1, NULL, &errcode, NULL, 0, OCI_HTYPE_ERROR);
        if (errcode == 22065) {
            /* OCI-22065: number to text translation for the given format causes overflow */
            if (NIL_P(fmt)) /* implicit conversion */
                return rb_usascii_str_new_cstr("overflow");
        }
        chkerr(rv);
    }
    return rb_usascii_str_new(buf, buf_size);
}

#to_d ⇒ BigDecimal

Returns self as a BigDecimal.

Returns:

  • (BigDecimal) 


1422
1423
1424
1425
 
# File 'ext/oci8/ocinumber.c', line 1422

static VALUE onum_to_d(VALUE self)
{
    return onum_to_d_real(_NUMBER(self), oci8_errhp);
}

#to_f ⇒ Float

Converts self to Float.

When OCI8.properties [:float_conversion_type] is :ruby, self is converted by self.to_s.to_f. When it is :oracle, self is converted by the Oracle OCI function OCINumberToReal().

Returns:

  • (Float) 


1375
1376
1377
1378
 
# File 'ext/oci8/ocinumber.c', line 1375

static VALUE onum_to_f(VALUE self)
{
    return rb_float_new(oci8_onum_to_dbl(_NUMBER(self), oci8_errhp));
}

#to_i ⇒ Integer

Returns self truncated to an Integer.

Returns:

  • (Integer) 


1356
1357
1358
1359
1360
1361
1362
1363
 
# File 'ext/oci8/ocinumber.c', line 1356

static VALUE onum_to_i(VALUE self)
{
    OCIError *errhp = oci8_errhp;
    OCINumber num;

    chkerr(OCINumberTrunc(errhp, _NUMBER(self), 0, &num));
    return oci8_make_integer(&num, errhp);
}

#to_onum ⇒ OraNumber

Returns self.

Returns:



1470
1471
1472
1473
 
# File 'ext/oci8/ocinumber.c', line 1470

static VALUE onum_to_onum(VALUE self)
{
    return self;
}

#to_r ⇒ Rational

Returns self as a Rational.

Returns:

  • (Rational) 


1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
 
# File 'ext/oci8/ocinumber.c', line 1387

static VALUE onum_to_r(VALUE self)
{
    VALUE x, y;
    int nshift = 0;
    OCINumber onum[2];
    int current = 0;
    boolean is_int;

    chkerr(OCINumberAssign(oci8_errhp, _NUMBER(self), &onum[0]));

    for (;;) {
        chkerr(OCINumberIsInt(oci8_errhp, &onum[current], &is_int));
        if (is_int) {
            break;
        }
        nshift++;
        chkerr(OCINumberShift(oci8_errhp, &onum[current], 1, &onum[1 - current]));
        current = 1 - current;
    }
    x = oci8_make_integer(&onum[current], oci8_errhp);
    if (nshift == 0) {
        y = INT2FIX(1);
    } else {
        y = rb_funcall(INT2FIX(10), rb_intern("**"), 1, INT2FIX(nshift));
    }
    return rb_Rational(x, y);
}

#to_s ⇒ String

Returns a string containing a representation of self.

Returns:

See Also:



1344
1345
1346
1347
 
# File 'ext/oci8/ocinumber.c', line 1344

static VALUE onum_to_s(VALUE self)
{
    return onum_to_char(0, NULL, self);
}

#truncate(decplace = 0) ⇒ OraNumber

TODO:

returns Integer when decplace is not specified.

Truncates self to a specified decimal place decplace.

Examples:

OraNumber(123.456).truncate      # => #<OraNumber:123>
OraNumber(123.456).truncate(1)   # => #<OraNumber:123.4>
OraNumber(123.456).truncate(2)   # => #<OraNumber:123.45>
OraNumber(123.456).truncate(-1)  # => #<OraNumber:120>

OraNumber(-123.456).truncate     # => #<OraNumber:-123>
OraNumber(-123.456).truncate(1)  # => #<OraNumber:-123.4>
OraNumber(-123.456).truncate(2)  # => #<OraNumber:-123.45>
OraNumber(-123.456).truncate(-1) # => #<OraNumber:-120>

Parameters:

  • decplace (Integer) (defaults to: 0)

Returns:



1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
 
# File 'ext/oci8/ocinumber.c', line 1236

static VALUE onum_trunc(int argc, VALUE *argv, VALUE self)
{
    OCIError *errhp = oci8_errhp;
    VALUE decplace;
    OCINumber r;

    rb_scan_args(argc, argv, "01", &decplace /* 0 */);
    chkerr(OCINumberTrunc(errhp, _NUMBER(self), NIL_P(decplace) ? 0 : NUM2INT(decplace), &r));
    return oci8_make_ocinumber(&r, errhp);
}

#zero? ⇒ Boolean

Returns true if self is zero.

Returns:

  • (Boolean) 


1481
1482
1483
1484
1485
1486
1487
1488
 
# File 'ext/oci8/ocinumber.c', line 1481

static VALUE onum_zero_p(VALUE self)
{
    OCIError *errhp = oci8_errhp;
    boolean result;

    chkerr(OCINumberIsZero(errhp, _NUMBER(self), &result));
    return result ? Qtrue : Qfalse;
}