reifydb-engine 0.4.11

Query execution and processing engine for ReifyDB
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

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2025 ReifyDB

//! Trusted mode tests for the bulk_insert module.
//!
//! Tests verify that trusted mode skips validation and coercion.

use reifydb_engine::test_prelude::*;

#[test]
fn test_trusted_mode_basic_insert() {
	let t = TestEngine::new();
	let identity = TestEngine::identity();

	t.admin("CREATE NAMESPACE test");
	t.admin("CREATE TABLE test::trusted_tbl { id: int4, name: utf8 }");

	// Use bulk_insert_trusted instead of bulk_insert
	let mut builder = t.bulk_insert_trusted(identity);
	builder.table("test::trusted_tbl")
		.row(params! { id: 1i32, name: "Alice" })
		.row(params! { id: 2i32, name: "Bob" })
		.done();
	let result = builder.execute().unwrap();

	assert_eq!(result.tables[0].inserted, 2);

	let frames = t.query("FROM test::trusted_tbl");
	assert_eq!(TestEngine::row_count(&frames), 2);

	let mut values: Vec<_> = frames[0]
		.rows()
		.map(|r| (r.get::<i32>("id").unwrap().unwrap(), r.get::<String>("name").unwrap().unwrap()))
		.collect();
	values.sort_by_key(|(id, _)| *id);
	assert_eq!(values, vec![(1, "Alice".to_string()), (2, "Bob".to_string())]);
}

#[test]
fn test_trusted_mode_ringbuffer() {
	let t = TestEngine::new();
	let identity = TestEngine::identity();

	t.admin("CREATE NAMESPACE test");
	t.admin("CREATE RINGBUFFER test::trusted_rb { seq: int4, data: utf8 } WITH { capacity: 100 }");

	let mut builder = t.bulk_insert_trusted(identity);
	builder.ringbuffer("test::trusted_rb")
		.row(params! { seq: 1i32, data: "first" })
		.row(params! { seq: 2i32, data: "second" })
		.done();
	let result = builder.execute().unwrap();

	assert_eq!(result.ringbuffers[0].inserted, 2);

	let frames = t.query("FROM test::trusted_rb");
	assert_eq!(TestEngine::row_count(&frames), 2);

	// Verify values
	let mut values: Vec<_> = frames[0]
		.rows()
		.map(|r| (r.get::<i32>("seq").unwrap().unwrap(), r.get::<String>("data").unwrap().unwrap()))
		.collect();
	values.sort_by_key(|(seq, _)| *seq);
	assert_eq!(values, vec![(1, "first".to_string()), (2, "second".to_string())]);
}

#[test]
fn test_trusted_mode_mixed_batch() {
	let t = TestEngine::new();
	let identity = TestEngine::identity();

	t.admin("CREATE NAMESPACE test");
	t.admin("CREATE TABLE test::t1 { a: int4 }");
	t.admin("CREATE TABLE test::t2 { b: int4 }");
	t.admin("CREATE RINGBUFFER test::rb1 { c: int4 } WITH { capacity: 50 }");

	let mut builder = t.bulk_insert_trusted(identity);
	builder.table("test::t1").row(params! { a: 10i32 }).done();
	builder.table("test::t2").row(params! { b: 20i32 }).row(params! { b: 30i32 }).done();
	builder.ringbuffer("test::rb1").row(params! { c: 100i32 }).done();
	let result = builder.execute().unwrap();

	assert_eq!(result.tables.len(), 2);
	assert_eq!(result.tables[0].inserted, 1);
	assert_eq!(result.tables[1].inserted, 2);
	assert_eq!(result.ringbuffers.len(), 1);
	assert_eq!(result.ringbuffers[0].inserted, 1);
}

#[test]
fn test_trusted_mode_large_batch() {
	let t = TestEngine::new();
	let identity = TestEngine::identity();

	t.admin("CREATE NAMESPACE test");
	t.admin("CREATE TABLE test::large { n: int4 }");

	// Insert 1000 rows in trusted mode for performance
	let rows: Vec<_> = (1..=1000).map(|n| params! { n: n as i32 }).collect();

	let mut builder = t.bulk_insert_trusted(identity);
	builder.table("test::large").rows(rows).done();
	let result = builder.execute().unwrap();

	assert_eq!(result.tables[0].inserted, 1000);

	let frames = t.query("FROM test::large");
	assert_eq!(TestEngine::row_count(&frames), 1000);
}