reifydb-engine 0.4.12

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

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

//! Error condition tests for the bulk_insert module.
//!
//! Tests cover all error types: namespace not found, table not found,
//! ringbuffer not found, column not found, too many values, and coercion failures.

use reifydb_engine::test_prelude::*;

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

	// Try to insert into a table in a non-existent namespace
	let mut builder = t.bulk_insert(identity);
	builder.table("nonexistent::mytable").row(params! { id: 1 }).done();
	let result = builder.execute();

	assert!(result.is_err());
	let err = result.unwrap_err();
	let msg = format!("{}", err);
	assert!(msg.contains("namespace") || msg.contains("not found"), "Expected namespace error, got: {}", msg);
}

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

	t.admin("CREATE NAMESPACE test");

	// Try to insert into a non-existent table
	let mut builder = t.bulk_insert(identity);
	builder.table("test::nonexistent").row(params! { id: 1 }).done();
	let result = builder.execute();

	assert!(result.is_err());
	let err = result.unwrap_err();
	let msg = format!("{}", err);
	assert!(msg.contains("table") || msg.contains("not found"), "Expected table error, got: {}", msg);
}

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

	t.admin("CREATE NAMESPACE test");

	// Try to insert into a non-existent ringbuffer
	let mut builder = t.bulk_insert(identity);
	builder.ringbuffer("test::nonexistent").row(params! { id: 1 }).done();
	let result = builder.execute();

	assert!(result.is_err());
	let err = result.unwrap_err();
	let msg = format!("{}", err);
	assert!(
		msg.contains("ring") || msg.contains("buffer") || msg.contains("not found"),
		"Expected ringbuffer error, got: {}",
		msg
	);
}

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

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

	// Try to insert with an unknown column name
	let mut builder = t.bulk_insert(identity);
	builder.table("test::users").row(params! { id: 1, name: "Alice", unknown_column: "value" }).done();
	let result = builder.execute();

	assert!(result.is_err());
	let err = result.unwrap_err();
	let msg = format!("{}", err);
	assert!(msg.contains("column") || msg.contains("not found"), "Expected column error, got: {}", msg);
}

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

	t.admin("CREATE NAMESPACE test");
	t.admin("CREATE TABLE test::small { a: int4, b: int4 }");

	// Try to insert with more positional values than columns
	let mut builder = t.bulk_insert(identity);
	builder.table("test::small").row(params![1, 2, 3, 4, 5]).done(); // 5 values for 2 columns
	let result = builder.execute();

	assert!(result.is_err());
	let err = result.unwrap_err();
	let msg = format!("{}", err);
	assert!(
		msg.contains("too many") || msg.contains("values") || msg.contains("column"),
		"Expected too many values error, got: {}",
		msg
	);
}

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

	t.admin("CREATE NAMESPACE test");
	t.admin("CREATE TABLE test::typed { num: int4 }");

	// Try to insert a string that cannot be coerced to int4
	let mut builder = t.bulk_insert(identity);
	builder.table("test::typed").row(params! { num: "not_a_number" }).done();
	let result = builder.execute();

	assert!(result.is_err());
	let err = result.unwrap_err();
	let msg = format!("{}", err);
	// The error should indicate a type/coercion issue
	assert!(
		msg.contains("type") || msg.contains("coerce") || msg.contains("convert") || msg.contains("cast"),
		"Expected coercion error, got: {}",
		msg
	);
}

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

	// Try to insert into a ringbuffer in a non-existent namespace
	let mut builder = t.bulk_insert(identity);
	builder.ringbuffer("nonexistent::events").row(params! { id: 1 }).done();
	let result = builder.execute();

	assert!(result.is_err());
	let err = result.unwrap_err();
	let msg = format!("{}", err);
	assert!(msg.contains("namespace") || msg.contains("not found"), "Expected namespace error, got: {}", msg);
}