chore: add additional test cases for fields and partitioning transforms to bids table schema

Author: burmecia

supabase-wrappers/src/interface.rs

@@ -948,3 +948,220 @@ pub trait ForeignDataWrapper<E: Into<ErrorReport>> {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn assert_cell_clone(cell: Cell) {
+        let cell_clone = cell.clone();
+
+        match (cell, cell_clone) {
+            (Cell::Bool(left), Cell::Bool(right)) => assert_eq!(left, right),
+            (Cell::I8(left), Cell::I8(right)) => assert_eq!(left, right),
+            (Cell::I16(left), Cell::I16(right)) => assert_eq!(left, right),
+            (Cell::F32(left), Cell::F32(right)) => assert_eq!(left, right),
+            (Cell::I32(left), Cell::I32(right)) => assert_eq!(left, right),
+            (Cell::F64(left), Cell::F64(right)) => assert_eq!(left, right),
+            (Cell::I64(left), Cell::I64(right)) => assert_eq!(left, right),
+            (Cell::String(left), Cell::String(right)) => assert_eq!(left, right),
+            (Cell::BoolArray(left), Cell::BoolArray(right)) => assert_eq!(left, right),
+            (Cell::I16Array(left), Cell::I16Array(right)) => assert_eq!(left, right),
+            (Cell::I32Array(left), Cell::I32Array(right)) => assert_eq!(left, right),
+            (Cell::I64Array(left), Cell::I64Array(right)) => assert_eq!(left, right),
+            (Cell::F32Array(left), Cell::F32Array(right)) => assert_eq!(left, right),
+            (Cell::F64Array(left), Cell::F64Array(right)) => assert_eq!(left, right),
+            (Cell::StringArray(left), Cell::StringArray(right)) => assert_eq!(left, right),
+            (left, right) => panic!("cell clone variant mismatch: left={left:?}, right={right:?}",),
+        }
+    }
+
+    // ==========================================================================
+    // Tests for Cell
+    // ==========================================================================
+    #[test]
+    fn test_cell_clone() {
+        let cell = Cell::String("hello".to_string());
+        assert_cell_clone(cell);
+    }
+
+    #[test]
+    fn test_cell_clone_primitives() {
+        let cases = vec![
+            Cell::Bool(true),
+            Cell::I8(-8),
+            Cell::I16(-16),
+            Cell::F32(123.456f32),
+            Cell::I32(32),
+            Cell::F64(654.321f64),
+            Cell::I64(64),
+            Cell::String("supabase".to_string()),
+        ];
+
+        for cell in cases {
+            assert_cell_clone(cell);
+        }
+    }
+
+    #[test]
+    fn test_cell_clone_array_variants() {
+        let cases = vec![
+            Cell::BoolArray(vec![Some(true), None, Some(false)]),
+            Cell::I16Array(vec![Some(-1), None, Some(2)]),
+            Cell::I32Array(vec![Some(-10), None, Some(20)]),
+            Cell::I64Array(vec![Some(-100), None, Some(200)]),
+            Cell::F32Array(vec![Some(1.5), None, Some(2.5)]),
+            Cell::F64Array(vec![Some(10.5), None, Some(20.5)]),
+            Cell::StringArray(vec![Some("a".to_string()), None, Some("b".to_string())]),
+        ];
+
+        for cell in cases {
+            let cell_clone = cell.clone();
+            assert_cell_clone(cell);
+            assert!(cell_clone.is_array());
+        }
+    }
+
+    #[test]
+    fn test_cell_clone_deep_copy_for_owned_types() {
+        let mut string_cell = Cell::String("hello".to_string());
+        let string_cell_clone = string_cell.clone();
+        if let Cell::String(value) = &mut string_cell {
+            value.push_str(" world");
+        }
+        match string_cell_clone {
+            Cell::String(value) => assert_eq!(value, "hello"),
+            other => panic!("expected Cell::String clone, got {other:?}"),
+        }
+        match string_cell {
+            Cell::String(value) => assert_eq!(value, "hello world"),
+            other => panic!("expected mutated Cell::String, got {other:?}"),
+        }
+
+        let mut string_array_cell =
+            Cell::StringArray(vec![Some("foo".to_string()), None, Some("bar".to_string())]);
+        let string_array_cell_clone = string_array_cell.clone();
+        if let Cell::StringArray(values) = &mut string_array_cell {
+            values[0] = Some("baz".to_string());
+        }
+        match string_array_cell_clone {
+            Cell::StringArray(values) => {
+                assert_eq!(
+                    values,
+                    vec![Some("foo".to_string()), None, Some("bar".to_string())]
+                )
+            }
+            other => panic!("expected Cell::StringArray clone, got {other:?}"),
+        }
+        match string_array_cell {
+            Cell::StringArray(values) => {
+                assert_eq!(
+                    values,
+                    vec![Some("baz".to_string()), None, Some("bar".to_string())]
+                )
+            }
+            other => panic!("expected mutated Cell::StringArray, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn test_cell_display_primitives_and_string() {
+        assert_eq!(format!("{}", Cell::Bool(true)), "true");
+        assert_eq!(format!("{}", Cell::I8(-8)), "-8");
+        assert_eq!(format!("{}", Cell::I16(16)), "16");
+        assert_eq!(format!("{}", Cell::I32(32)), "32");
+        assert_eq!(format!("{}", Cell::I64(64)), "64");
+        assert_eq!(format!("{}", Cell::F32(3.5)), "3.5");
+        assert_eq!(format!("{}", Cell::F64(7.25)), "7.25");
+        assert_eq!(format!("{}", Cell::String("hello".to_string())), "'hello'");
+    }
+
+    #[test]
+    fn test_cell_display_arrays_with_nulls() {
+        assert_eq!(
+            format!("{}", Cell::BoolArray(vec![Some(true), None, Some(false)])),
+            "[true,null,false]"
+        );
+        assert_eq!(
+            format!("{}", Cell::I32Array(vec![Some(1), None, Some(3)])),
+            "[1,null,3]"
+        );
+        assert_eq!(
+            format!(
+                "{}",
+                Cell::StringArray(vec![Some("foo".to_string()), None, Some("bar".to_string())])
+            ),
+            "[foo,null,bar]"
+        );
+    }
+
+    #[test]
+    fn test_cell_display_empty_arrays() {
+        assert_eq!(format!("{}", Cell::BoolArray(vec![])), "[]");
+        assert_eq!(format!("{}", Cell::I16Array(vec![])), "[]");
+        assert_eq!(format!("{}", Cell::I32Array(vec![])), "[]");
+        assert_eq!(format!("{}", Cell::I64Array(vec![])), "[]");
+        assert_eq!(format!("{}", Cell::F32Array(vec![])), "[]");
+        assert_eq!(format!("{}", Cell::F64Array(vec![])), "[]");
+        assert_eq!(format!("{}", Cell::StringArray(vec![])), "[]");
+    }
+
+    #[cfg(feature = "pg_test")]
+    #[test]
+    fn test_cell_into_datum_scalars_round_trip() {
+        let bool_datum = Cell::Bool(true).into_datum().expect("bool should convert");
+        let bool_value =
+            unsafe { bool::from_datum(bool_datum, false) }.expect("bool should decode");
+        assert!(bool_value);
+
+        let i32_datum = Cell::I32(42).into_datum().expect("i32 should convert");
+        let i32_value = unsafe { i32::from_datum(i32_datum, false) }.expect("i32 should decode");
+        assert_eq!(i32_value, 42);
+
+        let f64_datum = Cell::F64(12.5).into_datum().expect("f64 should convert");
+        let f64_value = unsafe { f64::from_datum(f64_datum, false) }.expect("f64 should decode");
+        assert_eq!(f64_value, 12.5);
+
+        let string_datum = Cell::String("hello".to_string())
+            .into_datum()
+            .expect("string should convert");
+        let string_value =
+            unsafe { String::from_datum(string_datum, false) }.expect("string should decode");
+        assert_eq!(string_value, "hello");
+    }
+
+    #[cfg(feature = "pg_test")]
+    #[test]
+    fn test_cell_into_datum_arrays_round_trip() {
+        let bool_array_datum = Cell::BoolArray(vec![Some(true), None, Some(false)])
+            .into_datum()
+            .expect("bool array should convert");
+        let bool_array_value = unsafe { Vec::<Option<bool>>::from_datum(bool_array_datum, false) }
+            .expect("bool array should decode");
+        assert_eq!(bool_array_value, vec![Some(true), None, Some(false)]);
+
+        let i64_array_datum = Cell::I64Array(vec![Some(1), None, Some(3)])
+            .into_datum()
+            .expect("i64 array should convert");
+        let i64_array_value = unsafe { Vec::<Option<i64>>::from_datum(i64_array_datum, false) }
+            .expect("i64 array should decode");
+        assert_eq!(i64_array_value, vec![Some(1), None, Some(3)]);
+
+        let string_array_datum =
+            Cell::StringArray(vec![Some("foo".to_string()), None, Some("bar".to_string())])
+                .into_datum()
+                .expect("string array should convert");
+        let string_array_value =
+            unsafe { Vec::<Option<String>>::from_datum(string_array_datum, false) }
+                .expect("string array should decode");
+        assert_eq!(
+            string_array_value,
+            vec![Some("foo".to_string()), None, Some("bar".to_string())]
+        );
+    }
+
+    #[test]
+    fn test_cell_into_datum_type_oid_is_invalid() {
+        assert_eq!(Cell::type_oid(), Oid::INVALID);
+    }
+}

wrappers/dockerfiles/s3/iceberg_seed.py

@@ -141,6 +141,10 @@ def create_bids_table(catalog, namespace):
         NestedField(field_id=36, name="pat_icol", field_type=IntegerType(), required=False),
         NestedField(field_id=37, name="pat_lcol", field_type=LongType(), required=False),
         NestedField(field_id=38, name="pat_tcol", field_type=TimestampType(), required=False),
+        NestedField(field_id=39, name="pat_tzcol", field_type=TimestamptzType(), required=False),
+        NestedField(field_id=40, name="pat_dtcol2", field_type=DateType(), required=False),
+        NestedField(field_id=41, name="pat_tzcol2", field_type=TimestamptzType(), required=False),
+        NestedField(field_id=42, name="pat_tzcol3", field_type=TimestamptzType(), required=False),
 
         identifier_field_ids=[1],
     )
@@ -161,6 +165,9 @@ def create_bids_table(catalog, namespace):
         PartitionField(
             source_id=7, field_id=1008, transform=DayTransform(), name="dt_day"
         ),
+        PartitionField(
+            source_id=8, field_id=1009, transform=DayTransform(), name="tstz_day"
+        ),
         PartitionField(
             source_id=11, field_id=1010, transform=IdentityTransform(), name="bcol_ident"
         ),
@@ -188,6 +195,18 @@ def create_bids_table(catalog, namespace):
         PartitionField(
             source_id=38, field_id=1026, transform=MonthTransform(), name="pat_tcol_month"
         ),
+        PartitionField(
+            source_id=39, field_id=1028, transform=MonthTransform(), name="pat_tzcol_month"
+        ),
+        PartitionField(
+            source_id=40, field_id=1030, transform=YearTransform(), name="pat_dtcol2_year"
+        ),
+        PartitionField(
+            source_id=41, field_id=1032, transform=YearTransform(), name="pat_tzcol2_year"
+        ),
+        PartitionField(
+            source_id=42, field_id=1034, transform=HourTransform(), name="pat_tzcol3_hour"
+        ),
     )
 
     sort_order = SortOrder(fields=[