polite 0.1.3

rusqlite × Polars bridge library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

// polite/tests/int_size.rs
use polars::prelude::*;
use polite::prelude::*;
use tempfile::NamedTempFile;

// 64-bit number just over i32::MAX
const BIG: i64 = i32::MAX as i64 + 1;

// These tests just check that we aren't getting any weird type inference

// A single small integer should be Int64 regardless of its value

#[test]
fn test_small_integer_promotes_to_i64_solo() {
    let db = NamedTempFile::new().unwrap();
    let conn = connect_sqlite(Some(db.path().to_str().unwrap())).unwrap();

    conn.execute("CREATE TABLE t (id INTEGER)", []).unwrap();
    conn.execute("INSERT INTO t (id) VALUES (?)", [42]).unwrap();

    let df = to_dataframe(db.path().to_str().unwrap(), "SELECT * FROM t").unwrap();
    let col = df.column("id").unwrap();

    // Ensure dtype is Int64
    assert_eq!(col.dtype(), &DataType::Int64);

    // Ensure the value is preserved
    let got = col.i64().unwrap().get(0).unwrap();
    assert_eq!(got, 42);
}

// Same goes with large numbers (larger than i32::MAX) even if a small one is first

#[test]
fn test_large_integer_promotes_to_i64_solo() {
    let db = NamedTempFile::new().unwrap();
    let conn = connect_sqlite(Some(db.path().to_str().unwrap())).unwrap();

    conn.execute("CREATE TABLE t (id INTEGER)", []).unwrap();
    conn.execute("INSERT INTO t (id) VALUES (?)", [BIG])
        .unwrap();

    let df = to_dataframe(db.path().to_str().unwrap(), "SELECT * FROM t").unwrap();
    let col = df.column("id").unwrap();

    // Ensure dtype is Int64
    assert_eq!(col.dtype(), &DataType::Int64);

    // Ensure the value is preserved
    let got = col.i64().unwrap().get(0).unwrap();
    assert_eq!(got, BIG);
}

#[test]
fn test_large_integer_promotes_to_i64_with_small_before() {
    let db = NamedTempFile::new().unwrap();
    let conn = connect_sqlite(Some(db.path().to_str().unwrap())).unwrap();

    conn.execute("CREATE TABLE t (id INTEGER)", []).unwrap();

    // Insert the big number after a small number
    conn.execute("INSERT INTO t (id) VALUES (42)", []).unwrap();
    conn.execute("INSERT INTO t (id) VALUES (?)", [BIG])
        .unwrap();

    let df = to_dataframe(db.path().to_str().unwrap(), "SELECT * FROM t").unwrap();
    let col = df.column("id").unwrap();

    assert_eq!(col.dtype(), &DataType::Int64);

    let values: Vec<i64> = col.i64().unwrap().into_no_null_iter().collect();
    assert!(values.contains(&42));
    assert!(values.contains(&BIG));
}

#[test]
fn test_large_integer_promotes_to_i64_with_small_after() {
    let db = NamedTempFile::new().unwrap();
    let conn = connect_sqlite(Some(db.path().to_str().unwrap())).unwrap();

    conn.execute("CREATE TABLE t (id INTEGER)", []).unwrap();

    // Insert the big number FIRST
    conn.execute("INSERT INTO t (id) VALUES (?)", [BIG])
        .unwrap();
    conn.execute("INSERT INTO t (id) VALUES (42)", []).unwrap();

    let df = to_dataframe(db.path().to_str().unwrap(), "SELECT * FROM t").unwrap();
    let col = df.column("id").unwrap();

    assert_eq!(col.dtype(), &DataType::Int64);

    let values: Vec<i64> = col.i64().unwrap().into_no_null_iter().collect();
    assert!(values.contains(&BIG));
    assert!(values.contains(&42));
}