How-to: Oracle Datatypes

Data types for Oracle 8 to Oracle 19.

Notes and Examples

VARCHAR2:
Storing character data as Varchar2 will save space:

Store 'SMITH' not 'SMITH     '

Oracle9i and above allow Varchar2 columns to be defined as a number of bytes VARCHAR2(50 BYTE) or a number of characters VARCHAR2(50 CHAR), the latter is useful if the database is ever converted to run a double-byte character set (such as Japanese), you won’t have to edit the column sizes. The default measure, normally BYTE, is set with nls_length_semantics.

If you create a column as Varchar2 (50) but only store 10 bytes, then Oracle will only save 10 bytes to disk. This does not mean that you should just create Varchar2 (4000) columns 'just in case the space is needed', that is a really bad idea which will reduce the performance and maintainability of your application.

CHAR:
Over time, when varchar2 columns are updated they will sometimes create chained rows, CHAR columns are fixed width they are not affected by this, so less DBA effort is required to maintain performance.

PL/SQL
When retrieving data for a NUMBER column, consider using the PL/SQL datatype: PLS_INTEGER for better performance.

LONG
Use BLOB instead of LONG

INTEGER
This ANSI datatype will be accepted by Oracle - it is actually a synonym for NUMBER(38)

The FLOAT datatype
This ANSI datatype will be accepted by Oracle - Very similar to NUMBER it stores zero, positive, and negative floating-point numbers

The NUMBER datatype
Stores zero, positive, and negative numbers, fixed or floating-point numbers

Fixed-point NUMBER
NUMBER(p,s)
precision p = length of the number in digits
scale s = places after the decimal point, or (for negative scale values) significant places before the decimal point.

Integer NUMBER
NUMBER(p)
This is a fixed-point number with precision p and scale 0. Equivalent to NUMBER(p,0)

Floating-Point NUMBER
NUMBER
floating-point number with decimal precision 38

PRECISION and SCALE

Oracle stores all numeric data in variable length format - storage space is therefore dependent on the length of all the individual values stored in the table. Precision and scale settings do not affect storage requirements. SCALE might appear to be truncating data, but Oracle does still store the entire number as typed.

PRECISION can be used to constrain input values.

If a column is defined like CREATE TABLE demo ( empid number(4) ); then an attempt to insert a 5 digit number 10045 will fail. If you need to constrain values to a specific range of numbers (e.g. <85 rather than the round number <100), then add a column constraint .

Note that the Units of measure for PRECISION are different if the datatype is FLOAT:

For NUMBER data types: precision p = Number of Digits
For FLOAT data types: precision p = Binary Precision (multiply by 0.30103 to convert)

So FLOAT = FLOAT (126) = 126 x 0.30103 = approx 37.9 digits of precision.

In theory it is possible to save storage space by having an application truncate a fractional value before inserting into a table, but you would have to be very sure the business logic made sense. This would have to be done at the application level.

If a table is created without any Precision/Scale CREATE TABLE demo ( empid number ); then the column will store values as given. When no scale is specified, the scale is zero.

Function parameters

Oracle does not allow a specific precision for function parameters, only type of the variable. This means that a parameter defined as integer or number(38) can accept fractional values. if you want to have an integer passed to a procedure/function, use pls_integer instead of integer.

Alternatively reassigning to a variable within the procedure will force Oracle to implicitly convert the datatype and precision to match the variable, thie requires a slightly different definition, e.g. number(37) .

Example

    The value 7456123.89 will display as follows

NUMBER        7456123.89 
NUMBER(9)     7456124 
NUMBER(9,1)   7456123.9
NUMBER(*,1)   7456123.9    
NUMBER(9,2)   7456123.89 
NUMBER(6)    [not accepted exceeds precision] 
NUMBER(7,-2)  7456100 
FLOAT         7456123.89 
FLOAT(12)     7456000.0

Select COLUMN_NAME, DATA_TYPE, DATA_LENGTH, DATA_PRECISION, DATA_SCALE
From cols Where table_name = 'Your_Table';

Varchar2 memory allocation

For a CHAR variable, PL/SQL allocates at compile time enough memory for the maximum size.

For a VARCHAR2 variable, memory allocation depends on the variables maximum size:

• If the maximum size is less than 4,000 bytes, PL/SQL allocates at compile time enough memory for the maximum size.
• If the maximum size is 4,000 bytes or more, PL/SQL allocates at run time enough memory for the actual value.
• (Prior to Oracle 11g Release 2 the cutover value was 2,000 bytes instead of 4,000)

In this way, PL/SQL optimizes smaller VARCHAR2 variables for performance and larger ones for efficient memory use.

For example, if you assign the same 500-byte value to VARCHAR2(3999 BYTE) and VARCHAR2(4000 BYTE) variables, PL/SQL allocates 3999 bytes for the former variable at compile time and 500 bytes for the latter variable at run time.

Boolean data

You can store boolean values as a one digit Oracle CHAR, rather than NUMBER.

Create TABLE my_demo (accountcode NUMBER, postableYN CHAR check (postableYN in (0,1)) );

-- Standard Boolean values: False=0 and True=1
Insert into my_demo values(525, '1');
Insert into my_demo values(526, '0');

Select accountcode, decode(postableYN,1,'True',0,'False') FROM my_demo;

-- or in French:
Select accountcode, decode(postableYN,1,'Vrai',0,'Faux') FROM my_demo;

An old space-saving trick was storing 'Y' and 'N', this requires no more (but also no less) than storing 0 and 1 but saves you the effort of writing a decode statement to display it. Of course if/when the application has to support other languages then you will need to add the decode anyway.

Comparison with other RDBMS's

Also consider the maximum length of a table name (or column name) and the maximum size of an SQL statement - these limits vary considerably between products and versions.

“Computer programmers do it byte by byte”

Related

Data Types - SQL Server