Function StringDataTransform

cpp/src/arrow/compute/kernels/scalar_string_ascii.cc:450–493

// length
template <typename Type>
Status StringDataTransform(KernelContext* ctx, const ExecSpan& batch,
                           TransformFunc transform, ExecResult* out) {
  using offset_type = typename Type::offset_type;

  const ArraySpan& input = batch[0].array;
  ArrayData* out_arr = out->array_data().get();

  const auto offsets = input.GetValues<offset_type>(1);
  int64_t offset_nbytes = (input.length + 1) * sizeof(offset_type);
  if (input.offset == 0) {
    // We can reuse offsets from input if the input owns it
    if (input.buffers[1].owner != nullptr) {
      out_arr->buffers[1] = input.GetBuffer(1);
    } else {
      RETURN_NOT_OK(ctx->Allocate(offset_nbytes).Value(&out_arr->buffers[1]));
      std::memcpy(out_arr->buffers[1]->mutable_data(), input.buffers[1].data,
                  offset_nbytes);
    }
  } else {
    // We must allocate new space for the offsets and shift the existing offsets
    RETURN_NOT_OK(ctx->Allocate(offset_nbytes).Value(&out_arr->buffers[1]));
    auto out_offsets =
        reinterpret_cast<offset_type*>(out_arr->buffers[1]->mutable_data());
    offset_type first_offset = offsets[0];
    for (int64_t i = 0; i < input.length; ++i) {
      *out_offsets++ = offsets[i] - first_offset;
    }
    *out_offsets = offsets[input.length] - first_offset;
  }

  int64_t data_nbytes = GetVarBinaryValuesLength<offset_type>(input);
  if (input.length > 0) {
    // Allocate space for output data
    if (data_nbytes > 0) {
      RETURN_NOT_OK(ctx->Allocate(data_nbytes).Value(&out_arr->buffers[2]));
      transform(input.buffers[2].data + offsets[0], data_nbytes,
                out_arr->buffers[2]->mutable_data());
    } else {
      // Empty buffer
      out_arr->buffers[2] = Buffer::FromString("");
    }
  }
  return Status::OK();
}

// ----------------------------------------------------------------------
// Predicates and classification