Distinction between int32 and int64 in SQLite (#369)

* Made distinction between INT32 and INT64 types in sqlite
* For statements when we know the declaration type, we make a distinction between INT32 and INT64 values
* This does not apply with `RETURNING` or implicit values, in these cases we don't know the decl type and we always return INT64
* This is work required for prisma/prisma#12784

Author: cprieto

src/connector/sqlite.rs

@@ -286,7 +286,7 @@ mod tests {
         let result = conn.select(select.clone()).await.unwrap();
         let result = result.into_single().unwrap();
 
-        assert_eq!(result.get("id").unwrap(), &Value::integer(1));
+        assert_eq!(result.get("id").unwrap(), &Value::int32(1));
         assert_eq!(result.get("txt").unwrap(), &Value::text("henlo"));
 
         // Check that we do get a separate, new database.

src/connector/sqlite/conversion.rs

@@ -1,3 +1,5 @@
+use std::convert::TryFrom;
+
 use crate::{
     ast::Value,
     connector::{
@@ -129,7 +131,9 @@ impl<'a> GetRow for SqliteRow<'a> {
         for (i, column) in self.columns().iter().enumerate() {
             let pv = match self.get_ref_unwrap(i) {
                 ValueRef::Null => match column {
-                    c if c.is_int32() | c.is_int64() | c.is_null() => Value::Int64(None),
+                    // NOTE: A value without decl_type would be Int32(None)
+                    c if c.is_int32() | c.is_null() => Value::Int32(None),
+                    c if c.is_int64() => Value::Int64(None),
                     c if c.is_text() => Value::Text(None),
                     c if c.is_bytes() => Value::Bytes(None),
                     c if c.is_float() => Value::Float(None),
@@ -148,29 +152,43 @@ impl<'a> GetRow for SqliteRow<'a> {
 
                             return Err(Error::builder(kind).build());
                         }
-                        None => Value::Int64(None),
+                        // When we don't know what to do, the default value would be Int32(None)
+                        None => Value::Int32(None),
                     },
                 },
-                ValueRef::Integer(i) => match column {
-                    c if c.is_bool() => {
-                        if i == 0 {
-                            Value::boolean(false)
-                        } else {
-                            Value::boolean(true)
+                ValueRef::Integer(i) => {
+                    match column {
+                        c if c.is_bool() => {
+                            if i == 0 {
+                                Value::boolean(false)
+                            } else {
+                                Value::boolean(true)
+                            }
                         }
+                        #[cfg(feature = "chrono")]
+                        c if c.is_date() => {
+                            let dt = chrono::NaiveDateTime::from_timestamp(i / 1000, 0);
+                            Value::date(dt.date())
+                        }
+                        #[cfg(feature = "chrono")]
+                        c if c.is_datetime() => {
+                            let dt = chrono::Utc.timestamp_millis(i);
+                            Value::datetime(dt)
+                        }
+                        c if c.is_int32() => {
+                            if let Ok(converted) = i32::try_from(i) {
+                                Value::int32(converted)
+                            } else {
+                                let msg = format!("Value {} does not fit in an INT column, try migrating the '{}' column type to BIGINT", i, c.name());
+                                let kind = ErrorKind::conversion(msg);
+
+                                return Err(Error::builder(kind).build());
+                            }
+                        }
+                        // NOTE: When SQLite does not know what type the return is (for example at explicit values and RETURNING statements) we will 'assume' int64
+                        _ => Value::int64(i),
                     }
-                    #[cfg(feature = "chrono")]
-                    c if c.is_date() => {
-                        let dt = chrono::NaiveDateTime::from_timestamp(i / 1000, 0);
-                        Value::date(dt.date())
-                    }
-                    #[cfg(feature = "chrono")]
-                    c if c.is_datetime() => {
-                        let dt = chrono::Utc.timestamp_millis(i);
-                        Value::datetime(dt)
-                    }
-                    _ => Value::int64(i),
-                },
+                }
                 #[cfg(feature = "bigdecimal")]
                 ValueRef::Real(f) if column.is_real() => {
                     use bigdecimal::{BigDecimal, FromPrimitive};