Implement filter kernel specially for FixedSizeByteArray

[alamb]

Is your feature request related to a problem or challenge? Please describe what you are trying to do.
We are trying to store UUIDs in arrow Arrays and one obvious thing to do is use FixedSizeByteArray

However @samuelcolvin did some experiments (see apache/datafusion#11170) and found that non obviously using Decimal128 was actually faster than FixedSizeByteArray

One reason for this may be that FixedSizeByteArray does not have special case handling in the filter kernel

arrow-rs/arrow-select/src/filter.rs

Lines 320 to 383 in f42d242

	match predicate.strategy {
	IterationStrategy::None => Ok(new_empty_array(values.data_type())),
	IterationStrategy::All => Ok(values.slice(0, predicate.count)),
	// actually filter
	_ => downcast_primitive_array! {
	values => Ok(Arc::new(filter_primitive(values, predicate))),
	DataType::Boolean => {
	let values = values.as_any().downcast_ref::<BooleanArray>().unwrap();
	Ok(Arc::new(filter_boolean(values, predicate)))
	}
	DataType::Utf8 => {
	Ok(Arc::new(filter_bytes(values.as_string::<i32>(), predicate)))
	}
	DataType::LargeUtf8 => {
	Ok(Arc::new(filter_bytes(values.as_string::<i64>(), predicate)))
	}
	DataType::Utf8View => {
	Ok(Arc::new(filter_byte_view(values.as_string_view(), predicate)))
	}
	DataType::Binary => {
	Ok(Arc::new(filter_bytes(values.as_binary::<i32>(), predicate)))
	}
	DataType::LargeBinary => {
	Ok(Arc::new(filter_bytes(values.as_binary::<i64>(), predicate)))
	}
	DataType::BinaryView => {
	Ok(Arc::new(filter_byte_view(values.as_binary_view(), predicate)))
	}
	DataType::RunEndEncoded(_, _) => {
	downcast_run_array!{
	values => Ok(Arc::new(filter_run_end_array(values, predicate)?)),
	t => unimplemented!("Filter not supported for RunEndEncoded type {:?}", t)
	}
	}
	DataType::Dictionary(_, _) => downcast_dictionary_array! {
	values => Ok(Arc::new(filter_dict(values, predicate))),
	t => unimplemented!("Filter not supported for dictionary type {:?}", t)
	}
	_ => {
	let data = values.to_data();
	// fallback to using MutableArrayData
	let mut mutable = MutableArrayData::new(
	vec![&data],
	false,
	predicate.count,
	);
	match &predicate.strategy {
	IterationStrategy::Slices(slices) => {
	slices
	.iter()
	.for_each(|(start, end)| mutable.extend(0, *start, *end));
	}
	_ => {
	let iter = SlicesIterator::new(&predicate.filter);
	iter.for_each(|(start, end)| mutable.extend(0, start, end));
	}
	}
	let data = mutable.freeze();
	Ok(make_array(data))
	}
	},
	}

Describe the solution you'd like

1. Add special case code for FixedSizeByteArray
2. Add benchmark showing it is faster
3. Add unit tests for functional test coverage

Describe alternatives you've considered

Additional context
This was pointed out by @samuelcolvin on apache/datafusion#11170 (comment)

[chloro-pn]

This requirement doesn't seem difficult to implement. If no one is available, please assign it to me. : )

[alamb]

Thanks @chloro-pn - that would be super helpful 🙏

[alamb]

label_issue.py automatically added labels {'arrow'} from #6186