sqlx-gen 0.5.4

Generate Rust structs from database schema introspection
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use sqlx::SqlitePool;
use sqlx_gen::introspect::sqlite::introspect;

async fn setup_pool() -> SqlitePool {
    SqlitePool::connect("sqlite::memory:").await.unwrap()
}

async fn exec(pool: &SqlitePool, sql: &str) {
    sqlx::query(sql).execute(pool).await.unwrap();
}

// --- empty database ---

#[tokio::test]
async fn test_empty_db_no_tables() {
    let pool = setup_pool().await;
    let schema = introspect(&pool, false).await.unwrap();
    assert!(schema.tables.is_empty());
}

#[tokio::test]
async fn test_empty_db_no_enums() {
    let pool = setup_pool().await;
    let schema = introspect(&pool, false).await.unwrap();
    assert!(schema.enums.is_empty());
}

#[tokio::test]
async fn test_empty_db_no_composites() {
    let pool = setup_pool().await;
    let schema = introspect(&pool, false).await.unwrap();
    assert!(schema.composite_types.is_empty());
}

#[tokio::test]
async fn test_empty_db_no_domains() {
    let pool = setup_pool().await;
    let schema = introspect(&pool, false).await.unwrap();
    assert!(schema.domains.is_empty());
}

// --- simple tables ---

#[tokio::test]
async fn test_one_table_two_columns() {
    let pool = setup_pool().await;
    exec(&pool, "CREATE TABLE users (id INTEGER NOT NULL, name TEXT NOT NULL)").await;
    let schema = introspect(&pool, false).await.unwrap();
    assert_eq!(schema.tables.len(), 1);
    assert_eq!(schema.tables[0].columns.len(), 2);
}

#[tokio::test]
async fn test_table_name_correct() {
    let pool = setup_pool().await;
    exec(&pool, "CREATE TABLE users (id INTEGER NOT NULL)").await;
    let schema = introspect(&pool, false).await.unwrap();
    assert_eq!(schema.tables[0].name, "users");
}

#[tokio::test]
async fn test_schema_name_main() {
    let pool = setup_pool().await;
    exec(&pool, "CREATE TABLE users (id INTEGER NOT NULL)").await;
    let schema = introspect(&pool, false).await.unwrap();
    assert_eq!(schema.tables[0].schema_name, "main");
}

#[tokio::test]
async fn test_column_names_and_order() {
    let pool = setup_pool().await;
    exec(&pool, "CREATE TABLE users (id INTEGER NOT NULL, name TEXT NOT NULL, email TEXT)").await;
    let schema = introspect(&pool, false).await.unwrap();
    let cols: Vec<&str> = schema.tables[0].columns.iter().map(|c| c.name.as_str()).collect();
    assert_eq!(cols, vec!["id", "name", "email"]);
}

// --- column types ---

#[tokio::test]
async fn test_integer_type() {
    let pool = setup_pool().await;
    exec(&pool, "CREATE TABLE t (id INTEGER NOT NULL)").await;
    let schema = introspect(&pool, false).await.unwrap();
    assert_eq!(schema.tables[0].columns[0].data_type, "INTEGER");
}

#[tokio::test]
async fn test_not_null_column() {
    let pool = setup_pool().await;
    exec(&pool, "CREATE TABLE t (id INTEGER NOT NULL)").await;
    let schema = introspect(&pool, false).await.unwrap();
    assert!(!schema.tables[0].columns[0].is_nullable);
}

#[tokio::test]
async fn test_nullable_column() {
    let pool = setup_pool().await;
    exec(&pool, "CREATE TABLE t (name TEXT)").await;
    let schema = introspect(&pool, false).await.unwrap();
    assert!(schema.tables[0].columns[0].is_nullable);
}

// --- multiple tables ---

#[tokio::test]
async fn test_multiple_tables_sorted() {
    let pool = setup_pool().await;
    exec(&pool, "CREATE TABLE zebra (id INTEGER NOT NULL)").await;
    exec(&pool, "CREATE TABLE alpha (id INTEGER NOT NULL)").await;
    exec(&pool, "CREATE TABLE mid (id INTEGER NOT NULL)").await;
    let schema = introspect(&pool, false).await.unwrap();
    assert_eq!(schema.tables.len(), 3);
    let names: Vec<&str> = schema.tables.iter().map(|t| t.name.as_str()).collect();
    assert_eq!(names, vec!["alpha", "mid", "zebra"]);
}

// --- views ---

#[tokio::test]
async fn test_view_introspected_with_flag() {
    let pool = setup_pool().await;
    exec(&pool, "CREATE TABLE users (id INTEGER NOT NULL, name TEXT NOT NULL)").await;
    exec(&pool, "CREATE VIEW active_users AS SELECT id, name FROM users").await;
    let schema = introspect(&pool, true).await.unwrap();
    assert_eq!(schema.views.len(), 1);
    assert_eq!(schema.views[0].name, "active_users");
}

#[tokio::test]
async fn test_view_columns_correct() {
    let pool = setup_pool().await;
    exec(&pool, "CREATE TABLE users (id INTEGER NOT NULL, name TEXT NOT NULL)").await;
    exec(&pool, "CREATE VIEW user_names AS SELECT id, name FROM users").await;
    let schema = introspect(&pool, true).await.unwrap();
    let cols: Vec<&str> = schema.views[0].columns.iter().map(|c| c.name.as_str()).collect();
    assert_eq!(cols, vec!["id", "name"]);
}

#[tokio::test]
async fn test_view_not_in_tables() {
    let pool = setup_pool().await;
    exec(&pool, "CREATE TABLE users (id INTEGER NOT NULL)").await;
    exec(&pool, "CREATE VIEW v AS SELECT id FROM users").await;
    let schema = introspect(&pool, true).await.unwrap();
    assert_eq!(schema.tables.len(), 1);
    assert_eq!(schema.views.len(), 1);
}

#[tokio::test]
async fn test_views_empty_when_flag_false() {
    let pool = setup_pool().await;
    exec(&pool, "CREATE TABLE users (id INTEGER NOT NULL)").await;
    exec(&pool, "CREATE VIEW v AS SELECT id FROM users").await;
    let schema = introspect(&pool, false).await.unwrap();
    assert!(schema.views.is_empty());
}