sql-splitter 1.13.1

High-performance CLI tool for splitting large SQL dump files into individual table files
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

//! Unit tests for analyzer module, extracted from src/analyzer/mod.rs

use sql_splitter::analyzer::Analyzer;
use tempfile::TempDir;

#[test]
fn test_analyzer_basic() {
    let temp_dir = TempDir::new().unwrap();
    let input_file = temp_dir.path().join("input.sql");

    std::fs::write(
        &input_file,
        b"CREATE TABLE users (id INT);\nINSERT INTO users VALUES (1);\nINSERT INTO users VALUES (2);\nCREATE TABLE posts (id INT);\nINSERT INTO posts VALUES (1);",
    )
    .unwrap();

    let analyzer = Analyzer::new(input_file);
    let stats = analyzer.analyze().unwrap();

    assert_eq!(stats.len(), 2);

    let users_stats = stats.iter().find(|s| s.table_name == "users").unwrap();
    assert_eq!(users_stats.insert_count, 2);
    assert_eq!(users_stats.create_count, 1);
    assert_eq!(users_stats.statement_count, 3);

    let posts_stats = stats.iter().find(|s| s.table_name == "posts").unwrap();
    assert_eq!(posts_stats.insert_count, 1);
    assert_eq!(posts_stats.create_count, 1);
    assert_eq!(posts_stats.statement_count, 2);
}

#[test]
fn test_analyzer_sorted_by_insert_count() {
    let temp_dir = TempDir::new().unwrap();
    let input_file = temp_dir.path().join("input.sql");

    std::fs::write(
        &input_file,
        b"CREATE TABLE a (id INT);\nINSERT INTO a VALUES (1);\nCREATE TABLE b (id INT);\nINSERT INTO b VALUES (1);\nINSERT INTO b VALUES (2);\nINSERT INTO b VALUES (3);",
    )
    .unwrap();

    let analyzer = Analyzer::new(input_file);
    let stats = analyzer.analyze().unwrap();

    assert_eq!(stats[0].table_name, "b");
    assert_eq!(stats[0].insert_count, 3);
    assert_eq!(stats[1].table_name, "a");
    assert_eq!(stats[1].insert_count, 1);
}

#[test]
fn test_analyzer_empty_file() {
    let temp_dir = TempDir::new().unwrap();
    let input_file = temp_dir.path().join("empty.sql");
    std::fs::write(&input_file, b"").unwrap();
    let analyzer = Analyzer::new(input_file);
    let stats = analyzer.analyze().unwrap();
    assert!(stats.is_empty());
}

#[test]
fn test_analyzer_only_inserts() {
    let temp_dir = TempDir::new().unwrap();
    let input_file = temp_dir.path().join("input.sql");
    std::fs::write(
        &input_file,
        b"INSERT INTO users VALUES (1);\nINSERT INTO users VALUES (2);\nINSERT INTO users VALUES (3);",
    )
    .unwrap();
    let analyzer = Analyzer::new(input_file);
    let stats = analyzer.analyze().unwrap();
    assert_eq!(stats.len(), 1);
    assert_eq!(stats[0].insert_count, 3);
    assert_eq!(stats[0].create_count, 0);
}

#[test]
fn test_analyzer_tracks_total_bytes() {
    let temp_dir = TempDir::new().unwrap();
    let input_file = temp_dir.path().join("input.sql");
    std::fs::write(
        &input_file,
        b"CREATE TABLE t (id INT);\nINSERT INTO t VALUES (1);",
    )
    .unwrap();
    let analyzer = Analyzer::new(input_file);
    let stats = analyzer.analyze().unwrap();
    assert_eq!(stats.len(), 1);
    assert!(stats[0].total_bytes > 0);
}

#[test]
fn test_analyzer_with_dialect() {
    use sql_splitter::parser::SqlDialect;
    let temp_dir = TempDir::new().unwrap();
    let input_file = temp_dir.path().join("input.sql");
    std::fs::write(
        &input_file,
        b"CREATE TABLE users (id INT);\nINSERT INTO users VALUES (1);",
    )
    .unwrap();
    let analyzer = Analyzer::new(input_file).with_dialect(SqlDialect::Postgres);
    let stats = analyzer.analyze().unwrap();
    assert_eq!(stats.len(), 1);
}

#[test]
fn test_analyzer_unknown_statements_skipped() {
    let temp_dir = TempDir::new().unwrap();
    let input_file = temp_dir.path().join("input.sql");
    std::fs::write(
        &input_file,
        b"SET NAMES utf8;\nSET FOREIGN_KEY_CHECKS = 0;\nCREATE TABLE t (id INT);\nINSERT INTO t VALUES (1);",
    )
    .unwrap();
    let analyzer = Analyzer::new(input_file);
    let stats = analyzer.analyze().unwrap();
    assert_eq!(stats.len(), 1);
    assert_eq!(stats[0].statement_count, 2);
}