Maximum NUMBER Precision

What’s the maximum precision for the NUMBER data type? For many years I believed it to be 38. Afterall, it’s in the documentation under the Datatype Limits of the Reference manual:

38 significant digits

We can easily test this out (the following on a 12.1.0.2 database):

```SQL>CREATE TABLE table_a
2     (val    NUMBER(38,0))
3  /

Table created.

SQL>CREATE TABLE table_b
2     (val    NUMBER(39,0))
3  /
(val    NUMBER(39,0))
*
ERROR at line 2:
ORA-01727: numeric precision specifier is out of range (1 to 38)
```

and see that we cannot create a NUMBER (39,0) column. However, what happens if we leave the precision off the data type and insert some really big numbers into it (38 to 42 digits):

```SQL>CREATE TABLE table_c
2     (val    NUMBER)
3  /

Table created.

SQL>INSERT INTO table_c
2  VALUES (99999999999999999999999999999999999999)
3  /

1 row created.

SQL>INSERT INTO table_c
2  VALUES (999999999999999999999999999999999999999)
3  /

1 row created.

SQL>INSERT INTO table_c
2  VALUES (9999999999999999999999999999999999999999)
3  /

1 row created.

SQL>INSERT INTO table_c
2  VALUES (99999999999999999999999999999999999999999)
3  /

1 row created.

SQL>INSERT INTO table_c
2  VALUES (999999999999999999999999999999999999999999)
3  /

1 row created.

SQL>COMMIT
2  /

Commit complete.
```

All values were accepted by the INSERT statements so let’s now see what we’ve ended up with in our table:

```SQL>COLUMN VAL FORMAT 9999999999999999999999999999999999999999999

SQL>SELECT val
2  ,      LENGTH(TO_CHAR(val)) AS length_val
3  FROM   table_c
4  /

VAL LENGTH_VAL
-------------------------------------------- ----------
99999999999999999999999999999999999999         38
999999999999999999999999999999999999999         39
9999999999999999999999999999999999999999         40
100000000000000000000000000000000000000000         40
1000000000000000000000000000000000000000000         40
```

It would appear that we can actually get 40 digits of precision into a NUMBER data type even though we cannot define it to be NUMBER(40,0). After 40 digits Oracle approximates the number, using 40 significant digits.

A careful read of the Oracle SQL Reference documentation confirms this behaviour:

NUMBER(p,s)

where:

• p is the precision, or the maximum number of significant decimal digits, where the most significant digit is the left-most nonzero digit, and the least significant digit is the right-most known digit. Oracle guarantees the portability of numbers with precision of up to 20 base-100 digits, which is equivalent to 39 or 40 decimal digits depending on the position of the decimal point.
• s is the scale, or the number of digits from the decimal point to the least significant digit. The scale can range from -84 to 127.
• Positive scale is the number of significant digits to the right of the decimal point to and including the least significant digit.
• Negative scale is the number of significant digits to the left of the decimal point, to but not including the least significant digit. For negative scale the least significant digit is on the left side of the decimal point, because the actual data is rounded to the specified number of places to the left of the decimal point. For example, a specification of (10,-2) means to round to hundreds.

Interesting to know. However, NUMBER(38) is going to be satisfactory for virtually all practical purposes… except if you need to store an IPv6 address in decimal form.

Following on from some recent questions this post goes back to basics with regard to what Oracle terms “multi-versioning read consistency”. I have posted on this subject before but as it’s so critical to how applications using Oracle will behave it’s worth another post, with emphasis on a very important point at the end…

“Multi-versioning read consistency” might appear to be just a rather grand sounding name (or another bit of techno-jargon) so here’s a brief outline of what it means:

• The data reurned by a query is based on what the data in the underlying tables contained when the query commenced
• By extension of the above point, the query is not impacted by changes to the table data over the time taken to execute and retrieve the query data

It’s time for an example to illustrate this. First we’ll set up a simple table, TAB, and insert a single row:

```CREATE TABLE tab
(id  NUMBER(6) NOT NULL)
/

INSERT INTO tab
VALUES (1);

COMMIT;
```

Next we’ll open a cursor that returns the data in TAB but we won’t actually retrieve the data yet.

```VARIABLE rc1 REFCURSOR

BEGIN
OPEN :rc1
FOR
SELECT *
FROM   tab
ORDER  BY id;
END;
/
```

Let’s head back to our table and do some data changes. We’ll do these changes as autonomous transactions so as to simulate an external process coming in and making these changes, removed from the session with the open cursor:

```DECLARE
PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
UPDATE tab
SET id = 2;

INSERT INTO tab
VALUES (2);

COMMIT;
END;
/
```

… and once again open a new cursor onto our table:

```VARIABLE rc2 REFCURSOR

BEGIN
OPEN :rc2
FOR
SELECT *
FROM   tab
ORDER  BY id;
END;
/
```

Lastly, just to reinforce things, we’ll do the whole thing yet again followed by a last update:

```DECLARE
PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
UPDATE tab
SET id = 3;

INSERT INTO tab
VALUES (3);

COMMIT;
END;
/

VARIABLE rc3 REFCURSOR

BEGIN
OPEN :rc3
FOR
SELECT *
FROM   tab
ORDER  BY id;
END;
/

DECLARE
PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
UPDATE tab
SET id = 4;

INSERT INTO tab
VALUES (4);

COMMIT;
END;
/
```

At the end of all this we have performed 4 inserts and 3 updates to our data. If we display the contents of our table as it exists at the end of the changes we get:

```SQL> SELECT *
2  FROM   tab
3  ORDER BY id;

ID
----------
4
4
4
4
```

Now let’s retrieve the data from our cursors and see what they contain:

```SQL> PRINT rc1

ID
----------
1

SQL> PRINT rc2

ID
----------
2
2

SQL> PRINT rc3

ID
----------
3
3
3
```

Even though the data in the table had changed and was committed after we opened the cursors Oracle still returned the data as it was at the point in time we opened the cursor, not what the table contained when we read from the cursor. This is Oracle’s multi-versioning read consistency in action.

Now for that very important point that I mentioned at the start…

The above exercise also highlights another aspect of Oracle:

Readers and writers don’t block each other.

If you look closely at the example, whilst we were holding open cursors to the table we were still able to update existing rows as well as insert new ones. No locks on the table data were being held by the cursors to prevent this… yet the data returned by the cursors were still as the table looked when the cursor was opened. This is a fundamental of how Oracle works. If you want to build a system that is performant under high levels of concurrent activity this is exactly the behaviour you will require.