This is an automated email from the ASF dual-hosted git repository.
github-bot pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-nanoarrow.git
The following commit(s) were added to refs/heads/main by this push:
new 8f1201d Update dist/ for commit
f218a6c2b0fdb92fc5ba26d811ce9f6b3d8d9e3e
8f1201d is described below
commit 8f1201d630c2baf527a2c014a08c31e262bbb877
Author: GitHub Actions <[email protected]>
AuthorDate: Tue Sep 13 15:25:42 2022 +0000
Update dist/ for commit f218a6c2b0fdb92fc5ba26d811ce9f6b3d8d9e3e
---
dist/nanoarrow.c | 57 +++++++++++++++++++++++++++++++++++++++++++++-----------
dist/nanoarrow.h | 18 +++++++++---------
2 files changed, 55 insertions(+), 20 deletions(-)
diff --git a/dist/nanoarrow.c b/dist/nanoarrow.c
index 8cec4e0..19e29ca 100644
--- a/dist/nanoarrow.c
+++ b/dist/nanoarrow.c
@@ -40,7 +40,7 @@ int ArrowErrorSet(struct ArrowError* error, const char* fmt,
...) {
if (chars_needed < 0) {
return EINVAL;
- } else if (chars_needed >= sizeof(error->message)) {
+ } else if (((size_t)chars_needed) >= sizeof(error->message)) {
return ERANGE;
} else {
return NANOARROW_OK;
@@ -491,7 +491,7 @@ ArrowErrorCode ArrowSchemaInitDateTime(struct ArrowSchema*
schema,
return EINVAL;
}
- if (n_chars >= sizeof(buffer)) {
+ if (((size_t)n_chars) >= sizeof(buffer)) {
schema->release(schema);
return ERANGE;
}
@@ -745,14 +745,14 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
}
parse_start = format + 2;
- schema_view->decimal_precision = strtol(parse_start, &parse_end, 10);
+ schema_view->decimal_precision = (int32_t)strtol(parse_start,
&parse_end, 10);
if (parse_end == parse_start || parse_end[0] != ',') {
ArrowErrorSet(error, "Expected 'precision,scale[,bitwidth]' following
'd:'");
return EINVAL;
}
parse_start = parse_end + 1;
- schema_view->decimal_scale = strtol(parse_start, &parse_end, 10);
+ schema_view->decimal_scale = (int32_t)strtol(parse_start, &parse_end,
10);
if (parse_end == parse_start) {
ArrowErrorSet(error, "Expected 'scale[,bitwidth]' following
'd:precision,'");
return EINVAL;
@@ -760,7 +760,7 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
schema_view->decimal_bitwidth = 128;
} else {
parse_start = parse_end + 1;
- schema_view->decimal_bitwidth = strtol(parse_start, &parse_end, 10);
+ schema_view->decimal_bitwidth = (int32_t)strtol(parse_start,
&parse_end, 10);
if (parse_start == parse_end) {
ArrowErrorSet(error, "Expected precision following
'd:precision,scale,'");
return EINVAL;
@@ -791,7 +791,7 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
return EINVAL;
}
- schema_view->fixed_size = strtol(format + 2, (char**)format_end_out, 10);
+ schema_view->fixed_size = (int32_t)strtol(format + 2,
(char**)format_end_out, 10);
return NANOARROW_OK;
// validity + offset + data
@@ -844,7 +844,8 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
schema_view->storage_data_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
schema_view->data_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
- schema_view->fixed_size = strtol(format + 3, (char**)format_end_out,
10);
+ schema_view->fixed_size =
+ (int32_t)strtol(format + 3, (char**)format_end_out, 10);
return NANOARROW_OK;
case 's':
schema_view->storage_data_type = NANOARROW_TYPE_STRUCT;
@@ -888,6 +889,11 @@ static ArrowErrorCode ArrowSchemaViewParse(struct
ArrowSchemaView* schema_view,
format);
return EINVAL;
}
+
+ default:
+ ArrowErrorSet(error, "Expected nested type format string but found
'%s'",
+ format);
+ return EINVAL;
}
// date/time types
@@ -1226,7 +1232,7 @@ ArrowErrorCode ArrowSchemaViewInit(struct
ArrowSchemaView* schema_view,
return EINVAL;
}
- int format_len = strlen(format);
+ size_t format_len = strlen(format);
if (format_len == 0) {
ArrowErrorSet(error, "Error parsing schema->format: Expected a string with
size > 0");
return EINVAL;
@@ -1399,15 +1405,15 @@ static ArrowErrorCode
ArrowMetadataBuilderAppendInternal(struct ArrowBuffer* buf
NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt32(buffer, 0));
}
- if (buffer->capacity_bytes < sizeof(int32_t)) {
+ if (((size_t)buffer->capacity_bytes) < sizeof(int32_t)) {
return EINVAL;
}
int32_t n_keys;
memcpy(&n_keys, buffer->data, sizeof(int32_t));
- int32_t key_size = key->n_bytes;
- int32_t value_size = value->n_bytes;
+ int32_t key_size = (int32_t)key->n_bytes;
+ int32_t value_size = (int32_t)value->n_bytes;
NANOARROW_RETURN_NOT_OK(ArrowBufferReserve(
buffer, sizeof(int32_t) + key_size + sizeof(int32_t) + value_size));
@@ -1841,6 +1847,32 @@ ArrowErrorCode ArrowArrayReserve(struct ArrowArray*
array,
return NANOARROW_OK;
}
+static ArrowErrorCode ArrowArrayFinalizeBuffers(struct ArrowArray* array) {
+ struct ArrowArrayPrivateData* private_data =
+ (struct ArrowArrayPrivateData*)array->private_data;
+
+ // The only buffer finalizing this currently does is make sure the data
+ // buffer for (Large)String|Binary is never NULL
+ switch (private_data->storage_type) {
+ case NANOARROW_TYPE_BINARY:
+ case NANOARROW_TYPE_STRING:
+ case NANOARROW_TYPE_LARGE_BINARY:
+ case NANOARROW_TYPE_LARGE_STRING:
+ if (ArrowArrayBuffer(array, 2)->data == NULL) {
+ ArrowBufferAppendUInt8(ArrowArrayBuffer(array, 2), 0);
+ }
+ break;
+ default:
+ break;
+ }
+
+ for (int64_t i = 0; i < array->n_children; i++) {
+ NANOARROW_RETURN_NOT_OK(ArrowArrayFinalizeBuffers(array->children[i]));
+ }
+
+ return NANOARROW_OK;
+}
+
static void ArrowArrayFlushInternalPointers(struct ArrowArray* array) {
struct ArrowArrayPrivateData* private_data =
(struct ArrowArrayPrivateData*)array->private_data;
@@ -1889,6 +1921,9 @@ static ArrowErrorCode ArrowArrayCheckInternalBufferSizes(
ArrowErrorCode ArrowArrayFinishBuilding(struct ArrowArray* array,
struct ArrowError* error) {
+ // Even if the data buffer is size zero, the value needs to be non-null
+ NANOARROW_RETURN_NOT_OK(ArrowArrayFinalizeBuffers(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);
diff --git a/dist/nanoarrow.h b/dist/nanoarrow.h
index 8ea267c..886f3ed 100644
--- a/dist/nanoarrow.h
+++ b/dist/nanoarrow.h
@@ -20,7 +20,7 @@
// #define NANOARROW_NAMESPACE YourNamespaceHere
-#define NANOARROW_BUILD_ID "gha7325d629245c290bd96fb645a5d38e72bba2f8af"
+#define NANOARROW_BUILD_ID "ghaf218a6c2b0fdb92fc5ba26d811ce9f6b3d8d9e3e"
#endif
// Licensed to the Apache Software Foundation (ASF) under one
@@ -1871,15 +1871,15 @@ static inline ArrowErrorCode ArrowArrayAppendInt(struct
ArrowArray* array,
break;
case NANOARROW_TYPE_INT32:
_NANOARROW_CHECK_RANGE(value, INT32_MIN, INT32_MAX);
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt32(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt32(data_buffer,
(int32_t)value));
break;
case NANOARROW_TYPE_INT16:
_NANOARROW_CHECK_RANGE(value, INT16_MIN, INT16_MAX);
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt16(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt16(data_buffer,
(int16_t)value));
break;
case NANOARROW_TYPE_INT8:
_NANOARROW_CHECK_RANGE(value, INT8_MIN, INT8_MAX);
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt8(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendInt8(data_buffer,
(int8_t)value));
break;
case NANOARROW_TYPE_UINT64:
case NANOARROW_TYPE_UINT32:
@@ -1921,15 +1921,15 @@ static inline ArrowErrorCode
ArrowArrayAppendUInt(struct ArrowArray* array,
break;
case NANOARROW_TYPE_UINT32:
_NANOARROW_CHECK_RANGE(value, 0, UINT32_MAX);
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendUInt32(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendUInt32(data_buffer,
(uint32_t)value));
break;
case NANOARROW_TYPE_UINT16:
_NANOARROW_CHECK_RANGE(value, 0, UINT16_MAX);
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendUInt16(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendUInt16(data_buffer,
(uint16_t)value));
break;
case NANOARROW_TYPE_UINT8:
_NANOARROW_CHECK_RANGE(value, 0, UINT8_MAX);
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendUInt8(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendUInt8(data_buffer,
(uint8_t)value));
break;
case NANOARROW_TYPE_INT64:
case NANOARROW_TYPE_INT32:
@@ -2072,7 +2072,7 @@ static inline ArrowErrorCode
ArrowArrayFinishElement(struct ArrowArray* array) {
return EINVAL;
}
NANOARROW_RETURN_NOT_OK(
- ArrowBufferAppendInt32(ArrowArrayBuffer(array, 1), child_length));
+ ArrowBufferAppendInt32(ArrowArrayBuffer(array, 1),
(int32_t)child_length));
break;
case NANOARROW_TYPE_LARGE_LIST:
child_length = array->children[0]->length;
@@ -2115,7 +2115,7 @@ static inline int8_t ArrowArrayViewIsNull(struct
ArrowArrayView* array_view, int
case NANOARROW_TYPE_DENSE_UNION:
case NANOARROW_TYPE_SPARSE_UNION:
// Not supported yet
- return 0xff;
+ return -1;
default:
return validity_buffer != NULL && !ArrowBitGet(validity_buffer, i);
}
