Campo booleano en Oracle

Ayer quería agregar un campo booleano a una tabla Oracle. Sin embargo, en realidad no hay un tipo de datos booleanos en Oracle. ¿Alguien aquí sabe la mejor manera de simular un booleano? Googleando el tema descubrió varios enfoques

1. Use un número entero y no se moleste en asignarle nada más que 0 o 1.

2. Use un campo de caracteres con 'Y' o 'N' como los únicos dos valores.

3. Use una enumeración con la restricción CHECK.

¿Los desarrolladores experimentados de Oracle saben qué enfoque es el preferido / canónico?

Encontré este enlace útil.

Aquí está el párrafo que destaca algunos de los pros / contras de cada enfoque.

El diseño más comúnmente visto es imitar las muchas banderas booleanas que usan las vistas del diccionario de datos de Oracle, seleccionando 'Y' para verdadero y 'N' para falso. Sin embargo, para interactuar correctamente con entornos host, como JDBC, OCCI y otros entornos de programación, es mejor seleccionar 0 para falso y 1 para verdadero para que pueda funcionar correctamente con las funciones getBoolean y setBoolean.

Básicamente abogan por el método número 2, por el bien de la eficiencia, utilizando

• valores de 0/1 (debido a la interoperabilidad con JDBC, getBoolean()etc.) con una restricción de verificación
• un tipo de CHAR (porque usa menos espacio que NUMBER).

Su ejemplo:

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

Oracle mismo usa Y / N para valores booleanos. Para completar, debe tenerse en cuenta que pl / sql tiene un tipo booleano, solo las tablas no lo tienen.

Si está utilizando el campo para indicar si el registro necesita ser procesado o no, puede considerar usar Y y NULL como valores. Esto genera un índice muy pequeño (lectura rápida) que ocupa muy poco espacio.

Para usar la menor cantidad de espacio, debe usar un campo CHAR restringido a 'Y' o 'N'. Oracle no es compatible con los tipos de datos BOOLEAN, BIT o TINYINT, por lo que el byte de CHAR es lo más pequeño posible.

La mejor opción es 0 y 1 (como números; otra respuesta sugiere 0 y 1 como CHAR para la eficiencia espacial, pero eso es demasiado retorcido para mí), usando NOT NULL y una restricción de verificación para limitar el contenido a esos valores. (Si necesita que la columna sea anulable, no se trata de un booleano sino de una enumeración con tres valores ...)

Ventajas de 0/1:

• Idioma independiente. 'Y' y 'N' estarían bien si todos lo usaran. Pero ellos no. En Francia usan 'O' y 'N' (lo he visto con mis propios ojos). No he programado en Finlandia para ver si usan 'E' y 'K' allí, sin duda son más inteligentes que eso, pero no puedes estar seguro.
• Congruente con la práctica en lenguajes de programación ampliamente utilizados (C, C ++, Perl, Javascript)
• Juega mejor con la capa de aplicación, por ejemplo, Hibernate
• Conduce a un SQL más conciso, por ejemplo, para descubrir cuántos plátanos están listos para comer en select sum(is_ripe) from bananaslugar de select count(*) from bananas where is_ripe = 'Y'o incluso (yuk)select sum(case is_ripe when 'Y' then 1 else 0) from bananas

Ventajas de 'Y' / 'N':

• Ocupa menos espacio que 0/1
• Es lo que sugiere Oracle, por lo que podría ser a lo que algunas personas están más acostumbradas

Otro póster sugería 'Y' / nulo para ganancias de rendimiento. Si ha demostrado que necesita el rendimiento, entonces es lo suficientemente justo, pero evítelo ya que hace que las consultas sean menos naturales (en some_column is nulllugar de some_column = 0) y en una unión izquierda combinará la falsedad con registros inexistentes.

Ya sea 1/0 o Y / N con una restricción de verificación. El camino del éter está bien. Personalmente prefiero 1/0 ya que hago mucho trabajo en perl, y hace que sea realmente fácil hacer operaciones booleanas en campos de bases de datos.

Si quieres una discusión realmente profunda de esta pregunta con uno de los principales jefes de Oracles, mira lo que Tom Kyte tiene para decir sobre esto Aquí

La base de datos en la que hice la mayor parte de mi trabajo utilizaba 'Y' / 'N' como booleanos. Con esa implementación, puedes realizar algunos trucos como:

1. Cuente las filas que son verdaderas:
   SELECCIONE SUMA (CASO CUANDO BOOLEAN_FLAG = 'Y' ENTONCES 1 OTRO 0) DESDE X

2. Al agrupar filas,
   imponga la lógica "Si una fila es verdadera, entonces todas son verdaderas": SELECCIONE MAX (BOOLEAN_FLAG) DE Y
   Por el contrario, use MIN para forzar la agrupación falsa si una fila es falsa.

Un ejemplo de trabajo para implementar la respuesta aceptada agregando una columna "booleana" a una tabla existente en una base de datos Oracle (usando el numbertipo):

ALTER TABLE my_table_name ADD (
my_new_boolean_column number(1) DEFAULT 0 NOT NULL
CONSTRAINT my_new_boolean_column CHECK (my_new_boolean_column in (1,0))
);

Esto crea una nueva columna en my_table_namellamada my_new_boolean_columncon valores predeterminados de 0. La columna no aceptará NULLvalores y restringirá los valores aceptados a cualquiera 0o 1.

En nuestras bases de datos usamos una enumeración que asegura que la pasemos VERDADERO o FALSO. Si lo hace en cualquiera de las dos primeras formas, es demasiado fácil comenzar a agregar un nuevo significado al entero sin pasar por un diseño adecuado, o terminar con ese campo de caracteres que tiene Y, y, N, n, T, t, F, f valores y tener que recordar qué sección de código usa qué tabla y qué versión de true está usando.