@@ -94,11 +94,11 @@ mod tests {
9494 FixedSizeBinaryBuilder , Float16Array , Float32Array , Float64Array , GenericByteBuilder ,
9595 GenericByteViewBuilder , Int16Array , Int32Array , Int64Array , Int8Array ,
9696 IntervalDayTimeArray , IntervalMonthDayNanoArray , IntervalYearMonthArray , LargeListArray ,
97- LargeStringArray , ListArray , MapArray , NullArray , StringArray , StringRunBuilder ,
98- StringViewArray , StructArray , Time32MillisecondArray , Time32SecondArray ,
99- Time64MicrosecondArray , Time64NanosecondArray , TimestampMicrosecondArray ,
100- TimestampMillisecondArray , TimestampNanosecondArray , TimestampSecondArray , UInt16Array ,
101- UInt32Array , UInt64Array , UInt8Array , UnionArray ,
97+ LargeListViewBuilder , LargeStringArray , ListArray , ListViewBuilder , MapArray , NullArray ,
98+ StringArray , StringRunBuilder , StringViewArray , StructArray , Time32MillisecondArray ,
99+ Time32SecondArray , Time64MicrosecondArray , Time64NanosecondArray ,
100+ TimestampMicrosecondArray , TimestampMillisecondArray , TimestampNanosecondArray ,
101+ TimestampSecondArray , UInt16Array , UInt32Array , UInt64Array , UInt8Array , UnionArray ,
102102 } ;
103103 use arrow:: buffer:: { NullBuffer , OffsetBuffer , ScalarBuffer } ;
104104 use arrow:: datatypes:: {
@@ -112,7 +112,8 @@ mod tests {
112112 use chrono:: { DateTime , NaiveDate , NaiveTime } ;
113113 use half:: f16;
114114 use parquet_variant:: {
115- Variant , VariantBuilder , VariantDecimal16 , VariantDecimal4 , VariantDecimal8 ,
115+ Variant , VariantBuilder , VariantBuilderExt , VariantDecimal16 , VariantDecimal4 ,
116+ VariantDecimal8 ,
116117 } ;
117118 use std:: { sync:: Arc , vec} ;
118119
@@ -1258,6 +1259,154 @@ mod tests {
12581259 ) ;
12591260 }
12601261
1262+ #[ test]
1263+ fn test_cast_to_variant_list_view ( ) {
1264+ // Create a ListViewArray with some data
1265+ let mut builder = ListViewBuilder :: new ( Int32Array :: builder ( 0 ) ) ;
1266+ builder. append_value ( & Int32Array :: from ( vec ! [ Some ( 0 ) , None , Some ( 2 ) ] ) ) ;
1267+ builder. append_value ( & Int32Array :: from ( vec ! [ Some ( 3 ) , Some ( 4 ) ] ) ) ;
1268+ builder. append_null ( ) ;
1269+ builder. append_value ( & Int32Array :: from ( vec ! [ None , None ] ) ) ;
1270+ let list_view_array = builder. finish ( ) ;
1271+
1272+ // Expected values
1273+ let ( metadata, value) = {
1274+ let mut builder = VariantBuilder :: new ( ) ;
1275+ let mut list = builder. new_list ( ) ;
1276+ list. append_value ( 0i32 ) ;
1277+ list. append_null ( ) ;
1278+ list. append_value ( 2i32 ) ;
1279+ list. finish ( ) ;
1280+ builder. finish ( )
1281+ } ;
1282+ let variant0 = Variant :: new ( & metadata, & value) ;
1283+
1284+ let ( metadata, value) = {
1285+ let mut builder = VariantBuilder :: new ( ) ;
1286+ let mut list = builder. new_list ( ) ;
1287+ list. append_value ( 3i32 ) ;
1288+ list. append_value ( 4i32 ) ;
1289+ list. finish ( ) ;
1290+ builder. finish ( )
1291+ } ;
1292+ let variant1 = Variant :: new ( & metadata, & value) ;
1293+
1294+ let ( metadata, value) = {
1295+ let mut builder = VariantBuilder :: new ( ) ;
1296+ let mut list = builder. new_list ( ) ;
1297+ list. append_null ( ) ;
1298+ list. append_null ( ) ;
1299+ list. finish ( ) ;
1300+ builder. finish ( )
1301+ } ;
1302+ let variant3 = Variant :: new ( & metadata, & value) ;
1303+
1304+ run_test (
1305+ Arc :: new ( list_view_array) ,
1306+ vec ! [ Some ( variant0) , Some ( variant1) , None , Some ( variant3) ] ,
1307+ ) ;
1308+ }
1309+
1310+ #[ test]
1311+ fn test_cast_to_variant_sliced_list_view ( ) {
1312+ // Create a ListViewArray with some data
1313+ let mut builder = ListViewBuilder :: new ( Int32Array :: builder ( 0 ) ) ;
1314+ builder. append_value ( & Int32Array :: from ( vec ! [ Some ( 0 ) , Some ( 1 ) , Some ( 2 ) ] ) ) ;
1315+ builder. append_value ( & Int32Array :: from ( vec ! [ Some ( 3 ) , None ] ) ) ;
1316+ builder. append_null ( ) ;
1317+ let list_view_array = builder. finish ( ) ;
1318+
1319+ // Expected value for slice(1, 2) - should get the second and third elements
1320+ let ( metadata, value) = {
1321+ let mut builder = VariantBuilder :: new ( ) ;
1322+ let mut list = builder. new_list ( ) ;
1323+ list. append_value ( 3i32 ) ;
1324+ list. append_null ( ) ;
1325+ list. finish ( ) ;
1326+ builder. finish ( )
1327+ } ;
1328+ let variant = Variant :: new ( & metadata, & value) ;
1329+
1330+ run_test (
1331+ Arc :: new ( list_view_array. slice ( 1 , 2 ) ) ,
1332+ vec ! [ Some ( variant) , None ] ,
1333+ ) ;
1334+ }
1335+
1336+ #[ test]
1337+ fn test_cast_to_variant_large_list_view ( ) {
1338+ // Create a LargeListViewArray with some data
1339+ let mut builder = LargeListViewBuilder :: new ( Int64Array :: builder ( 0 ) ) ;
1340+ builder. append_value ( & Int64Array :: from ( vec ! [ Some ( 0 ) , None , Some ( 2 ) ] ) ) ;
1341+ builder. append_value ( & Int64Array :: from ( vec ! [ Some ( 3 ) , Some ( 4 ) ] ) ) ;
1342+ builder. append_null ( ) ;
1343+ builder. append_value ( & Int64Array :: from ( vec ! [ None , None ] ) ) ;
1344+ let large_list_view_array = builder. finish ( ) ;
1345+
1346+ // Expected values
1347+ let ( metadata, value) = {
1348+ let mut builder = VariantBuilder :: new ( ) ;
1349+ let mut list = builder. new_list ( ) ;
1350+ list. append_value ( 0i64 ) ;
1351+ list. append_null ( ) ;
1352+ list. append_value ( 2i64 ) ;
1353+ list. finish ( ) ;
1354+ builder. finish ( )
1355+ } ;
1356+ let variant0 = Variant :: new ( & metadata, & value) ;
1357+
1358+ let ( metadata, value) = {
1359+ let mut builder = VariantBuilder :: new ( ) ;
1360+ let mut list = builder. new_list ( ) ;
1361+ list. append_value ( 3i64 ) ;
1362+ list. append_value ( 4i64 ) ;
1363+ list. finish ( ) ;
1364+ builder. finish ( )
1365+ } ;
1366+ let variant1 = Variant :: new ( & metadata, & value) ;
1367+
1368+ let ( metadata, value) = {
1369+ let mut builder = VariantBuilder :: new ( ) ;
1370+ let mut list = builder. new_list ( ) ;
1371+ list. append_null ( ) ;
1372+ list. append_null ( ) ;
1373+ list. finish ( ) ;
1374+ builder. finish ( )
1375+ } ;
1376+ let variant3 = Variant :: new ( & metadata, & value) ;
1377+
1378+ run_test (
1379+ Arc :: new ( large_list_view_array) ,
1380+ vec ! [ Some ( variant0) , Some ( variant1) , None , Some ( variant3) ] ,
1381+ ) ;
1382+ }
1383+
1384+ #[ test]
1385+ fn test_cast_to_variant_sliced_large_list_view ( ) {
1386+ // Create a LargeListViewArray with some data
1387+ let mut builder = LargeListViewBuilder :: new ( Int64Array :: builder ( 0 ) ) ;
1388+ builder. append_value ( & Int64Array :: from ( vec ! [ Some ( 0 ) , Some ( 1 ) , Some ( 2 ) ] ) ) ;
1389+ builder. append_value ( & Int64Array :: from ( vec ! [ Some ( 3 ) , None ] ) ) ;
1390+ builder. append_null ( ) ;
1391+ let large_list_view_array = builder. finish ( ) ;
1392+
1393+ // Expected value for slice(1, 2) - should get the second and third elements
1394+ let ( metadata, value) = {
1395+ let mut builder = VariantBuilder :: new ( ) ;
1396+ let mut list = builder. new_list ( ) ;
1397+ list. append_value ( 3i64 ) ;
1398+ list. append_null ( ) ;
1399+ list. finish ( ) ;
1400+ builder. finish ( )
1401+ } ;
1402+ let variant = Variant :: new ( & metadata, & value) ;
1403+
1404+ run_test (
1405+ Arc :: new ( large_list_view_array. slice ( 1 , 2 ) ) ,
1406+ vec ! [ Some ( variant) , None ] ,
1407+ ) ;
1408+ }
1409+
12611410 #[ test]
12621411 fn test_cast_to_variant_struct ( ) {
12631412 // Test a simple struct with two fields: id (int64) and age (int32)
0 commit comments