Make FromSql strongly typed about rusqlite HOT 4 CLOSED

This is described as a feature of SQLite. I'm not really a fan either, but I don't think there's anything we can do on the Rust side since that's just how SQLite works. That FAQ is talking about insertion, but it makes the problem clear for FromSql too - if you can store strings into a column you claimed was an Integer, you can also get strings out of a column that claims to be an Integer.

The relevant section of the C API is documented at https://www.sqlite.org/c3ref/column_blob.html. We could, in theory, call sqlite3_column_type and check the declared storage type against the FromSql implementor type, but this has at least 3 problems:

• We'd be blocking the (admittedly sketchy in Rust, probably) use case documented in the FAQ above.
• We'd be blocking the automatic conversions SQLite can do (e.g., if you store "1234" in a string column and ask for the value as an int, you'll get 1234 as an int).
• Columns might be declared with no type information at all; this is perfectly legal in SQLite:

create table foo(x);
insert into foo(x) values(1234);
insert into foo(x) values('hello');

We could expose sqlite3_column_type in the Rust API, though, and then you could use that to do checks if you wanted. Would that be sufficient for what you're trying to do?

from rusqlite.

What if you provided both the unsafe API (as currently implemented) and a safe API that fails in those three cases you mentioned? Then people who want the extra features can use the unsafe API (probably fine to leave this as get), and people who want the type checks can opt into it (name would be get_safe or something similar).

from rusqlite.

Yeah, that seems reasonable. What would you think about an API like this:

1. Add a new method to FromSql which allows implementors to report whether the column is a valid type for themselves. Default to true, which is the current behavior.

pub trait FromSql {
    unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> SqliteResult<Self>;

    // implementors can override this and use sqlite3_column_type to reject conversion
    // when using get_checked
    unsafe fn is_valid_column_type(stmt: *mut sqlite3_stmt, col: c_int) -> bool {
        true
    }
}

1. Add get_checked to SqliteRow, returning a Result that would be Err if is_valid_column_type returns false.

from rusqlite.

Sure, sounds good.

from rusqlite.