Skip to content

Commit 3aace6b

Browse files
sdf-jklsdf-jkl
authored
move cast_to_variant tests to slt (#38)
* move cast_to_variant tests to slt * change comment
1 parent ff2957e commit 3aace6b

3 files changed

Lines changed: 107 additions & 289 deletions

File tree

‎src/cast_to_variant.rs‎

Lines changed: 2 additions & 288 deletions
Original file line numberDiff line numberDiff line change
@@ -191,86 +191,13 @@ impl ScalarUDFImpl for CastToVariantUdf {
191191

192192
#[cfg(test)]
193193
mod tests {
194-
195-
use arrow::array::{FixedSizeBinaryBuilder, Int32Array, StringArray, StringViewArray};
196-
use arrow_schema::Fields;
197-
use parquet_variant::Variant;
198-
use parquet_variant_compute::{VariantArray, VariantType};
199-
200-
use crate::shared::{build_variant_array_from_json, build_variant_array_from_json_array};
201-
202194
use super::*;
203-
204-
#[test]
205-
fn test_scalar_float64() {
206-
let udf = CastToVariantUdf::default();
207-
208-
let arg_field = Arc::new(Field::new("input", DataType::Float64, true));
209-
let return_field = Arc::new(Field::new(
210-
"res",
211-
udf.return_type(&[DataType::Float64]).unwrap(),
212-
true,
213-
));
214-
215-
let args = ScalarFunctionArgs {
216-
args: vec![ColumnarValue::Scalar(ScalarValue::Float64(Some(3.25)))],
217-
return_field,
218-
arg_fields: vec![arg_field],
219-
number_rows: Default::default(),
220-
config_options: Default::default(),
221-
};
222-
223-
let res = udf.invoke_with_args(args).unwrap();
224-
225-
let ColumnarValue::Scalar(ScalarValue::Struct(variant_array)) = res else {
226-
panic!("expected struct scalar")
227-
};
228-
229-
let variant_array = VariantArray::try_new(variant_array.as_ref()).unwrap();
230-
231-
assert_eq!(variant_array.value(0), Variant::Double(3.25));
232-
}
233-
234-
#[test]
235-
fn test_array_int32() {
236-
let udf = CastToVariantUdf::default();
237-
238-
let arg_field = Arc::new(Field::new("input", DataType::Int32, true));
239-
let return_field = Arc::new(Field::new(
240-
"res",
241-
udf.return_type(&[DataType::Int32]).unwrap(),
242-
true,
243-
));
244-
245-
let args = ScalarFunctionArgs {
246-
args: vec![ColumnarValue::Array(Arc::new(Int32Array::from(vec![
247-
Some(1),
248-
None,
249-
Some(-5),
250-
])) as ArrayRef)],
251-
return_field,
252-
arg_fields: vec![arg_field],
253-
number_rows: Default::default(),
254-
config_options: Default::default(),
255-
};
256-
257-
let res = udf.invoke_with_args(args).unwrap();
258-
259-
let ColumnarValue::Array(arr) = res else {
260-
panic!("expected array output")
261-
};
262-
263-
let variant_array = VariantArray::try_new(arr.as_ref()).unwrap();
264-
265-
assert_eq!(variant_array.value(0), Variant::Int32(1));
266-
assert!(variant_array.is_null(1));
267-
assert_eq!(variant_array.value(2), Variant::Int32(-5));
268-
}
195+
use arrow_schema::Fields;
196+
use parquet_variant_compute::VariantType;
269197

270198
#[test]
271199
fn test_return_field_extension_type() {
272200
let udf = CastToVariantUdf::default();
273-
274201
let arg_field = Arc::new(Field::new("input", DataType::Utf8, true));
275202

276203
let return_field = udf
@@ -289,217 +216,4 @@ mod tests {
289216
]))
290217
);
291218
}
292-
293-
#[test]
294-
fn test_scalar_binary_views() {
295-
let expected_variant_array = build_variant_array_from_json(&serde_json::json!({
296-
"name": "norm",
297-
}));
298-
299-
let (input_metadata, input_value) = {
300-
let metadata = expected_variant_array.metadata_field().value(0);
301-
let value = expected_variant_array.value_field().unwrap().value(0);
302-
303-
(metadata, value)
304-
};
305-
306-
let udf = CastToVariantUdf::default();
307-
308-
let metadata_field = Arc::new(Field::new("metadata", DataType::BinaryView, true));
309-
let variant_field = Arc::new(Field::new("value", DataType::BinaryView, true));
310-
311-
let return_field = Arc::new(Field::new(
312-
"res",
313-
udf.return_type(&[DataType::BinaryView, DataType::BinaryView])
314-
.unwrap(),
315-
true,
316-
));
317-
318-
let args = ScalarFunctionArgs {
319-
args: vec![
320-
ColumnarValue::Scalar(ScalarValue::BinaryView(Some(input_metadata.to_vec()))),
321-
ColumnarValue::Scalar(ScalarValue::BinaryView(Some(input_value.to_vec()))),
322-
],
323-
return_field,
324-
arg_fields: vec![metadata_field, variant_field],
325-
number_rows: Default::default(),
326-
config_options: Default::default(),
327-
};
328-
329-
let res = udf.invoke_with_args(args).unwrap();
330-
331-
let ColumnarValue::Scalar(ScalarValue::Struct(variant_array)) = res else {
332-
panic!("expected scalar value struct array")
333-
};
334-
335-
let variant_array = VariantArray::try_new(variant_array.as_ref()).unwrap();
336-
337-
assert_eq!(&variant_array, &expected_variant_array);
338-
}
339-
340-
#[test]
341-
fn test_array_string() {
342-
let udf = CastToVariantUdf::default();
343-
344-
let arg_field = Arc::new(Field::new("input", DataType::Utf8, true));
345-
let return_field = Arc::new(Field::new(
346-
"res",
347-
udf.return_type(&[DataType::Utf8]).unwrap(),
348-
true,
349-
));
350-
351-
let args = ScalarFunctionArgs {
352-
args: vec![ColumnarValue::Array(Arc::new(StringArray::from(vec![
353-
Some("abcdefghijklmnop"),
354-
None,
355-
Some("hello world"),
356-
])) as ArrayRef)],
357-
return_field,
358-
arg_fields: vec![arg_field],
359-
number_rows: Default::default(),
360-
config_options: Default::default(),
361-
};
362-
363-
let res = udf.invoke_with_args(args).unwrap();
364-
365-
let ColumnarValue::Array(arr) = res else {
366-
panic!("expected array output")
367-
};
368-
369-
let variant_array = VariantArray::try_new(arr.as_ref()).unwrap();
370-
371-
assert_eq!(variant_array.value(0), Variant::from("abcdefghijklmnop"));
372-
assert!(variant_array.is_null(1));
373-
assert_eq!(variant_array.value(2), Variant::from("hello world"));
374-
}
375-
376-
#[test]
377-
fn test_fixed_size_binary_uuid_like() {
378-
let udf = CastToVariantUdf::default();
379-
380-
let arg_field = Arc::new(Field::new("input", DataType::FixedSizeBinary(16), true));
381-
let return_field = Arc::new(Field::new(
382-
"res",
383-
udf.return_type(&[DataType::FixedSizeBinary(16)]).unwrap(),
384-
true,
385-
));
386-
387-
let mut builder = FixedSizeBinaryBuilder::with_capacity(3, 16);
388-
builder.append_value([1u8; 16]).unwrap();
389-
builder.append_null();
390-
builder.append_value([2u8; 16]).unwrap();
391-
let array = builder.finish();
392-
393-
let args = ScalarFunctionArgs {
394-
args: vec![ColumnarValue::Array(Arc::new(array) as ArrayRef)],
395-
return_field,
396-
arg_fields: vec![arg_field],
397-
number_rows: Default::default(),
398-
config_options: Default::default(),
399-
};
400-
401-
let res = udf.invoke_with_args(args).unwrap();
402-
403-
let ColumnarValue::Array(arr) = res else {
404-
panic!("expected array output")
405-
};
406-
407-
let variant_array = VariantArray::try_new(arr.as_ref()).unwrap();
408-
409-
assert_eq!(variant_array.value(0), Variant::Binary(&[1u8; 16]));
410-
assert!(variant_array.is_null(1));
411-
assert_eq!(variant_array.value(2), Variant::Binary(&[2u8; 16]));
412-
}
413-
414-
#[test]
415-
fn test_array_binary_views() {
416-
let expected_variant_array = build_variant_array_from_json_array(&[
417-
Some(serde_json::json!({
418-
"name": "norm",
419-
})),
420-
None,
421-
None,
422-
Some(serde_json::json!({
423-
"id": 1,
424-
"parent_id": 0,
425-
"child_ids": [2, 3, 4, 5]
426-
})),
427-
]);
428-
429-
let (input_metadata_array, input_value_array) = {
430-
let metadata = expected_variant_array.metadata_field().clone();
431-
let value = expected_variant_array.value_field().unwrap().clone();
432-
433-
(metadata, value)
434-
};
435-
436-
let udf = CastToVariantUdf::default();
437-
438-
let metadata_field = Arc::new(Field::new("metadata", DataType::BinaryView, true));
439-
let variant_field = Arc::new(Field::new("value", DataType::BinaryView, true));
440-
441-
let return_field = Arc::new(Field::new(
442-
"res",
443-
udf.return_type(&[DataType::BinaryView, DataType::BinaryView])
444-
.unwrap(),
445-
true,
446-
));
447-
448-
let args = ScalarFunctionArgs {
449-
args: vec![
450-
ColumnarValue::Array(Arc::new(input_metadata_array) as ArrayRef),
451-
ColumnarValue::Array(Arc::new(input_value_array) as ArrayRef),
452-
],
453-
return_field,
454-
arg_fields: vec![metadata_field, variant_field],
455-
number_rows: Default::default(),
456-
config_options: Default::default(),
457-
};
458-
459-
let res = udf.invoke_with_args(args).unwrap();
460-
461-
let ColumnarValue::Array(variant_array) = res else {
462-
panic!("expected scalar value struct array")
463-
};
464-
465-
let variant_array = VariantArray::try_new(variant_array.as_ref()).unwrap();
466-
467-
assert_eq!(&variant_array, &expected_variant_array);
468-
}
469-
470-
#[test]
471-
fn test_array_string_view() {
472-
let udf = CastToVariantUdf::default();
473-
474-
let arg_field = Arc::new(Field::new("input", DataType::Utf8View, true));
475-
let return_field = Arc::new(Field::new(
476-
"res",
477-
udf.return_type(&[DataType::Utf8View]).unwrap(),
478-
true,
479-
));
480-
481-
let args = ScalarFunctionArgs {
482-
args: vec![ColumnarValue::Array(Arc::new(StringViewArray::from(vec![
483-
Some("short"),
484-
None,
485-
Some("another"),
486-
])) as ArrayRef)],
487-
return_field,
488-
arg_fields: vec![arg_field],
489-
number_rows: Default::default(),
490-
config_options: Default::default(),
491-
};
492-
493-
let res = udf.invoke_with_args(args).unwrap();
494-
495-
let ColumnarValue::Array(arr) = res else {
496-
panic!("expected array output")
497-
};
498-
499-
let variant_array = VariantArray::try_new(arr.as_ref()).unwrap();
500-
501-
assert_eq!(variant_array.value(0), Variant::from("short"));
502-
assert!(variant_array.is_null(1));
503-
assert_eq!(variant_array.value(2), Variant::from("another"));
504-
}
505219
}

‎tests/sqllogictests.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ async fn run_sqllogictests() -> Result<(), Box<dyn std::error::Error>> {
3030
test_files.sort();
3131

3232
for test_file in test_files {
33-
println!("Running test file: {:?}", test_file);
33+
println!("Running test file: {test_file:?}");
3434

3535
let relative_path = test_file
3636
.strip_prefix(&test_files_dir)

0 commit comments

Comments
 (0)