Oracle Tip: Choosing an efficient design for Boolean column values

Takeaway: When designing a database table structure, it's important to choose an efficient strategy for storing a logical Boolean that you can use in many programming environments. Find out how from this Oracle expert.

When designing a database table structure, it's important to choose an efficient strategy for storing a logical Boolean that you can use in many programming environments. (Although Oracle doesn't come with a Boolean datatype for database columns, it does have a Boolean datatype in PL/SQL.)

Any Boolean-defined column should also be properly constrained by checks to make sure that only valid values are entered at insert/update time.

create table tbool (bool char check (bool in ('N','Y'));
insert into tbool values ('N');
insert into tbool values ('Y');

The most commonly seen design is to imitate the
many Boolean-like flags that Oracle's data dictionary views use,
selecting 'Y' for true and 'N' for false. However, to interact
correctly with host environments, such as JDBC, OCCI, and other
programming environments, it's better to select 0 for false and 1 for true so it can work
correctly with the getBoolean and setBoolean functions.

We could define a Boolean as NUMBER(1);
however, in Oracle's internal number format, 0 takes 1 byte and 1
takes 2 bytes after the length byte (so it's more efficient to
store it as CHAR). Even though the character is defined as CHAR,
SQL can convert and verify against actual numbers.

create table tbool (bool char check (bool in
(0,1));
insert into tbool values(0);
insert into tbool values(1);

Here is a Java example:

import java.sql.*;

public class bool
{
    public static void main(String[] args)
throws SQLException
    {
        try
        {
           
Class.forName("oracle.jdbc.driver.OracleDriver");
        }
        catch
(ClassNotFoundException e)
        {
            System.out.println("error:
driver not in CLASSPATH");
            return;

}
        Connection conn =
DriverManager.getConnection(
           
"jdbc:oracle:oci8:@","scott","tiger");
        Statement stmt =
conn.createStatement();
        ResultSet rset =
stmt.executeQuery("select bool from tbool");
        Boolean
bool;
        while
(rset.next())
        {
            if
(rset.getBoolean(1))
               
System.out.println("bool is true");
            else
System.out.println("bool is false");
        }
        rset.close();

stmt.close();

conn.close();

}
}

Also, in OCI, OCCI, and PRO/C, if the selected
value is requested as an integer (SQLT_INT or OCCIINT), it will
automatically convert into binary 0 or 1 by the client-side
libraries, which can be used as native Boolean values.

Here is the same sample in OCCI:

#include <string>
#include <iostream>
#include <occi.h>
using namespace oracle::occi;
using namespace std;

int main(int argc,char* argv[])
{
    bool b;
    Environment* env =
Environment::createEnvironment();
    try
    {
        Connection* conn =
env->createConnection("scott","tiger");
        Statement* stmt =
conn->createStatement("select bool from tbool");
        ResultSet* rset =
stmt->executeQuery();
        rset->setDataBuffer(1,&b,OCCIINT,sizeof(bool));

while
(rset->next())
        {
            if
(b) cout << "bool was true" << endl;
            else
cout << "bool was false" << endl;
        }
        stmt->closeResultSet(rset);

conn->terminateStatement(stmt);
        env->terminateConnection(conn);

}
    catch (SQLException e)
    {
        cout <<
e.what() << endl;
    }
    Environment::terminateEnvironment(env);
    return 0;
}

By using setDataBuffer with a C++ bool value,
the correct integer value gets bound to a C++ bool. Unfortunately,
there's no getBoolean in OCCI. Therefore, it may be more portable
to use an int or char, or use rset->getInt(1) instead
of binding. (Note: In my tests, there is apparently a bug in OCCI
where using getInt(1) on a CHAR column failed unless I used
to_number(bool) or bool+0.)

When creating a Boolean data column, you should
be careful to make sure that the column is properly "nullable." If
a column with two possible values isn't constrained with NOT NULL,
then you're allowing three possible values: true, false, and unknown. This is often not
what is intended and host languages environments must deal with the
possibility that NULL is returned. Either 2-value or 3-value may be
acceptable in certain circumstances. This SQL restricts a BOOLEAN
value to 2-values only:

create table tbool (bool char not null check (bool
in (0,1));

However, Oracle SQL still requires a condition
operator, so there's no way to get around testing for the actual
value being 1 or 0, although you can hide these values in a
standardization package. For instance, see how I can reuse/expose
the keywords true and false through a PL/SQL
package:

create or replace package bool
as
    subtype bool is char;
    function false return bool;
    function true return bool;
    function val(b bool) return
varchar2;
end bool;
/
show error

create or replace package body bool
as
    function false return bool
    is
    begin
        return 0;
    end false;
    --
    function true return bool
    is
    begin
        return 1;
    end true;
    --
    function val(b bool) return varchar2
    is
    begin
        if b = true
then
            return
'true';
        end if;
        return
'false';
    end val;
end bool;
/
show error

insert into tbool values(bool.false);
insert into tbool values(bool.true);

select bool.val(bool) from tbool where bool = bool.true;