laminar-derive 0.18.5

Derive macros for LaminarDB Record and FromRecordBatch traits
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

# laminar-derive

Derive macros for LaminarDB -- `Record`, `FromRecordBatch`, `FromRow`, and `ConnectorConfig`.

## Overview

Procedural macros for Arrow RecordBatch conversion and connector config parsing. Eliminates the boilerplate of writing `to_record_batch()` / `from_batch()` by hand.

## Macros

### `#[derive(Record)]`

Generates `Record::schema()`, `Record::to_record_batch()`, and `Record::event_time()` for typed data ingestion.

```rust
use laminar_derive::Record;

#[derive(Record)]
struct Trade {
    symbol: String,
    price: f64,
    volume: i64,
    #[event_time]
    ts: i64,
}
```

**Attributes:**
- `#[event_time]` -- marks a field as the event time column
- `#[column("name")]` -- overrides the Arrow column name
- `#[nullable]` -- marks a non-Option field as nullable in the schema

**Supported types:** `bool`, `i8`-`i64`, `u8`-`u64`, `f32`, `f64`, `String`, `Vec<u8>`, `Option<T>`

### `#[derive(FromRecordBatch)]`

Generates `from_batch()` and `from_batch_all()` for deserializing Arrow RecordBatches into typed structs. Fields are matched by name.

```rust
use laminar_derive::FromRecordBatch;

#[derive(FromRecordBatch)]
struct OhlcBar {
    symbol: String,
    open: f64,
    high: f64,
    low: f64,
    close: f64,
}
```

### `#[derive(FromRow)]`

Like `FromRecordBatch`, but also implements `laminar_db::FromBatch`. Fields are matched by **position** (column order in SELECT), not by name.

```rust
use laminar_derive::FromRow;

#[derive(FromRow)]
struct Result {
    symbol: String,    // 1st SELECT column
    total: i64,        // 2nd SELECT column
    avg_price: f64,    // 3rd SELECT column
}
```

### `#[derive(ConnectorConfig)]`

Generates `from_config()`, `validate()`, and `config_keys()` for connector configuration parsing.

```rust
use laminar_derive::ConnectorConfig;

#[derive(ConnectorConfig)]
struct MySourceConfig {
    #[config(key = "bootstrap.servers", required, description = "Kafka brokers")]
    bootstrap_servers: String,

    #[config(key = "batch.size", default = "1000")]
    batch_size: usize,

    #[config(key = "timeout.ms", default = "30000", duration_ms)]
    timeout: std::time::Duration,

    #[config(key = "api.key", env = "MY_API_KEY")]
    api_key: Option<String>,
}
```

**Attributes:**
- `#[config(key = "...")]` -- config key name
- `#[config(required)]` -- field is required
- `#[config(default = "...")]` -- default value
- `#[config(env = "...")]` -- environment variable fallback
- `#[config(description = "...")]` -- documentation for the key
- `#[config(duration_ms)]` -- parse as `Duration` from milliseconds

## Related Crates

- [`laminar-core`](../laminar-core) -- `Record` trait definition
- [`laminar-db`](../laminar-db) -- `TypedSubscription<T>` and `SourceHandle<T>` that use derived traits
- [`laminar-connectors`](../laminar-connectors) -- Connector SDK that uses `ConnectorConfig`