spiresql 0.1.2

SQL interface for SpireDB
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

//! Tests for the statistics module.
//!
//! Tests cover:
//! - CachedStats structure
//! - ColumnStatistics structure  
//! - Default values

use ahash::HashMap;
use spiresql::sql::statistics::{CachedStats, ColumnStatistics};

/// Test CachedStats structure.
#[test]
fn test_cached_stats_structure() {
    let stats = CachedStats {
        row_count: 1000,
        size_bytes: 102400,
        column_stats: HashMap::default(),
    };

    assert_eq!(stats.row_count, 1000);
    assert_eq!(stats.size_bytes, 102400);
    assert!(stats.column_stats.is_empty());
}

/// Test CachedStats with columns.
#[test]
fn test_cached_stats_with_columns() {
    let mut column_stats = HashMap::default();
    column_stats.insert(
        "id".to_string(),
        ColumnStatistics {
            distinct_count: 1000,
            null_count: 0,
            min_value: None,
            max_value: None,
        },
    );

    let stats = CachedStats {
        row_count: 5000,
        size_bytes: 512000,
        column_stats,
    };

    assert_eq!(stats.column_stats.len(), 1);
    let id_stats = stats.column_stats.get("id").unwrap();
    assert_eq!(id_stats.distinct_count, 1000);
    assert_eq!(id_stats.null_count, 0);
}

/// Test ColumnStatistics with distinct count.
#[test]
fn test_column_statistics_distinct() {
    let stats = ColumnStatistics {
        distinct_count: 25,
        null_count: 10,
        min_value: None,
        max_value: None,
    };

    assert_eq!(stats.distinct_count, 25);
    assert_eq!(stats.null_count, 10);
}

/// Test ColumnStatistics clone.
#[test]
fn test_column_statistics_clone() {
    let stats = ColumnStatistics {
        distinct_count: 50,
        null_count: 0,
        min_value: None,
        max_value: None,
    };
    let cloned = stats.clone();

    assert_eq!(stats.distinct_count, cloned.distinct_count);
}

/// Test empty CachedStats.
#[test]
fn test_empty_cached_stats() {
    let stats = CachedStats {
        row_count: 0,
        size_bytes: 0,
        column_stats: HashMap::default(),
    };

    assert_eq!(stats.row_count, 0);
    assert_eq!(stats.size_bytes, 0);
}

/// Test high cardinality column.
#[test]
fn test_high_cardinality_column() {
    let stats = ColumnStatistics {
        distinct_count: 1_000_000,
        null_count: 0,
        min_value: None,
        max_value: None,
    };

    assert_eq!(stats.distinct_count, 1_000_000);
}

/// Test CachedStats debug.
#[test]
fn test_cached_stats_debug() {
    let stats = CachedStats {
        row_count: 42,
        size_bytes: 4096,
        column_stats: HashMap::default(),
    };
    let debug_str = format!("{:?}", stats);

    assert!(debug_str.contains("42"));
}

/// Test ColumnStatistics debug.
#[test]
fn test_column_statistics_debug() {
    let stats = ColumnStatistics {
        distinct_count: 100,
        null_count: 5,
        min_value: None,
        max_value: None,
    };
    let debug_str = format!("{:?}", stats);

    assert!(debug_str.contains("100"));
}