Skip to main content

realm_codec/
write.rs

1//! Write support: build Realm v9 binary files from scratch.
2//!
3//! The entry point is [`RealmBuilder`]. Tables and columns are declared via
4//! [`TableBuilder`], then the whole database is serialised to bytes or written
5//! to disk.
6
7use std::path::Path;
8
9use crate::{ColumnType, RealmError, Result, Value};
10
11// ── Local constants (mirrors format.rs, kept local to avoid pub(crate) leakage) ─
12
13const 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// ── Public API ────────────────────────────────────────────────────────────────
20
21/// Builder for creating a Realm v9 database file from scratch.
22///
23/// Use [`RealmBuilder::table`] to add tables, then serialise with
24/// [`RealmBuilder::to_bytes`] or [`RealmBuilder::write`].
25///
26/// # Example
27///
28/// ```
29/// use realm_codec::{RealmBuilder, RealmFile, ColumnType, Value};
30///
31/// let mut builder = RealmBuilder::new();
32/// builder
33///     .table("class_Note")
34///     .column("id",      ColumnType::String)
35///     .column("content", ColumnType::String)
36///     .column("done",    ColumnType::Bool)
37///     .row(vec![
38///         Value::String("abc".into()),
39///         Value::String("Hello, world!".into()),
40///         Value::Bool(false),
41///     ]);
42///
43/// let bytes = builder.to_bytes();
44/// let realm = RealmFile::from_bytes(&bytes).unwrap();
45/// let table = realm.table("class_Note").unwrap();
46/// assert_eq!(table.rows.len(), 1);
47/// assert_eq!(table.get(&table.rows[0], "id").as_str(), "abc");
48/// ```
49#[derive(Debug, Default)]
50pub struct RealmBuilder {
51    tables: Vec<TableDef>,
52}
53
54/// A table being constructed inside a [`RealmBuilder`].
55///
56/// Obtained from [`RealmBuilder::table`].
57pub 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    /// Create an empty builder.
70    pub fn new() -> Self {
71        RealmBuilder::default()
72    }
73
74    /// Add a table and return a [`TableBuilder`] to define its schema and rows.
75    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    /// Serialise the entire database to a Realm v9 binary byte vector.
85    pub fn to_bytes(&self) -> Vec<u8> {
86        serialize(&self.tables)
87    }
88
89    /// Write the database to a file.
90    ///
91    /// Creates or truncates the file at `path`.
92    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    /// Declare a column.
99    ///
100    /// Column names longer than 31 bytes are silently truncated (32-byte slot
101    /// with one byte reserved for the tail).
102    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    /// Append a row.
108    ///
109    /// Values beyond the declared column count are ignored.
110    /// Missing trailing values are treated as [`Value::Null`] on read.
111    pub fn row(&mut self, values: Vec<Value>) -> &mut Self {
112        self.def.rows.push(values);
113        self
114    }
115}
116
117// ── Serialiser ────────────────────────────────────────────────────────────────
118
119struct Serializer {
120    buf: Vec<u8>,
121}
122
123impl Serializer {
124    fn new() -> Self {
125        // Reserve 24 bytes for the file header (filled in at finalise time).
126        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    /// Write an 8-byte NodeHeader; return the start offset of the node.
136    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    /// `WTYPE_BITS` array of `u64` values (absolute refs or 64-bit integers).
149    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    /// `WTYPE_BITS` array of `i64` values (Int / Timestamp / Link columns).
159    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    /// `WTYPE_BITS` 1-bit packed array (Bool columns).
169    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    /// `WTYPE_BITS` f32 array (Float columns).
182    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    /// `WTYPE_BITS` f64 array (Double columns).
192    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    /// `WTYPE_BITS` 4-bit nibble array (column type codes in the spec).
202    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    /// `WTYPE_MULTIPLY` array where each slot is exactly `slot_width` bytes.
215    ///
216    /// Used for table names (64-byte slots) and column names (32-byte slots).
217    /// Strings longer than `slot_width - 1` bytes are silently truncated.
218    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; // tail = slot_width - len - 1
227            self.buf.extend_from_slice(&slot);
228        }
229        self.align();
230        start
231    }
232
233    /// Write a single string as a raw-bytes node (`WTYPE_BITS` width=8).
234    ///
235    /// The node header records `size = string.len()`. The reader reconstructs
236    /// the string via its "raw bytes up to first null" fallback path.
237    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    /// Write a String/Data column as a ref array.
246    ///
247    /// Each non-empty string gets its own node; the column array stores absolute
248    /// byte offsets (`WTYPE_BITS` u64, `has_refs = true`). Empty strings use
249    /// ref = 0 (the special-cased value in the reader).
250    fn write_string_column(&mut self, strings: &[&str]) -> usize {
251        // Write individual string nodes first, collect their offsets.
252        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// ── Width encoding ────────────────────────────────────────────────────────────
271
272/// Encode a width value to a 3-bit `width_enc` field.
273///
274/// For `WTYPE_BITS`: `w` is bits per element.
275/// For `WTYPE_MULTIPLY`: `w` is bytes per slot.
276/// Both use the same encoding table: 0→0, 1→1, 2→2, 4→3, 8→4, 16→5, 32→6, 64→7.
277#[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
282// ── Serialisation helpers ─────────────────────────────────────────────────────
283
284fn 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    // Write all tables bottom-up; collect their refs.
307    let table_refs: Vec<u64> = tables
308        .iter()
309        .map(|t| serialize_table(&mut s, t) as u64)
310        .collect();
311
312    // Group: names array (64-byte multiply slots) + table refs array.
313    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    // Write column data arrays first (leaves), then spec, then table array.
324    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// ── Tests ─────────────────────────────────────────────────────────────────────
389
390#[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        // stored as f32, so compare with f32 precision
512        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}