Function MakeMisalignedDecimalArray

cpp/src/gandiva/tests/decimal_alignment_test.cc:51–109

Create a decimal128 array with data at a specific alignment offset This simulates the real-world scenario where Arrow data from external sources (like JNI/Java) may not be 16-byte aligned.

// This simulates the real-world scenario where Arrow data from external sources
// (like JNI/Java) may not be 16-byte aligned.
std::shared_ptr<arrow::Array> MakeMisalignedDecimalArray(
    const std::shared_ptr<arrow::Decimal128Type>& type,
    const std::vector<Decimal128>& values, int alignment_offset) {
  // Allocate buffer with extra space for misalignment
  int64_t data_size = values.size() * 16;  // 16 bytes per Decimal128
  int64_t buffer_size = data_size + 16;    // Extra space for offset

  std::shared_ptr<arrow::Buffer> buffer;
  ARROW_EXPECT_OK(arrow::AllocateBuffer(buffer_size).Value(&buffer));

  // Calculate the starting offset to achieve desired alignment
  // We want the data to be 8-byte aligned but NOT 16-byte aligned
  uint8_t* raw_data = buffer->mutable_data();
  uintptr_t addr = reinterpret_cast<uintptr_t>(raw_data);

  // Find offset to get to 8-byte aligned but not 16-byte aligned address
  int offset_to_8 = (8 - (addr % 8)) % 8;
  int current_16_alignment = (addr + offset_to_8) % 16;

  int final_offset;
  if (alignment_offset == 8) {
    // Want 8-byte aligned but NOT 16-byte aligned
    if (current_16_alignment == 0) {
      final_offset = offset_to_8 + 8;  // Add 8 to break 16-byte alignment
    } else {
      final_offset = offset_to_8;
    }
  } else {
    // Want 16-byte aligned
    final_offset = (16 - (addr % 16)) % 16;
  }

  // Copy decimal values to the offset location
  uint8_t* data_start = raw_data + final_offset;
  for (size_t i = 0; i < values.size(); i++) {
    memcpy(data_start + i * 16, values[i].ToBytes().data(), 16);
  }

  // Verify alignment
  uintptr_t data_addr = reinterpret_cast<uintptr_t>(data_start);
  EXPECT_EQ(data_addr % 8, 0) << "Data should be 8-byte aligned";
  if (alignment_offset == 8) {
    EXPECT_NE(data_addr % 16, 0) << "Data should NOT be 16-byte aligned";
  }

  // Create a sliced buffer starting at our offset
  auto sliced_buffer = arrow::SliceBuffer(buffer, final_offset, data_size);

  // Create validity buffer (all valid)
  std::shared_ptr<arrow::Buffer> validity_buffer;
  ARROW_EXPECT_OK(arrow::AllocateBuffer((values.size() + 7) / 8).Value(&validity_buffer));
  memset(validity_buffer->mutable_data(), 0xFF, validity_buffer->size());

  // Create the array with our misaligned data buffer
  auto array_data = arrow::ArrayData::Make(type, static_cast<int64_t>(values.size()),
                                           {validity_buffer, sliced_buffer});

  return std::make_shared<arrow::Decimal128Array>(array_data);