I think some comments that explained how this was different than https://docs.rs/arrow/latest/arrow/array/type.StringBuilder.html would help. Maybe simply a note that it didn't check UTF8 again?

I wonder if we could get the same effect by adding an unsafe function to StringBuilder, like

/// Adds bytes to the in progress string, without checking for valid utf8
/// 
/// Safety: requires that bytes are valid utf8, otherwise an invalid StringArray will result
unsafe fn append_unchecked(&mut self, bytes: &[u8]) 

And then using StringBuilder here

The Write trait impl of StringBuilder can meet my current needs, but it is not very convenient to use, so I've defined a StringArrayBuilder. I agree with your suggestion to add an unsafe function to StringBuilder.

https://github.com/apache/arrow-rs/blob/9f36c883459405ecd9a5f4fdfa9a3317ab52302c/arrow-array/src/builder/generic_bytes_builder.rs#L231-L257

let mut builder = GenericStringBuilder::<i32>::new();

 // Write data
write!(builder, "foo").unwrap();
write!(builder, "bar").unwrap();

// Finish value
builder.append_value("baz");

// Write second value
write!(builder, "v2").unwrap();
builder.append_value("");
let array = builder.finish();

assert_eq!(array.value(0), "foobarbaz");
assert_eq!(array.value(1), "v2");

Another issue is that we don't need NullBufferBuilder here, but GenericByteBuilder defaults to using NullBufferBuilder, which I believe introduces unnecessary overhead.

Is the primary speed savings gained from not checking UTF8 validity (and just copying byte slices)?

1. My initial intention for optimizing this function was to avoid creating a new String and then using push_str each time in concat function, like:

let mut owned_string: String = "".to_owned();
for arg in args {
    match arg {
        ColumnarValue::Scalar(ScalarValue::Utf8(maybe_value)) => {
            if let Some(value) = maybe_value {
                owned_string.push_str(value);
            }
        }
        ColumnarValue::Array(v) => {
            if v.is_valid(index) {
                let v = as_string_array(v).unwrap();
                owned_string.push_str(v.value(index));
            }
        }
        _ => unreachable!(),
    }
}
Some(owned_string)

3. Additionally, by precalculating the expected length of the result, I avoided the need to reallocate memory.
4. I used the extend_from_slice function because I referred to the append_slice function of BufferBuilder.

    #[inline]
    pub fn append_slice(&mut self, slice: &[T]) {
        self.buffer.extend_from_slice(slice);
        self.len += slice.len();
    }

Is it really necessary to avoid the bounds check for a single offset?

Since it is safe here and there is a theoretical performance improvement, I have opted to use push_unchecked in this case.

I was trying to think if there was some way to create an invalid result with this API and I think the answer is No (even if append_offset wasn't called ever the offsets would still be valid.