jcs.org
Serenity Operating System
1/*
2 * Copyright (c) 2021, Jan de Visser <jan@de-visser.net>
3 * Copyright (c) 2022, Tim Flynn <trflynn89@serenityos.org>
4 *
5 * SPDX-License-Identifier: BSD-2-Clause
6 */
7
8#include <unistd.h>
9
10#include <LibSQL/Meta.h>
11#include <LibSQL/Row.h>
12#include <LibSQL/Tuple.h>
13#include <LibSQL/Value.h>
14#include <LibTest/TestCase.h>
15
16TEST_CASE(null_value)
17{
18 SQL::Value v(SQL::SQLType::Null);
19 EXPECT_EQ(v.type(), SQL::SQLType::Null);
20 EXPECT_EQ(v.to_deprecated_string(), "(null)"sv);
21 EXPECT(!v.to_bool().has_value());
22 EXPECT(!v.to_int<i32>().has_value());
23 EXPECT(!v.to_int<u32>().has_value());
24 EXPECT(!v.to_double().has_value());
25}
26
27TEST_CASE(assign_null)
28{
29 SQL::Value v("Test");
30 EXPECT_EQ(v.type(), SQL::SQLType::Text);
31 EXPECT(!v.is_null());
32
33 v = SQL::Value();
34 EXPECT_EQ(v.type(), SQL::SQLType::Null);
35 EXPECT(v.is_null());
36}
37
38TEST_CASE(text_value)
39{
40 {
41 SQL::Value v(SQL::SQLType::Text);
42 EXPECT_EQ(v.type(), SQL::SQLType::Text);
43 EXPECT(v.is_null());
44
45 v = "Test"sv;
46 EXPECT_EQ(v.type(), SQL::SQLType::Text);
47 EXPECT_EQ(v.to_deprecated_string(), "Test"sv);
48 }
49 {
50 SQL::Value v(DeprecatedString("String Test"sv));
51 EXPECT_EQ(v.type(), SQL::SQLType::Text);
52 EXPECT_EQ(v.to_deprecated_string(), "String Test"sv);
53
54 v = DeprecatedString("String Test 2"sv);
55 EXPECT_EQ(v.type(), SQL::SQLType::Text);
56 EXPECT_EQ(v.to_deprecated_string(), "String Test 2"sv);
57 }
58 {
59 SQL::Value v("const char * Test");
60 EXPECT_EQ(v.type(), SQL::SQLType::Text);
61 EXPECT_EQ(v.to_deprecated_string(), "const char * Test"sv);
62
63 v = "const char * Test 2";
64 EXPECT_EQ(v.type(), SQL::SQLType::Text);
65 EXPECT_EQ(v.to_deprecated_string(), "const char * Test 2"sv);
66 }
67}
68
69TEST_CASE(text_value_to_other_types)
70{
71 {
72 SQL::Value v("42");
73 EXPECT_EQ(v.type(), SQL::SQLType::Text);
74
75 EXPECT(v.to_int<i32>().has_value());
76 EXPECT_EQ(v.to_int<i32>().value(), 42);
77
78 EXPECT(v.to_double().has_value());
79 EXPECT((v.to_double().value() - 42.0) < NumericLimits<double>().epsilon());
80 }
81 {
82 SQL::Value v("true");
83 EXPECT_EQ(v.type(), SQL::SQLType::Text);
84
85 EXPECT(v.to_bool().has_value());
86 EXPECT(v.to_bool().value());
87 }
88 {
89 SQL::Value v("false");
90 EXPECT_EQ(v.type(), SQL::SQLType::Text);
91
92 EXPECT(v.to_bool().has_value());
93 EXPECT(!v.to_bool().value());
94 }
95 {
96 SQL::Value v("foo");
97 EXPECT_EQ(v.type(), SQL::SQLType::Text);
98
99 EXPECT(!v.to_bool().has_value());
100 EXPECT(!v.to_int<i32>().has_value());
101 EXPECT(!v.to_int<u32>().has_value());
102 EXPECT(!v.to_double().has_value());
103 }
104 {
105 SQL::Value v("3.14");
106 EXPECT_EQ(v.type(), SQL::SQLType::Text);
107
108 EXPECT(v.to_double().has_value());
109 EXPECT((v.to_double().value() - 3.14) < NumericLimits<double>().epsilon());
110 }
111}
112
113TEST_CASE(assign_int_to_text_value)
114{
115 SQL::Value v(SQL::SQLType::Text);
116 EXPECT_EQ(v.type(), SQL::SQLType::Text);
117 EXPECT(v.is_null());
118
119 v = 42;
120 EXPECT_EQ(v.type(), SQL::SQLType::Integer);
121 EXPECT_EQ(v, 42);
122}
123
124TEST_CASE(serialize_text_value)
125{
126 SQL::Value v("Test");
127 EXPECT_EQ(v.type(), SQL::SQLType::Text);
128 EXPECT_EQ(v, "Test"sv);
129
130 SQL::Serializer serializer;
131 serializer.serialize<SQL::Value>(v);
132
133 serializer.rewind();
134 auto v2 = serializer.deserialize<SQL::Value>();
135 EXPECT_EQ(v2.type(), SQL::SQLType::Text);
136 EXPECT_EQ(v2, "Test"sv);
137 EXPECT_EQ(v2, v);
138}
139
140TEST_CASE(integer_value)
141{
142 {
143 SQL::Value v(SQL::SQLType::Integer);
144 EXPECT_EQ(v.type(), SQL::SQLType::Integer);
145 EXPECT(v.is_null());
146
147 v = 42;
148 EXPECT_EQ(v.type(), SQL::SQLType::Integer);
149
150 EXPECT(v.to_int<i32>().has_value());
151 EXPECT_EQ(v.to_int<i32>().value(), 42);
152 EXPECT_EQ(v.to_deprecated_string(), "42"sv);
153
154 EXPECT(v.to_double().has_value());
155 EXPECT((v.to_double().value() - 42.0) < NumericLimits<double>().epsilon());
156
157 EXPECT(v.to_bool().has_value());
158 EXPECT(v.to_bool().value());
159 }
160 {
161 SQL::Value v(0);
162 EXPECT_EQ(v.type(), SQL::SQLType::Integer);
163
164 EXPECT(v.to_int<i32>().has_value());
165 EXPECT_EQ(v.to_int<i32>().value(), 0);
166
167 EXPECT(v.to_bool().has_value());
168 EXPECT(!v.to_bool().value());
169 }
170 {
171 SQL::Value v(42);
172 EXPECT_EQ(v.type(), SQL::SQLType::Integer);
173
174 EXPECT(v.to_int<i32>().has_value());
175 EXPECT_EQ(v.to_int<i32>().value(), 42);
176 }
177 {
178 SQL::Value text("42");
179 SQL::Value integer(SQL::SQLType::Integer);
180 integer = text;
181
182 EXPECT(integer.to_int<i32>().has_value());
183 EXPECT_EQ(integer.to_int<i32>().value(), 42);
184 }
185}
186
187TEST_CASE(serialize_int_value)
188{
189 SQL::Value v(42);
190 EXPECT_EQ(v.type(), SQL::SQLType::Integer);
191 EXPECT_EQ(v, 42);
192
193 SQL::Serializer serializer;
194 serializer.serialize<SQL::Value>(v);
195
196 serializer.rewind();
197 auto v2 = serializer.deserialize<SQL::Value>();
198 EXPECT_EQ(v2.type(), SQL::SQLType::Integer);
199 EXPECT_EQ(v2, 42);
200 EXPECT_EQ(v2, v);
201}
202
203TEST_CASE(serialize_downsized_int_value)
204{
205 auto run_test_for_value = [](auto value) {
206 using T = decltype(value);
207 SQL::Value v(value);
208
209 SQL::Serializer serializer;
210 serializer.serialize(v);
211 serializer.rewind();
212
213 auto type_flags = serializer.deserialize<u8>();
214 auto type_data = type_flags & 0xf0;
215 auto type = static_cast<SQL::SQLType>(type_flags & 0x0f);
216
217 EXPECT_NE(type_data, 0);
218 EXPECT_EQ(type, SQL::SQLType::Integer);
219
220 auto deserialized = serializer.deserialize<T>();
221 EXPECT_EQ(deserialized, value);
222 };
223
224 run_test_for_value(NumericLimits<i8>::min());
225 run_test_for_value(NumericLimits<i8>::max());
226
227 run_test_for_value(NumericLimits<i16>::min());
228 run_test_for_value(NumericLimits<i16>::max());
229
230 run_test_for_value(NumericLimits<i32>::min());
231 run_test_for_value(NumericLimits<i32>::max());
232
233 run_test_for_value(NumericLimits<i64>::min());
234 run_test_for_value(NumericLimits<i64>::max());
235
236 run_test_for_value(NumericLimits<u8>::min());
237 run_test_for_value(NumericLimits<u8>::max());
238
239 run_test_for_value(NumericLimits<u16>::min());
240 run_test_for_value(NumericLimits<u16>::max());
241
242 run_test_for_value(NumericLimits<u32>::min());
243 run_test_for_value(NumericLimits<u32>::max());
244
245 run_test_for_value(NumericLimits<u64>::min());
246 run_test_for_value(NumericLimits<u64>::max());
247}
248
249TEST_CASE(float_value)
250{
251 {
252 SQL::Value v(SQL::SQLType::Float);
253 EXPECT_EQ(v.type(), SQL::SQLType::Float);
254 EXPECT(v.is_null());
255
256 v = 3.14;
257 EXPECT_EQ(v.type(), SQL::SQLType::Float);
258
259 EXPECT(v.to_double().has_value());
260 EXPECT((v.to_double().value() - 3.14) < NumericLimits<double>().epsilon());
261
262 EXPECT(v.to_int<i32>().has_value());
263 EXPECT_EQ(v.to_int<i32>().value(), 3);
264 EXPECT_EQ(v.to_deprecated_string(), "3.14");
265
266 EXPECT(v.to_bool().has_value());
267 EXPECT(v.to_bool().value());
268
269 v = 0.0;
270 EXPECT_EQ(v.type(), SQL::SQLType::Float);
271
272 EXPECT(v.to_double().has_value());
273 EXPECT(v.to_double().value() < NumericLimits<double>().epsilon());
274
275 EXPECT(v.to_int<i32>().has_value());
276 EXPECT_EQ(v.to_int<i32>().value(), 0);
277 EXPECT_EQ(v.to_deprecated_string(), "0"sv);
278
279 EXPECT(v.to_bool().has_value());
280 EXPECT(!v.to_bool().value());
281 }
282 {
283 SQL::Value v(3.14);
284 EXPECT_EQ(v.type(), SQL::SQLType::Float);
285 EXPECT((v.to_double().value() - 3.14) < NumericLimits<double>().epsilon());
286 }
287 {
288 SQL::Value v(3.51);
289 EXPECT_EQ(v.type(), SQL::SQLType::Float);
290
291 EXPECT(v.to_int<i32>().has_value());
292 EXPECT_EQ(v.to_int<i32>().value(), 4);
293 }
294 {
295 SQL::Value v(-3.14);
296 EXPECT_EQ(v.type(), SQL::SQLType::Float);
297
298 EXPECT(v.to_int<i32>().has_value());
299 EXPECT_EQ(v.to_int<i32>().value(), -3);
300 }
301 {
302 SQL::Value v(-3.51);
303 EXPECT_EQ(v.type(), SQL::SQLType::Float);
304
305 EXPECT(v.to_int<i32>().has_value());
306 EXPECT_EQ(v.to_int<i32>().value(), -4);
307 }
308}
309
310TEST_CASE(serialize_float_value)
311{
312 SQL::Value v(3.14);
313 EXPECT_EQ(v.type(), SQL::SQLType::Float);
314 EXPECT(v.to_double().value() - 3.14 < NumericLimits<double>().epsilon());
315
316 SQL::Serializer serializer;
317 serializer.serialize<SQL::Value>(v);
318
319 serializer.rewind();
320 auto v2 = serializer.deserialize<SQL::Value>();
321 EXPECT_EQ(v2.type(), SQL::SQLType::Float);
322 EXPECT((v.to_double().value() - 3.14) < NumericLimits<double>().epsilon());
323 EXPECT_EQ(v2, v);
324}
325
326TEST_CASE(copy_value)
327{
328 SQL::Value text("42");
329 SQL::Value copy(text);
330 EXPECT_EQ(copy, "42"sv);
331}
332
333TEST_CASE(to_int)
334{
335 SQL::Value text("42");
336 SQL::Value integer(42);
337 EXPECT_EQ(text, integer);
338 EXPECT_EQ(integer, text);
339
340 SQL::Value int_64 { static_cast<i64>(123) };
341 EXPECT_EQ(int_64.to_int<i8>(), 123);
342 EXPECT_EQ(int_64.to_int<i16>(), 123);
343 EXPECT_EQ(int_64.to_int<i32>(), 123);
344 EXPECT_EQ(int_64.to_int<u8>(), 123u);
345 EXPECT_EQ(int_64.to_int<u16>(), 123u);
346 EXPECT_EQ(int_64.to_int<u32>(), 123u);
347 EXPECT_EQ(int_64.to_int<u64>(), 123u);
348
349 SQL::Value uint_64 { static_cast<i64>(123) };
350 EXPECT_EQ(uint_64.to_int<i8>(), 123);
351 EXPECT_EQ(uint_64.to_int<i16>(), 123);
352 EXPECT_EQ(uint_64.to_int<i32>(), 123);
353 EXPECT_EQ(uint_64.to_int<i64>(), 123);
354 EXPECT_EQ(uint_64.to_int<u8>(), 123u);
355 EXPECT_EQ(uint_64.to_int<u16>(), 123u);
356 EXPECT_EQ(uint_64.to_int<u32>(), 123u);
357}
358
359TEST_CASE(to_int_failures)
360{
361 SQL::Value large_int_64 { NumericLimits<i64>::max() };
362 EXPECT(!large_int_64.to_int<i8>().has_value());
363 EXPECT(!large_int_64.to_int<i16>().has_value());
364 EXPECT(!large_int_64.to_int<i32>().has_value());
365 EXPECT(!large_int_64.to_int<u8>().has_value());
366 EXPECT(!large_int_64.to_int<u16>().has_value());
367 EXPECT(!large_int_64.to_int<u32>().has_value());
368
369 SQL::Value large_int_32 { NumericLimits<i32>::max() };
370 EXPECT(!large_int_32.to_int<i8>().has_value());
371 EXPECT(!large_int_32.to_int<i16>().has_value());
372 EXPECT(!large_int_32.to_int<u8>().has_value());
373 EXPECT(!large_int_32.to_int<u16>().has_value());
374
375 SQL::Value small_int_64 { NumericLimits<i64>::min() };
376 EXPECT(!small_int_64.to_int<i8>().has_value());
377 EXPECT(!small_int_64.to_int<i16>().has_value());
378 EXPECT(!small_int_64.to_int<i32>().has_value());
379 EXPECT(!small_int_64.to_int<u8>().has_value());
380 EXPECT(!small_int_64.to_int<u16>().has_value());
381 EXPECT(!small_int_64.to_int<u32>().has_value());
382 EXPECT(!small_int_64.to_int<u64>().has_value());
383
384 SQL::Value small_int_32 { NumericLimits<i32>::min() };
385 EXPECT(!small_int_32.to_int<i8>().has_value());
386 EXPECT(!small_int_32.to_int<i16>().has_value());
387 EXPECT(!small_int_32.to_int<u8>().has_value());
388 EXPECT(!small_int_32.to_int<u16>().has_value());
389 EXPECT(!small_int_32.to_int<u32>().has_value());
390 EXPECT(!small_int_32.to_int<u64>().has_value());
391
392 SQL::Value large_uint_64 { NumericLimits<u64>::max() };
393 EXPECT(!large_uint_64.to_int<i8>().has_value());
394 EXPECT(!large_uint_64.to_int<i16>().has_value());
395 EXPECT(!large_uint_64.to_int<i32>().has_value());
396 EXPECT(!large_uint_64.to_int<i64>().has_value());
397 EXPECT(!large_uint_64.to_int<u8>().has_value());
398 EXPECT(!large_uint_64.to_int<u16>().has_value());
399 EXPECT(!large_uint_64.to_int<u32>().has_value());
400
401 SQL::Value large_uint_32 { NumericLimits<u32>::max() };
402 EXPECT(!large_uint_32.to_int<i8>().has_value());
403 EXPECT(!large_uint_32.to_int<i16>().has_value());
404 EXPECT(!large_uint_32.to_int<u8>().has_value());
405 EXPECT(!large_uint_32.to_int<u16>().has_value());
406}
407
408TEST_CASE(bool_value)
409{
410 {
411 SQL::Value v(SQL::SQLType::Boolean);
412 EXPECT_EQ(v.type(), SQL::SQLType::Boolean);
413 EXPECT(v.is_null());
414
415 v = true;
416 EXPECT_EQ(v.type(), SQL::SQLType::Boolean);
417
418 EXPECT(v.to_bool().has_value());
419 EXPECT(v.to_bool().value());
420
421 EXPECT(v.to_int<i32>().has_value());
422 EXPECT_EQ(v.to_int<i32>().value(), 1);
423 EXPECT_EQ(v.to_deprecated_string(), "true"sv);
424
425 EXPECT(v.to_double().has_value());
426 EXPECT((v.to_double().value() - 1.0) < NumericLimits<double>().epsilon());
427 }
428 {
429 SQL::Value v(false);
430 EXPECT_EQ(v.type(), SQL::SQLType::Boolean);
431
432 EXPECT(v.to_bool().has_value());
433 EXPECT(!v.to_bool().value());
434
435 EXPECT(v.to_int<i32>().has_value());
436 EXPECT_EQ(v.to_int<i32>().value(), 0);
437 EXPECT_EQ(v.to_deprecated_string(), "false"sv);
438
439 EXPECT(v.to_double().has_value());
440 EXPECT(v.to_double().value() < NumericLimits<double>().epsilon());
441 }
442 {
443 SQL::Value v(true);
444 EXPECT_EQ(v.type(), SQL::SQLType::Boolean);
445
446 EXPECT(v.to_bool().has_value());
447 EXPECT(v.to_bool().value());
448
449 EXPECT(v.to_int<i32>().has_value());
450 EXPECT_EQ(v.to_int<i32>().value(), 1);
451 EXPECT_EQ(v.to_deprecated_string(), "true"sv);
452
453 EXPECT(v.to_double().has_value());
454 EXPECT((v.to_double().value() - 1.0) < NumericLimits<double>().epsilon());
455 }
456}
457
458TEST_CASE(serialize_boolean_value)
459{
460 SQL::Value v(true);
461 EXPECT_EQ(v.type(), SQL::SQLType::Boolean);
462 EXPECT_EQ(v.to_bool(), true);
463
464 SQL::Serializer serializer;
465 serializer.serialize<SQL::Value>(v);
466
467 serializer.rewind();
468 auto v2 = serializer.deserialize<SQL::Value>();
469 EXPECT_EQ(v2.type(), SQL::SQLType::Boolean);
470 EXPECT_EQ(v2.to_bool(), true);
471 EXPECT_EQ(v, v2);
472}
473
474TEST_CASE(tuple_value)
475{
476 NonnullRefPtr<SQL::TupleDescriptor> descriptor = adopt_ref(*new SQL::TupleDescriptor);
477 descriptor->append({ "schema", "table", "col1", SQL::SQLType::Text, SQL::Order::Ascending });
478 descriptor->append({ "schema", "table", "col2", SQL::SQLType::Integer, SQL::Order::Descending });
479 auto v = MUST(SQL::Value::create_tuple(move(descriptor)));
480
481 Vector<SQL::Value> values;
482 values.empend("Test");
483 values.empend(42);
484 MUST(v.assign_tuple(values));
485
486 auto values2 = v.to_vector();
487 EXPECT(values2.has_value());
488 EXPECT_EQ(values, values2.value());
489}
490
491TEST_CASE(copy_tuple_value)
492{
493 NonnullRefPtr<SQL::TupleDescriptor> descriptor = adopt_ref(*new SQL::TupleDescriptor);
494 descriptor->append({ "schema", "table", "col1", SQL::SQLType::Text, SQL::Order::Ascending });
495 descriptor->append({ "schema", "table", "col2", SQL::SQLType::Integer, SQL::Order::Descending });
496 auto v = MUST(SQL::Value::create_tuple(move(descriptor)));
497
498 Vector<SQL::Value> values;
499 values.empend("Test");
500 values.empend(42);
501 MUST(v.assign_tuple(values));
502
503 auto values2 = v;
504 EXPECT_EQ(values2.type(), v.type());
505 EXPECT_EQ(v.type(), SQL::SQLType::Tuple);
506 EXPECT_EQ(values, values2.to_vector().value());
507}
508
509TEST_CASE(tuple_value_wrong_type)
510{
511 NonnullRefPtr<SQL::TupleDescriptor> descriptor = adopt_ref(*new SQL::TupleDescriptor);
512 descriptor->append({ "schema", "table", "col1", SQL::SQLType::Text, SQL::Order::Ascending });
513 auto v = MUST(SQL::Value::create_tuple(move(descriptor)));
514
515 Vector<SQL::Value> values;
516 values.empend(42);
517
518 auto result = v.assign_tuple(move(values));
519 EXPECT(result.is_error());
520}
521
522TEST_CASE(tuple_value_too_many_values)
523{
524 NonnullRefPtr<SQL::TupleDescriptor> descriptor = adopt_ref(*new SQL::TupleDescriptor);
525 descriptor->append({ "schema", "table", "col1", SQL::SQLType::Text, SQL::Order::Ascending });
526 auto v = MUST(SQL::Value::create_tuple(move(descriptor)));
527
528 Vector<SQL::Value> values;
529 values.empend("Test");
530 values.empend(42);
531
532 auto result = v.assign_tuple(move(values));
533 EXPECT(result.is_error());
534}
535
536TEST_CASE(tuple_value_not_enough_values)
537{
538 NonnullRefPtr<SQL::TupleDescriptor> descriptor = adopt_ref(*new SQL::TupleDescriptor);
539 descriptor->append({ "schema", "table", "col1", SQL::SQLType::Text, SQL::Order::Ascending });
540 descriptor->append({ "schema", "table", "col2", SQL::SQLType::Integer, SQL::Order::Ascending });
541 auto v = MUST(SQL::Value::create_tuple(move(descriptor)));
542
543 Vector<SQL::Value> values;
544 values.empend("Test");
545 MUST(v.assign_tuple(values));
546
547 EXPECT_EQ(v.type(), SQL::SQLType::Tuple);
548
549 auto values_opt = v.to_vector();
550 EXPECT(values_opt.has_value());
551 EXPECT_EQ(values_opt.value().size(), 2u);
552
553 auto col2 = values_opt.value()[1];
554 EXPECT_EQ(col2.type(), SQL::SQLType::Integer);
555}
556
557TEST_CASE(serialize_tuple_value)
558{
559 NonnullRefPtr<SQL::TupleDescriptor> descriptor = adopt_ref(*new SQL::TupleDescriptor);
560 descriptor->append({ "schema", "table", "col1", SQL::SQLType::Text, SQL::Order::Ascending });
561 descriptor->append({ "schema", "table", "col2", SQL::SQLType::Integer, SQL::Order::Descending });
562 auto v = MUST(SQL::Value::create_tuple(move(descriptor)));
563
564 Vector<SQL::Value> values;
565 values.empend("Test");
566 values.empend(42);
567 MUST(v.assign_tuple(values));
568
569 SQL::Serializer serializer;
570 serializer.serialize<SQL::Value>(v);
571
572 serializer.rewind();
573 auto v2 = serializer.deserialize<SQL::Value>();
574 EXPECT_EQ(v2.type(), SQL::SQLType::Tuple);
575 EXPECT_EQ(v, v2);
576}
577
578TEST_CASE(order_text_values)
579{
580 SQL::Value v1(SQL::SQLType::Text);
581 v1 = "Test_A";
582 SQL::Value v2(SQL::SQLType::Text);
583 v2 = "Test_B";
584 EXPECT(v1 <= v2);
585 EXPECT(v1 < v2);
586 EXPECT(v2 >= v1);
587 EXPECT(v2 > v1);
588}
589
590TEST_CASE(order_int_values)
591{
592 SQL::Value v1(SQL::SQLType::Integer);
593 v1 = 12;
594 SQL::Value v2(SQL::SQLType::Integer);
595 v2 = 42;
596 EXPECT(v1 <= v2);
597 EXPECT(v1 < v2);
598 EXPECT(v2 >= v1);
599 EXPECT(v2 > v1);
600}
601
602TEST_CASE(tuple)
603{
604 NonnullRefPtr<SQL::TupleDescriptor> descriptor = adopt_ref(*new SQL::TupleDescriptor);
605 descriptor->append({ "schema", "table", "col1", SQL::SQLType::Text, SQL::Order::Ascending });
606 descriptor->append({ "schema", "table", "col2", SQL::SQLType::Integer, SQL::Order::Descending });
607 SQL::Tuple tuple(descriptor);
608
609 tuple["col1"] = "Test";
610 tuple["col2"] = 42;
611 EXPECT_EQ(tuple[0], "Test"sv);
612 EXPECT_EQ(tuple[1], 42);
613}
614
615TEST_CASE(serialize_tuple)
616{
617 NonnullRefPtr<SQL::TupleDescriptor> descriptor = adopt_ref(*new SQL::TupleDescriptor);
618 descriptor->append({ "schema", "table", "col1", SQL::SQLType::Text, SQL::Order::Ascending });
619 descriptor->append({ "schema", "table", "col2", SQL::SQLType::Integer, SQL::Order::Descending });
620 SQL::Tuple tuple(descriptor);
621
622 tuple["col1"] = "Test";
623 tuple["col2"] = 42;
624
625 EXPECT_EQ(tuple[0], "Test"sv);
626 EXPECT_EQ(tuple[1], 42);
627
628 SQL::Serializer serializer;
629 serializer.serialize<SQL::Tuple>(tuple);
630
631 serializer.rewind();
632 auto tuple2 = serializer.deserialize<SQL::Tuple>();
633 EXPECT_EQ(tuple2[0], "Test"sv);
634 EXPECT_EQ(tuple2[1], 42);
635}
636
637TEST_CASE(copy_tuple)
638{
639 NonnullRefPtr<SQL::TupleDescriptor> descriptor = adopt_ref(*new SQL::TupleDescriptor);
640 descriptor->append({ "schema", "table", "col1", SQL::SQLType::Text, SQL::Order::Ascending });
641 descriptor->append({ "schema", "table", "col2", SQL::SQLType::Integer, SQL::Order::Descending });
642 SQL::Tuple tuple(descriptor);
643
644 tuple["col1"] = "Test";
645 tuple["col2"] = 42;
646
647 SQL::Tuple copy;
648 copy = tuple;
649 EXPECT_EQ(tuple, copy);
650
651 SQL::Tuple copy_2(copy);
652 EXPECT_EQ(tuple, copy_2);
653}
654
655TEST_CASE(compare_tuples)
656{
657 NonnullRefPtr<SQL::TupleDescriptor> descriptor = adopt_ref(*new SQL::TupleDescriptor);
658 descriptor->append({ "schema", "table", "col1", SQL::SQLType::Text, SQL::Order::Ascending });
659 descriptor->append({ "schema", "table", "col2", SQL::SQLType::Integer, SQL::Order::Descending });
660
661 SQL::Tuple tuple1(descriptor);
662 tuple1["col1"] = "Test";
663 tuple1["col2"] = 42;
664
665 SQL::Tuple tuple2(descriptor);
666 tuple2["col1"] = "Test";
667 tuple2["col2"] = 12;
668
669 SQL::Tuple tuple3(descriptor);
670 tuple3["col1"] = "Text";
671 tuple3["col2"] = 12;
672
673 EXPECT(tuple1 <= tuple2);
674 EXPECT(tuple1 < tuple2);
675 EXPECT(tuple2 >= tuple1);
676 EXPECT(tuple2 > tuple1);
677
678 EXPECT(tuple1 <= tuple3);
679 EXPECT(tuple1 < tuple3);
680 EXPECT(tuple3 >= tuple1);
681 EXPECT(tuple3 > tuple1);
682}
683
684TEST_CASE(add)
685{
686 {
687 SQL::Value value1 { 21 };
688 SQL::Value value2 { 42 };
689
690 auto result = value1.add(value2);
691 EXPECT(!result.is_error());
692 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
693 EXPECT_EQ(result.value(), 63);
694 }
695 {
696 SQL::Value value1 { 21 };
697 SQL::Value value2 { static_cast<u8>(42) };
698
699 auto result = value1.add(value2);
700 EXPECT(!result.is_error());
701 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
702 EXPECT_EQ(result.value(), 63);
703 }
704 {
705 SQL::Value value1 { static_cast<u8>(21) };
706 SQL::Value value2 { 42 };
707
708 auto result = value1.add(value2);
709 EXPECT(!result.is_error());
710 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
711 EXPECT_EQ(result.value(), 63);
712 }
713 {
714 SQL::Value value1 { static_cast<double>(21) };
715 SQL::Value value2 { 42 };
716
717 auto result = value1.add(value2);
718 EXPECT(!result.is_error());
719 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
720 EXPECT_EQ(result.value(), 63);
721 }
722 {
723 SQL::Value value1 { static_cast<double>(21.5) };
724 SQL::Value value2 { 42 };
725
726 auto result = value1.add(value2);
727 EXPECT(!result.is_error());
728 EXPECT_EQ(result.value().type(), SQL::SQLType::Float);
729 EXPECT((result.value().to_double().value() - 63.5) < NumericLimits<double>().epsilon());
730 }
731}
732
733TEST_CASE(add_error)
734{
735 {
736 // Fails to coerce value2 to the signedness of value1.
737 SQL::Value value1 { 1 };
738 SQL::Value value2 { NumericLimits<u64>::max() };
739
740 auto result = value1.add(value2);
741 EXPECT(result.is_error());
742 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
743 }
744 {
745 // Fails to coerce value2 to the signedness of value1.
746 SQL::Value value1 { static_cast<u64>(1) };
747 SQL::Value value2 { -1 };
748
749 auto result = value1.add(value2);
750 EXPECT(result.is_error());
751 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
752 }
753 {
754 // The operation itself would overflow.
755 SQL::Value value1 { static_cast<u64>(1) };
756 SQL::Value value2 { NumericLimits<u64>::max() };
757
758 auto result = value1.add(value2);
759 EXPECT(result.is_error());
760 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
761 }
762 {
763 // Cannot convert value to a number.
764 SQL::Value value1 { 1 };
765 SQL::Value value2 { "foo"sv };
766
767 auto result = value1.add(value2);
768 EXPECT(result.is_error());
769 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::NumericOperatorTypeMismatch);
770 }
771}
772
773TEST_CASE(subtract)
774{
775 {
776 SQL::Value value1 { 21 };
777 SQL::Value value2 { 42 };
778
779 auto result = value1.subtract(value2);
780 EXPECT(!result.is_error());
781 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
782 EXPECT_EQ(result.value(), -21);
783 }
784 {
785 SQL::Value value1 { 21 };
786 SQL::Value value2 { static_cast<u8>(42) };
787
788 auto result = value1.subtract(value2);
789 EXPECT(!result.is_error());
790 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
791 EXPECT_EQ(result.value(), -21);
792 }
793 {
794 SQL::Value value1 { static_cast<u8>(42) };
795 SQL::Value value2 { 21 };
796
797 auto result = value1.subtract(value2);
798 EXPECT(!result.is_error());
799 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
800 EXPECT_EQ(result.value(), 21);
801 }
802 {
803 SQL::Value value1 { static_cast<double>(21) };
804 SQL::Value value2 { 42 };
805
806 auto result = value1.subtract(value2);
807 EXPECT(!result.is_error());
808 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
809 EXPECT_EQ(result.value(), -21);
810 }
811 {
812 SQL::Value value1 { static_cast<double>(21.5) };
813 SQL::Value value2 { 42 };
814
815 auto result = value1.subtract(value2);
816 EXPECT(!result.is_error());
817 EXPECT_EQ(result.value().type(), SQL::SQLType::Float);
818 EXPECT((result.value().to_double().value() - 20.5) < NumericLimits<double>().epsilon());
819 }
820}
821
822TEST_CASE(subtract_error)
823{
824 {
825 // Fails to coerce value2 to the signedness of value1.
826 SQL::Value value1 { 1 };
827 SQL::Value value2 { NumericLimits<u64>::max() };
828
829 auto result = value1.subtract(value2);
830 EXPECT(result.is_error());
831 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
832 }
833 {
834 // Fails to coerce value2 to the signedness of value1.
835 SQL::Value value1 { static_cast<u64>(1) };
836 SQL::Value value2 { -1 };
837
838 auto result = value1.subtract(value2);
839 EXPECT(result.is_error());
840 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
841 }
842 {
843 // The operation itself would overflow.
844 SQL::Value value1 { static_cast<u64>(0) };
845 SQL::Value value2 { static_cast<u64>(1) };
846
847 auto result = value1.subtract(value2);
848 EXPECT(result.is_error());
849 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
850 }
851 {
852 // Cannot convert value to a number.
853 SQL::Value value1 { 1 };
854 SQL::Value value2 { "foo"sv };
855
856 auto result = value1.subtract(value2);
857 EXPECT(result.is_error());
858 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::NumericOperatorTypeMismatch);
859 }
860}
861
862TEST_CASE(multiply)
863{
864 {
865 SQL::Value value1 { 2 };
866 SQL::Value value2 { 21 };
867
868 auto result = value1.multiply(value2);
869 EXPECT(!result.is_error());
870 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
871 EXPECT_EQ(result.value(), 42);
872 }
873 {
874 SQL::Value value1 { 2 };
875 SQL::Value value2 { static_cast<u8>(21) };
876
877 auto result = value1.multiply(value2);
878 EXPECT(!result.is_error());
879 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
880 EXPECT_EQ(result.value(), 42);
881 }
882 {
883 SQL::Value value1 { static_cast<u8>(2) };
884 SQL::Value value2 { 21 };
885
886 auto result = value1.multiply(value2);
887 EXPECT(!result.is_error());
888 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
889 EXPECT_EQ(result.value(), 42);
890 }
891 {
892 SQL::Value value1 { static_cast<double>(2) };
893 SQL::Value value2 { 21 };
894
895 auto result = value1.multiply(value2);
896 EXPECT(!result.is_error());
897 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
898 EXPECT_EQ(result.value(), 42);
899 }
900 {
901 SQL::Value value1 { static_cast<double>(2.5) };
902 SQL::Value value2 { 21 };
903
904 auto result = value1.multiply(value2);
905 EXPECT(!result.is_error());
906 EXPECT_EQ(result.value().type(), SQL::SQLType::Float);
907 EXPECT((result.value().to_double().value() - 52.5) < NumericLimits<double>().epsilon());
908 }
909}
910
911TEST_CASE(multiply_error)
912{
913 {
914 // Fails to coerce value2 to the signedness of value1.
915 SQL::Value value1 { 1 };
916 SQL::Value value2 { NumericLimits<u64>::max() };
917
918 auto result = value1.multiply(value2);
919 EXPECT(result.is_error());
920 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
921 }
922 {
923 // Fails to coerce value2 to the signedness of value1.
924 SQL::Value value1 { static_cast<u64>(1) };
925 SQL::Value value2 { -1 };
926
927 auto result = value1.multiply(value2);
928 EXPECT(result.is_error());
929 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
930 }
931 {
932 // The operation itself would overflow.
933 SQL::Value value1 { NumericLimits<i64>::max() };
934 SQL::Value value2 { 2 };
935
936 auto result = value1.multiply(value2);
937 EXPECT(result.is_error());
938 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
939 }
940 {
941 // Cannot convert value to a number.
942 SQL::Value value1 { 1 };
943 SQL::Value value2 { "foo"sv };
944
945 auto result = value1.multiply(value2);
946 EXPECT(result.is_error());
947 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::NumericOperatorTypeMismatch);
948 }
949}
950
951TEST_CASE(divide)
952{
953 {
954 SQL::Value value1 { 42 };
955 SQL::Value value2 { -2 };
956
957 auto result = value1.divide(value2);
958 EXPECT(!result.is_error());
959 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
960 EXPECT_EQ(result.value(), -21);
961 }
962 {
963 SQL::Value value1 { 42 };
964 SQL::Value value2 { static_cast<u8>(2) };
965
966 auto result = value1.divide(value2);
967 EXPECT(!result.is_error());
968 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
969 EXPECT_EQ(result.value(), 21);
970 }
971 {
972 SQL::Value value1 { static_cast<u8>(42) };
973 SQL::Value value2 { 2 };
974
975 auto result = value1.divide(value2);
976 EXPECT(!result.is_error());
977 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
978 EXPECT_EQ(result.value(), 21);
979 }
980 {
981 SQL::Value value1 { static_cast<double>(42) };
982 SQL::Value value2 { 2 };
983
984 auto result = value1.divide(value2);
985 EXPECT(!result.is_error());
986 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
987 EXPECT_EQ(result.value(), 21);
988 }
989 {
990 SQL::Value value1 { static_cast<double>(43) };
991 SQL::Value value2 { 2 };
992
993 auto result = value1.divide(value2);
994 EXPECT(!result.is_error());
995 EXPECT_EQ(result.value().type(), SQL::SQLType::Float);
996 EXPECT((result.value().to_double().value() - 21.5) < NumericLimits<double>().epsilon());
997 }
998}
999
1000TEST_CASE(divide_error)
1001{
1002 {
1003 // The operation itself would overflow.
1004 SQL::Value value1 { 1 };
1005 SQL::Value value2 { 0 };
1006
1007 auto result = value1.divide(value2);
1008 EXPECT(result.is_error());
1009 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
1010 }
1011 {
1012 // Cannot convert value to a number.
1013 SQL::Value value1 { 1 };
1014 SQL::Value value2 { "foo"sv };
1015
1016 auto result = value1.divide(value2);
1017 EXPECT(result.is_error());
1018 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::NumericOperatorTypeMismatch);
1019 }
1020}
1021
1022TEST_CASE(modulo)
1023{
1024 {
1025 SQL::Value value1 { 21 };
1026 SQL::Value value2 { 2 };
1027
1028 auto result = value1.modulo(value2);
1029 EXPECT(!result.is_error());
1030 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
1031 EXPECT_EQ(result.value(), 1);
1032 }
1033 {
1034 SQL::Value value1 { 21 };
1035 SQL::Value value2 { static_cast<u8>(2) };
1036
1037 auto result = value1.modulo(value2);
1038 EXPECT(!result.is_error());
1039 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
1040 EXPECT_EQ(result.value(), 1);
1041 }
1042 {
1043 SQL::Value value1 { static_cast<u8>(21) };
1044 SQL::Value value2 { 2 };
1045
1046 auto result = value1.modulo(value2);
1047 EXPECT(!result.is_error());
1048 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
1049 EXPECT_EQ(result.value(), 1);
1050 }
1051 {
1052 SQL::Value value1 { static_cast<double>(21) };
1053 SQL::Value value2 { 2 };
1054
1055 auto result = value1.modulo(value2);
1056 EXPECT(!result.is_error());
1057 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
1058 EXPECT_EQ(result.value(), 1);
1059 }
1060}
1061
1062TEST_CASE(modulo_error)
1063{
1064 {
1065 // Fails to coerce value2 to the signedness of value1.
1066 SQL::Value value1 { 1 };
1067 SQL::Value value2 { NumericLimits<u64>::max() };
1068
1069 auto result = value1.modulo(value2);
1070 EXPECT(result.is_error());
1071 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
1072 }
1073 {
1074 // Fails to coerce value2 to the signedness of value1.
1075 SQL::Value value1 { static_cast<u64>(1) };
1076 SQL::Value value2 { -1 };
1077
1078 auto result = value1.modulo(value2);
1079 EXPECT(result.is_error());
1080 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
1081 }
1082 {
1083 // The operation itself would overflow.
1084 SQL::Value value1 { 21 };
1085 SQL::Value value2 { 0 };
1086
1087 auto result = value1.modulo(value2);
1088 EXPECT(result.is_error());
1089 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
1090 }
1091 {
1092 // Cannot convert value to an integer.
1093 SQL::Value value1 { 1 };
1094 SQL::Value value2 { "foo"sv };
1095
1096 auto result = value1.modulo(value2);
1097 EXPECT(result.is_error());
1098 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::NumericOperatorTypeMismatch);
1099 }
1100 {
1101 // Cannot convert value to an integer.
1102 SQL::Value value1 { static_cast<double>(21.5) };
1103 SQL::Value value2 { 2 };
1104
1105 auto result = value1.modulo(value2);
1106 EXPECT(result.is_error());
1107 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::NumericOperatorTypeMismatch);
1108 }
1109}
1110
1111TEST_CASE(shift_left)
1112{
1113 {
1114 SQL::Value value1 { 0b0011'0000 };
1115 SQL::Value value2 { 2 };
1116
1117 auto result = value1.shift_left(value2);
1118 EXPECT(!result.is_error());
1119 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
1120 EXPECT_EQ(result.value(), 0b1100'0000);
1121 }
1122 {
1123 SQL::Value value1 { 0b0011'0000 };
1124 SQL::Value value2 { static_cast<u8>(2) };
1125
1126 auto result = value1.shift_left(value2);
1127 EXPECT(!result.is_error());
1128 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
1129 EXPECT_EQ(result.value(), 0b1100'0000);
1130 }
1131 {
1132 SQL::Value value1 { static_cast<u8>(0b0011'0000) };
1133 SQL::Value value2 { 2 };
1134
1135 auto result = value1.shift_left(value2);
1136 EXPECT(!result.is_error());
1137 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
1138 EXPECT_EQ(result.value(), 0b1100'0000);
1139 }
1140 {
1141 SQL::Value value1 { static_cast<double>(0b0011'0000) };
1142 SQL::Value value2 { 2 };
1143
1144 auto result = value1.shift_left(value2);
1145 EXPECT(!result.is_error());
1146 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
1147 EXPECT_EQ(result.value(), 0b1100'0000);
1148 }
1149}
1150
1151TEST_CASE(shift_left_error)
1152{
1153 {
1154 // Fails to coerce value2 to the signedness of value1.
1155 SQL::Value value1 { 1 };
1156 SQL::Value value2 { NumericLimits<u64>::max() };
1157
1158 auto result = value1.shift_left(value2);
1159 EXPECT(result.is_error());
1160 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
1161 }
1162 {
1163 // Fails to coerce value2 to the signedness of value1.
1164 SQL::Value value1 { static_cast<u64>(1) };
1165 SQL::Value value2 { -1 };
1166
1167 auto result = value1.shift_left(value2);
1168 EXPECT(result.is_error());
1169 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
1170 }
1171 {
1172 // The operation itself would overflow.
1173 SQL::Value value1 { 21 };
1174 SQL::Value value2 { -1 };
1175
1176 auto result = value1.shift_left(value2);
1177 EXPECT(result.is_error());
1178 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
1179 }
1180 {
1181 // The operation itself would overflow.
1182 SQL::Value value1 { 21 };
1183 SQL::Value value2 { 64 };
1184
1185 auto result = value1.shift_left(value2);
1186 EXPECT(result.is_error());
1187 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
1188 }
1189 {
1190 // Cannot convert value to an integer.
1191 SQL::Value value1 { 1 };
1192 SQL::Value value2 { "foo"sv };
1193
1194 auto result = value1.shift_left(value2);
1195 EXPECT(result.is_error());
1196 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::NumericOperatorTypeMismatch);
1197 }
1198 {
1199 // Cannot convert value to an integer.
1200 SQL::Value value1 { static_cast<double>(21.5) };
1201 SQL::Value value2 { 2 };
1202
1203 auto result = value1.shift_left(value2);
1204 EXPECT(result.is_error());
1205 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::NumericOperatorTypeMismatch);
1206 }
1207}
1208
1209TEST_CASE(shift_right)
1210{
1211 {
1212 SQL::Value value1 { 0b0011'0000 };
1213 SQL::Value value2 { 2 };
1214
1215 auto result = value1.shift_right(value2);
1216 EXPECT(!result.is_error());
1217 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
1218 EXPECT_EQ(result.value(), 0b0000'1100);
1219 }
1220 {
1221 SQL::Value value1 { 0b0011'0000 };
1222 SQL::Value value2 { static_cast<u8>(2) };
1223
1224 auto result = value1.shift_right(value2);
1225 EXPECT(!result.is_error());
1226 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
1227 EXPECT_EQ(result.value(), 0b0000'1100);
1228 }
1229 {
1230 SQL::Value value1 { static_cast<u8>(0b0011'0000) };
1231 SQL::Value value2 { 2 };
1232
1233 auto result = value1.shift_right(value2);
1234 EXPECT(!result.is_error());
1235 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
1236 EXPECT_EQ(result.value(), 0b0000'1100);
1237 }
1238 {
1239 SQL::Value value1 { static_cast<double>(0b0011'0000) };
1240 SQL::Value value2 { 2 };
1241
1242 auto result = value1.shift_right(value2);
1243 EXPECT(!result.is_error());
1244 EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
1245 EXPECT_EQ(result.value(), 0b0000'1100);
1246 }
1247}
1248
1249TEST_CASE(shift_right_error)
1250{
1251 {
1252 // Fails to coerce value2 to the signedness of value1.
1253 SQL::Value value1 { 1 };
1254 SQL::Value value2 { NumericLimits<u64>::max() };
1255
1256 auto result = value1.shift_right(value2);
1257 EXPECT(result.is_error());
1258 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
1259 }
1260 {
1261 // Fails to coerce value2 to the signedness of value1.
1262 SQL::Value value1 { static_cast<u64>(1) };
1263 SQL::Value value2 { -1 };
1264
1265 auto result = value1.shift_right(value2);
1266 EXPECT(result.is_error());
1267 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
1268 }
1269 {
1270 // The operation itself would overflow.
1271 SQL::Value value1 { 21 };
1272 SQL::Value value2 { -1 };
1273
1274 auto result = value1.shift_right(value2);
1275 EXPECT(result.is_error());
1276 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
1277 }
1278 {
1279 // The operation itself would overflow.
1280 SQL::Value value1 { 21 };
1281 SQL::Value value2 { 64 };
1282
1283 auto result = value1.shift_right(value2);
1284 EXPECT(result.is_error());
1285 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::IntegerOverflow);
1286 }
1287 {
1288 // Cannot convert value to an integer.
1289 SQL::Value value1 { 1 };
1290 SQL::Value value2 { "foo"sv };
1291
1292 auto result = value1.shift_right(value2);
1293 EXPECT(result.is_error());
1294 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::NumericOperatorTypeMismatch);
1295 }
1296 {
1297 // Cannot convert value to an integer.
1298 SQL::Value value1 { static_cast<double>(21.5) };
1299 SQL::Value value2 { 2 };
1300
1301 auto result = value1.shift_right(value2);
1302 EXPECT(result.is_error());
1303 EXPECT_EQ(result.error().error(), SQL::SQLErrorCode::NumericOperatorTypeMismatch);
1304 }
1305}