duckdb-bitstring 0.7.0

BIT type support for duckdb-rs
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use bit_vec::BitVec;
use duckdb::{self, params, Connection};
use duckdb_bitstring::{Bitstring, BitstringError};

fn setup() -> Connection {
    let db = duckdb::Connection::open_in_memory().unwrap();
    db.execute_batch(
        "create table t1 (id int, d bit);
        insert into t1 values (1, '10110'::bit);
        insert into t1 values (2, '001011010110001011001011010110'::bit);
        insert into t1 values (3, '1111111111'::bit);",
    )
    .unwrap();
    db
}

fn get_bitvec() -> BitVec {
    let mut bv = BitVec::from_bytes(&[0b01101100, 0b10000011, 0b10101011]);
    bv.split_off(4)
}

fn check_new_row(db: Connection) {
    let id: i32 = db
        .query_row(
            "select id from t1 where d = '11001000001110101011'::bit",
            [],
            |row| row.get::<_, i32>(0),
        )
        .unwrap();
    assert_eq!(id, 4);
}

#[test]
fn test_param_owned() {
    let db = setup();
    let owned_bv = get_bitvec();

    db.execute(
        "insert into t1 values (?, ?::bit)",
        params![4, Bitstring::from(owned_bv)],
    )
    .unwrap();

    check_new_row(db);
}

#[test]
fn test_param_ref() {
    let db = setup();
    let bv = get_bitvec();

    test_param_ref_inner(&bv, db);
}

fn test_param_ref_inner(bv: &BitVec, db: Connection) {
    db.execute(
        "insert into t1 values (?, ?::bit)",
        params![4, Bitstring::from(bv)],
    )
    .unwrap();

    check_new_row(db);
}

#[test]
fn test_param_ref2() {
    let db = setup();
    let bv = get_bitvec();

    test_param_ref2_inner1(&bv, db);
}

fn test_param_ref2_inner1(bv: &BitVec, db: Connection) {
    let bs = Bitstring::from(bv);
    test_param_ref2_inner2(&bs, db);
}

fn test_param_ref2_inner2(bs: &Bitstring, db: Connection) {
    db.execute("insert into t1 values (?, ?::bit)", params![4, bs])
        .unwrap();

    check_new_row(db);
}

#[test]
fn test_param_option() {
    let db = setup();
    let bs = Some(Bitstring::from(get_bitvec()));

    db.execute("insert into t1 values (?, ?::bit)", params![4, bs])
        .unwrap();

    check_new_row(db);
}

#[test]
fn test_param_option_none() {
    let db = setup();
    let bs: Option<Bitstring> = None;

    db.execute("insert into t1 values (?, ?::bit)", params![4, bs])
        .unwrap();

    let id: i32 = db
        .query_row("select id from t1 where d is null", [], |row| {
            row.get::<_, i32>(0)
        })
        .unwrap();
    assert_eq!(id, 4);
}

#[test]
fn test_error_empty() {
    let db = setup();
    let bv = BitVec::new();

    let result = db.execute(
        "insert into t1 values (?, ?::bit)",
        params![4, Bitstring::from(bv)],
    );
    assert!(matches!(
        result,
        Err(duckdb::Error::ToSqlConversionFailure(_))
    ));

    if let Err(duckdb::Error::ToSqlConversionFailure(err)) = result {
        matches!(err.downcast_ref().unwrap(), BitstringError::EmptyBitstring);
    } else {
        unreachable!(); // The assert! before the if branch already confirmed it matches.
    }
}