Function ExecArrayCoalesce

cpp/src/arrow/compute/kernels/scalar_if_else.cc:2112–2186

// Implement 'coalesce' for any mix of scalar/array arguments for any fixed-width type
template <typename Type>
Status ExecArrayCoalesce(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
  ArraySpan* output = out->array_span_mutable();
  const int64_t out_offset = output->offset;
  // Use output validity buffer as mask to decide what values to copy
  uint8_t* out_valid = output->buffers[0].data;

  // Clear output validity buffer - no values are set initially
  bit_util::SetBitsTo(out_valid, out_offset, batch.length, false);
  uint8_t* out_values = output->buffers[1].data;

  for (const ExecValue& value : batch.values) {
    if (value.null_count() == 0) {
      // Valid scalar, or all-valid array
      CopyValuesAllValid<Type>(value, out_valid, out_values, out_offset, batch.length);
      break;
    } else if (value.is_array()) {
      // Array with nulls
      const ArraySpan& arr = value.array;
      const int64_t in_offset = arr.offset;
      const int64_t in_null_count = arr.GetNullCount();
      DCHECK_GT(in_null_count, 0);
      const DataType& type = *arr.type;
      const uint8_t* in_valid = arr.buffers[0].data;
      const uint8_t* in_values = arr.buffers[1].data;

      if (in_null_count < 0.8 * batch.length) {
        // The input is not mostly null, we deem it more efficient to
        // copy values even underlying null slots instead of the more
        // expensive bitmasking using BinaryBitBlockCounter.
        BitRunReader bit_reader(out_valid, out_offset, batch.length);
        int64_t offset = 0;
        while (true) {
          const auto run = bit_reader.NextRun();
          if (run.length == 0) {
            break;
          }
          if (!run.set) {
            // Copy from input
            CopyDataUtils<Type>::CopyData(type, in_values, in_offset + offset, out_values,
                                          out_offset + offset, run.length);
          }
          offset += run.length;
        }
        arrow::internal::BitmapOr(out_valid, out_offset, in_valid, in_offset,
                                  batch.length, out_offset, out_valid);
      } else {
        BinaryBitBlockCounter counter(in_valid, in_offset, out_valid, out_offset,
                                      batch.length);
        int64_t offset = 0;
        while (offset < batch.length) {
          const auto block = counter.NextAndNotWord();
          if (block.AllSet()) {
            CopyValues<Type>(value, offset, block.length, out_valid, out_values,
                             out_offset + offset);
          } else if (block.popcount) {
            for (int64_t j = 0; j < block.length; ++j) {
              if (!bit_util::GetBit(out_valid, out_offset + offset + j) &&
                  bit_util::GetBit(in_valid, in_offset + offset + j)) {