Skip to main content

reifydb_function/json/
object.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright (c) 2025 ReifyDB
3
4use reifydb_core::value::column::data::ColumnData;
5use reifydb_type::value::{Value, r#type::Type};
6
7use crate::{
8	ScalarFunction, ScalarFunctionContext,
9	error::{ScalarFunctionError, ScalarFunctionResult},
10	propagate_options,
11};
12
13pub struct JsonObject;
14
15impl JsonObject {
16	pub fn new() -> Self {
17		Self
18	}
19}
20
21impl ScalarFunction for JsonObject {
22	fn scalar(&self, ctx: ScalarFunctionContext) -> ScalarFunctionResult<ColumnData> {
23		if let Some(result) = propagate_options(self, &ctx) {
24			return result;
25		}
26
27		let columns = ctx.columns;
28		let row_count = ctx.row_count;
29
30		if columns.len() % 2 != 0 {
31			return Err(ScalarFunctionError::ExecutionFailed {
32				function: ctx.fragment.clone(),
33				reason: "json::object requires an even number of arguments (key-value pairs)"
34					.to_string(),
35			});
36		}
37
38		// Validate that key columns (even indices) are Utf8
39		for i in (0..columns.len()).step_by(2) {
40			let col = columns.get(i).unwrap();
41			match col.data() {
42				ColumnData::Utf8 {
43					..
44				} => {}
45				other => {
46					return Err(ScalarFunctionError::InvalidArgumentType {
47						function: ctx.fragment.clone(),
48						argument_index: i,
49						expected: vec![Type::Utf8],
50						actual: other.get_type(),
51					});
52				}
53			}
54		}
55
56		let num_pairs = columns.len() / 2;
57		let mut results: Vec<Box<Value>> = Vec::with_capacity(row_count);
58
59		for row in 0..row_count {
60			let mut fields = Vec::with_capacity(num_pairs);
61			for pair in 0..num_pairs {
62				let key_col = columns.get(pair * 2).unwrap();
63				let val_col = columns.get(pair * 2 + 1).unwrap();
64
65				let key: String = key_col.data().get_as::<String>(row).unwrap_or_default();
66				let value = val_col.data().get_value(row);
67
68				fields.push((key, value));
69			}
70			results.push(Box::new(Value::Record(fields)));
71		}
72
73		Ok(ColumnData::any(results))
74	}
75
76	fn return_type(&self, _input_types: &[Type]) -> Type {
77		Type::Any
78	}
79}