How does implicit conversions occur in sqlite? - sqlite

Question

In SQLite, dynamic typing is used and implicit conversions are done in expressions. For example
SELECT (3 < 2); -- false
SELECT (3 < '2'); -- true (what's happning here?)
SELECT ('3' < '2'); -- false
SELECT (3 < 20); -- true
SELECT (3 < '20'); -- true (what's happning here?)
SELECT ('3' < '20'); -- false
But the official documentation and the O'REILLY book Using SQLite say nothing about how operands are casted in implicit conversions.
In C++, Standard strictly defines (i.e. explicitly explains) how implicit conversions occur. For example, if either operand is of the type long double, another operand is casted to long double.
Is there such a rule in SQLite?

Answer 1

From Datatypes In SQLite Version 3/4.1. Sort Order:
An INTEGER or REAL value is less than any TEXT or BLOB value.
Obviously:
SELECT TYPEOF(3);
returns integer
and
SELECT TYPEOF('2');
SELECT TYPEOF('20');
return text.
So there is no conversion here:
SELECT 3 < '2';
which returns true.
But there is an implicit conversion in an expression like this:
SELECT 3 < '2' + 0;
which returns false and this conversion is forced by the operator + which applies a numeric operation to '2' thus converting it to an integer.
Edit to clarify:
This behavior applies only to literal values like 3 and '2'.
When it comes to expressions or column values then an implicit conversion does happen.
So if you define a table like:
create table test(id integer);
insert into test(id) values (1), (2), (3);
a statement like:
select * from test where id > '1'
will return:
| id |
| --- |
| 2 |
| 3 |
see the demo.

Answer 2

Implicit conversions sometimes occur but sometimes don't. The conditions which determine whether conversions are done before comparisons are described in 4.2. Type Conversions Prior To Comparison. According to the section,
Affinity is applied to operands of a comparison operator prior to the comparison according to the following rules in the order shown:
If one operand has INTEGER, REAL or NUMERIC affinity and the other operand has TEXT or BLOB or no affinity then NUMERIC affinity is applied to other operand.
If one operand has TEXT affinity and the other has no affinity, then TEXT affinity is applied to the other operand.
Otherwise, no affinity is applied and both operands are compared as is.
But how is the type affinity of an expression (including literals) defined? It is explained in 3.2. Affinity Of Expressions as
Every table column has a type affinity (one of BLOB, TEXT, INTEGER, REAL, or NUMERIC) but expressions do no necessarily have an affinity.
Expression affinity is determined by the following rules:
The right-hand operand of an IN or NOT IN operator has no affinity if the operand is a list and has the same affinity as the affinity of the result set expression if the operand is a SELECT.
When an expression is a simple reference to a column of a real table (not a VIEW or subquery) then the expression has the same affinity as the table column.
Parentheses around the column name are ignored. Hence if X and Y.Z are column names, then (X) and (Y.Z) are also considered column names and have the affinity of the corresponding columns.
Any operators applied to column names, including the no-op unary "+" operator, convert the column name into an expression which always has no affinity. Hence even if X and Y.Z are column names, the expressions +X and +Y.Z are not column names and have no affinity.
An expression of the form "CAST(expr AS type)" has an affinity that is the same as a column with a declared type of "type".
A COLLATE operator has the same affinity as its left-hand side operand.
Otherwise, an expression has no affinity.
So in the cases of examples in OP, literals have no affinity and are thus compared as-is. Since
An INTEGER or REAL value is less than any TEXT or BLOB value.
as pointed out in forpas's answer, 3 < '2' returns true.
These rules correctly describes apparently strange behavior referred to in this comment. CAST ('1' AS INTEGER) does have the type affinity INTEGER so that >= '1' is interpreted as >= 1 and thus CAST ('1' AS INTEGER) >= '1' returns true whereas 1 >= '1' returns false.