Booleans API Functions into SQL SELECT

Question

Hello,
our API is using a huge set of boolean «is_{what we want to check}» functions. These simple atomic functions are used into more sophisticated PL/SQL funcs or procs.
Sometime, we need to use these bool funcs directly into our SQL queries.
Here is a simplified example we want:
SELECT id1, id2, is_valid(id1, id2)
FROM table
WHERE ... stuff ...;
or
SELECT col1, col2, ...
FROM table
WHERE is_valid(id1, id2) IS TRUE ;
or
SELECT col1, col2, ...
FROM table
WHERE is_valid(id1, id2) = TRUE ;
to be valid queries....
I know that booleans aren't supported natively in the SQL, I created a function that translate bool to char:
FUNCTION bool_to_char (p_bool IN BOOLEAN)
RETURN VARCHAR2
IS
v_retour VARCHAR2 (5);
BEGIN
v_retour := CASE p_bool
WHEN TRUE
THEN 'TRUE'
WHEN FALSE
THEN 'FALSE'
END;
RETURN v_retour;
END;
So, when I call this func into my sql, it's not working anymore:
SELECT id1, id2, bool_to_char(is_valid(id1, id2))
FROM table
WHERE ... stuff ...;
or
SELECT col1, col2, ...
FROM table
WHERE bool_to_char(is_valid(id1, id2)) = 'TRUE';
I'm searching for a solution to make this possible... The only fast solution that came in my mind is to encapsulate every boolean functions to return a corresponding varchar value. Not that good....
Any ideas or suggestions?

Answer 1

SQL standards have been developed over the years and whilst some vendors have tweaked SQL functionality to make their database better than others, one thing that is not part of SQL standards is support for BOOLEAN. 3GL and 4GL languages most often support boolean values, which are represented internally as a binary number.
For those interested, in some languages the BOOLEAN is represented as -1 for TRUE and 0 for FALSE. In binary, -1 is represented as all the bits set to 1 whilst 0 is all the bits set to 0. There was a nice feature in one of the BASIC versions (I think it was BBC Basic if I remember correctly) that allowed you to use booleans within assignments such as...
x := y + (z AND (y < 100))If the "y<100" condition evaluated to TRUE, this would translate as...
x := y + (z AND TRUE)which, in binary terms (let's assume all numbers are single bytes for illustrative purposes) would be...
x := y + (z AND 11111111)The "z AND 11111111" would perform a logical AND between the z value and the binary 11111111 resulting in a value of z... giving...
x := y + zIf the condition evaluated to false on the other hand it would go as follows...
x := y + (z AND FALSE)
x := y + (z AND 00000000)So, "z AND 00000000" would logically AND to give a result of 0 and thus giving...
x := ySo it was useful to use in conditional arithmetic, avoiding having to put IF statements in the code.
Getting back to the thread...
Using PL/SQL functions so extensively in SQL is a bad idea as it will inevitably cause a lot of context switching between the SQL and PL/SQL engines. This will have a noticable effect on performance of queries. Where possible, if the test can be done within SQL, then it should be done there rather than calling PL/SQL.
;)