首页 > Linux操作系统 > Linux操作系统 > oracle中dump函数及oracle NUMBER类型内部存储机制

oracle中dump函数及oracle NUMBER类型内部存储机制

原创 Linux操作系统 作者:gaopengtttt 时间:2009-04-21 11:30:48 0 删除 编辑




类型 <[长度]>,符号/指数位 [数字1,数字2,数字3,......,数字20]


1.类型: Number型,Type=2 (类型代码可以从Oracle的文档上查到)






正数:指数=符号/指数位 - 193 (最高位为1是代表正数)
负数:指数=62 - 第一字节




每个<数字位>乘以100^(指数-N) (N是有效位数的顺序位,第一个有效位的N=0)


SQL> select dump(123456.789) from dual;
Typ=2 Len=6: 195,13,35,57,79,91

<指数>:     195 - 193 = 2
<数字1>      13 - 1      = 12 *100^(2-0) 120000
<数字2>      35 - 1      = 34 *100^(2-1) 3400
<数字3>      57 - 1      = 56 *100^(2-2) 56
<数字4>      79 - 1      = 78 *100^(2-3) .78
<数字5>      91 - 1      = 90 *100^(2-4) .009

SQL> select dump(-123456.789) from dual;
Typ=2 Len=7: 60,89,67,45,23,11,102

<指数>       62 - 60 = 2(最高位是0,代表为负数)
<数字1> 101 - 89 = 12 *100^(2-0) 120000
<数字2> 101 - 67 = 34 *100^(2-1) 3400
<数字3> 101 - 45 = 56 *100^(2-2) 56
<数字4> 101 - 23 = 78 *100^(2-3) .78
<数字5> 101 - 11 = 90 *100^(2-4) .009








Internal representation of the NUMBER datatype

As with other datatypes, stored numbers are preceded by a length byte which stores the size of the datum in bytes, or 0xFF for NULLs. The actual data bytes for non-null numbers represent the value in scientific notation. For example, the number 12.3 is represented as +0.123 * 10². The high order bit of the first byte represents the sign. The sign bit is set for positive numbers; and clear for negative numbers. The remainder of the first byte represents the exponent, and then up to 20 bytes may be used to represent the significant digits excluding trailing zeros. This is sometimes called the mantissa.

Each byte of the mantissa normally represents two decimal digits. For positive numbers an offset of 1 is added to avoid null bytes, while for negative numbers an offset of 101 is added to the negated digit pair. Thus a mantissa byte with the decimal value of 100 might represent the digit pair "99" in a positive number, or the digit pair "01" in a negative number. The interpretation must be based on the sign bit. Negative numbers with less than 20 mantissa bytes also have a byte with the (impossible) decimal value 102 appended. I don't know what purpose this serves.

If there are an odd number of significant digits before the decimal point, the first mantissa byte can only represent 1 digit because the decimal exponent must be even. In this case, the 20-byte mantissa can represent at most 39 decimal digits. However, the last digit may not be accurate if a more precise value has been truncated for storage. This is why the maximum guaranteed precision for Oracle numbers is 38 decimal digits, even though 40 digits can be represented.

The decimal exponent is guaranteed to be even by the alignment of the mantissa. Thus the value stored for the exponent is always halved and is expressed such that the decimal point falls before the first digit of the mantissa. It again represents a pair of decimal digits, this time with an offset of 64 for positive numbers, and 63 for the negated exponent of negative numbers. Thus a set of exponent bits with the decimal value of 65 might represent the exponent +2 in a positive number, or the exponent -4 in a negative number. Please note that the encoding of the exponent is based on the sign of the number, and not on the sign of the exponent itself.

Finally, there are special encodings for zero, and positive and negative infinity. Zero is represented by the single byte 0x80. Negative infinity is represented by 0x00, and positive infinity is represented by the two bytes 0xFF65. These are illustrated in the listing below.

SQL> select n, dump(n,16) from special_numbers;

  N DUMP(N,16)
--- ------------------------------------------
  0 Typ=2 Len=1: 80
 -~ Typ=2 Len=1: 0
  ~ Typ=2 Len=2: ff,65

For the rest, the best way to familiarize yourself further with the internal representation of numbers is to use the dump function to examine the representation of some sample values. This is simulated below. Just type a number and then press "Enter" to check out its representation. For example, try to find out why 110 takes one more byte of storage than 1100 despite being a smaller number.

Normalized number: +0.1230 * 10^2
Sign bit:          1
Exponent bits:     65 = (64 + 2/2)
First byte:        193
Mantissa digits:   12,30
Mantissa bytes:    13,31

来自 “ ITPUB博客 ” ,链接:,如需转载,请注明出处,否则将追究法律责任。

wxh gp_22389860 <<深入理解MySQL主从原理专栏>> 发布 可加WX了解


  • 博文量
  • 访问量