1use std::path::Path;
8
9use crate::{ColumnType, RealmError, Result, Value};
10
11const WTYPE_BITS: u8 = 0;
14const WTYPE_MULTIPLY: u8 = 1;
15const MAGIC: &[u8; 4] = b"T-DB";
16const VERSION: u32 = 9;
17const FILE_HEADER_SIZE: usize = 24;
18
19#[derive(Debug, Default)]
50pub struct RealmBuilder {
51 tables: Vec<TableDef>,
52}
53
54pub struct TableBuilder<'a> {
58 def: &'a mut TableDef,
59}
60
61#[derive(Debug)]
62struct TableDef {
63 name: String,
64 columns: Vec<(String, ColumnType)>,
65 rows: Vec<Vec<Value>>,
66}
67
68impl RealmBuilder {
69 pub fn new() -> Self {
71 RealmBuilder::default()
72 }
73
74 pub fn table(&mut self, name: impl Into<String>) -> TableBuilder<'_> {
76 self.tables.push(TableDef {
77 name: name.into(),
78 columns: Vec::new(),
79 rows: Vec::new(),
80 });
81 TableBuilder { def: self.tables.last_mut().unwrap() }
82 }
83
84 pub fn to_bytes(&self) -> Vec<u8> {
86 serialize(&self.tables)
87 }
88
89 pub fn write<P: AsRef<Path>>(&self, path: P) -> Result<()> {
93 std::fs::write(path, self.to_bytes()).map_err(RealmError::Io)
94 }
95}
96
97impl<'a> TableBuilder<'a> {
98 pub fn column(&mut self, name: impl Into<String>, col_type: ColumnType) -> &mut Self {
103 self.def.columns.push((name.into(), col_type));
104 self
105 }
106
107 pub fn row(&mut self, values: Vec<Value>) -> &mut Self {
112 self.def.rows.push(values);
113 self
114 }
115}
116
117struct Serializer {
120 buf: Vec<u8>,
121}
122
123impl Serializer {
124 fn new() -> Self {
125 Serializer { buf: vec![0u8; FILE_HEADER_SIZE] }
127 }
128
129 fn align(&mut self) {
130 while !self.buf.len().is_multiple_of(8) {
131 self.buf.push(0);
132 }
133 }
134
135 fn write_header(&mut self, size: usize, wenc: u8, wtype: u8, has_refs: bool) -> usize {
137 self.align();
138 let start = self.buf.len();
139 let mut h4 = (wtype << 3) | (wenc & 0x07);
140 if has_refs { h4 |= 0x40; }
141 let h5 = ((size >> 16) & 0xFF) as u8;
142 let h6 = ((size >> 8) & 0xFF) as u8;
143 let h7 = (size & 0xFF) as u8;
144 self.buf.extend_from_slice(&[0, 0, 0, 0, h4, h5, h6, h7]);
145 start
146 }
147
148 fn write_u64_array(&mut self, values: &[u64], has_refs: bool) -> usize {
150 let start = self.write_header(values.len(), wenc(64), WTYPE_BITS, has_refs);
151 for &v in values {
152 self.buf.extend_from_slice(&v.to_le_bytes());
153 }
154 self.align();
155 start
156 }
157
158 fn write_i64_array(&mut self, values: &[i64]) -> usize {
160 let start = self.write_header(values.len(), wenc(64), WTYPE_BITS, false);
161 for &v in values {
162 self.buf.extend_from_slice(&(v as u64).to_le_bytes());
163 }
164 self.align();
165 start
166 }
167
168 fn write_bool_array(&mut self, values: &[bool]) -> usize {
170 let start = self.write_header(values.len(), 1, WTYPE_BITS, false);
171 let n_bytes = values.len().div_ceil(8);
172 let mut bytes = vec![0u8; n_bytes];
173 for (i, &b) in values.iter().enumerate() {
174 if b { bytes[i / 8] |= 1u8 << (i % 8); }
175 }
176 self.buf.extend_from_slice(&bytes);
177 self.align();
178 start
179 }
180
181 fn write_f32_array(&mut self, values: &[f32]) -> usize {
183 let start = self.write_header(values.len(), wenc(32), WTYPE_BITS, false);
184 for &v in values {
185 self.buf.extend_from_slice(&v.to_bits().to_le_bytes());
186 }
187 self.align();
188 start
189 }
190
191 fn write_f64_array(&mut self, values: &[f64]) -> usize {
193 let start = self.write_header(values.len(), wenc(64), WTYPE_BITS, false);
194 for &v in values {
195 self.buf.extend_from_slice(&v.to_bits().to_le_bytes());
196 }
197 self.align();
198 start
199 }
200
201 fn write_nibble_array(&mut self, values: &[u8]) -> usize {
203 let start = self.write_header(values.len(), 3, WTYPE_BITS, false);
204 let n_bytes = values.len().div_ceil(2);
205 let mut bytes = vec![0u8; n_bytes];
206 for (i, &v) in values.iter().enumerate() {
207 bytes[i / 2] |= (v & 0x0f) << ((i % 2) * 4);
208 }
209 self.buf.extend_from_slice(&bytes);
210 self.align();
211 start
212 }
213
214 fn write_multiply_strings(&mut self, strings: &[&str], slot_width: u8) -> usize {
219 let start = self.write_header(strings.len(), wenc(slot_width), WTYPE_MULTIPLY, false);
220 let w = slot_width as usize;
221 for s in strings {
222 let mut slot = vec![0u8; w];
223 let bytes = s.as_bytes();
224 let copy_len = bytes.len().min(w.saturating_sub(1));
225 slot[..copy_len].copy_from_slice(&bytes[..copy_len]);
226 slot[w - 1] = (w - copy_len - 1) as u8; self.buf.extend_from_slice(&slot);
228 }
229 self.align();
230 start
231 }
232
233 fn write_string_node(&mut self, s: &str) -> usize {
238 let bytes = s.as_bytes();
239 let start = self.write_header(bytes.len(), wenc(8), WTYPE_BITS, false);
240 self.buf.extend_from_slice(bytes);
241 self.align();
242 start
243 }
244
245 fn write_string_column(&mut self, strings: &[&str]) -> usize {
251 let refs: Vec<u64> = strings
253 .iter()
254 .map(|&s| {
255 if s.is_empty() { 0 } else { self.write_string_node(s) as u64 }
256 })
257 .collect();
258 self.write_u64_array(&refs, true)
259 }
260
261 fn finalize(mut self, group_ref: usize) -> Vec<u8> {
262 self.buf[0..8].copy_from_slice(&(group_ref as u64).to_le_bytes());
263 self.buf[8..16].copy_from_slice(&0u64.to_le_bytes());
264 self.buf[16..20].copy_from_slice(MAGIC);
265 self.buf[20..24].copy_from_slice(&VERSION.to_le_bytes());
266 self.buf
267 }
268}
269
270#[inline]
278fn wenc(w: u8) -> u8 {
279 match w { 0 => 0, 1 => 1, 2 => 2, 4 => 3, 8 => 4, 16 => 5, 32 => 6, 64 => 7, _ => 0 }
280}
281
282fn col_type_code(ct: ColumnType) -> u8 {
285 match ct {
286 ColumnType::Int => 0,
287 ColumnType::Bool => 1,
288 ColumnType::String => 2,
289 ColumnType::Data => 3,
290 ColumnType::Float => 4,
291 ColumnType::Double => 5,
292 ColumnType::Timestamp => 7,
293 ColumnType::Link | ColumnType::BackLink => 8,
294 ColumnType::LinkList => 9,
295 ColumnType::Unknown(v) => v,
296 }
297}
298
299fn row_val(row: &[Value], col_idx: usize) -> &Value {
300 row.get(col_idx).unwrap_or(&Value::Null)
301}
302
303fn serialize(tables: &[TableDef]) -> Vec<u8> {
304 let mut s = Serializer::new();
305
306 let table_refs: Vec<u64> = tables
308 .iter()
309 .map(|t| serialize_table(&mut s, t) as u64)
310 .collect();
311
312 let names: Vec<&str> = tables.iter().map(|t| t.name.as_str()).collect();
314 let names_ref = s.write_multiply_strings(&names, 64) as u64;
315 let refs_ref = s.write_u64_array(&table_refs, true) as u64;
316
317 let group_ref = s.write_u64_array(&[names_ref, refs_ref], true);
318
319 s.finalize(group_ref)
320}
321
322fn serialize_table(s: &mut Serializer, table: &TableDef) -> usize {
323 let col_refs: Vec<u64> = table
325 .columns
326 .iter()
327 .enumerate()
328 .map(|(ci, (_, ct))| serialize_column(s, &table.rows, ci, *ct) as u64)
329 .collect();
330
331 let spec_ref = serialize_spec(s, &table.columns) as u64;
332
333 let mut arr = vec![spec_ref];
334 arr.extend_from_slice(&col_refs);
335 s.write_u64_array(&arr, true)
336}
337
338fn serialize_spec(s: &mut Serializer, columns: &[(String, ColumnType)]) -> usize {
339 let type_codes: Vec<u8> = columns.iter().map(|(_, ct)| col_type_code(*ct)).collect();
340 let types_ref = s.write_nibble_array(&type_codes) as u64;
341
342 let names: Vec<&str> = columns.iter().map(|(n, _)| n.as_str()).collect();
343 let names_ref = s.write_multiply_strings(&names, 32) as u64;
344
345 s.write_u64_array(&[types_ref, names_ref], true)
346}
347
348fn serialize_column(s: &mut Serializer, rows: &[Vec<Value>], ci: usize, ct: ColumnType) -> usize {
349 match ct {
350 ColumnType::Int => {
351 let v: Vec<i64> = rows.iter().map(|r| row_val(r, ci).as_int()).collect();
352 s.write_i64_array(&v)
353 }
354 ColumnType::Bool => {
355 let v: Vec<bool> = rows.iter().map(|r| row_val(r, ci).as_bool()).collect();
356 s.write_bool_array(&v)
357 }
358 ColumnType::Float => {
359 let v: Vec<f32> = rows.iter().map(|r| row_val(r, ci).as_float() as f32).collect();
360 s.write_f32_array(&v)
361 }
362 ColumnType::Double => {
363 let v: Vec<f64> = rows.iter().map(|r| row_val(r, ci).as_float()).collect();
364 s.write_f64_array(&v)
365 }
366 ColumnType::Timestamp => {
367 let v: Vec<i64> = rows.iter().map(|r| row_val(r, ci).as_timestamp()).collect();
368 s.write_i64_array(&v)
369 }
370 ColumnType::String | ColumnType::Data => {
371 let v: Vec<&str> = rows.iter().map(|r| row_val(r, ci).as_str()).collect();
372 s.write_string_column(&v)
373 }
374 ColumnType::Link | ColumnType::LinkList | ColumnType::BackLink => {
375 let v: Vec<i64> = rows
376 .iter()
377 .map(|r| match row_val(r, ci) {
378 Value::Link(i) => *i as i64,
379 other => other.as_int(),
380 })
381 .collect();
382 s.write_i64_array(&v)
383 }
384 ColumnType::Unknown(_) => s.write_u64_array(&[], false),
385 }
386}
387
388#[cfg(test)]
391mod tests {
392 use super::*;
393 use crate::RealmFile;
394
395 fn roundtrip(builder: RealmBuilder) -> crate::RealmFile {
396 let bytes = builder.to_bytes();
397 RealmFile::from_bytes(&bytes).expect("round-trip parse failed")
398 }
399
400 #[test]
401 fn wenc_all_values() {
402 assert_eq!(wenc(0), 0);
403 assert_eq!(wenc(1), 1);
404 assert_eq!(wenc(2), 2);
405 assert_eq!(wenc(4), 3);
406 assert_eq!(wenc(8), 4);
407 assert_eq!(wenc(16), 5);
408 assert_eq!(wenc(32), 6);
409 assert_eq!(wenc(64), 7);
410 }
411
412 #[test]
413 fn empty_builder_roundtrip() {
414 let realm = roundtrip(RealmBuilder::new());
415 assert_eq!(realm.tables().len(), 0);
416 }
417
418 #[test]
419 fn single_table_no_rows() {
420 let mut b = RealmBuilder::new();
421 b.table("Foo")
422 .column("id", ColumnType::Int)
423 .column("name", ColumnType::String);
424 let realm = roundtrip(b);
425 let t = realm.table("Foo").expect("table Foo not found");
426 assert_eq!(t.columns.len(), 2);
427 assert_eq!(t.rows.len(), 0);
428 assert_eq!(t.columns[0].0, "id");
429 assert_eq!(t.columns[1].0, "name");
430 }
431
432 #[test]
433 fn int_column_roundtrip() {
434 let mut b = RealmBuilder::new();
435 b.table("T").column("n", ColumnType::Int)
436 .row(vec![Value::Int(0)])
437 .row(vec![Value::Int(42)])
438 .row(vec![Value::Int(-1)])
439 .row(vec![Value::Int(i64::MAX)]);
440 let realm = roundtrip(b);
441 let t = realm.table("T").unwrap();
442 assert_eq!(t.rows.len(), 4);
443 assert_eq!(t.get(&t.rows[0], "n").as_int(), 0);
444 assert_eq!(t.get(&t.rows[1], "n").as_int(), 42);
445 assert_eq!(t.get(&t.rows[2], "n").as_int(), -1);
446 assert_eq!(t.get(&t.rows[3], "n").as_int(), i64::MAX);
447 }
448
449 #[test]
450 fn bool_column_roundtrip() {
451 let mut b = RealmBuilder::new();
452 b.table("T").column("flag", ColumnType::Bool)
453 .row(vec![Value::Bool(true)])
454 .row(vec![Value::Bool(false)])
455 .row(vec![Value::Bool(true)]);
456 let realm = roundtrip(b);
457 let t = realm.table("T").unwrap();
458 assert_eq!(t.get(&t.rows[0], "flag").as_bool(), true);
459 assert_eq!(t.get(&t.rows[1], "flag").as_bool(), false);
460 assert_eq!(t.get(&t.rows[2], "flag").as_bool(), true);
461 }
462
463 #[test]
464 fn string_column_short_roundtrip() {
465 let mut b = RealmBuilder::new();
466 b.table("T").column("s", ColumnType::String)
467 .row(vec![Value::String("hello".into())])
468 .row(vec![Value::String("world".into())])
469 .row(vec![Value::String("".into())]);
470 let realm = roundtrip(b);
471 let t = realm.table("T").unwrap();
472 assert_eq!(t.get(&t.rows[0], "s").as_str(), "hello");
473 assert_eq!(t.get(&t.rows[1], "s").as_str(), "world");
474 assert_eq!(t.get(&t.rows[2], "s").as_str(), "");
475 }
476
477 #[test]
478 fn string_column_long_roundtrip() {
479 let long = "a".repeat(500);
480 let mut b = RealmBuilder::new();
481 b.table("T").column("body", ColumnType::String)
482 .row(vec![Value::String(long.clone())]);
483 let realm = roundtrip(b);
484 let t = realm.table("T").unwrap();
485 assert_eq!(t.get(&t.rows[0], "body").as_str(), long);
486 }
487
488 #[test]
489 fn timestamp_column_roundtrip() {
490 let mut b = RealmBuilder::new();
491 b.table("T").column("ts", ColumnType::Timestamp)
492 .row(vec![Value::Timestamp(1_700_000_000)])
493 .row(vec![Value::Timestamp(0)])
494 .row(vec![Value::Timestamp(-1)]);
495 let realm = roundtrip(b);
496 let t = realm.table("T").unwrap();
497 assert_eq!(t.get(&t.rows[0], "ts").as_timestamp(), 1_700_000_000);
498 assert_eq!(t.get(&t.rows[1], "ts").as_timestamp(), 0);
499 assert_eq!(t.get(&t.rows[2], "ts").as_timestamp(), -1);
500 }
501
502 #[test]
503 fn float_column_roundtrip() {
504 let mut b = RealmBuilder::new();
505 b.table("T").column("f", ColumnType::Float)
506 .row(vec![Value::Float(3.14_f32 as f64)])
507 .row(vec![Value::Float(0.0)])
508 .row(vec![Value::Float(-1.5_f32 as f64)]);
509 let realm = roundtrip(b);
510 let t = realm.table("T").unwrap();
511 assert!((t.get(&t.rows[0], "f").as_float() - 3.14_f32 as f64).abs() < 1e-5);
513 assert_eq!(t.get(&t.rows[1], "f").as_float(), 0.0);
514 }
515
516 #[test]
517 fn double_column_roundtrip() {
518 let pi = std::f64::consts::PI;
519 let mut b = RealmBuilder::new();
520 b.table("T").column("d", ColumnType::Double)
521 .row(vec![Value::Float(pi)])
522 .row(vec![Value::Float(f64::MAX)]);
523 let realm = roundtrip(b);
524 let t = realm.table("T").unwrap();
525 assert!((t.get(&t.rows[0], "d").as_float() - pi).abs() < 1e-15);
526 assert_eq!(t.get(&t.rows[1], "d").as_float(), f64::MAX);
527 }
528
529 #[test]
530 fn multi_column_roundtrip() {
531 let mut b = RealmBuilder::new();
532 b.table("Note")
533 .column("id", ColumnType::String)
534 .column("body", ColumnType::String)
535 .column("done", ColumnType::Bool)
536 .column("score", ColumnType::Int)
537 .row(vec![
538 Value::String("1".into()),
539 Value::String("Buy milk".into()),
540 Value::Bool(true),
541 Value::Int(5),
542 ])
543 .row(vec![
544 Value::String("2".into()),
545 Value::String("Write tests".into()),
546 Value::Bool(false),
547 Value::Int(10),
548 ]);
549 let realm = roundtrip(b);
550 let t = realm.table("Note").unwrap();
551 assert_eq!(t.rows.len(), 2);
552 assert_eq!(t.get(&t.rows[0], "id").as_str(), "1");
553 assert_eq!(t.get(&t.rows[0], "body").as_str(), "Buy milk");
554 assert_eq!(t.get(&t.rows[0], "done").as_bool(), true);
555 assert_eq!(t.get(&t.rows[0], "score").as_int(), 5);
556 assert_eq!(t.get(&t.rows[1], "done").as_bool(), false);
557 }
558
559 #[test]
560 fn multiple_tables_roundtrip() {
561 let mut b = RealmBuilder::new();
562 b.table("A").column("x", ColumnType::Int).row(vec![Value::Int(1)]);
563 b.table("B").column("y", ColumnType::String).row(vec![Value::String("hi".into())]);
564 let realm = roundtrip(b);
565 assert_eq!(realm.tables().len(), 2);
566 assert!(realm.table("A").is_some());
567 assert!(realm.table("B").is_some());
568 assert_eq!(realm.table("A").unwrap().get(&realm.table("A").unwrap().rows[0], "x").as_int(), 1);
569 assert_eq!(realm.table("B").unwrap().get(&realm.table("B").unwrap().rows[0], "y").as_str(), "hi");
570 }
571
572 #[test]
573 fn table_name_preserved() {
574 let mut b = RealmBuilder::new();
575 b.table("class_BlockDataModel").column("id", ColumnType::String);
576 let realm = roundtrip(b);
577 assert!(realm.table("class_BlockDataModel").is_some());
578 }
579
580 #[test]
581 fn unicode_string_roundtrip() {
582 let s = "こんにちは world 🦀";
583 let mut b = RealmBuilder::new();
584 b.table("T").column("s", ColumnType::String).row(vec![Value::String(s.into())]);
585 let realm = roundtrip(b);
586 let t = realm.table("T").unwrap();
587 assert_eq!(t.get(&t.rows[0], "s").as_str(), s);
588 }
589
590 #[test]
591 fn many_rows_roundtrip() {
592 let n = 200usize;
593 let mut b = RealmBuilder::new();
594 let mut tb = b.table("T");
595 tb.column("i", ColumnType::Int);
596 for i in 0..n { tb.row(vec![Value::Int(i as i64)]); }
597 let realm = roundtrip(b);
598 let t = realm.table("T").unwrap();
599 assert_eq!(t.rows.len(), n);
600 for (i, row) in t.rows.iter().enumerate() {
601 assert_eq!(t.get(row, "i").as_int(), i as i64, "row {i}");
602 }
603 }
604
605 #[test]
606 fn write_to_file_roundtrip() {
607 let mut b = RealmBuilder::new();
608 b.table("T").column("v", ColumnType::Int).row(vec![Value::Int(99)]);
609
610 let path = std::env::temp_dir().join("realm_writer_test.realm");
611 b.write(&path).expect("write failed");
612 let realm = RealmFile::open(&path).expect("open failed");
613 let _ = std::fs::remove_file(&path);
614
615 let t = realm.table("T").unwrap();
616 assert_eq!(t.get(&t.rows[0], "v").as_int(), 99);
617 }
618}