Merge 'fix 24/48 bit width serial types parsing' from Nikita Sivukhin

For serial types 3 and 5 SQLite uses twos-complement representation of
24bit and 48bit widths integers. Limbo need to follow same

Reviewed-by: Jussi Saurio (@jussisaurio)

Closes #1020

Author: jussisaurio

core/storage/sqlite3_ondisk.rs

@@ -995,8 +995,11 @@ pub fn read_value(buf: &[u8], serial_type: &SerialType) -> Result<(OwnedValue, u
             if buf.len() < 3 {
                 crate::bail_corrupt_error!("Invalid BEInt24 value");
             }
+            let sign_extension = if buf[0] <= 127 { 0 } else { 255 };
             Ok((
-                OwnedValue::Integer(i32::from_be_bytes([0, buf[0], buf[1], buf[2]]) as i64),
+                OwnedValue::Integer(
+                    i32::from_be_bytes([sign_extension, buf[0], buf[1], buf[2]]) as i64
+                ),
                 3,
             ))
         }
@@ -1013,9 +1016,17 @@ pub fn read_value(buf: &[u8], serial_type: &SerialType) -> Result<(OwnedValue, u
             if buf.len() < 6 {
                 crate::bail_corrupt_error!("Invalid BEInt48 value");
             }
+            let sign_extension = if buf[0] <= 127 { 0 } else { 255 };
             Ok((
                 OwnedValue::Integer(i64::from_be_bytes([
-                    0, 0, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5],
+                    sign_extension,
+                    sign_extension,
+                    buf[0],
+                    buf[1],
+                    buf[2],
+                    buf[3],
+                    buf[4],
+                    buf[5],
                 ])),
                 6,
             ))
@@ -1419,6 +1430,18 @@ mod tests {
     #[case(&[], SerialType::ConstInt1, OwnedValue::Integer(1))]
     #[case(&[1, 2, 3], SerialType::Blob(3), OwnedValue::Blob(vec![1, 2, 3].into()))]
     #[case(&[65, 66, 67], SerialType::String(3), OwnedValue::build_text("ABC"))]
+    #[case(&[0x80], SerialType::Int8, OwnedValue::Integer(-128))]
+    #[case(&[0x80, 0], SerialType::BEInt16, OwnedValue::Integer(-32768))]
+    #[case(&[0x80, 0, 0], SerialType::BEInt24, OwnedValue::Integer(-8388608))]
+    #[case(&[0x80, 0, 0, 0], SerialType::BEInt32, OwnedValue::Integer(-2147483648))]
+    #[case(&[0x80, 0, 0, 0, 0, 0], SerialType::BEInt48, OwnedValue::Integer(-140737488355328))]
+    #[case(&[0x80, 0, 0, 0, 0, 0, 0, 0], SerialType::BEInt64, OwnedValue::Integer(-9223372036854775808))]
+    #[case(&[0x7f], SerialType::Int8, OwnedValue::Integer(127))]
+    #[case(&[0x7f, 0xff], SerialType::BEInt16, OwnedValue::Integer(32767))]
+    #[case(&[0x7f, 0xff, 0xff], SerialType::BEInt24, OwnedValue::Integer(8388607))]
+    #[case(&[0x7f, 0xff, 0xff, 0xff], SerialType::BEInt32, OwnedValue::Integer(2147483647))]
+    #[case(&[0x7f, 0xff, 0xff, 0xff, 0xff, 0xff], SerialType::BEInt48, OwnedValue::Integer(140737488355327))]
+    #[case(&[0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff], SerialType::BEInt64, OwnedValue::Integer(9223372036854775807))]
     fn test_read_value(
         #[case] buf: &[u8],
         #[case] serial_type: SerialType,

tests/integration/fuzz/grammar_generator.rs

@@ -26,7 +26,7 @@ pub enum SymbolType {
         random_length: usize,
     },
     Int {
-        range: Range<i32>,
+        range: Range<i64>,
     },
     #[allow(dead_code)]
     Optional {
@@ -63,7 +63,7 @@ pub fn rand_str(fixed_prefix: &str, random_length: usize) -> SymbolType {
     }
 }
 
-pub fn rand_int(range: Range<i32>) -> SymbolType {
+pub fn rand_int(range: Range<i64>) -> SymbolType {
     SymbolType::Int { range }
 }
 

tests/integration/fuzz/mod.rs

@@ -4,7 +4,7 @@ pub mod grammar_generator;
 mod tests {
     use std::rc::Rc;
 
-    use rand::{RngCore, SeedableRng};
+    use rand::SeedableRng;
     use rand_chacha::ChaCha8Rng;
     use rusqlite::params;
 
@@ -632,11 +632,18 @@ mod tests {
     pub fn table_logical_expression_fuzz_ex1() {
         let _ = env_logger::try_init();
 
-        for queries in [[
-            "CREATE TABLE t(x)",
-            "INSERT INTO t VALUES (10)",
-            "SELECT * FROM t WHERE  x = 1 AND 1 OR 0",
-        ]] {
+        for queries in [
+            [
+                "CREATE TABLE t(x)",
+                "INSERT INTO t VALUES (10)",
+                "SELECT * FROM t WHERE  x = 1 AND 1 OR 0",
+            ],
+            [
+                "CREATE TABLE t(x)",
+                "INSERT INTO t VALUES (-3258184727)",
+                "SELECT * FROM t",
+            ],
+        ] {
             let db = TempDatabase::new_empty();
             let limbo_conn = db.connect_limbo();
             let sqlite_conn = rusqlite::Connection::open_in_memory().unwrap();
@@ -663,6 +670,15 @@ mod tests {
         let (in_op, in_op_builder) = g.create_handle();
         let (paren, paren_builder) = g.create_handle();
 
+        let number = g
+            .create()
+            .choice()
+            .option_symbol(rand_int(-0xff..0x100))
+            .option_symbol(rand_int(-0xffff..0x10000))
+            .option_symbol(rand_int(-0xffffff..0x1000000))
+            .option_symbol(rand_int(-0xffffffff..0x100000000))
+            .option_symbol(rand_int(-0xffffffffffff..0x1000000000000))
+            .build();
         value_builder
             .choice()
             .option(
@@ -673,7 +689,7 @@ mod tests {
                     .push_str(")")
                     .build(),
             )
-            .option_symbol(rand_int(0..i32::MAX))
+            .option(number)
             .options_str(["x", "y", "z"])
             .option(
                 g.create()
@@ -742,8 +758,13 @@ mod tests {
         log::info!("seed: {}", seed);
 
         for _ in 0..100 {
-            let (x, y, z) = (rng.next_u32(), rng.next_u32(), rng.next_u32());
+            let (x, y, z) = (
+                g.generate(&mut rng, number, 1),
+                g.generate(&mut rng, number, 1),
+                g.generate(&mut rng, number, 1),
+            );
             let query = format!("INSERT INTO t VALUES ({}, {}, {})", x, y, z);
+            log::info!("insert: {}", query);
             assert_eq!(
                 limbo_exec_rows(&db, &limbo_conn, &query),
                 sqlite_exec_rows(&sqlite_conn, &query)