Skip to content

Commit 515e51e

Browse files
committed
test: fold the resolver's ambiguity tests into the tests that already cover them
Three of the new `field_resolver.rs` tests repeated rules that existing tests already reach through `match_struct_fields`. Remove them and keep what was new: `issue_5783_nested_name_duplicate` gains a field that differs from the duplicate only in case, which a case-sensitive read must resolve on its own, and `unrequested_duplicate_field_id_reads_fine` gains a name collision that the requested field's id match never compares.
1 parent 2cd2f2f commit 515e51e

3 files changed

Lines changed: 13 additions & 58 deletions

File tree

‎native/core/src/parquet/field_resolver.rs‎

Lines changed: 0 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -349,61 +349,4 @@ mod test {
349349
assert_eq!(resolver.select(0).unwrap(), Selection::ByName(&[1]));
350350
});
351351
}
352-
353-
/// `matchCaseInsensitiveField` folds names, and fails when the fold is ambiguous.
354-
#[test]
355-
fn case_insensitive_name_collision_is_an_error() {
356-
let requested = [field("b", None), field("c", None)];
357-
let file = [field("A", None), field("B", None), field("b", None)];
358-
with_resolver(&requested, &file, false, false, |resolver| {
359-
assert_eq!(resolver.select(0).unwrap(), Selection::ByName(&[1, 2]));
360-
let message = resolver.resolve(0).unwrap_err().to_string();
361-
assert!(
362-
message.contains("Found duplicate field(s)") && message.contains("[B, b]"),
363-
"{message}"
364-
);
365-
assert_eq!(resolver.resolve(1).unwrap(), None);
366-
});
367-
}
368-
369-
/// Case-sensitive matching compares exact names, so a repeated exact name is the only
370-
/// ambiguity. Comet rejects it where Spark would read the last field of that name.
371-
#[test]
372-
fn case_sensitive_repeated_name_is_an_error() {
373-
let requested = [field("b", None)];
374-
let file = [field("B", None), field("b", None), field("b", None)];
375-
with_resolver(&requested, &file, true, false, |resolver| {
376-
assert_eq!(resolver.select(0).unwrap(), Selection::ByName(&[1, 2]));
377-
let message = resolver.resolve(0).unwrap_err().to_string();
378-
assert!(
379-
message.contains("Found duplicate Parquet field name 'b'")
380-
&& !message.contains("case-insensitive"),
381-
"{message}"
382-
);
383-
});
384-
}
385-
386-
/// A requested id the file repeats raises `_LEGACY_ERROR_TEMP_2094`, but a repeated id or
387-
/// name that no requested field selects stays harmless, as in Spark.
388-
#[test]
389-
fn only_a_requested_ambiguity_is_an_error() {
390-
let requested = [field("f", Some(1)), field("g", Some(2))];
391-
let file = [
392-
field("x", Some(1)),
393-
field("y", Some(1)),
394-
field("z", Some(2)),
395-
field("g", None),
396-
field("G", None),
397-
];
398-
with_resolver(&requested, &file, false, true, |resolver| {
399-
let message = resolver.resolve(0).unwrap_err().to_string();
400-
assert!(
401-
message.contains("_LEGACY_ERROR_TEMP_2094")
402-
&& message.contains("id=1 matches [x, y]"),
403-
"{message}"
404-
);
405-
assert_eq!(resolver.resolve(1).unwrap(), Some(2));
406-
assert_eq!(resolver.name_matches(1), &[3, 4]);
407-
});
408-
}
409352
}

‎native/core/src/parquet/parquet_support.rs‎

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2190,7 +2190,9 @@ mod tests {
21902190
}
21912191

21922192
/// Companion to `requested_duplicate_field_id_errors`: a duplicated file id that no
2193-
/// requested field looks up stays harmless, as Spark only raises inside `matchIdField`.
2193+
/// requested field looks up stays harmless, as Spark only raises inside `matchIdField`. So
2194+
/// does a name that two file fields share once folded, here `f` and `F`, when the requested
2195+
/// field of that name resolves by id, since `matchIdField` never compares names.
21942196
#[test]
21952197
fn unrequested_duplicate_field_id_reads_fine() {
21962198
use crate::parquet::parquet_support::{parquet_convert_array, SparkParquetOptions};
@@ -2204,6 +2206,8 @@ mod tests {
22042206
("x", DataType::Int32, 1),
22052207
("y", DataType::Int32, 1),
22062208
("z", DataType::Int32, 2),
2209+
("f", DataType::Int32, 3),
2210+
("F", DataType::Int32, 4),
22072211
]) else {
22082212
unreachable!()
22092213
};
@@ -2213,6 +2217,8 @@ mod tests {
22132217
Arc::new(Int32Array::from(vec![42])),
22142218
Arc::new(Int32Array::from(vec![43])),
22152219
Arc::new(Int32Array::from(vec![44])),
2220+
Arc::new(Int32Array::from(vec![45])),
2221+
Arc::new(Int32Array::from(vec![46])),
22162222
],
22172223
None,
22182224
));

‎native/core/src/parquet/schema_adapter.rs‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3644,6 +3644,7 @@ pub(crate) mod test {
36443644
let fields = vec![
36453645
Arc::new(Field::new("dup", DataType::Int64, true)),
36463646
Arc::new(Field::new("dup", DataType::Int64, true)),
3647+
Arc::new(Field::new("Dup", DataType::Int64, true)),
36473648
];
36483649
let mut options = SparkParquetOptions::new(EvalMode::Legacy, "UTC");
36493650
options.case_sensitive = true;
@@ -3652,6 +3653,11 @@ pub(crate) mod test {
36523653
.to_string();
36533654
assert!(error.contains("duplicate"), "{error}");
36543655
assert!(!error.contains("case-insensitive"), "{error}");
3656+
// A case-sensitive read compares exact names, so `Dup` resolves to itself alone.
3657+
assert_eq!(
3658+
super::match_struct_fields(&fields, &fields[2..], &options).unwrap(),
3659+
vec![Some(2)]
3660+
);
36553661
}
36563662

36573663
#[test]

0 commit comments

Comments
 (0)