serde_sql 0.1.1

Stream serde structs into SQLite INSERT statements using a reusable buffer.
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

# serde_sql

[![Crates.io](https://img.shields.io/crates/v/serde_sql.svg)](https://crates.io/crates/serde_sql)
[![Docs.rs](https://img.shields.io/docsrs/serde_sql)](https://docs.rs/serde_sql)
[![CI](https://github.com/JakkuSakura/serde_sql/actions/workflows/ci.yml/badge.svg)](https://github.com/JakkuSakura/serde_sql/actions)

`serde_sql` streams [`serde::Serialize`](https://docs.rs/serde/latest/serde/trait.Serialize.html)
structs directly into SQLite statements without allocating intermediate field structures.
You provide a `String` buffer and value; the crate appends the literal value list `(v1, v2, …)` so
you can embed it in any SQL template. When bootstrapping tables, the crate can also infer a basic
`CREATE TABLE` definition from an example record.

## Features

- Zero-copy output: serialise straight into an existing `String`.
- Handles `Option`, numbers, booleans, and strings with proper escaping.
- Nested structures (maps/arrays) are emitted as JSON text literals.

## Quick start

```toml
[dependencies]
serde_sql = "0.1"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
```

```rust
use serde::Serialize;
use serde_sql::{infer_table_ddl, serialize_insert};

#[derive(Serialize)]
struct User {
    id: u64,
    name: String,
    active: bool,
    notes: Option<String>,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut insert = String::new();
    insert.push_str("INSERT INTO users VALUES ");
    serialize_insert(
        &mut insert,
        &User {
            id: 1,
            name: "Alice".into(),
            active: true,
            notes: Some("admin".into()),
        },
    )?;

    let ddl = infer_table_ddl(
        "users",
        &User {
            id: 0,
            name: "example".into(),
            active: false,
            notes: None,
        },
    )?;

    assert_eq!(insert, "INSERT INTO users VALUES (1, 'Alice', 1, 'admin')");
    assert_eq!(
        ddl,
        r#"CREATE TABLE IF NOT EXISTS "users" (
    "id" INTEGER NOT NULL,
    "name" TEXT NOT NULL,
    "active" INTEGER NOT NULL,
    "notes" TEXT
);"#
    );
    Ok(())
}
```

### Example

```sh
cargo run --example basic
cargo run --example ddl
```

## Testing

```sh
cargo test
```

## Documentation

- API docs can be generated locally via `cargo doc --open`.
- Additional usage notes live under `docs/usage.md`.