diff --git a/arrow-array/src/array/map_array.rs b/arrow-array/src/array/map_array.rs index 2e4d054ec639..0d041831d6c1 100644 --- a/arrow-array/src/array/map_array.rs +++ b/arrow-array/src/array/map_array.rs @@ -372,9 +372,13 @@ impl MapArray { let entry_offsets_buffer = Buffer::from(entry_offsets.to_byte_slice()); let keys_data = StringArray::from_iter_values(keys); - let keys_field = Arc::new(Field::new("keys", DataType::Utf8, false)); + let keys_field = Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )); let values_field = Arc::new(Field::new( - "values", + Field::MAP_VALUE_FIELD_DEFAULT_NAME, values.data_type().clone(), values.null_count() > 0, )); @@ -386,7 +390,7 @@ impl MapArray { let map_data_type = DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, entry_struct.data_type().clone(), false, )), @@ -631,8 +635,16 @@ mod tests { // [[0, 1, 2], [3, 4, 5], [6, 7]] let entry_offsets = Buffer::from([0, 3, 6, 8].to_byte_slice()); - let keys = Arc::new(Field::new("keys", DataType::Int32, false)); - let values = Arc::new(Field::new("values", DataType::UInt32, false)); + let keys = Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Int32, + false, + )); + let values = Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::UInt32, + false, + )); let entry_struct = StructArray::from(vec![ (keys, make_array(keys_data)), (values, make_array(values_data)), @@ -641,7 +653,7 @@ mod tests { // Construct a map array from the above two let map_data_type = DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, entry_struct.data_type().clone(), false, )), @@ -677,8 +689,16 @@ mod tests { // [[0, 1, 2], [3, 4, 5], [6, 7]] let entry_offsets = Buffer::from([0, 3, 6, 8].to_byte_slice()); - let keys_field = Arc::new(Field::new("keys", DataType::Int32, false)); - let values_field = Arc::new(Field::new("values", DataType::UInt32, true)); + let keys_field = Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Int32, + false, + )); + let values_field = Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::UInt32, + true, + )); let entry_struct = StructArray::from(vec![ (keys_field.clone(), make_array(key_data)), (values_field.clone(), make_array(value_data.clone())), @@ -687,7 +707,7 @@ mod tests { // Construct a map array from the above two let map_data_type = DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, entry_struct.data_type().clone(), false, )), @@ -798,8 +818,16 @@ mod tests { // [[3, 4, 5], [6, 7]] let entry_offsets = Buffer::from([0, 3, 5].to_byte_slice()); - let keys = Arc::new(Field::new("keys", DataType::Int32, false)); - let values = Arc::new(Field::new("values", DataType::UInt32, false)); + let keys = Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Int32, + false, + )); + let values = Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::UInt32, + false, + )); let entry_struct = StructArray::from(vec![ (keys, make_array(keys_data)), (values, make_array(values_data)), @@ -808,7 +836,7 @@ mod tests { // Construct a map array from the above two let map_data_type = DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, entry_struct.data_type().clone(), false, )), @@ -839,8 +867,8 @@ mod tests { // A DictionaryArray has similar buffer layout to a MapArray // but the meaning of the values differs let struct_t = DataType::Struct(Fields::from(vec![ - Field::new("keys", DataType::Int32, true), - Field::new("values", DataType::UInt32, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int32, true), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::UInt32, true), ])); let dict_t = DataType::Dictionary(Box::new(DataType::Int32), Box::new(struct_t)); let _ = MapArray::from(ArrayData::new_empty(&dict_t)); @@ -871,8 +899,16 @@ mod tests { let key_array = Arc::new(StringArray::from(vec!["a", "b", "c"])) as ArrayRef; let value_array = Arc::new(UInt32Array::from(vec![0u32, 10, 20])) as ArrayRef; - let keys_field = Arc::new(Field::new("keys", DataType::Utf8, false)); - let values_field = Arc::new(Field::new("values", DataType::UInt32, false)); + let keys_field = Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )); + let values_field = Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::UInt32, + false, + )); let struct_array = StructArray::from(vec![(keys_field, key_array), (values_field, value_array)]); assert_eq!( @@ -896,8 +932,8 @@ mod tests { fn test_try_new() { let offsets = OffsetBuffer::new(vec![0, 1, 4, 5].into()); let fields = Fields::from(vec![ - Field::new("key", DataType::Int32, false), - Field::new("values", DataType::Int32, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int32, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, false), ]); let columns = vec![ Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])) as _, @@ -905,7 +941,11 @@ mod tests { ]; let entries = StructArray::new(fields.clone(), columns, None); - let field = Arc::new(Field::new("entries", DataType::Struct(fields), false)); + let field = Arc::new(Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + DataType::Struct(fields), + false, + )); MapArray::new(field.clone(), offsets.clone(), entries.clone(), None, false); @@ -958,7 +998,11 @@ mod tests { ]; let s = StructArray::new(fields.clone(), columns, None); - let field = Arc::new(Field::new("entries", DataType::Struct(fields), false)); + let field = Arc::new(Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + DataType::Struct(fields), + false, + )); let err = MapArray::try_new(field, offsets, s, None, false).unwrap_err(); assert_eq!( @@ -973,12 +1017,16 @@ mod tests { let keys = Int32Array::from(vec![Some(1), None]); let values = Int32Array::from(vec![None, Some(2)]); let fields = Fields::from(vec![ - Field::new("keys", DataType::Int32, true), - Field::new("values", DataType::Int32, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int32, true), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), ]); let entries = StructArray::new(fields.clone(), vec![Arc::new(keys), Arc::new(values)], None); - let field = Arc::new(Field::new("entries", DataType::Struct(fields), false)); + let field = Arc::new(Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + DataType::Struct(fields), + false, + )); let err = MapArray::try_new(field, OffsetBuffer::from_lengths([2]), entries, None, false) .unwrap_err(); diff --git a/arrow-array/src/array/mod.rs b/arrow-array/src/array/mod.rs index e389b462fbe1..cf1e0b85a026 100644 --- a/arrow-array/src/array/mod.rs +++ b/arrow-array/src/array/mod.rs @@ -1178,10 +1178,10 @@ mod tests { fn test_null_map() { let data_type = DataType::Map( Arc::new(Field::new( - "entry", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Int32, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), ])), false, )), diff --git a/arrow-array/src/builder/map_builder.rs b/arrow-array/src/builder/map_builder.rs index a6d49181762b..d1862af4e8ac 100644 --- a/arrow-array/src/builder/map_builder.rs +++ b/arrow-array/src/builder/map_builder.rs @@ -79,9 +79,9 @@ pub struct MapFieldNames { impl Default for MapFieldNames { fn default() -> Self { Self { - entry: "entries".to_string(), - key: "keys".to_string(), - value: "values".to_string(), + entry: Field::MAP_ENTRIES_FIELD_DEFAULT_NAME.to_string(), + key: Field::MAP_KEY_FIELD_DEFAULT_NAME.to_string(), + value: Field::MAP_VALUE_FIELD_DEFAULT_NAME.to_string(), } } } @@ -395,10 +395,14 @@ mod tests { map.data_type(), &DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct( vec![ - Arc::new(Field::new("keys", DataType::Int32, false)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Int32, + false + )), value_field.clone() ] .into() @@ -419,10 +423,14 @@ mod tests { map.data_type(), &DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct( vec![ - Arc::new(Field::new("keys", DataType::Int32, false)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Int32, + false + )), value_field ] .into() @@ -439,7 +447,7 @@ mod tests { let mut key_metadata = HashMap::new(); key_metadata.insert("foo".to_string(), "bar".to_string()); let key_field = Arc::new( - Field::new("keys", DataType::Int32, false).with_metadata(key_metadata.clone()), + Field::new("other_key", DataType::Int32, false).with_metadata(key_metadata.clone()), ); let mut builder = MapBuilder::new(None, Int32Builder::new(), Int32Builder::new()) .with_keys_field(key_field.clone()); @@ -453,14 +461,18 @@ mod tests { map.data_type(), &DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct( vec![ Arc::new( - Field::new("keys", DataType::Int32, false) + Field::new("other_key", DataType::Int32, false) .with_metadata(key_metadata) ), - Arc::new(Field::new("values", DataType::Int32, true)) + Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Int32, + true + )) ] .into() ), @@ -511,7 +523,11 @@ mod tests { #[should_panic(expected = "Keys field must not be nullable")] fn test_with_nullable_keys_field() { let mut builder = MapBuilder::new(None, Int32Builder::new(), Int32Builder::new()) - .with_keys_field(Arc::new(Field::new("keys", DataType::Int32, true))); + .with_keys_field(Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Int32, + true, + ))); builder.keys().append_value(1); builder.values().append_value(2); @@ -524,7 +540,11 @@ mod tests { #[should_panic(expected = "Incorrect datatype")] fn test_keys_field_type_mismatch() { let mut builder = MapBuilder::new(None, Int32Builder::new(), Int32Builder::new()) - .with_keys_field(Arc::new(Field::new("keys", DataType::Utf8, false))); + .with_keys_field(Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + ))); builder.keys().append_value(1); builder.values().append_value(2); diff --git a/arrow-avro/benches/avro_writer.rs b/arrow-avro/benches/avro_writer.rs index 58b014c5a3fe..efb8141985d0 100644 --- a/arrow-avro/benches/avro_writer.rs +++ b/arrow-avro/benches/avro_writer.rs @@ -623,10 +623,18 @@ static DECIMAL256_DATA: Lazy> = Lazy::new(|| { static MAP_DATA: Lazy> = Lazy::new(|| { use arrow_array::builder::{MapBuilder, StringBuilder}; - let key_field = Arc::new(Field::new("keys", DataType::Utf8, false)); - let value_field = Arc::new(Field::new("values", DataType::Utf8, true)); + let key_field = Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )); + let value_field = Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Utf8, + true, + )); let entry_struct = Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(vec![key_field.as_ref().clone(), value_field.as_ref().clone()].into()), false, ); diff --git a/arrow-avro/src/codec.rs b/arrow-avro/src/codec.rs index 975b906cf78c..e21d4df5c39f 100644 --- a/arrow-avro/src/codec.rs +++ b/arrow-avro/src/codec.rs @@ -929,12 +929,12 @@ impl Codec { } Self::Struct(f) => DataType::Struct(f.iter().map(|x| x.field()).collect()), Self::Map(value_type) => { - let val_field = value_type.field_with_name("value"); + let val_field = value_type.field_with_name(Field::MAP_VALUE_FIELD_DEFAULT_NAME); DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Utf8, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), val_field, ])), false, diff --git a/arrow-avro/src/reader/mod.rs b/arrow-avro/src/reader/mod.rs index 874a8534d02c..2767a514152c 100644 --- a/arrow-avro/src/reader/mod.rs +++ b/arrow-avro/src/reader/mod.rs @@ -3063,12 +3063,16 @@ mod test { list_builder.append(true); } arrays.push(Arc::new(list_builder.finish())); - let values_field = Arc::new(Field::new("value", DataType::Int64, false)); + let values_field = Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Int64, + false, + )); let mut map_builder = MapBuilder::new( Some(builder::MapFieldNames { - entry: "entries".to_string(), - key: "key".to_string(), - value: "value".to_string(), + entry: Field::MAP_ENTRIES_FIELD_DEFAULT_NAME.to_string(), + key: Field::MAP_KEY_FIELD_DEFAULT_NAME.to_string(), + value: Field::MAP_VALUE_FIELD_DEFAULT_NAME.to_string(), }), StringBuilder::new(), Int64Builder::new(), @@ -6273,9 +6277,9 @@ mod test { iaa_builder.append(true); let int_array_array = iaa_builder.finish(); let field_names = MapFieldNames { - entry: "entries".to_string(), - key: "key".to_string(), - value: "value".to_string(), + entry: Field::MAP_ENTRIES_FIELD_DEFAULT_NAME.to_string(), + key: Field::MAP_KEY_FIELD_DEFAULT_NAME.to_string(), + value: Field::MAP_VALUE_FIELD_DEFAULT_NAME.to_string(), }; let mut int_map_builder = MapBuilder::new(Some(field_names), StringBuilder::new(), Int32Builder::new()); @@ -6287,9 +6291,9 @@ mod test { int_map_builder.append(true).unwrap(); // finalize map for row 0 let int_map = int_map_builder.finish(); let field_names2 = MapFieldNames { - entry: "entries".to_string(), - key: "key".to_string(), - value: "value".to_string(), + entry: Field::MAP_ENTRIES_FIELD_DEFAULT_NAME.to_string(), + key: Field::MAP_KEY_FIELD_DEFAULT_NAME.to_string(), + value: Field::MAP_VALUE_FIELD_DEFAULT_NAME.to_string(), }; let mut ima_builder = ListBuilder::new(MapBuilder::new( Some(field_names2), @@ -6375,17 +6379,17 @@ mod test { .with_metadata(meta_h.clone()); // G.value : Struct<{ h: ... }> with metadata (G) let g_value_struct_field = Field::new( - "value", + Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Struct(vec![h_field.clone()].into()), true, ) .with_metadata(meta_g_value.clone()); // entries struct for Map G let entries_struct_field = Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct( vec![ - Field::new("key", DataType::Utf8, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), g_value_struct_field.clone(), ] .into(), @@ -6444,9 +6448,9 @@ mod test { }, { let map_field_names = MapFieldNames { - entry: "entries".to_string(), - key: "key".to_string(), - value: "value".to_string(), + entry: Field::MAP_ENTRIES_FIELD_DEFAULT_NAME.to_string(), + key: Field::MAP_KEY_FIELD_DEFAULT_NAME.to_string(), + value: Field::MAP_VALUE_FIELD_DEFAULT_NAME.to_string(), }; let i_list_builder = ListBuilder::new(Float64Builder::new()); let h_struct_builder = StructBuilder::new( @@ -6472,7 +6476,7 @@ mod test { ) .with_values_field(Arc::new( Field::new( - "value", + Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Struct(vec![h_field.clone()].into()), true, ) @@ -8705,11 +8709,11 @@ mod test { ) .unwrap(); let map_entries_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Utf8, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), Field::new( - "value", + Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Union(uf_map_vals.clone(), UnionMode::Dense), true, ), @@ -8739,10 +8743,10 @@ mod test { Field::new("y", DataType::Binary, false), ]); let union_map_entries = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Utf8, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, false), ])), false, )); @@ -8921,10 +8925,10 @@ mod test { Field::new(item_name, DataType::Struct(kv_fields.clone()), false).with_metadata(kv_md), ); let map_int_entries = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Int32, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, false), ])), false, )); @@ -9167,8 +9171,8 @@ mod test { let vals = Int32Array::from(vec![1, 2, 10]); let entries = StructArray::new( Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Int32, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, false), ]), vec![Arc::new(keys) as ArrayRef, Arc::new(vals) as ArrayRef], None, @@ -9316,8 +9320,8 @@ mod test { let vals = StringArray::from(vec!["v"]); let entries = StructArray::new( Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Utf8, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, false), ]), vec![Arc::new(keys) as ArrayRef, Arc::new(vals) as ArrayRef], None, @@ -9395,9 +9399,9 @@ mod test { }); let entries = StructArray::new( Fields::from(vec![ - Field::new("key", DataType::Utf8, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), Field::new( - "value", + Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Union(uf_map_vals.clone(), UnionMode::Dense), true, ), diff --git a/arrow-avro/src/reader/record.rs b/arrow-avro/src/reader/record.rs index 23c7fed9bbf2..13382557ee6d 100644 --- a/arrow-avro/src/reader/record.rs +++ b/arrow-avro/src/reader/record.rs @@ -506,11 +506,15 @@ impl Decoder { Self::Record(arrow_fields.into(), encodings, field_defaults, projector) } (Codec::Map(child), _) => { - let val_field = child.field_with_name("value"); + let val_field = child.field_with_name(ArrowField::MAP_VALUE_FIELD_DEFAULT_NAME); let map_field = Arc::new(ArrowField::new( - "entries", + ArrowField::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - ArrowField::new("key", DataType::Utf8, false), + ArrowField::new( + ArrowField::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + ), val_field, ])), false, diff --git a/arrow-avro/src/schema.rs b/arrow-avro/src/schema.rs index db36e48a2237..ece56c6e713c 100644 --- a/arrow-avro/src/schema.rs +++ b/arrow-avro/src/schema.rs @@ -2986,11 +2986,19 @@ mod tests { let avro_list = AvroSchema::try_from(&list_schema).unwrap(); assert_json_contains(&avro_list.json_string, "\"type\":\"array\""); assert_json_contains(&avro_list.json_string, "\"items\""); - let value_field = ArrowField::new("value", DataType::Boolean, true); + let value_field = ArrowField::new( + arrow_schema::Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Boolean, + true, + ); let entries_struct = ArrowField::new( - "entries", + arrow_schema::Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - ArrowField::new("key", DataType::Utf8, false), + ArrowField::new( + arrow_schema::Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + ), value_field.clone(), ])), false, @@ -3188,11 +3196,19 @@ mod tests { #[cfg(feature = "avro_custom_types")] #[test] fn test_map_duration_value_extra() { - let val_field = ArrowField::new("value", DataType::Duration(TimeUnit::Second), true); + let val_field = ArrowField::new( + ArrowField::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Duration(TimeUnit::Second), + true, + ); let entries_struct = ArrowField::new( - "entries", + ArrowField::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - ArrowField::new("key", DataType::Utf8, false), + ArrowField::new( + ArrowField::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + ), val_field, ])), false, @@ -3239,11 +3255,19 @@ mod tests { ); let expected_b = ArrowField::new("b", DataType::List(Arc::new(expected_list_item)), false); - let expected_map_value = ArrowField::new("value", DataType::Float64, false); + let expected_map_value = ArrowField::new( + arrow_schema::Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Float64, + false, + ); let expected_entries = ArrowField::new( - "entries", + arrow_schema::Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - ArrowField::new("key", DataType::Utf8, false), + ArrowField::new( + arrow_schema::Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + ), expected_map_value, ])), false, diff --git a/arrow-avro/src/writer/encoder.rs b/arrow-avro/src/writer/encoder.rs index bdfd91ffdd32..23ace7d04971 100644 --- a/arrow-avro/src/writer/encoder.rs +++ b/arrow-avro/src/writer/encoder.rs @@ -1011,7 +1011,7 @@ fn find_struct_child_index(fields: &arrow_schema::Fields, name: &str) -> Option< fn find_map_value_field_index(fields: &arrow_schema::Fields) -> Option { // Prefer common Arrow field names; fall back to second child if exactly two - find_struct_child_index(fields, "value") + find_struct_child_index(fields, Field::MAP_VALUE_FIELD_DEFAULT_NAME) .or_else(|| find_struct_child_index(fields, "values")) .or_else(|| if fields.len() == 2 { Some(1) } else { None }) } @@ -2893,8 +2893,8 @@ mod tests { let keys = StringArray::from(vec!["k1", "k2"]); let values = Int32Array::from(vec![1, 2]); let entries_fields = Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Int32, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), ]); let entries = StructArray::new( entries_fields, @@ -2903,7 +2903,12 @@ mod tests { ); let offsets = arrow_buffer::OffsetBuffer::new(vec![0i32, 2, 2].into()); let map = MapArray::new( - Field::new("entries", entries.data_type().clone(), false).into(), + Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + entries.data_type().clone(), + false, + ) + .into(), offsets, entries, None, @@ -3378,8 +3383,8 @@ mod tests { let values = Int32Array::from(vec![Some(7), None]); let entries_fields = Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Int32, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), ]); let entries = StructArray::new( entries_fields, @@ -3390,7 +3395,12 @@ mod tests { // Single row -> offsets [0, 2] let offsets = arrow_buffer::OffsetBuffer::new(vec![0i32, 2].into()); let map = MapArray::new( - Field::new("entries", entries.data_type().clone(), false).into(), + Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + entries.data_type().clone(), + false, + ) + .into(), offsets, entries, None, diff --git a/arrow-cast/src/cast/mod.rs b/arrow-cast/src/cast/mod.rs index 3dbafe67a6f6..35dce48e6828 100644 --- a/arrow-cast/src/cast/mod.rs +++ b/arrow-cast/src/cast/mod.rs @@ -9182,10 +9182,10 @@ mod tests { // Cast null from and to map let data_type = DataType::Map( Arc::new(Field::new_struct( - "entry", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Int32, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), ], false, )), @@ -10186,15 +10186,7 @@ mod tests { fn test_cast_map_dont_allow_change_of_order() { let string_builder = StringBuilder::new(); let value_builder = StringBuilder::new(); - let mut builder = MapBuilder::new( - Some(MapFieldNames { - entry: "entries".to_string(), - key: "key".to_string(), - value: "value".to_string(), - }), - string_builder, - value_builder, - ); + let mut builder = MapBuilder::new(None, string_builder, value_builder); builder.keys().append_value("0"); builder.values().append_value("test_val_1"); @@ -10209,11 +10201,11 @@ mod tests { let new_ordered = true; let new_type = DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct( vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Utf8, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, false), ] .into(), ), @@ -10237,15 +10229,7 @@ mod tests { fn test_cast_map_dont_allow_when_container_cant_cast() { let string_builder = StringBuilder::new(); let value_builder = IntervalDayTimeArray::builder(2); - let mut builder = MapBuilder::new( - Some(MapFieldNames { - entry: "entries".to_string(), - key: "key".to_string(), - value: "value".to_string(), - }), - string_builder, - value_builder, - ); + let mut builder = MapBuilder::new(None, string_builder, value_builder); builder.keys().append_value("0"); builder.values().append_value(IntervalDayTime::new(1, 1)); @@ -10260,11 +10244,15 @@ mod tests { let new_ordered = true; let new_type = DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct( vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Duration(TimeUnit::Second), false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Duration(TimeUnit::Second), + false, + ), ] .into(), ), @@ -10290,9 +10278,10 @@ mod tests { let value_builder = StringBuilder::new(); let mut builder = MapBuilder::new( Some(MapFieldNames { - entry: "entries".to_string(), - key: "key".to_string(), - value: "value".to_string(), + // Explicitly writing the name so it will be apparent from what names to what names are we converting to + entry: Field::MAP_ENTRIES_FIELD_DEFAULT_NAME.to_string(), + key: Field::MAP_KEY_FIELD_DEFAULT_NAME.to_string(), + value: Field::MAP_VALUE_FIELD_DEFAULT_NAME.to_string(), }), string_builder, value_builder, @@ -10362,15 +10351,7 @@ mod tests { fn test_cast_map_contained_values() { let string_builder = StringBuilder::new(); let value_builder = Int8Builder::new(); - let mut builder = MapBuilder::new( - Some(MapFieldNames { - entry: "entries".to_string(), - key: "key".to_string(), - value: "value".to_string(), - }), - string_builder, - value_builder, - ); + let mut builder = MapBuilder::new(None, string_builder, value_builder); builder.keys().append_value("0"); builder.values().append_value(44); @@ -10383,11 +10364,11 @@ mod tests { let new_type = DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct( vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Utf8, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, false), ] .into(), ), diff --git a/arrow-cast/src/pretty.rs b/arrow-cast/src/pretty.rs index 61ce5598992d..ca6f82a031c4 100644 --- a/arrow-cast/src/pretty.rs +++ b/arrow-cast/src/pretty.rs @@ -1486,7 +1486,7 @@ mod tests { Int32Builder::new(), ) .with_values_field( - Field::new("values", DataType::Int32, true).with_metadata(money_metadata.clone()), + Field::new("my_values", DataType::Int32, true).with_metadata(money_metadata.clone()), ); array .keys() diff --git a/arrow-data/src/data.rs b/arrow-data/src/data.rs index 1c5d1bebd33d..13e5f730e6e4 100644 --- a/arrow-data/src/data.rs +++ b/arrow-data/src/data.rs @@ -2944,7 +2944,7 @@ mod tests { #[test] fn should_fail_validation_when_having_map_entries_only_have_1_field() { let struct_data_type = DataType::Struct(Fields::from(vec![Field::new( - "key", + Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int32, false, )])); @@ -2961,7 +2961,15 @@ mod tests { }; let results = test_both_builder_and_array_data( - DataType::Map(Field::new("entries", struct_data_type, false).into(), false), + DataType::Map( + Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + struct_data_type, + false, + ) + .into(), + false, + ), 1, None, 0, @@ -2991,8 +2999,8 @@ mod tests { #[test] fn should_fail_validation_when_having_map_entries_have_3_fields() { let struct_data_type = DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Int32, false), - Field::new("values", DataType::Utf8, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int32, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, true), Field::new("other", DataType::Int32, true), ])); @@ -3012,7 +3020,15 @@ mod tests { }; let results = test_both_builder_and_array_data( - DataType::Map(Field::new("entries", struct_data_type, false).into(), false), + DataType::Map( + Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + struct_data_type, + false, + ) + .into(), + false, + ), 1, None, 0, @@ -3042,8 +3058,8 @@ mod tests { #[test] fn should_fail_validation_when_having_nullable_map_keys() { let struct_data_type = DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Int32, true), - Field::new("values", DataType::Utf8, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int32, true), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, true), ])); let key_array_data = valid_non_nullable_int32_array_data(2); @@ -3059,7 +3075,15 @@ mod tests { }; let results = test_both_builder_and_array_data( - DataType::Map(Field::new("entries", struct_data_type, false).into(), false), + DataType::Map( + Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + struct_data_type, + false, + ) + .into(), + false, + ), 1, None, 0, @@ -3086,8 +3110,8 @@ mod tests { #[test] fn should_fail_validation_when_having_entries_is_nullable_for_map() { let struct_data_type = DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Int32, false), - Field::new("values", DataType::Utf8, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int32, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, true), ])); let key_array_data = valid_non_nullable_int32_array_data(2); @@ -3104,7 +3128,15 @@ mod tests { }; let results = test_both_builder_and_array_data( - DataType::Map(Field::new("entries", struct_data_type, true).into(), false), + DataType::Map( + Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + struct_data_type, + true, + ) + .into(), + false, + ), 1, None, 0, @@ -3132,8 +3164,8 @@ mod tests { #[test] fn should_allow_to_create_map_from_data() { let struct_data_type = DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Int32, false), - Field::new("values", DataType::Utf8, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int32, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, true), ])); let key_array_data = valid_non_nullable_int32_array_data(2); @@ -3149,7 +3181,15 @@ mod tests { }; let results = test_both_builder_and_array_data( - DataType::Map(Field::new("entries", struct_data_type, false).into(), false), + DataType::Map( + Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + struct_data_type, + false, + ) + .into(), + false, + ), 1, None, 0, @@ -3195,10 +3235,10 @@ mod tests { fn empty_and_null_map_array_should_pass_validation() { let dt = DataType::Map( Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Int32, false), - Field::new("values", DataType::Utf8, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int32, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, true), ])), false, ) diff --git a/arrow-flight/src/encode.rs b/arrow-flight/src/encode.rs index 52325dde46dd..810d416d9ae0 100644 --- a/arrow-flight/src/encode.rs +++ b/arrow-flight/src/encode.rs @@ -1503,9 +1503,19 @@ mod tests { let schema = Arc::new(Schema::new(vec![Field::new_map( "dict_map", - "entries", - Field::new_dictionary("keys", DataType::UInt16, DataType::Utf8, false), - Field::new_dictionary("values", DataType::UInt16, DataType::Utf8, true), + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + Field::new_dictionary( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::UInt16, + DataType::Utf8, + false, + ), + Field::new_dictionary( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::UInt16, + DataType::Utf8, + true, + ), false, false, )])); @@ -1520,9 +1530,9 @@ mod tests { let mut decoder = FlightDataDecoder::new(encoder); let expected_schema = Schema::new(vec![Field::new_map( "dict_map", - "entries", - Field::new("keys", DataType::Utf8, false), - Field::new("values", DataType::Utf8, true), + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, true), false, false, )]); @@ -1599,9 +1609,19 @@ mod tests { let schema = Arc::new(Schema::new(vec![Field::new_map( "dict_map", - "entries", - Field::new_dictionary("keys", DataType::UInt16, DataType::Utf8, false), - Field::new_dictionary("values", DataType::UInt16, DataType::Utf8, true), + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + Field::new_dictionary( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::UInt16, + DataType::Utf8, + false, + ), + Field::new_dictionary( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::UInt16, + DataType::Utf8, + true, + ), false, false, )])); diff --git a/arrow-flight/src/sql/metadata/sql_info.rs b/arrow-flight/src/sql/metadata/sql_info.rs index 155946ea6ce6..885d15dd6f87 100644 --- a/arrow-flight/src/sql/metadata/sql_info.rs +++ b/arrow-flight/src/sql/metadata/sql_info.rs @@ -179,11 +179,11 @@ static UNION_TYPE: Lazy = Lazy::new(|| { "int32_to_int32_list_map", DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("keys", DataType::Int32, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int32, false), Field::new( - "values", + Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::List(Arc::new(Field::new_list_field(DataType::Int32, true))), true, ), diff --git a/arrow-integration-testing/src/lib.rs b/arrow-integration-testing/src/lib.rs index cf572d769df5..613408ae593e 100644 --- a/arrow-integration-testing/src/lib.rs +++ b/arrow-integration-testing/src/lib.rs @@ -86,18 +86,22 @@ pub fn canonicalize_schema(schema: &Schema) -> Schema { DataType::Map(child_field, sorted) => match child_field.data_type() { DataType::Struct(fields) if fields.len() == 2 => { let first_field = &fields[0]; - let key_field = - Arc::new(Field::new("key", first_field.data_type().clone(), false)); + let key_field = Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + first_field.data_type().clone(), + false, + )); let second_field = &fields[1]; let value_field = Arc::new(Field::new( - "value", + Field::MAP_VALUE_FIELD_DEFAULT_NAME, second_field.data_type().clone(), second_field.is_nullable(), )); let fields = Fields::from([key_field, value_field]); let struct_type = DataType::Struct(fields); - let child_field = Field::new("entries", struct_type, false); + let child_field = + Field::new(Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, struct_type, false); Arc::new(Field::new( field.name().as_str(), diff --git a/arrow-ipc/src/reader.rs b/arrow-ipc/src/reader.rs index 672091da2acf..8349cafc7200 100644 --- a/arrow-ipc/src/reader.rs +++ b/arrow-ipc/src/reader.rs @@ -2748,7 +2748,7 @@ mod tests { #[allow(deprecated)] let keys_field = Arc::new(Field::new_dict( - "keys", + Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)), false, 1, @@ -2756,7 +2756,7 @@ mod tests { )); #[allow(deprecated)] let values_field = Arc::new(Field::new_dict( - "values", + Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)), true, 2, @@ -2768,7 +2768,7 @@ mod tests { ]); let map_data_type = DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, entry_struct.data_type().clone(), false, )), @@ -2959,7 +2959,7 @@ mod tests { let key_dict_array = DictionaryArray::new(key_dict_keys, utf8_view_array.clone()); #[allow(deprecated)] let keys_field = Arc::new(Field::new_dict( - "keys", + Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8View)), false, 1, @@ -2970,7 +2970,7 @@ mod tests { let value_dict_array = DictionaryArray::new(value_dict_keys, bin_view_array); #[allow(deprecated)] let values_field = Arc::new(Field::new_dict( - "values", + Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::BinaryView)), true, 2, @@ -2983,7 +2983,7 @@ mod tests { let map_data_type = DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, entry_struct.data_type().clone(), false, )), diff --git a/arrow-ipc/src/writer.rs b/arrow-ipc/src/writer.rs index 8559b79b6074..ecd0f0f66724 100644 --- a/arrow-ipc/src/writer.rs +++ b/arrow-ipc/src/writer.rs @@ -4091,9 +4091,24 @@ mod tests { #[test] fn encode_map_array() { - let keys = Arc::new(Field::new("keys", DataType::UInt32, false)); - let values = Arc::new(Field::new("values", DataType::UInt32, true)); - let map_field = Field::new_map("map", "entries", keys, values, false, true); + let keys = Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::UInt32, + false, + )); + let values = Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::UInt32, + true, + )); + let map_field = Field::new_map( + "map", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + keys, + values, + false, + true, + ); let schema = Arc::new(Schema::new(vec![map_field])); let values = Arc::new(generate_map_array_data()); @@ -4425,17 +4440,17 @@ mod tests { #[allow(deprecated)] let entries_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct( vec![ Field::new_dict( - "key", + Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)), false, 1, false, ), - Field::new("value", DataType::Int32, true), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), ] .into(), ), @@ -4445,14 +4460,18 @@ mod tests { let entries = StructArray::from(vec![ ( Arc::new(Field::new( - "key", + Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)), false, )), Arc::new(dict_keys) as ArrayRef, ), ( - Arc::new(Field::new("value", DataType::Int32, true)), + Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Int32, + true, + )), Arc::new(values) as ArrayRef, ), ]); @@ -4493,12 +4512,12 @@ mod tests { #[allow(deprecated)] let entries_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct( vec![ - Field::new("key", DataType::Utf8, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), Field::new_dict( - "value", + Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)), true, 2, @@ -4512,12 +4531,16 @@ mod tests { let entries = StructArray::from(vec![ ( - Arc::new(Field::new("key", DataType::Utf8, false)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )), Arc::new(keys) as ArrayRef, ), ( Arc::new(Field::new( - "value", + Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)), true, )), diff --git a/arrow-json/benches/json_reader.rs b/arrow-json/benches/json_reader.rs index 36ab1b82fe48..3fb35f2d55c3 100644 --- a/arrow-json/benches/json_reader.rs +++ b/arrow-json/benches/json_reader.rs @@ -363,11 +363,11 @@ fn build_map_values(rows: usize, entries: usize) -> Vec { fn build_map_schema() -> Arc { let entries_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct( vec![ - Field::new("keys", DataType::Utf8, false), - Field::new("values", DataType::Int64, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int64, true), ] .into(), ), diff --git a/arrow-json/src/reader/mod.rs b/arrow-json/src/reader/mod.rs index 6c2ce5cba079..ee8d0a542a99 100644 --- a/arrow-json/src/reader/mod.rs +++ b/arrow-json/src/reader/mod.rs @@ -1287,9 +1287,13 @@ mod tests { "#; let map = Field::new_map( "map", - "entries", - Field::new("key", DataType::Utf8, false), - Field::new_list("value", Field::new("element", DataType::Utf8, true), true), + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new_list( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + Field::new("element", DataType::Utf8, true), + true, + ), false, true, ); @@ -1325,9 +1329,9 @@ mod tests { fn test_map_non_nullable_value() { let map = Field::new_map( "map", - "entries", - Field::new("keys", DataType::Utf8, false), - Field::new("values", DataType::Utf8, false), + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, false), false, false, ); @@ -1342,7 +1346,7 @@ mod tests { assert_eq!( err.to_string(), - "Invalid argument error: Found unmasked nulls for non-nullable StructArray field \"values\"" + "Invalid argument error: Found unmasked nulls for non-nullable StructArray field \"value\"" ); } @@ -3061,9 +3065,9 @@ mod tests { Field::new("b", DataType::new_list(DataType::Int32, true), true), Field::new_map( "c", - "entries", - Field::new("keys", DataType::Utf8, false), - Field::new("values", DataType::Int32, true), + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), false, false, ), @@ -3251,10 +3255,10 @@ mod tests { "map", DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("keys", DataType::Utf8, false), - Field::new("values", DataType::Utf8, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, true), ])), false, // not nullable )), @@ -3509,10 +3513,10 @@ mod tests { "map", DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("keys", DataType::Utf8, false), - Field::new("values", DataType::Utf8, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, true), ])), false, // not nullable )), @@ -3570,10 +3574,10 @@ mod tests { "map", DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("keys", DataType::Utf8, false), - Field::new("values", DataType::Utf8, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, true), ])), false, // not nullable )), diff --git a/arrow-json/src/writer/mod.rs b/arrow-json/src/writer/mod.rs index 559916d06ac1..341779afedca 100644 --- a/arrow-json/src/writer/mod.rs +++ b/arrow-json/src/writer/mod.rs @@ -1421,15 +1421,23 @@ mod tests { fn run_json_writer_map_with_keys(keys_array: ArrayRef) { let values_array = super::Int64Array::from(vec![10, 20, 30, 40, 50]); - let keys_field = Arc::new(Field::new("keys", keys_array.data_type().clone(), false)); - let values_field = Arc::new(Field::new("values", DataType::Int64, false)); + let keys_field = Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + keys_array.data_type().clone(), + false, + )); + let values_field = Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Int64, + false, + )); let entry_struct = StructArray::from(vec![ (keys_field, keys_array.clone()), (values_field, Arc::new(values_array) as ArrayRef), ]); let entries_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, entry_struct.data_type().clone(), false, )); diff --git a/arrow-row/src/lib.rs b/arrow-row/src/lib.rs index e3edfa174d7c..05d819493266 100644 --- a/arrow-row/src/lib.rs +++ b/arrow-row/src/lib.rs @@ -4426,7 +4426,11 @@ mod tests { #[test] fn test_single_map_with_non_nullable_values() { // Use `with_values_field` on `MapBuilder` to set the values are not nullable - let value_field = Arc::new(Field::new("values", DataType::Int32, false)); + let value_field = Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Int32, + false, + )); let mut builder = MapBuilder::new(None, StringBuilder::new(), Int32Builder::new()) .with_values_field(value_field); // Entry 0: {"a": 1, "b": 2} @@ -4464,7 +4468,11 @@ mod tests { #[test] fn test_single_map_with_non_nullable_map_but_with_nullable_values() { // Map column is non-nullable, but values are nullable - let value_field = Arc::new(Field::new("values", DataType::Int32, true)); + let value_field = Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Int32, + true, + )); let mut builder = MapBuilder::new(None, StringBuilder::new(), Int32Builder::new()) .with_values_field(value_field); @@ -4845,9 +4853,17 @@ mod tests { let nulls = NullBuffer::from_iter((0..len).map(|_| rng.random_bool(valid_percent))); let field = Arc::new(Field::new_map( "", - "entries", - Field::new("keys", keys.data_type().clone(), false), - Field::new("values", values.data_type().clone(), true), + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + keys.data_type().clone(), + false, + ), + Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + values.data_type().clone(), + true, + ), false, true, )); @@ -6355,11 +6371,19 @@ mod tests { let offsets = OffsetBuffer::new(vec![0, 1, 1, 3].into()); let entries_fields = vec![ - Arc::new(Field::new("keys", DataType::Utf8, false)), - Arc::new(Field::new("values", DataType::Null, true)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )), + Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Null, + true, + )), ]; let struct_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(entries_fields.clone().into()), false, )); @@ -6386,11 +6410,19 @@ mod tests { let offsets = OffsetBuffer::new(vec![0, 1, 1, 3].into()); let entries_fields = vec![ - Arc::new(Field::new("keys", DataType::Utf8, false)), - Arc::new(Field::new("values", DataType::Null, true)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )), + Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Null, + true, + )), ]; let struct_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(entries_fields.clone().into()), false, )); @@ -6416,11 +6448,19 @@ mod tests { let offsets = OffsetBuffer::new(vec![0i32].into()); let entries_fields = vec![ - Arc::new(Field::new("keys", DataType::Utf8, false)), - Arc::new(Field::new("values", DataType::Null, true)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )), + Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Null, + true, + )), ]; let struct_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(entries_fields.clone().into()), false, )); @@ -6444,11 +6484,19 @@ mod tests { let offsets = OffsetBuffer::new(vec![0, 1, 1, 3].into()); let entries_fields = vec![ - Arc::new(Field::new("keys", DataType::Utf8, false)), - Arc::new(Field::new("values", DataType::Null, true)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )), + Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Null, + true, + )), ]; let struct_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(entries_fields.clone().into()), false, )); @@ -6474,11 +6522,19 @@ mod tests { let offsets = OffsetBuffer::new(vec![0, 0, 0, 0].into()); let entries_fields = vec![ - Arc::new(Field::new("keys", DataType::Utf8, false)), - Arc::new(Field::new("values", DataType::Null, true)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )), + Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Null, + true, + )), ]; let struct_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(entries_fields.clone().into()), false, )); @@ -6507,11 +6563,19 @@ mod tests { let inner_null_values = Arc::new(NullArray::new(3)) as ArrayRef; let inner_entries_fields = vec![ - Arc::new(Field::new("keys", DataType::Utf8, false)), - Arc::new(Field::new("values", DataType::Null, true)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )), + Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Null, + true, + )), ]; let inner_struct_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(inner_entries_fields.clone().into()), false, )); @@ -6535,11 +6599,19 @@ mod tests { let inner_map_type = DataType::Map(inner_struct_field.clone(), false); let outer_entries_fields = vec![ - Arc::new(Field::new("keys", DataType::Utf8, false)), - Arc::new(Field::new("values", inner_map_type, true)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )), + Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + inner_map_type, + true, + )), ]; let outer_struct_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(outer_entries_fields.clone().into()), false, )); @@ -6574,11 +6646,19 @@ mod tests { let null_values = Arc::new(NullArray::new(3)) as ArrayRef; let entries_fields = vec![ - Arc::new(Field::new("keys", DataType::Utf8, false)), - Arc::new(Field::new("values", DataType::Null, true)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )), + Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Null, + true, + )), ]; let struct_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(entries_fields.clone().into()), false, )); @@ -6625,11 +6705,19 @@ mod tests { let list_type = list_array.data_type().clone(); let entries_fields = vec![ - Arc::new(Field::new("keys", DataType::Utf8, false)), - Arc::new(Field::new("values", list_type, true)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Utf8, + false, + )), + Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + list_type, + true, + )), ]; let struct_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(entries_fields.clone().into()), false, )); diff --git a/arrow-schema/src/datatype_display.rs b/arrow-schema/src/datatype_display.rs index 203d4a1584b1..354c3a2b35fb 100644 --- a/arrow-schema/src/datatype_display.rs +++ b/arrow-schema/src/datatype_display.rs @@ -433,11 +433,11 @@ mod tests { #[test] fn test_display_map() { let entry_field = Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct( vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Int32, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), ] .into(), ), @@ -451,11 +451,11 @@ mod tests { // Test with metadata let mut entry_field_with_metadata = Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct( vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Int32, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), ] .into(), ), diff --git a/arrow-schema/src/datatype_parse.rs b/arrow-schema/src/datatype_parse.rs index 8721954086de..cc4dbf44ad66 100644 --- a/arrow-schema/src/datatype_parse.rs +++ b/arrow-schema/src/datatype_parse.rs @@ -1209,9 +1209,9 @@ mod test { DataType::Map( Arc::new(Field::new_map( "nested_map", - "entries", - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Int32, true), + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), false, true, )), diff --git a/arrow-schema/src/ffi.rs b/arrow-schema/src/ffi.rs index f377ffc7efdd..d8f779c36456 100644 --- a/arrow-schema/src/ffi.rs +++ b/arrow-schema/src/ffi.rs @@ -958,13 +958,19 @@ mod tests { #[test] fn test_map_keys_sorted() { - let keys = Field::new("keys", DataType::Int32, false); - let values = Field::new("values", DataType::UInt32, false); + let keys = Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int32, false); + let values = Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::UInt32, false); let entry_struct = DataType::Struct(vec![keys, values].into()); // Construct a map array from the above two - let map_data_type = - DataType::Map(Arc::new(Field::new("entries", entry_struct, false)), true); + let map_data_type = DataType::Map( + Arc::new(Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + entry_struct, + false, + )), + true, + ); let arrow_schema = FFI_ArrowSchema::try_from(map_data_type).unwrap(); assert!(arrow_schema.map_keys_sorted()); diff --git a/arrow-schema/src/field.rs b/arrow-schema/src/field.rs index 18d35d4c7c26..a0f6fb9a3e2f 100644 --- a/arrow-schema/src/field.rs +++ b/arrow-schema/src/field.rs @@ -150,6 +150,18 @@ impl AsRef for Field { impl Field { /// Default list member field name pub const LIST_FIELD_DEFAULT_NAME: &'static str = "item"; + /// Default field name for the entries field for Map + /// + /// See [Arrow Spec](https://github.com/apache/arrow/blob/b19c4761b558ade94ae05743062d92aacedef10e/format/Schema.fbs#L127-L138)) + pub const MAP_ENTRIES_FIELD_DEFAULT_NAME: &'static str = "entries"; + /// Default field name for the key field for Map + /// + /// See [Arrow Spec](https://github.com/apache/arrow/blob/b19c4761b558ade94ae05743062d92aacedef10e/format/Schema.fbs#L127-L138)) + pub const MAP_KEY_FIELD_DEFAULT_NAME: &'static str = "key"; + /// Default field name for the value field for Map + /// + /// See [Arrow Spec](https://github.com/apache/arrow/blob/b19c4761b558ade94ae05743062d92aacedef10e/format/Schema.fbs#L127-L138)) + pub const MAP_VALUE_FIELD_DEFAULT_NAME: &'static str = "value"; /// Creates a new field with the given name, data type, and nullability /// diff --git a/arrow-schema/src/fields.rs b/arrow-schema/src/fields.rs index 3d19cb963f96..f06d5631ede3 100644 --- a/arrow-schema/src/fields.rs +++ b/arrow-schema/src/fields.rs @@ -675,9 +675,13 @@ mod tests { ), Field::new_map( "g", - "entries", - Field::new("keys", DataType::LargeUtf8, false), - Field::new("values", DataType::Int32, true), + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::LargeUtf8, + false, + ), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), false, false, ), diff --git a/arrow/src/util/data_gen.rs b/arrow/src/util/data_gen.rs index 20bf4fc0efd6..1953519df4fe 100644 --- a/arrow/src/util/data_gen.rs +++ b/arrow/src/util/data_gen.rs @@ -849,9 +849,9 @@ mod tests { fn test_create_map_array() { let map_field = Field::new_map( "map", - "entries", - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Utf8, true), + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, true), false, false, ); diff --git a/arrow/tests/array_transform.rs b/arrow/tests/array_transform.rs index 548e7c3a26c8..630e9fd59687 100644 --- a/arrow/tests/array_transform.rs +++ b/arrow/tests/array_transform.rs @@ -798,11 +798,19 @@ fn test_map_nulls_append() { let expected_entry_array = StructArray::from(vec![ ( - Arc::new(Field::new("keys", DataType::Int64, false)), + Arc::new(Field::new( + Field::MAP_KEY_FIELD_DEFAULT_NAME, + DataType::Int64, + false, + )), Arc::new(expected_key_array) as ArrayRef, ), ( - Arc::new(Field::new("values", DataType::Int64, true)), + Arc::new(Field::new( + Field::MAP_VALUE_FIELD_DEFAULT_NAME, + DataType::Int64, + true, + )), Arc::new(expected_value_array) as ArrayRef, ), ]); @@ -812,10 +820,10 @@ fn test_map_nulls_append() { let expected_list_data = ArrayData::try_new( DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("keys", DataType::Int64, false), - Field::new("values", DataType::Int64, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int64, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int64, true), ])), false, )), diff --git a/parquet-variant-compute/src/arrow_to_variant.rs b/parquet-variant-compute/src/arrow_to_variant.rs index 03a84109ffa0..b9e7fff06461 100644 --- a/parquet-variant-compute/src/arrow_to_variant.rs +++ b/parquet-variant-compute/src/arrow_to_variant.rs @@ -1378,8 +1378,8 @@ mod tests { let keys = StringArray::from(vec!["key1", "key2", "key3"]); let values = Int32Array::from(vec![1, 2, 3]); let entries_fields = Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Int32, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), ]); let entries = StructArray::new( entries_fields.clone(), @@ -1399,7 +1399,7 @@ mod tests { // Create the map field let map_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(entries_fields), false, // Keys are non-nullable )); diff --git a/parquet-variant-compute/src/cast_to_variant.rs b/parquet-variant-compute/src/cast_to_variant.rs index 1b26ffe07d2a..ef90e61373b0 100644 --- a/parquet-variant-compute/src/cast_to_variant.rs +++ b/parquet-variant-compute/src/cast_to_variant.rs @@ -1983,8 +1983,8 @@ mod tests { let keys = StringArray::from(vec!["key1", "key2", "key3"]); let values = Int32Array::from(vec![1, 2, 3]); let entries_fields = Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Int32, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), ]); let entries = StructArray::new( entries_fields.clone(), @@ -1999,7 +1999,7 @@ mod tests { let null_buffer = Some(NullBuffer::from(vec![true, true, false, true])); let map_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(entries_fields), false, )); @@ -2039,8 +2039,8 @@ mod tests { fn test_cast_to_variant_map_with_non_string_keys() { let offsets = OffsetBuffer::new(vec![0, 1, 3].into()); let fields = Fields::from(vec![ - Field::new("key", DataType::Int32, false), - Field::new("values", DataType::Int32, false), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Int32, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, false), ]); let columns = vec![ Arc::new(Int32Array::from(vec![1, 2, 3])) as _, @@ -2048,7 +2048,11 @@ mod tests { ]; let entries = StructArray::new(fields.clone(), columns, None); - let field = Arc::new(Field::new("entries", DataType::Struct(fields), false)); + let field = Arc::new(Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + DataType::Struct(fields), + false, + )); let map_array = MapArray::new(field.clone(), offsets.clone(), entries.clone(), None, false); diff --git a/parquet-variant-compute/src/shred_variant.rs b/parquet-variant-compute/src/shred_variant.rs index 389012ddc0bb..495728b9a4af 100644 --- a/parquet-variant-compute/src/shred_variant.rs +++ b/parquet-variant-compute/src/shred_variant.rs @@ -1471,10 +1471,10 @@ mod tests { ), DataType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Int32, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Int32, true), ])), false, )), diff --git a/parquet-variant-compute/src/variant_to_arrow.rs b/parquet-variant-compute/src/variant_to_arrow.rs index 66666ee138e8..d7c61b7653af 100644 --- a/parquet-variant-compute/src/variant_to_arrow.rs +++ b/parquet-variant-compute/src/variant_to_arrow.rs @@ -1460,10 +1460,10 @@ mod tests { let item_field = Arc::new(Field::new("item", DataType::Int32, true)); let struct_fields = Fields::from(vec![Field::new("child", DataType::Int32, true)]); let map_entries_field = Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Float64, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Float64, true), ])), true, )); diff --git a/parquet/src/arrow/array_reader/map_array.rs b/parquet/src/arrow/array_reader/map_array.rs index 5d88df6cea1d..117f3b73ba9e 100644 --- a/parquet/src/arrow/array_reader/map_array.rs +++ b/parquet/src/arrow/array_reader/map_array.rs @@ -158,10 +158,10 @@ mod tests { "map", ArrowType::Map( Arc::new(Field::new( - "entries", + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, ArrowType::Struct(Fields::from(vec![ - Field::new("keys", ArrowType::Utf8, false), - Field::new("values", ArrowType::Int32, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, ArrowType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, ArrowType::Int32, true), ])), false, )), diff --git a/parquet/src/arrow/arrow_writer/levels.rs b/parquet/src/arrow/arrow_writer/levels.rs index cbac5cfe5444..efd77036a590 100644 --- a/parquet/src/arrow/arrow_writer/levels.rs +++ b/parquet/src/arrow/arrow_writer/levels.rs @@ -1909,13 +1909,17 @@ mod tests { {"stocks":{"hedged": "$YYY", "long": null, "short": "$D"}} "#; let entries_struct_type = DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Utf8, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, true), ])); let stocks_field = Field::new( "stocks", DataType::Map( - Arc::new(Field::new("entries", entries_struct_type, false)), + Arc::new(Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + entries_struct_type, + false, + )), false, ), // not nullable, so the keys have max level = 1 diff --git a/parquet/src/arrow/arrow_writer/mod.rs b/parquet/src/arrow/arrow_writer/mod.rs index 79b8ebe8bebd..a1fb21ec2759 100644 --- a/parquet/src/arrow/arrow_writer/mod.rs +++ b/parquet/src/arrow/arrow_writer/mod.rs @@ -2753,13 +2753,17 @@ mod tests { {"stocks":{"hedged": "$YYY", "long": null, "short": "$D"}} "#; let entries_struct_type = DataType::Struct(Fields::from(vec![ - Field::new("key", DataType::Utf8, false), - Field::new("value", DataType::Utf8, true), + Field::new(Field::MAP_KEY_FIELD_DEFAULT_NAME, DataType::Utf8, false), + Field::new(Field::MAP_VALUE_FIELD_DEFAULT_NAME, DataType::Utf8, true), ])); let stocks_field = Field::new( "stocks", DataType::Map( - Arc::new(Field::new("entries", entries_struct_type, false)), + Arc::new(Field::new( + Field::MAP_ENTRIES_FIELD_DEFAULT_NAME, + entries_struct_type, + false, + )), false, ), true, @@ -4008,9 +4012,9 @@ mod tests { Field::new_list("my_list", Field::new("item", DataType::Int32, false), false); let map_field = Field::new_map( "my_map", - "entries", - Field::new("keys", DataType::Int32, false), - Field::new("values", DataType::Int32, true), + "my_entries", + Field::new("my_keys", DataType::Int32, false), + Field::new("my_values", DataType::Int32, true), false, true, ); @@ -4038,9 +4042,9 @@ mod tests { let map_field = &schema.get_fields()[1].get_fields()[0]; // Coerced name of "entries" should be "key_value" assert_eq!(map_field.name(), "key_value"); - // Coerced name of "keys" should be "key" + // Coerced name of "my_keys" should be "key" assert_eq!(map_field.get_fields()[0].name(), "key"); - // Coerced name of "values" should be "value" + // Coerced name of "my_values" should be "value" assert_eq!(map_field.get_fields()[1].name(), "value"); // Double check schema after reading from the file diff --git a/parquet/src/arrow/schema/mod.rs b/parquet/src/arrow/schema/mod.rs index 7878e7c49bd3..f1d7ea7e887b 100644 --- a/parquet/src/arrow/schema/mod.rs +++ b/parquet/src/arrow/schema/mod.rs @@ -1731,9 +1731,9 @@ mod tests { ), Field::new_map( "my_map", - "entries", - Field::new("keys", DataType::Utf8, false), - Field::new("values", DataType::Int32, true), + "my_entries", + Field::new("my_keys", DataType::Utf8, false), + Field::new("my_values", DataType::Int32, true), false, true, ), @@ -1776,9 +1776,9 @@ mod tests { } } OPTIONAL GROUP my_map (MAP) { - REPEATED GROUP entries { - REQUIRED BINARY keys (STRING); - OPTIONAL INT32 values; + REPEATED GROUP my_entries { + REQUIRED BINARY my_keys (STRING); + OPTIONAL INT32 my_values; } } }