This is an automated email from the ASF dual-hosted git repository.
lidavidm pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-adbc.git
The following commit(s) were added to refs/heads/main by this push:
new 59121d1b3 chore(c/vendor): Update vendored nanoarrow to 0.8.0 (#3944)
59121d1b3 is described below
commit 59121d1b34bd4e175c761af7f2f34118bf895e23
Author: Dewey Dunnington <[email protected]>
AuthorDate: Wed Feb 11 17:42:18 2026 -0600
chore(c/vendor): Update vendored nanoarrow to 0.8.0 (#3944)
Updates vendored nanoarrow to 0.8.0. The main update involves the
ability to construct or deconstruct string view arrays by buffer (as
opposed to constructing using the appenders), which I don't think is
used in ADBC.
---
c/vendor/nanoarrow/nanoarrow.c | 116 ++++++++++++++++++++++++--------------
c/vendor/nanoarrow/nanoarrow.h | 118 ++++++++++++++++++++++++++-------------
c/vendor/nanoarrow/nanoarrow.hpp | 2 +-
c/vendor/vendor_nanoarrow.sh | 2 +-
4 files changed, 155 insertions(+), 83 deletions(-)
diff --git a/c/vendor/nanoarrow/nanoarrow.c b/c/vendor/nanoarrow/nanoarrow.c
index 80b79eee5..123e8e845 100644
--- a/c/vendor/nanoarrow/nanoarrow.c
+++ b/c/vendor/nanoarrow/nanoarrow.c
@@ -2328,7 +2328,6 @@ static void ArrowArrayReleaseInternal(struct ArrowArray*
array) {
ArrowBufferReset(&private_data->variadic_buffers[i]);
}
ArrowFree(private_data->variadic_buffers);
- ArrowFree(private_data->variadic_buffer_sizes);
ArrowFree(private_data);
}
@@ -2364,6 +2363,10 @@ static void ArrowArrayReleaseInternal(struct ArrowArray*
array) {
array->release = NULL;
}
+static int ArrowArrayIsInternal(struct ArrowArray* array) {
+ return array->release == &ArrowArrayReleaseInternal;
+}
+
static ArrowErrorCode ArrowArraySetStorageType(struct ArrowArray* array,
enum ArrowType storage_type) {
switch (storage_type) {
@@ -2460,7 +2463,6 @@ ArrowErrorCode ArrowArrayInitFromType(struct ArrowArray*
array,
}
private_data->n_variadic_buffers = 0;
private_data->variadic_buffers = NULL;
- private_data->variadic_buffer_sizes = NULL;
private_data->list_view_offset = 0;
array->private_data = private_data;
@@ -2623,25 +2625,35 @@ ArrowErrorCode ArrowArraySetBuffer(struct ArrowArray*
array, int64_t i,
struct ArrowArrayPrivateData* private_data =
(struct ArrowArrayPrivateData*)array->private_data;
- switch (i) {
- case 0:
- ArrowBufferMove(buffer, &private_data->bitmap.buffer);
- private_data->buffer_data[i] = private_data->bitmap.buffer.data;
- break;
- case 1:
- case 2:
- ArrowBufferMove(buffer, &private_data->buffers[i - 1]);
- private_data->buffer_data[i] = private_data->buffers[i - 1].data;
- break;
- default:
- return EINVAL;
+ if (i >= array->n_buffers || i < 0) {
+ return EINVAL;
}
+ // Find the `i`th buffer, release what is currently there, and move the
+ // supplied buffer into that slot.
+ struct ArrowBuffer* dst = ArrowArrayBuffer(array, i);
+ ArrowBufferReset(dst);
+ ArrowBufferMove(buffer, dst);
+
+ // Flush the pointer into array->buffers. In theory clients should call
+ // ArrowArrayFinishBuilding() to flush the pointer values before passing
+ // this array elsewhere; however, in early nanoarrow versions this was not
+ // needed and some code may depend on this being true.
+ private_data->buffer_data[i] = dst->data;
+ array->buffers = private_data->buffer_data;
+
return NANOARROW_OK;
}
static ArrowErrorCode ArrowArrayViewInitFromArray(struct ArrowArrayView*
array_view,
- struct ArrowArray* array) {
+ struct ArrowArray* array,
+ struct ArrowError* error) {
+ if (!ArrowArrayIsInternal(array)) {
+ ArrowErrorSet(error,
+ "Can't initialize internal ArrowArrayView from external
ArrowArray");
+ return EINVAL;
+ }
+
struct ArrowArrayPrivateData* private_data =
(struct ArrowArrayPrivateData*)array->private_data;
@@ -2666,7 +2678,8 @@ static ArrowErrorCode ArrowArrayViewInitFromArray(struct
ArrowArrayView* array_v
}
for (int64_t i = 0; i < array->n_children; i++) {
- result = ArrowArrayViewInitFromArray(array_view->children[i],
array->children[i]);
+ result =
+ ArrowArrayViewInitFromArray(array_view->children[i],
array->children[i], error);
if (result != NANOARROW_OK) {
ArrowArrayViewReset(array_view);
return result;
@@ -2680,7 +2693,8 @@ static ArrowErrorCode ArrowArrayViewInitFromArray(struct
ArrowArrayView* array_v
return result;
}
- result = ArrowArrayViewInitFromArray(array_view->dictionary,
array->dictionary);
+ result =
+ ArrowArrayViewInitFromArray(array_view->dictionary, array->dictionary,
error);
if (result != NANOARROW_OK) {
ArrowArrayViewReset(array_view);
return result;
@@ -2693,7 +2707,7 @@ static ArrowErrorCode ArrowArrayViewInitFromArray(struct
ArrowArrayView* array_v
static ArrowErrorCode ArrowArrayReserveInternal(struct ArrowArray* array,
struct ArrowArrayView*
array_view) {
// Loop through buffers and reserve the extra space that we know about
- for (int64_t i = 0; i < array->n_buffers; i++) {
+ for (int64_t i = 0; i < NANOARROW_MAX_FIXED_BUFFERS; i++) {
// Don't reserve on a validity buffer that hasn't been allocated yet
if (array_view->layout.buffer_type[i] == NANOARROW_BUFFER_TYPE_VALIDITY &&
ArrowArrayBuffer(array, i)->data == NULL) {
@@ -2721,7 +2735,7 @@ static ArrowErrorCode ArrowArrayReserveInternal(struct
ArrowArray* array,
ArrowErrorCode ArrowArrayReserve(struct ArrowArray* array,
int64_t additional_size_elements) {
struct ArrowArrayView array_view;
- NANOARROW_RETURN_NOT_OK(ArrowArrayViewInitFromArray(&array_view, array));
+ NANOARROW_RETURN_NOT_OK(ArrowArrayViewInitFromArray(&array_view, array,
NULL));
// Calculate theoretical buffer sizes (recursively)
ArrowArrayViewSetLength(&array_view, array->length +
additional_size_elements);
@@ -2753,47 +2767,62 @@ static ArrowErrorCode ArrowArrayFinalizeBuffers(struct
ArrowArray* array) {
}
for (int64_t i = 0; i < array->n_children; i++) {
- NANOARROW_RETURN_NOT_OK(ArrowArrayFinalizeBuffers(array->children[i]));
+ if (ArrowArrayIsInternal(array->children[i])) {
+ NANOARROW_RETURN_NOT_OK(ArrowArrayFinalizeBuffers(array->children[i]));
+ }
}
- if (array->dictionary != NULL) {
+ if (array->dictionary != NULL && ArrowArrayIsInternal(array->dictionary)) {
NANOARROW_RETURN_NOT_OK(ArrowArrayFinalizeBuffers(array->dictionary));
}
return NANOARROW_OK;
}
-static void ArrowArrayFlushInternalPointers(struct ArrowArray* array) {
+static ArrowErrorCode ArrowArrayFlushInternalPointers(struct ArrowArray*
array) {
+ NANOARROW_DCHECK(ArrowArrayIsInternal(array));
struct ArrowArrayPrivateData* private_data =
(struct ArrowArrayPrivateData*)array->private_data;
- const bool is_binary_view = private_data->storage_type ==
NANOARROW_TYPE_STRING_VIEW ||
- private_data->storage_type ==
NANOARROW_TYPE_BINARY_VIEW;
- const int32_t nfixed_buf = is_binary_view ? 2 : NANOARROW_MAX_FIXED_BUFFERS;
+ if (array->n_buffers > NANOARROW_MAX_FIXED_BUFFERS) {
+ // If the variadic sizes buffer was not set and there is at least one
variadic
+ // buffer, populate it now (if there are no variadic buffers there will be
exactly
+ // three total buffers and we don't need to do anything special here).
Notably, this
+ // will occur when building a BinaryView/StringView array by element using
the
+ // appender.
+ struct ArrowBuffer* sizes_buffer = ArrowArrayBuffer(array,
array->n_buffers - 1);
+ if (sizes_buffer->data == NULL && sizes_buffer->size_bytes == 0) {
+ NANOARROW_RETURN_NOT_OK(
+ ArrowBufferReserve(sizes_buffer, private_data->n_variadic_buffers));
+ for (int64_t i = 0; i < private_data->n_variadic_buffers; i++) {
+ struct ArrowBuffer* variadic_buffer =
+ ArrowArrayBuffer(array, i + NANOARROW_BINARY_VIEW_FIXED_BUFFERS);
+ NANOARROW_RETURN_NOT_OK(
+ ArrowBufferAppendInt64(sizes_buffer, variadic_buffer->size_bytes));
+ }
+ }
+ }
- for (int32_t i = 0; i < nfixed_buf; i++) {
+ for (int32_t i = 0; i < array->n_buffers; i++) {
private_data->buffer_data[i] = ArrowArrayBuffer(array, i)->data;
}
- if (is_binary_view) {
- const int32_t nvirt_buf = private_data->n_variadic_buffers;
- private_data->buffer_data = (const void**)ArrowRealloc(
- private_data->buffer_data, sizeof(void*) * (nfixed_buf + nvirt_buf +
1));
- for (int32_t i = 0; i < nvirt_buf; i++) {
- private_data->buffer_data[nfixed_buf + i] =
private_data->variadic_buffers[i].data;
- }
- private_data->buffer_data[nfixed_buf + nvirt_buf] =
- private_data->variadic_buffer_sizes;
- array->buffers = (const void**)(private_data->buffer_data);
- }
+ array->buffers = (const void**)(private_data->buffer_data);
+ // Flush internal pointers for child/dictionary arrays if we allocated them.
Clients
+ // building arrays by buffer might have moved arrays from some other source
(e.g.,
+ // to create a record batch) and calling this function in that case will
cause a crash.
for (int64_t i = 0; i < array->n_children; i++) {
- ArrowArrayFlushInternalPointers(array->children[i]);
+ if (ArrowArrayIsInternal(array->children[i])) {
+
NANOARROW_RETURN_NOT_OK(ArrowArrayFlushInternalPointers(array->children[i]));
+ }
}
- if (array->dictionary != NULL) {
- ArrowArrayFlushInternalPointers(array->dictionary);
+ if (array->dictionary != NULL && ArrowArrayIsInternal(array->dictionary)) {
+
NANOARROW_RETURN_NOT_OK(ArrowArrayFlushInternalPointers(array->dictionary));
}
+
+ return NANOARROW_OK;
}
ArrowErrorCode ArrowArrayFinishBuilding(struct ArrowArray* array,
@@ -2809,7 +2838,7 @@ ArrowErrorCode ArrowArrayFinishBuilding(struct
ArrowArray* array,
// Make sure the value we get with array->buffers[i] is set to the actual
// pointer (which may have changed from the original due to reallocation)
- ArrowArrayFlushInternalPointers(array);
+ NANOARROW_RETURN_NOT_OK_WITH_ERROR(ArrowArrayFlushInternalPointers(array),
error);
if (validation_level == NANOARROW_VALIDATION_LEVEL_NONE) {
return NANOARROW_OK;
@@ -2817,8 +2846,8 @@ ArrowErrorCode ArrowArrayFinishBuilding(struct
ArrowArray* array,
// For validation, initialize an ArrowArrayView with our known buffer sizes
struct ArrowArrayView array_view;
- NANOARROW_RETURN_NOT_OK_WITH_ERROR(ArrowArrayViewInitFromArray(&array_view,
array),
- error);
+ NANOARROW_RETURN_NOT_OK_WITH_ERROR(
+ ArrowArrayViewInitFromArray(&array_view, array, error), error);
int result = ArrowArrayViewValidate(&array_view, validation_level, error);
ArrowArrayViewReset(&array_view);
return result;
@@ -4040,6 +4069,7 @@ ArrowErrorCode ArrowBasicArrayStreamInit(struct
ArrowArrayStream* array_stream,
(struct ArrowArray*)ArrowMalloc(n_arrays * sizeof(struct ArrowArray));
if (private_data->arrays == NULL) {
ArrowBasicArrayStreamRelease(array_stream);
+ ArrowFree(private_data);
return ENOMEM;
}
}
diff --git a/c/vendor/nanoarrow/nanoarrow.h b/c/vendor/nanoarrow/nanoarrow.h
index 1fcac16ac..539b2ac9f 100644
--- a/c/vendor/nanoarrow/nanoarrow.h
+++ b/c/vendor/nanoarrow/nanoarrow.h
@@ -19,9 +19,9 @@
#define NANOARROW_CONFIG_H_INCLUDED
#define NANOARROW_VERSION_MAJOR 0
-#define NANOARROW_VERSION_MINOR 7
+#define NANOARROW_VERSION_MINOR 8
#define NANOARROW_VERSION_PATCH 0
-#define NANOARROW_VERSION "0.7.0"
+#define NANOARROW_VERSION "0.8.0"
#define NANOARROW_VERSION_INT \
(NANOARROW_VERSION_MAJOR * 10000 + NANOARROW_VERSION_MINOR * 100 + \
@@ -909,9 +909,6 @@ struct ArrowArrayPrivateData {
// Variadic buffers for binary view types
struct ArrowBuffer* variadic_buffers;
- // Size of each variadic buffer in bytes
- int64_t* variadic_buffer_sizes;
-
// The current offset used to build list views
int64_t list_view_offset;
};
@@ -1322,7 +1319,7 @@ static inline ArrowErrorCode ArrowArrayStreamGetSchema(
struct ArrowArrayStream* array_stream, struct ArrowSchema* out,
struct ArrowError* error);
-/// \brief Call the get_schema callback of an ArrowArrayStream
+/// \brief Call the get_next callback of an ArrowArrayStream
/// \ingroup nanoarrow-arrow-cdata
///
/// Unlike the get_next callback, this wrapper checks the return code
@@ -1333,12 +1330,13 @@ static inline ArrowErrorCode ArrowArrayStreamGetNext(
struct ArrowArrayStream* array_stream, struct ArrowArray* out,
struct ArrowError* error);
-/// \brief Call the get_next callback of an ArrowArrayStream
+/// \brief Call the get_last_error callback of an ArrowArrayStream
/// \ingroup nanoarrow-arrow-cdata
///
-/// Unlike the get_next callback, this function never returns NULL (i.e., its
-/// result is safe to use in printf-style error formatters). Null values from
the
-/// original callback are reported as "<get_last_error() returned NULL>".
+/// Unlike the get_last_error callback, this function never returns NULL (i.e.,
+/// its result is safe to use in printf-style error formatters). Null values
+/// from the original callback are reported as
+/// "<get_last_error() returned NULL>".
static inline const char* ArrowArrayStreamGetLastError(
struct ArrowArrayStream* array_stream);
@@ -1993,6 +1991,12 @@ NANOARROW_DLL void ArrowArraySetValidityBitmap(struct
ArrowArray* array,
NANOARROW_DLL ArrowErrorCode ArrowArraySetBuffer(struct ArrowArray* array,
int64_t i,
struct ArrowBuffer* buffer);
+/// \brief Add variadic buffers to a string or binary view array
+///
+/// array must have been allocated using ArrowArrayInitFromType()
+static inline ArrowErrorCode ArrowArrayAddVariadicBuffers(struct ArrowArray*
array,
+ int32_t n_buffers);
+
/// \brief Get the validity bitmap of an ArrowArray
///
/// array must have been allocated using ArrowArrayInitFromType()
@@ -2332,8 +2336,8 @@ NANOARROW_DLL ArrowErrorCode ArrowBasicArrayStreamInit(
/// \brief Set the ith ArrowArray in this ArrowArrayStream.
///
/// array_stream must have been initialized with ArrowBasicArrayStreamInit().
-/// This function move the ownership of array to the array_stream. i must
-/// be greater than zero and less than the value of n_arrays passed in
+/// This function moves the ownership of array to the array_stream. i must
+/// be greater than or equal to zero and less than the value of n_arrays
passed in
/// ArrowBasicArrayStreamInit(). Callers are not required to fill all
/// n_arrays members (i.e., n_arrays is a maximum bound).
NANOARROW_DLL void ArrowBasicArrayStreamSetArray(struct ArrowArrayStream*
array_stream,
@@ -3139,8 +3143,25 @@ static inline struct ArrowBuffer*
ArrowArrayBuffer(struct ArrowArray* array, int
switch (i) {
case 0:
return &private_data->bitmap.buffer;
+ case 1:
+ return private_data->buffers;
default:
- return private_data->buffers + i - 1;
+ if (array->n_buffers > 3 && i == (array->n_buffers - 1)) {
+ // The variadic buffer sizes buffer if for a BinaryView/String view
array
+ // is always stored in private_data->buffers[1]; however, from the
numbered
+ // buffers perspective this is the array->buffers[array->n_buffers -
1].
+ return private_data->buffers + 1;
+ } else if (array->n_buffers > 3) {
+ // If there are one or more variadic buffers, they are stored in
+ // private_data->variadic_buffers
+ return private_data->variadic_buffers + (i - 2);
+ } else {
+ // Otherwise, we're just accessing buffer at index 2 (e.g.,
String/Binary
+ // data buffer or variadic sizes buffer for the case where there are no
+ // variadic buffers)
+ NANOARROW_DCHECK(i == 2);
+ return private_data->buffers + i - 1;
+ }
}
}
@@ -3373,49 +3394,65 @@ static inline ArrowErrorCode
_ArrowArrayAppendEmptyInternal(struct ArrowArray* a
}
// Add appropriate buffer fill
- struct ArrowBuffer* buffer;
- int64_t size_bytes;
-
for (int i = 0; i < NANOARROW_MAX_FIXED_BUFFERS; i++) {
- buffer = ArrowArrayBuffer(array, i);
- size_bytes = private_data->layout.element_size_bits[i] / 8;
+ struct ArrowBuffer* buffer = ArrowArrayBuffer(array, i);
+ int64_t size_bytes = private_data->layout.element_size_bits[i] / 8;
switch (private_data->layout.buffer_type[i]) {
case NANOARROW_BUFFER_TYPE_NONE:
case NANOARROW_BUFFER_TYPE_VARIADIC_DATA:
case NANOARROW_BUFFER_TYPE_VARIADIC_SIZE:
case NANOARROW_BUFFER_TYPE_VALIDITY:
- continue;
+ // These buffer types don't require initialization for empty appends:
+ // - NONE: No buffer exists
+ // - VARIADIC_*: Handled by child arrays
+ // - VALIDITY: Already handled in previous bitmap logic
+ break;
+
case NANOARROW_BUFFER_TYPE_SIZE:
+ // Size buffers (e.g., string/array lengths) should be
zero-initialized:
+ // This ensures empty elements have logical zero-length
NANOARROW_RETURN_NOT_OK(ArrowBufferAppendFill(buffer, 0, size_bytes *
n));
- continue;
+ break;
+
case NANOARROW_BUFFER_TYPE_DATA_OFFSET:
- // Append the current value at the end of the offset buffer for each
element
+ // Offset buffers require special handling to maintain continuity.
+ // 1. Reserve space for new offset entries
NANOARROW_RETURN_NOT_OK(ArrowBufferReserve(buffer, size_bytes * n));
+ // 2. Duplicate last offset value for each new (empty) element
for (int64_t j = 0; j < n; j++) {
ArrowBufferAppendUnsafe(buffer, buffer->data + size_bytes *
(array->length + j),
size_bytes);
}
- // Skip the data buffer
+ // 3. Skip next buffer (DATA) since it's paired with offsets
+ // Rationale: Offset buffers are always followed by data buffers
+ // that don't require separate initialization here
i++;
- continue;
+ break;
+
case NANOARROW_BUFFER_TYPE_DATA:
- // Zero out the next bit of memory
+ // Fixed-width data buffers require zero-initialization:
if (private_data->layout.element_size_bits[i] % 8 == 0) {
+ // Byte-aligned: use efficient memset-style fill
NANOARROW_RETURN_NOT_OK(ArrowBufferAppendFill(buffer, 0, size_bytes
* n));
} else {
+ // Bit-packed: use special bitwise initialization
NANOARROW_RETURN_NOT_OK(_ArrowArrayAppendBits(array, i, 0, n));
}
- continue;
+ break;
+
case NANOARROW_BUFFER_TYPE_VIEW_OFFSET:
+ // View offset buffers (for string/binary view types) require
zero-initialization.
NANOARROW_RETURN_NOT_OK(ArrowBufferReserve(buffer, size_bytes * n));
NANOARROW_RETURN_NOT_OK(ArrowBufferAppendFill(buffer, 0, size_bytes *
n));
- continue;
+ break;
+
case NANOARROW_BUFFER_TYPE_TYPE_ID:
case NANOARROW_BUFFER_TYPE_UNION_OFFSET:
- // These cases return above
+ // These buffer types should have been handled by the outer type
switch and
+ // are not expected here, indicating an internal logic error.
return EINVAL;
}
}
@@ -3607,9 +3644,9 @@ static inline int32_t
ArrowArrayVariadicBufferCount(struct ArrowArray* array) {
}
static inline ArrowErrorCode ArrowArrayAddVariadicBuffers(struct ArrowArray*
array,
- int32_t nbuffers) {
+ int32_t n_buffers) {
const int32_t n_current_bufs = ArrowArrayVariadicBufferCount(array);
- const int32_t nvariadic_bufs_needed = n_current_bufs + nbuffers;
+ const int32_t nvariadic_bufs_needed = n_current_bufs + n_buffers;
struct ArrowArrayPrivateData* private_data =
(struct ArrowArrayPrivateData*)array->private_data;
@@ -3619,19 +3656,24 @@ static inline ArrowErrorCode
ArrowArrayAddVariadicBuffers(struct ArrowArray* arr
if (private_data->variadic_buffers == NULL) {
return ENOMEM;
}
- private_data->variadic_buffer_sizes = (int64_t*)ArrowRealloc(
- private_data->variadic_buffer_sizes, sizeof(int64_t) *
nvariadic_bufs_needed);
- if (private_data->variadic_buffer_sizes == NULL) {
- return ENOMEM;
- }
+
+ private_data->n_variadic_buffers = nvariadic_bufs_needed;
+ array->n_buffers = NANOARROW_BINARY_VIEW_FIXED_BUFFERS + 1 +
nvariadic_bufs_needed;
+
+ private_data->buffer_data = (const void**)ArrowRealloc(
+ private_data->buffer_data, array->n_buffers * sizeof(void*));
for (int32_t i = n_current_bufs; i < nvariadic_bufs_needed; i++) {
ArrowBufferInit(&private_data->variadic_buffers[i]);
- private_data->variadic_buffer_sizes[i] = 0;
+ private_data->buffer_data[NANOARROW_BINARY_VIEW_FIXED_BUFFERS + i] = NULL;
}
- private_data->n_variadic_buffers = nvariadic_bufs_needed;
- array->n_buffers = NANOARROW_BINARY_VIEW_FIXED_BUFFERS + 1 +
nvariadic_bufs_needed;
+ // Zero out memory for the final buffer (variadic sizes buffer we haven't
built yet)
+ private_data->buffer_data[NANOARROW_BINARY_VIEW_FIXED_BUFFERS +
nvariadic_bufs_needed] =
+ NULL;
+
+ // Ensure array->buffers points to a valid value
+ array->buffers = private_data->buffer_data;
return NANOARROW_OK;
}
@@ -3669,7 +3711,6 @@ static inline ArrowErrorCode ArrowArrayAppendBytes(struct
ArrowArray* array,
bvt.ref.offset = (int32_t)variadic_buf->size_bytes;
NANOARROW_RETURN_NOT_OK(
ArrowBufferAppend(variadic_buf, value.data.as_char,
value.size_bytes));
- private_data->variadic_buffer_sizes[buf_index] =
variadic_buf->size_bytes;
}
NANOARROW_RETURN_NOT_OK(ArrowBufferAppend(data_buffer, &bvt, sizeof(bvt)));
} else {
@@ -4174,6 +4215,7 @@ static inline int64_t ArrowArrayViewListChildOffset(
const struct ArrowArrayView* array_view, int64_t i) {
switch (array_view->storage_type) {
case NANOARROW_TYPE_LIST:
+ case NANOARROW_TYPE_MAP:
case NANOARROW_TYPE_LIST_VIEW:
return array_view->buffer_views[1].data.as_int32[i];
case NANOARROW_TYPE_LARGE_LIST:
diff --git a/c/vendor/nanoarrow/nanoarrow.hpp b/c/vendor/nanoarrow/nanoarrow.hpp
index 6f224f66f..59773b7db 100644
--- a/c/vendor/nanoarrow/nanoarrow.hpp
+++ b/c/vendor/nanoarrow/nanoarrow.hpp
@@ -69,7 +69,7 @@ NANOARROW_CXX_NAMESPACE_BEGIN
class Exception : public std::exception {
public:
Exception(const std::string& msg) : msg_(msg) {}
- const char* what() const noexcept { return msg_.c_str(); }
+ const char* what() const noexcept override { return msg_.c_str(); }
private:
std::string msg_;
diff --git a/c/vendor/vendor_nanoarrow.sh b/c/vendor/vendor_nanoarrow.sh
index d213b6af5..e2c2b869c 100755
--- a/c/vendor/vendor_nanoarrow.sh
+++ b/c/vendor/vendor_nanoarrow.sh
@@ -21,7 +21,7 @@
main() {
local -r repo_url="https://github.com/apache/arrow-nanoarrow";
# Check releases page: https://github.com/apache/arrow-nanoarrow/releases/
- local -r commit_sha=2cfba631b40886f1418a463f3b7c4552c8ae0dc7
+ local -r commit_sha=a579fbf5d192e85b6249935e117de7d02a6dc4e9
echo "Fetching $commit_sha from $repo_url"
SCRATCH=$(mktemp -d)
