You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by pa...@apache.org on 2023/01/03 21:53:13 UTC
[arrow-nanoarrow] branch main updated: Revisit some poorly chosen names (#86)
This is an automated email from the ASF dual-hosted git repository.
paleolimbot 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 e134b4a Revisit some poorly chosen names (#86)
e134b4a is described below
commit e134b4adbf8d8d5861b3bb30c4dc0cb046d0b5e7
Author: Dewey Dunnington <de...@dunnington.ca>
AuthorDate: Tue Jan 3 17:53:07 2023 -0400
Revisit some poorly chosen names (#86)
* rename with passing tests
* run clang-format
* fix some more references to n_bytes
* data_type -> type
* make timezone null-terminated
* undo bad search/replace
---
dist/nanoarrow.c | 230 +++++++++++++++++------------------
dist/nanoarrow.h | 74 +++++------
python/src/nanoarrow/nanoarrow_c.pxd | 4 +-
r/src/altrep.c | 2 +-
r/src/array.c | 3 +-
r/src/buffer.c | 4 +-
r/src/convert.c | 8 +-
r/src/convert_array.c | 2 +-
r/src/infer_ptype.c | 2 +-
r/src/init.c | 21 ++--
r/src/materialize_blob.h | 4 +-
r/src/materialize_chr.h | 2 +-
r/src/materialize_date.h | 2 +-
r/src/materialize_difftime.h | 2 +-
r/src/materialize_posixct.h | 2 +-
r/src/pointers.c | 13 +-
r/src/pointers_cpp.cc | 2 +-
r/src/schema.c | 40 +++---
r/src/util.c | 12 +-
r/src/version.c | 8 +-
src/nanoarrow/array.c | 30 ++---
src/nanoarrow/array_inline.h | 41 ++++---
src/nanoarrow/array_test.cc | 98 +++++++--------
src/nanoarrow/buffer_inline.h | 4 +-
src/nanoarrow/buffer_test.cc | 2 +-
src/nanoarrow/nanoarrow.h | 42 +++----
src/nanoarrow/nanoarrow_types.h | 12 +-
src/nanoarrow/schema.c | 204 +++++++++++++++----------------
src/nanoarrow/schema_test.cc | 164 +++++++++++++------------
29 files changed, 520 insertions(+), 514 deletions(-)
diff --git a/dist/nanoarrow.c b/dist/nanoarrow.c
index 7f9d18c..699980c 100644
--- a/dist/nanoarrow.c
+++ b/dist/nanoarrow.c
@@ -267,8 +267,8 @@ static void ArrowSchemaRelease(struct ArrowSchema* schema) {
schema->release = NULL;
}
-static const char* ArrowSchemaFormatTemplate(enum ArrowType data_type) {
- switch (data_type) {
+static const char* ArrowSchemaFormatTemplate(enum ArrowType type) {
+ switch (type) {
case NANOARROW_TYPE_UNINITIALIZED:
return NULL;
case NANOARROW_TYPE_NA:
@@ -335,8 +335,8 @@ static const char* ArrowSchemaFormatTemplate(enum ArrowType data_type) {
}
static int ArrowSchemaInitChildrenIfNeeded(struct ArrowSchema* schema,
- enum ArrowType data_type) {
- switch (data_type) {
+ enum ArrowType type) {
+ switch (type) {
case NANOARROW_TYPE_LIST:
case NANOARROW_TYPE_LARGE_LIST:
case NANOARROW_TYPE_FIXED_SIZE_LIST:
@@ -376,22 +376,22 @@ void ArrowSchemaInit(struct ArrowSchema* schema) {
schema->release = &ArrowSchemaRelease;
}
-ArrowErrorCode ArrowSchemaSetType(struct ArrowSchema* schema, enum ArrowType data_type) {
+ArrowErrorCode ArrowSchemaSetType(struct ArrowSchema* schema, enum ArrowType type) {
// We don't allocate the dictionary because it has to be nullptr
// for non-dictionary-encoded arrays.
- // Set the format to a valid format string for data_type
- const char* template_format = ArrowSchemaFormatTemplate(data_type);
+ // Set the format to a valid format string for type
+ const char* template_format = ArrowSchemaFormatTemplate(type);
- // If data_type isn't recognized and not explicitly unset
- if (template_format == NULL && data_type != NANOARROW_TYPE_UNINITIALIZED) {
+ // If type isn't recognized and not explicitly unset
+ if (template_format == NULL && type != NANOARROW_TYPE_UNINITIALIZED) {
return EINVAL;
}
NANOARROW_RETURN_NOT_OK(ArrowSchemaSetFormat(schema, template_format));
// For types with an umabiguous child structure, allocate children
- return ArrowSchemaInitChildrenIfNeeded(schema, data_type);
+ return ArrowSchemaInitChildrenIfNeeded(schema, type);
}
ArrowErrorCode ArrowSchemaSetTypeStruct(struct ArrowSchema* schema, int64_t n_children) {
@@ -404,11 +404,10 @@ ArrowErrorCode ArrowSchemaSetTypeStruct(struct ArrowSchema* schema, int64_t n_ch
return NANOARROW_OK;
}
-ArrowErrorCode ArrowSchemaInitFromType(struct ArrowSchema* schema,
- enum ArrowType data_type) {
+ArrowErrorCode ArrowSchemaInitFromType(struct ArrowSchema* schema, enum ArrowType type) {
ArrowSchemaInit(schema);
- int result = ArrowSchemaSetType(schema, data_type);
+ int result = ArrowSchemaSetType(schema, type);
if (result != NANOARROW_OK) {
schema->release(schema);
return result;
@@ -418,14 +417,14 @@ ArrowErrorCode ArrowSchemaInitFromType(struct ArrowSchema* schema,
}
ArrowErrorCode ArrowSchemaSetTypeFixedSize(struct ArrowSchema* schema,
- enum ArrowType data_type, int32_t fixed_size) {
+ enum ArrowType type, int32_t fixed_size) {
if (fixed_size <= 0) {
return EINVAL;
}
char buffer[64];
int n_chars;
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_FIXED_SIZE_BINARY:
n_chars = snprintf(buffer, sizeof(buffer), "w:%d", (int)fixed_size);
break;
@@ -439,15 +438,14 @@ ArrowErrorCode ArrowSchemaSetTypeFixedSize(struct ArrowSchema* schema,
buffer[n_chars] = '\0';
NANOARROW_RETURN_NOT_OK(ArrowSchemaSetFormat(schema, buffer));
- if (data_type == NANOARROW_TYPE_FIXED_SIZE_LIST) {
- NANOARROW_RETURN_NOT_OK(ArrowSchemaInitChildrenIfNeeded(schema, data_type));
+ if (type == NANOARROW_TYPE_FIXED_SIZE_LIST) {
+ NANOARROW_RETURN_NOT_OK(ArrowSchemaInitChildrenIfNeeded(schema, type));
}
return NANOARROW_OK;
}
-ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema,
- enum ArrowType data_type,
+ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema, enum ArrowType type,
int32_t decimal_precision,
int32_t decimal_scale) {
if (decimal_precision <= 0) {
@@ -456,7 +454,7 @@ ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema,
char buffer[64];
int n_chars;
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_DECIMAL128:
n_chars =
snprintf(buffer, sizeof(buffer), "d:%d,%d", decimal_precision, decimal_scale);
@@ -488,8 +486,7 @@ static const char* ArrowTimeUnitFormatString(enum ArrowTimeUnit time_unit) {
}
}
-ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema,
- enum ArrowType data_type,
+ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema, enum ArrowType type,
enum ArrowTimeUnit time_unit,
const char* timezone) {
const char* time_unit_str = ArrowTimeUnitFormatString(time_unit);
@@ -499,7 +496,7 @@ ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema,
char buffer[128];
int n_chars;
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_TIME32:
case NANOARROW_TYPE_TIME64:
if (timezone != NULL) {
@@ -532,8 +529,8 @@ ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema,
return ArrowSchemaSetFormat(schema, buffer);
}
-ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema,
- enum ArrowType data_type, int64_t n_children) {
+ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema, enum ArrowType type,
+ int64_t n_children) {
if (n_children < 0 || n_children > 127) {
return EINVAL;
}
@@ -545,7 +542,7 @@ ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema,
int n_chars;
char* format_cursor = format_out;
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_SPARSE_UNION:
n_chars = snprintf(format_cursor, format_out_size, "+us:");
format_cursor += n_chars;
@@ -744,9 +741,9 @@ ArrowErrorCode ArrowSchemaDeepCopy(struct ArrowSchema* schema,
}
static void ArrowSchemaViewSetPrimitive(struct ArrowSchemaView* schema_view,
- enum ArrowType data_type) {
- schema_view->data_type = data_type;
- schema_view->storage_data_type = data_type;
+ enum ArrowType type) {
+ schema_view->type = type;
+ schema_view->storage_type = type;
}
static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
@@ -761,8 +758,8 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
switch (format[0]) {
case 'n':
- schema_view->data_type = NANOARROW_TYPE_NA;
- schema_view->storage_data_type = NANOARROW_TYPE_NA;
+ schema_view->type = NANOARROW_TYPE_NA;
+ schema_view->storage_type = NANOARROW_TYPE_NA;
*format_end_out = format + 1;
return NANOARROW_OK;
case 'b':
@@ -862,8 +859,8 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
// validity + data
case 'w':
- schema_view->data_type = NANOARROW_TYPE_FIXED_SIZE_BINARY;
- schema_view->storage_data_type = NANOARROW_TYPE_FIXED_SIZE_BINARY;
+ schema_view->type = NANOARROW_TYPE_FIXED_SIZE_BINARY;
+ schema_view->storage_type = NANOARROW_TYPE_FIXED_SIZE_BINARY;
if (format[1] != ':' || format[2] == '\0') {
ArrowErrorSet(error, "Expected ':<width>' following 'w'");
return EINVAL;
@@ -874,25 +871,25 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
// validity + offset + data
case 'z':
- schema_view->data_type = NANOARROW_TYPE_BINARY;
- schema_view->storage_data_type = NANOARROW_TYPE_BINARY;
+ schema_view->type = NANOARROW_TYPE_BINARY;
+ schema_view->storage_type = NANOARROW_TYPE_BINARY;
*format_end_out = format + 1;
return NANOARROW_OK;
case 'u':
- schema_view->data_type = NANOARROW_TYPE_STRING;
- schema_view->storage_data_type = NANOARROW_TYPE_STRING;
+ schema_view->type = NANOARROW_TYPE_STRING;
+ schema_view->storage_type = NANOARROW_TYPE_STRING;
*format_end_out = format + 1;
return NANOARROW_OK;
// validity + large_offset + data
case 'Z':
- schema_view->data_type = NANOARROW_TYPE_LARGE_BINARY;
- schema_view->storage_data_type = NANOARROW_TYPE_LARGE_BINARY;
+ schema_view->type = NANOARROW_TYPE_LARGE_BINARY;
+ schema_view->storage_type = NANOARROW_TYPE_LARGE_BINARY;
*format_end_out = format + 1;
return NANOARROW_OK;
case 'U':
- schema_view->data_type = NANOARROW_TYPE_LARGE_STRING;
- schema_view->storage_data_type = NANOARROW_TYPE_LARGE_STRING;
+ schema_view->type = NANOARROW_TYPE_LARGE_STRING;
+ schema_view->storage_type = NANOARROW_TYPE_LARGE_STRING;
*format_end_out = format + 1;
return NANOARROW_OK;
@@ -901,15 +898,15 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
switch (format[1]) {
// list has validity + offset or offset
case 'l':
- schema_view->storage_data_type = NANOARROW_TYPE_LIST;
- schema_view->data_type = NANOARROW_TYPE_LIST;
+ schema_view->storage_type = NANOARROW_TYPE_LIST;
+ schema_view->type = NANOARROW_TYPE_LIST;
*format_end_out = format + 2;
return NANOARROW_OK;
// large list has validity + large_offset or large_offset
case 'L':
- schema_view->storage_data_type = NANOARROW_TYPE_LARGE_LIST;
- schema_view->data_type = NANOARROW_TYPE_LARGE_LIST;
+ schema_view->storage_type = NANOARROW_TYPE_LARGE_LIST;
+ schema_view->type = NANOARROW_TYPE_LARGE_LIST;
*format_end_out = format + 2;
return NANOARROW_OK;
@@ -920,19 +917,19 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
return EINVAL;
}
- schema_view->storage_data_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
- schema_view->data_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
+ schema_view->storage_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
+ schema_view->type = NANOARROW_TYPE_FIXED_SIZE_LIST;
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;
- schema_view->data_type = NANOARROW_TYPE_STRUCT;
+ schema_view->storage_type = NANOARROW_TYPE_STRUCT;
+ schema_view->type = NANOARROW_TYPE_STRUCT;
*format_end_out = format + 2;
return NANOARROW_OK;
case 'm':
- schema_view->storage_data_type = NANOARROW_TYPE_MAP;
- schema_view->data_type = NANOARROW_TYPE_MAP;
+ schema_view->storage_type = NANOARROW_TYPE_MAP;
+ schema_view->type = NANOARROW_TYPE_MAP;
*format_end_out = format + 2;
return NANOARROW_OK;
@@ -940,12 +937,12 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
case 'u':
switch (format[2]) {
case 'd':
- schema_view->storage_data_type = NANOARROW_TYPE_DENSE_UNION;
- schema_view->data_type = NANOARROW_TYPE_DENSE_UNION;
+ schema_view->storage_type = NANOARROW_TYPE_DENSE_UNION;
+ schema_view->type = NANOARROW_TYPE_DENSE_UNION;
break;
case 's':
- schema_view->storage_data_type = NANOARROW_TYPE_SPARSE_UNION;
- schema_view->data_type = NANOARROW_TYPE_SPARSE_UNION;
+ schema_view->storage_type = NANOARROW_TYPE_SPARSE_UNION;
+ schema_view->type = NANOARROW_TYPE_SPARSE_UNION;
break;
default:
ArrowErrorSet(error,
@@ -991,12 +988,12 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
switch (format[2]) {
case 'D':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_DATE32;
+ schema_view->type = NANOARROW_TYPE_DATE32;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'm':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_DATE64;
+ schema_view->type = NANOARROW_TYPE_DATE64;
*format_end_out = format + 3;
return NANOARROW_OK;
default:
@@ -1010,25 +1007,25 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
switch (format[2]) {
case 's':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_TIME32;
+ schema_view->type = NANOARROW_TYPE_TIME32;
schema_view->time_unit = NANOARROW_TIME_UNIT_SECOND;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'm':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_TIME32;
+ schema_view->type = NANOARROW_TYPE_TIME32;
schema_view->time_unit = NANOARROW_TIME_UNIT_MILLI;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'u':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_TIME64;
+ schema_view->type = NANOARROW_TYPE_TIME64;
schema_view->time_unit = NANOARROW_TIME_UNIT_MICRO;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'n':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_TIME64;
+ schema_view->type = NANOARROW_TYPE_TIME64;
schema_view->time_unit = NANOARROW_TIME_UNIT_NANO;
*format_end_out = format + 3;
return NANOARROW_OK;
@@ -1044,22 +1041,22 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
switch (format[2]) {
case 's':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_TIMESTAMP;
+ schema_view->type = NANOARROW_TYPE_TIMESTAMP;
schema_view->time_unit = NANOARROW_TIME_UNIT_SECOND;
break;
case 'm':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_TIMESTAMP;
+ schema_view->type = NANOARROW_TYPE_TIMESTAMP;
schema_view->time_unit = NANOARROW_TIME_UNIT_MILLI;
break;
case 'u':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_TIMESTAMP;
+ schema_view->type = NANOARROW_TYPE_TIMESTAMP;
schema_view->time_unit = NANOARROW_TIME_UNIT_MICRO;
break;
case 'n':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_TIMESTAMP;
+ schema_view->type = NANOARROW_TYPE_TIMESTAMP;
schema_view->time_unit = NANOARROW_TIME_UNIT_NANO;
break;
default:
@@ -1076,7 +1073,7 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
}
schema_view->timezone.data = format + 4;
- schema_view->timezone.n_bytes = strlen(format + 4);
+ schema_view->timezone.size_bytes = strlen(format + 4);
*format_end_out = format + strlen(format);
return NANOARROW_OK;
@@ -1085,25 +1082,25 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
switch (format[2]) {
case 's':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_DURATION;
+ schema_view->type = NANOARROW_TYPE_DURATION;
schema_view->time_unit = NANOARROW_TIME_UNIT_SECOND;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'm':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_DURATION;
+ schema_view->type = NANOARROW_TYPE_DURATION;
schema_view->time_unit = NANOARROW_TIME_UNIT_MILLI;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'u':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_DURATION;
+ schema_view->type = NANOARROW_TYPE_DURATION;
schema_view->time_unit = NANOARROW_TIME_UNIT_MICRO;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'n':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_DURATION;
+ schema_view->type = NANOARROW_TYPE_DURATION;
schema_view->time_unit = NANOARROW_TIME_UNIT_NANO;
*format_end_out = format + 3;
return NANOARROW_OK;
@@ -1205,7 +1202,7 @@ static ArrowErrorCode ArrowSchemaViewValidateMap(struct ArrowSchemaView* schema_
static ArrowErrorCode ArrowSchemaViewValidateDictionary(
struct ArrowSchemaView* schema_view, struct ArrowError* error) {
// check for valid index type
- switch (schema_view->storage_data_type) {
+ switch (schema_view->storage_type) {
case NANOARROW_TYPE_UINT8:
case NANOARROW_TYPE_INT8:
case NANOARROW_TYPE_UINT16:
@@ -1229,9 +1226,9 @@ static ArrowErrorCode ArrowSchemaViewValidateDictionary(
}
static ArrowErrorCode ArrowSchemaViewValidate(struct ArrowSchemaView* schema_view,
- enum ArrowType data_type,
+ enum ArrowType type,
struct ArrowError* error) {
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_NA:
case NANOARROW_TYPE_BOOL:
case NANOARROW_TYPE_UINT8:
@@ -1290,7 +1287,7 @@ static ArrowErrorCode ArrowSchemaViewValidate(struct ArrowSchemaView* schema_vie
default:
ArrowErrorSet(error, "Expected a valid enum ArrowType value but found %d",
- (int)schema_view->data_type);
+ (int)schema_view->type);
return EINVAL;
}
@@ -1335,7 +1332,7 @@ ArrowErrorCode ArrowSchemaViewInit(struct ArrowSchemaView* schema_view,
memcpy(child_error, ArrowErrorMessage(error), 1024);
ArrowErrorSet(error, "Error parsing schema->format: %s", child_error);
}
-
+
return result;
}
@@ -1346,25 +1343,25 @@ ArrowErrorCode ArrowSchemaViewInit(struct ArrowSchemaView* schema_view,
}
if (schema->dictionary != NULL) {
- schema_view->data_type = NANOARROW_TYPE_DICTIONARY;
+ schema_view->type = NANOARROW_TYPE_DICTIONARY;
}
- result = ArrowSchemaViewValidate(schema_view, schema_view->storage_data_type, error);
+ result = ArrowSchemaViewValidate(schema_view, schema_view->storage_type, error);
if (result != NANOARROW_OK) {
return result;
}
- if (schema_view->storage_data_type != schema_view->data_type) {
- result = ArrowSchemaViewValidate(schema_view, schema_view->data_type, error);
+ if (schema_view->storage_type != schema_view->type) {
+ result = ArrowSchemaViewValidate(schema_view, schema_view->type, error);
if (result != NANOARROW_OK) {
return result;
}
}
- ArrowLayoutInit(&schema_view->layout, schema_view->storage_data_type);
- if (schema_view->storage_data_type == NANOARROW_TYPE_FIXED_SIZE_BINARY) {
+ ArrowLayoutInit(&schema_view->layout, schema_view->storage_type);
+ if (schema_view->storage_type == NANOARROW_TYPE_FIXED_SIZE_BINARY) {
schema_view->layout.element_size_bits[1] = schema_view->fixed_size * 8;
- } else if (schema_view->storage_data_type == NANOARROW_TYPE_FIXED_SIZE_LIST) {
+ } else if (schema_view->storage_type == NANOARROW_TYPE_FIXED_SIZE_LIST) {
schema_view->layout.child_size_elements = schema_view->fixed_size;
}
@@ -1380,8 +1377,8 @@ ArrowErrorCode ArrowSchemaViewInit(struct ArrowSchemaView* schema_view,
static int64_t ArrowSchemaTypeToStringInternal(struct ArrowSchemaView* schema_view,
char* out, int64_t n) {
- const char* type_string = ArrowTypeString(schema_view->data_type);
- switch (schema_view->data_type) {
+ const char* type_string = ArrowTypeString(schema_view->type);
+ switch (schema_view->type) {
case NANOARROW_TYPE_DECIMAL128:
case NANOARROW_TYPE_DECIMAL256:
return snprintf(out, n, "%s(%d, %d)", type_string,
@@ -1390,7 +1387,7 @@ static int64_t ArrowSchemaTypeToStringInternal(struct ArrowSchemaView* schema_vi
case NANOARROW_TYPE_TIMESTAMP:
return snprintf(out, n, "%s('%s', '%.*s')", type_string,
ArrowTimeUnitString(schema_view->time_unit),
- (int)schema_view->timezone.n_bytes, schema_view->timezone.data);
+ (int)schema_view->timezone.size_bytes, schema_view->timezone.data);
case NANOARROW_TYPE_TIME32:
case NANOARROW_TYPE_TIME64:
case NANOARROW_TYPE_DURATION:
@@ -1426,23 +1423,24 @@ int64_t ArrowSchemaToString(struct ArrowSchema* schema, char* out, int64_t n,
// Extension type and dictionary should include both the top-level type
// and the storage type.
- int is_extension = schema_view.extension_name.n_bytes > 0;
+ int is_extension = schema_view.extension_name.size_bytes > 0;
int is_dictionary = schema->dictionary != NULL;
int64_t n_chars = 0;
int64_t n_chars_last = 0;
// Uncommon but not technically impossible that both are true
if (is_extension && is_dictionary) {
- n_chars_last = snprintf(
- out + n_chars, n, "%.*s{dictionary(%s)<", (int)schema_view.extension_name.n_bytes,
- schema_view.extension_name.data, ArrowTypeString(schema_view.storage_data_type));
+ n_chars_last = snprintf(out + n_chars, n, "%.*s{dictionary(%s)<",
+ (int)schema_view.extension_name.size_bytes,
+ schema_view.extension_name.data,
+ ArrowTypeString(schema_view.storage_type));
} else if (is_extension) {
n_chars_last =
- snprintf(out + n_chars, n, "%.*s{", (int)schema_view.extension_name.n_bytes,
+ snprintf(out + n_chars, n, "%.*s{", (int)schema_view.extension_name.size_bytes,
schema_view.extension_name.data);
} else if (is_dictionary) {
n_chars_last = snprintf(out + n_chars, n, "dictionary(%s)<",
- ArrowTypeString(schema_view.storage_data_type));
+ ArrowTypeString(schema_view.storage_type));
}
n_chars += n_chars_last;
@@ -1550,7 +1548,7 @@ ArrowErrorCode ArrowMetadataReaderRead(struct ArrowMetadataReader* reader,
pos += sizeof(int32_t);
key_out->data = reader->metadata + reader->offset + pos;
- key_out->n_bytes = key_size;
+ key_out->size_bytes = key_size;
pos += key_size;
int32_t value_size;
@@ -1558,7 +1556,7 @@ ArrowErrorCode ArrowMetadataReaderRead(struct ArrowMetadataReader* reader,
pos += sizeof(int32_t);
value_out->data = reader->metadata + reader->offset + pos;
- value_out->n_bytes = value_size;
+ value_out->size_bytes = value_size;
pos += value_size;
reader->offset += pos;
@@ -1578,7 +1576,7 @@ int64_t ArrowMetadataSizeOf(const char* metadata) {
int64_t size = sizeof(int32_t);
while (ArrowMetadataReaderRead(&reader, &key, &value) == NANOARROW_OK) {
- size += sizeof(int32_t) + key.n_bytes + sizeof(int32_t) + value.n_bytes;
+ size += sizeof(int32_t) + key.size_bytes + sizeof(int32_t) + value.size_bytes;
}
return size;
@@ -1594,11 +1592,11 @@ static ArrowErrorCode ArrowMetadataGetValueInternal(const char* metadata,
while (ArrowMetadataReaderRead(&reader, &existing_key, &existing_value) ==
NANOARROW_OK) {
- int key_equal = key->n_bytes == existing_key.n_bytes &&
- strncmp(key->data, existing_key.data, existing_key.n_bytes) == 0;
+ int key_equal = key->size_bytes == existing_key.size_bytes &&
+ strncmp(key->data, existing_key.data, existing_key.size_bytes) == 0;
if (key_equal) {
value_out->data = existing_value.data;
- value_out->n_bytes = existing_value.n_bytes;
+ value_out->size_bytes = existing_value.size_bytes;
break;
}
}
@@ -1645,8 +1643,8 @@ static ArrowErrorCode ArrowMetadataBuilderAppendInternal(struct ArrowBuffer* buf
int32_t n_keys;
memcpy(&n_keys, buffer->data, sizeof(int32_t));
- int32_t key_size = (int32_t)key->n_bytes;
- int32_t value_size = (int32_t)value->n_bytes;
+ int32_t key_size = (int32_t)key->size_bytes;
+ int32_t value_size = (int32_t)value->size_bytes;
NANOARROW_RETURN_NOT_OK(ArrowBufferReserve(
buffer, sizeof(int32_t) + key_size + sizeof(int32_t) + value_size));
@@ -1694,9 +1692,9 @@ static ArrowErrorCode ArrowMetadataBuilderSetInternal(struct ArrowBuffer* buffer
return result;
}
- if (key->n_bytes == existing_key.n_bytes &&
+ if (key->size_bytes == existing_key.size_bytes &&
strncmp((const char*)key->data, (const char*)existing_key.data,
- existing_key.n_bytes) == 0) {
+ existing_key.size_bytes) == 0) {
result = ArrowMetadataBuilderAppendInternal(&new_buffer, key, value);
value = NULL;
} else {
@@ -2060,7 +2058,7 @@ static ArrowErrorCode ArrowArrayReserveInternal(struct ArrowArray* array,
}
int64_t additional_size_bytes =
- array_view->buffer_views[i].n_bytes - ArrowArrayBuffer(array, i)->size_bytes;
+ array_view->buffer_views[i].size_bytes - ArrowArrayBuffer(array, i)->size_bytes;
if (additional_size_bytes > 0) {
NANOARROW_RETURN_NOT_OK(
@@ -2147,7 +2145,7 @@ static ArrowErrorCode ArrowArrayCheckInternalBufferSizes(
continue;
}
- int64_t expected_size = array_view->buffer_views[i].n_bytes;
+ int64_t expected_size = array_view->buffer_views[i].size_bytes;
int64_t actual_size = ArrowArrayBuffer(array, i)->size_bytes;
if (actual_size < expected_size) {
@@ -2248,7 +2246,7 @@ ArrowErrorCode ArrowArrayViewInitFromSchema(struct ArrowArrayView* array_view,
return result;
}
- ArrowArrayViewInitFromType(array_view, schema_view.storage_data_type);
+ ArrowArrayViewInitFromType(array_view, schema_view.storage_type);
array_view->layout = schema_view.layout;
result = ArrowArrayViewAllocateChildren(array_view, schema->n_children);
@@ -2311,25 +2309,25 @@ void ArrowArrayViewSetLength(struct ArrowArrayView* array_view, int64_t length)
switch (array_view->layout.buffer_type[i]) {
case NANOARROW_BUFFER_TYPE_VALIDITY:
- array_view->buffer_views[i].n_bytes = _ArrowBytesForBits(length);
+ array_view->buffer_views[i].size_bytes = _ArrowBytesForBits(length);
continue;
case NANOARROW_BUFFER_TYPE_DATA_OFFSET:
// Probably don't want/need to rely on the producer to have allocated an
// offsets buffer of length 1 for a zero-size array
- array_view->buffer_views[i].n_bytes =
+ array_view->buffer_views[i].size_bytes =
(length != 0) * element_size_bytes * (length + 1);
continue;
case NANOARROW_BUFFER_TYPE_DATA:
- array_view->buffer_views[i].n_bytes =
+ array_view->buffer_views[i].size_bytes =
_ArrowRoundUpToMultipleOf8(array_view->layout.element_size_bits[i] * length) /
8;
continue;
case NANOARROW_BUFFER_TYPE_TYPE_ID:
case NANOARROW_BUFFER_TYPE_UNION_OFFSET:
- array_view->buffer_views[i].n_bytes = element_size_bytes * length;
+ array_view->buffer_views[i].size_bytes = element_size_bytes * length;
continue;
case NANOARROW_BUFFER_TYPE_NONE:
- array_view->buffer_views[i].n_bytes = 0;
+ array_view->buffer_views[i].size_bytes = 0;
continue;
}
}
@@ -2368,7 +2366,7 @@ ArrowErrorCode ArrowArrayViewSetArray(struct ArrowArrayView* array_view,
// If the null_count is 0, the validity buffer can be NULL
if (array_view->layout.buffer_type[i] == NANOARROW_BUFFER_TYPE_VALIDITY &&
array->null_count == 0 && array->buffers[i] == NULL) {
- array_view->buffer_views[i].n_bytes = 0;
+ array_view->buffer_views[i].size_bytes = 0;
}
array_view->buffer_views[i].data.data = array->buffers[i];
@@ -2389,18 +2387,18 @@ ArrowErrorCode ArrowArrayViewSetArray(struct ArrowArrayView* array_view,
switch (array_view->storage_type) {
case NANOARROW_TYPE_STRING:
case NANOARROW_TYPE_BINARY:
- if (array_view->buffer_views[1].n_bytes != 0) {
+ if (array_view->buffer_views[1].size_bytes != 0) {
last_offset =
array_view->buffer_views[1].data.as_int32[array->offset + array->length];
- array_view->buffer_views[2].n_bytes = last_offset;
+ array_view->buffer_views[2].size_bytes = last_offset;
}
break;
case NANOARROW_TYPE_LARGE_STRING:
case NANOARROW_TYPE_LARGE_BINARY:
- if (array_view->buffer_views[1].n_bytes != 0) {
+ if (array_view->buffer_views[1].size_bytes != 0) {
last_offset =
array_view->buffer_views[1].data.as_int64[array->offset + array->length];
- array_view->buffer_views[2].n_bytes = last_offset;
+ array_view->buffer_views[2].size_bytes = last_offset;
}
break;
case NANOARROW_TYPE_STRUCT:
@@ -2426,7 +2424,7 @@ ArrowErrorCode ArrowArrayViewSetArray(struct ArrowArrayView* array_view,
return EINVAL;
}
- if (array_view->buffer_views[1].n_bytes != 0) {
+ if (array_view->buffer_views[1].size_bytes != 0) {
last_offset =
array_view->buffer_views[1].data.as_int32[array->offset + array->length];
if (array->children[0]->length < last_offset) {
@@ -2448,7 +2446,7 @@ ArrowErrorCode ArrowArrayViewSetArray(struct ArrowArrayView* array_view,
return EINVAL;
}
- if (array_view->buffer_views[1].n_bytes != 0) {
+ if (array_view->buffer_views[1].size_bytes != 0) {
last_offset =
array_view->buffer_views[1].data.as_int64[array->offset + array->length];
if (array->children[0]->length < last_offset) {
diff --git a/dist/nanoarrow.h b/dist/nanoarrow.h
index 7f29e71..5958b74 100644
--- a/dist/nanoarrow.h
+++ b/dist/nanoarrow.h
@@ -388,13 +388,13 @@ enum ArrowBufferType {
struct ArrowStringView {
/// \brief A pointer to the start of the string
///
- /// If n_bytes is 0, this value may be NULL.
+ /// If size_bytes is 0, this value may be NULL.
const char* data;
/// \brief The size of the string in bytes,
///
/// (Not including the null terminator.)
- int64_t n_bytes;
+ int64_t size_bytes;
};
/// \brief Return a view of a const C string
@@ -404,9 +404,9 @@ static inline struct ArrowStringView ArrowCharView(const char* value) {
out.data = value;
if (value) {
- out.n_bytes = (int64_t)strlen(value);
+ out.size_bytes = (int64_t)strlen(value);
} else {
- out.n_bytes = 0;
+ out.size_bytes = 0;
}
return out;
@@ -417,7 +417,7 @@ static inline struct ArrowStringView ArrowCharView(const char* value) {
struct ArrowBufferView {
/// \brief A pointer to the start of the buffer
///
- /// If n_bytes is 0, this value may be NULL.
+ /// If size_bytes is 0, this value may be NULL.
union {
const void* data;
const int8_t* as_int8;
@@ -434,7 +434,7 @@ struct ArrowBufferView {
} data;
/// \brief The size of the buffer in bytes
- int64_t n_bytes;
+ int64_t size_bytes;
};
/// \brief Array buffer allocation and deallocation
@@ -842,44 +842,44 @@ ArrowErrorCode ArrowSchemaSetTypeStruct(struct ArrowSchema* schema, int64_t n_ch
/// \brief Set the format field of a fixed-size schema
///
-/// Returns EINVAL for fixed_size <= 0 or for data_type that is not
+/// Returns EINVAL for fixed_size <= 0 or for type that is not
/// NANOARROW_TYPE_FIXED_SIZE_BINARY or NANOARROW_TYPE_FIXED_SIZE_LIST.
/// For NANOARROW_TYPE_FIXED_SIZE_LIST, the appropriate number of children are
/// allocated, initialized, and named; however, the caller must
/// ArrowSchemaSetType() the first child. Schema must have been initialized using
/// ArrowSchemaInit() or ArrowSchemaDeepCopy().
ArrowErrorCode ArrowSchemaSetTypeFixedSize(struct ArrowSchema* schema,
- enum ArrowType data_type, int32_t fixed_size);
+ enum ArrowType type, int32_t fixed_size);
/// \brief Set the format field of a decimal schema
///
-/// Returns EINVAL for scale <= 0 or for data_type that is not
+/// Returns EINVAL for scale <= 0 or for type that is not
/// NANOARROW_TYPE_DECIMAL128 or NANOARROW_TYPE_DECIMAL256. Schema must have been
/// initialized using ArrowSchemaInit() or ArrowSchemaDeepCopy().
ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema,
- enum ArrowType data_type,
+ enum ArrowType type,
int32_t decimal_precision,
int32_t decimal_scale);
/// \brief Set the format field of a time, timestamp, or duration schema
///
-/// Returns EINVAL for data_type that is not
+/// Returns EINVAL for type that is not
/// NANOARROW_TYPE_TIME32, NANOARROW_TYPE_TIME64,
/// NANOARROW_TYPE_TIMESTAMP, or NANOARROW_TYPE_DURATION. The
-/// timezone parameter must be NULL for a non-timestamp data_type. Schema must have been
+/// timezone parameter must be NULL for a non-timestamp type. Schema must have been
/// initialized using ArrowSchemaInit() or ArrowSchemaDeepCopy().
ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema,
- enum ArrowType data_type,
+ enum ArrowType type,
enum ArrowTimeUnit time_unit,
const char* timezone);
/// \brief Seet the format field of a union schema
///
-/// Returns EINVAL for a data_type that is not NANOARROW_TYPE_DENSE_UNION
+/// Returns EINVAL for a type that is not NANOARROW_TYPE_DENSE_UNION
/// or NANOARROW_TYPE_SPARSE_UNION. The specified number of children are
/// allocated, and initialized.
ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema,
- enum ArrowType data_type, int64_t n_children);
+ enum ArrowType type, int64_t n_children);
/// \brief Make a (recursive) copy of a schema
///
@@ -1008,14 +1008,14 @@ struct ArrowSchemaView {
/// This value will never be NANOARROW_TYPE_EXTENSION (see
/// extension_name and/or extension_metadata to check for
/// an extension type).
- enum ArrowType data_type;
+ enum ArrowType type;
/// \brief The storage data type represented by the schema
///
/// This value will never be NANOARROW_TYPE_DICTIONARY, NANOARROW_TYPE_EXTENSION
/// or any datetime type. This value represents only the type required to
/// interpret the buffers in the array.
- enum ArrowType storage_data_type;
+ enum ArrowType storage_type;
/// \brief The storage layout represented by the schema
struct ArrowLayout layout;
@@ -1750,12 +1750,12 @@ static inline ArrowErrorCode ArrowBufferAppendFloat(struct ArrowBuffer* buffer,
static inline ArrowErrorCode ArrowBufferAppendStringView(struct ArrowBuffer* buffer,
struct ArrowStringView value) {
- return ArrowBufferAppend(buffer, value.data, value.n_bytes);
+ return ArrowBufferAppend(buffer, value.data, value.size_bytes);
}
static inline ArrowErrorCode ArrowBufferAppendBufferView(struct ArrowBuffer* buffer,
struct ArrowBufferView value) {
- return ArrowBufferAppend(buffer, value.data.data, value.n_bytes);
+ return ArrowBufferAppend(buffer, value.data.data, value.size_bytes);
}
static inline ArrowErrorCode ArrowBufferAppendFill(struct ArrowBuffer* buffer,
@@ -2522,33 +2522,33 @@ static inline ArrowErrorCode ArrowArrayAppendBytes(struct ArrowArray* array,
case NANOARROW_TYPE_STRING:
case NANOARROW_TYPE_BINARY:
offset = ((int32_t*)offset_buffer->data)[array->length];
- if ((offset + value.n_bytes) > INT32_MAX) {
+ if ((offset + value.size_bytes) > INT32_MAX) {
return EINVAL;
}
- offset += value.n_bytes;
+ offset += value.size_bytes;
NANOARROW_RETURN_NOT_OK(ArrowBufferAppend(offset_buffer, &offset, sizeof(int32_t)));
NANOARROW_RETURN_NOT_OK(
- ArrowBufferAppend(data_buffer, value.data.data, value.n_bytes));
+ ArrowBufferAppend(data_buffer, value.data.data, value.size_bytes));
break;
case NANOARROW_TYPE_LARGE_STRING:
case NANOARROW_TYPE_LARGE_BINARY:
large_offset = ((int64_t*)offset_buffer->data)[array->length];
- large_offset += value.n_bytes;
+ large_offset += value.size_bytes;
NANOARROW_RETURN_NOT_OK(
ArrowBufferAppend(offset_buffer, &large_offset, sizeof(int64_t)));
NANOARROW_RETURN_NOT_OK(
- ArrowBufferAppend(data_buffer, value.data.data, value.n_bytes));
+ ArrowBufferAppend(data_buffer, value.data.data, value.size_bytes));
break;
case NANOARROW_TYPE_FIXED_SIZE_BINARY:
- if (value.n_bytes != fixed_size_bytes) {
+ if (value.size_bytes != fixed_size_bytes) {
return EINVAL;
}
NANOARROW_RETURN_NOT_OK(
- ArrowBufferAppend(data_buffer, value.data.data, value.n_bytes));
+ ArrowBufferAppend(data_buffer, value.data.data, value.size_bytes));
break;
default:
return EINVAL;
@@ -2569,7 +2569,7 @@ static inline ArrowErrorCode ArrowArrayAppendString(struct ArrowArray* array,
struct ArrowBufferView buffer_view;
buffer_view.data.data = value.data;
- buffer_view.n_bytes = value.n_bytes;
+ buffer_view.size_bytes = value.size_bytes;
switch (private_data->storage_type) {
case NANOARROW_TYPE_STRING:
@@ -2833,20 +2833,20 @@ static inline struct ArrowStringView ArrowArrayViewGetStringUnsafe(
case NANOARROW_TYPE_STRING:
case NANOARROW_TYPE_BINARY:
view.data = data_view + offsets_view->data.as_int32[i];
- view.n_bytes = offsets_view->data.as_int32[i + 1] - offsets_view->data.as_int32[i];
+ view.size_bytes = offsets_view->data.as_int32[i + 1] - offsets_view->data.as_int32[i];
break;
case NANOARROW_TYPE_LARGE_STRING:
case NANOARROW_TYPE_LARGE_BINARY:
view.data = data_view + offsets_view->data.as_int64[i];
- view.n_bytes = offsets_view->data.as_int64[i + 1] - offsets_view->data.as_int64[i];
+ view.size_bytes = offsets_view->data.as_int64[i + 1] - offsets_view->data.as_int64[i];
break;
case NANOARROW_TYPE_FIXED_SIZE_BINARY:
- view.n_bytes = array_view->layout.element_size_bits[1] / 8;
- view.data = array_view->buffer_views[1].data.as_char + (i * view.n_bytes);
+ view.size_bytes = array_view->layout.element_size_bits[1] / 8;
+ view.data = array_view->buffer_views[1].data.as_char + (i * view.size_bytes);
break;
default:
view.data = NULL;
- view.n_bytes = 0;
+ view.size_bytes = 0;
break;
}
@@ -2863,21 +2863,21 @@ static inline struct ArrowBufferView ArrowArrayViewGetBytesUnsafe(
switch (array_view->storage_type) {
case NANOARROW_TYPE_STRING:
case NANOARROW_TYPE_BINARY:
- view.n_bytes = offsets_view->data.as_int32[i + 1] - offsets_view->data.as_int32[i];
+ view.size_bytes = offsets_view->data.as_int32[i + 1] - offsets_view->data.as_int32[i];
view.data.as_uint8 = data_view + offsets_view->data.as_int32[i];
break;
case NANOARROW_TYPE_LARGE_STRING:
case NANOARROW_TYPE_LARGE_BINARY:
- view.n_bytes = offsets_view->data.as_int64[i + 1] - offsets_view->data.as_int64[i];
+ view.size_bytes = offsets_view->data.as_int64[i + 1] - offsets_view->data.as_int64[i];
view.data.as_uint8 = data_view + offsets_view->data.as_int64[i];
break;
case NANOARROW_TYPE_FIXED_SIZE_BINARY:
- view.n_bytes = array_view->layout.element_size_bits[1] / 8;
- view.data.as_uint8 = array_view->buffer_views[1].data.as_uint8 + (i * view.n_bytes);
+ view.size_bytes = array_view->layout.element_size_bits[1] / 8;
+ view.data.as_uint8 = array_view->buffer_views[1].data.as_uint8 + (i * view.size_bytes);
break;
default:
view.data.data = NULL;
- view.n_bytes = 0;
+ view.size_bytes = 0;
break;
}
diff --git a/python/src/nanoarrow/nanoarrow_c.pxd b/python/src/nanoarrow/nanoarrow_c.pxd
index 9bfc488..440f449 100644
--- a/python/src/nanoarrow/nanoarrow_c.pxd
+++ b/python/src/nanoarrow/nanoarrow_c.pxd
@@ -25,7 +25,7 @@ cdef extern from "nanoarrow.h":
const char* format
int64_t n_children
void (*release)(ArrowSchema*)
-
+
struct ArrowArray:
int64_t length
int64_t null_count
@@ -104,7 +104,7 @@ cdef extern from "nanoarrow.h":
struct ArrowBufferView:
buffer_data data
- int64_t n_bytes
+ int64_t size_bytes
struct ArrowBuffer:
uint8_t* data
diff --git a/r/src/altrep.c b/r/src/altrep.c
index 9a85e2b..b4c1c5c 100644
--- a/r/src/altrep.c
+++ b/r/src/altrep.c
@@ -77,7 +77,7 @@ static SEXP nanoarrow_altstring_elt(SEXP altrep_sexp, R_xlen_t i) {
}
struct ArrowStringView item = ArrowArrayViewGetStringUnsafe(&converter->array_view, i);
- return Rf_mkCharLenCE(item.data, item.n_bytes, CE_UTF8);
+ return Rf_mkCharLenCE(item.data, item.size_bytes, CE_UTF8);
}
static SEXP nanoarrow_altstring_materialize(SEXP altrep_sexp) {
diff --git a/r/src/array.c b/r/src/array.c
index 6fa034b..313d5af 100644
--- a/r/src/array.c
+++ b/r/src/array.c
@@ -224,7 +224,8 @@ static SEXP borrow_buffer(struct ArrowArrayView* array_view, int64_t i, SEXP she
const char* names[] = {"size_bytes", "element_size_bits", ""};
SEXP buffer_info = PROTECT(Rf_mkNamed(VECSXP, names));
- SET_VECTOR_ELT(buffer_info, 0, length_from_int64(array_view->buffer_views[i].n_bytes));
+ SET_VECTOR_ELT(buffer_info, 0,
+ length_from_int64(array_view->buffer_views[i].size_bytes));
SET_VECTOR_ELT(buffer_info, 1,
length_from_int64(array_view->layout.element_size_bits[i]));
diff --git a/r/src/buffer.c b/r/src/buffer.c
index 12f83b0..c1a6930 100644
--- a/r/src/buffer.c
+++ b/r/src/buffer.c
@@ -21,9 +21,7 @@
#include <string.h>
-SEXP nanoarrow_c_buffer_info(SEXP buffer_xptr) {
- return R_ExternalPtrTag(buffer_xptr);
-}
+SEXP nanoarrow_c_buffer_info(SEXP buffer_xptr) { return R_ExternalPtrTag(buffer_xptr); }
SEXP nanoarrow_c_buffer_as_raw(SEXP buffer_xptr) {
SEXP info = R_ExternalPtrTag(buffer_xptr);
diff --git a/r/src/convert.c b/r/src/convert.c
index b3891b8..f87698d 100644
--- a/r/src/convert.c
+++ b/r/src/convert.c
@@ -72,8 +72,8 @@ SEXP nanoarrow_converter_from_type(enum VectorType vector_type) {
R_RegisterCFinalizer(converter_xptr, &finalize_converter);
ArrowArrayViewInitFromType(&converter->array_view, NANOARROW_TYPE_UNINITIALIZED);
- converter->schema_view.data_type = NANOARROW_TYPE_UNINITIALIZED;
- converter->schema_view.storage_data_type = NANOARROW_TYPE_UNINITIALIZED;
+ converter->schema_view.type = NANOARROW_TYPE_UNINITIALIZED;
+ converter->schema_view.storage_type = NANOARROW_TYPE_UNINITIALIZED;
converter->src.array_view = &converter->array_view;
converter->dst.vec_sexp = R_NilValue;
converter->options = NULL;
@@ -304,7 +304,7 @@ int nanoarrow_converter_set_schema(SEXP converter_xptr, SEXP schema_xptr) {
// For extension types, warn that we are about to strip the extension type, as we don't
// have a mechanism for dealing with them yet
- if (converter->schema_view.extension_name.n_bytes > 0) {
+ if (converter->schema_view.extension_name.size_bytes > 0) {
int64_t schema_chars = ArrowSchemaToString(schema, NULL, 0, 1);
SEXP fmt_shelter = PROTECT(Rf_allocVector(RAWSXP, schema_chars + 1));
ArrowSchemaToString(schema, (char*)RAW(fmt_shelter), schema_chars + 1, 1);
@@ -321,7 +321,7 @@ int nanoarrow_converter_set_schema(SEXP converter_xptr, SEXP schema_xptr) {
}
// Sub-par error for dictionary types until we have a way to deal with them
- if (converter->schema_view.data_type == NANOARROW_TYPE_DICTIONARY) {
+ if (converter->schema_view.type == NANOARROW_TYPE_DICTIONARY) {
ArrowErrorSet(&converter->error,
"Conversion to dictionary-encoded array is not supported");
return ENOTSUP;
diff --git a/r/src/convert_array.c b/r/src/convert_array.c
index 5508e6f..bb31958 100644
--- a/r/src/convert_array.c
+++ b/r/src/convert_array.c
@@ -51,7 +51,7 @@ static SEXP call_convert_array(SEXP array_xptr, SEXP ptype_sexp) {
static void call_stop_cant_convert_array(SEXP array_xptr, enum VectorType type,
SEXP ptype_sexp) {
SEXP fun = PROTECT(Rf_install("stop_cant_convert_array"));
-
+
if (ptype_sexp == R_NilValue) {
ptype_sexp = PROTECT(nanoarrow_alloc_type(type, 0));
SEXP call = PROTECT(Rf_lang3(fun, array_xptr, ptype_sexp));
diff --git a/r/src/infer_ptype.c b/r/src/infer_ptype.c
index 70ab15f..ed72522 100644
--- a/r/src/infer_ptype.c
+++ b/r/src/infer_ptype.c
@@ -76,7 +76,7 @@ enum VectorType nanoarrow_infer_vector_type_schema(SEXP schema_xptr) {
Rf_error("nanoarrow_infer_vector_type_schema(): %s", ArrowErrorMessage(&error));
}
- return nanoarrow_infer_vector_type(schema_view.data_type);
+ return nanoarrow_infer_vector_type(schema_view.type);
}
// The same as the above, but from a nanoarrow_array()
diff --git a/r/src/init.c b/r/src/init.c
index 2d42ae8..f0b0751 100644
--- a/r/src/init.c
+++ b/r/src/init.c
@@ -29,14 +29,18 @@ extern SEXP nanoarrow_c_altrep_is_materialized(SEXP x_sexp);
extern SEXP nanoarrow_c_altrep_force_materialize(SEXP x_sexp, SEXP recursive_sexp);
extern SEXP nanoarrow_c_array_stream_get_schema(SEXP array_stream_xptr);
extern SEXP nanoarrow_c_array_stream_get_next(SEXP array_stream_xptr);
-extern SEXP nanoarrow_c_basic_array_stream(SEXP batches_sexp, SEXP schema_xptr, SEXP validate_sexp);
+extern SEXP nanoarrow_c_basic_array_stream(SEXP batches_sexp, SEXP schema_xptr,
+ SEXP validate_sexp);
extern SEXP nanoarrow_c_array_view(SEXP array_xptr, SEXP schema_xptr);
-extern SEXP nanoarrow_c_array_set_schema(SEXP array_xptr, SEXP schema_xptr, SEXP validate_sexp);
+extern SEXP nanoarrow_c_array_set_schema(SEXP array_xptr, SEXP schema_xptr,
+ SEXP validate_sexp);
extern SEXP nanoarrow_c_infer_schema_array(SEXP array_xptr);
-extern SEXP nanoarrow_c_array_proxy(SEXP array_xptr, SEXP array_view_xptr, SEXP recursive_sexp);
+extern SEXP nanoarrow_c_array_proxy(SEXP array_xptr, SEXP array_view_xptr,
+ SEXP recursive_sexp);
extern SEXP nanoarrow_c_buffer_info(SEXP buffer_xptr);
extern SEXP nanoarrow_c_buffer_as_raw(SEXP buffer_xptr);
-extern SEXP nanoarrow_c_convert_array_stream(SEXP array_stream_xptr, SEXP ptype_sexp, SEXP size_sexp, SEXP n_sexp);
+extern SEXP nanoarrow_c_convert_array_stream(SEXP array_stream_xptr, SEXP ptype_sexp,
+ SEXP size_sexp, SEXP n_sexp);
extern SEXP nanoarrow_c_convert_array(SEXP array_xptr, SEXP ptype_sexp);
extern SEXP nanoarrow_c_infer_ptype(SEXP schema_xptr);
extern SEXP nanoarrow_c_allocate_schema(void);
@@ -60,9 +64,12 @@ extern SEXP nanoarrow_c_version_runtime();
static const R_CallMethodDef CallEntries[] = {
{"nanoarrow_c_make_altrep_chr", (DL_FUNC)&nanoarrow_c_make_altrep_chr, 1},
{"nanoarrow_c_is_altrep", (DL_FUNC)&nanoarrow_c_is_altrep, 1},
- {"nanoarrow_c_altrep_is_materialized", (DL_FUNC)&nanoarrow_c_altrep_is_materialized, 1},
- {"nanoarrow_c_altrep_force_materialize", (DL_FUNC)&nanoarrow_c_altrep_force_materialize, 2},
- {"nanoarrow_c_array_stream_get_schema", (DL_FUNC)&nanoarrow_c_array_stream_get_schema, 1},
+ {"nanoarrow_c_altrep_is_materialized", (DL_FUNC)&nanoarrow_c_altrep_is_materialized,
+ 1},
+ {"nanoarrow_c_altrep_force_materialize",
+ (DL_FUNC)&nanoarrow_c_altrep_force_materialize, 2},
+ {"nanoarrow_c_array_stream_get_schema", (DL_FUNC)&nanoarrow_c_array_stream_get_schema,
+ 1},
{"nanoarrow_c_array_stream_get_next", (DL_FUNC)&nanoarrow_c_array_stream_get_next, 1},
{"nanoarrow_c_basic_array_stream", (DL_FUNC)&nanoarrow_c_basic_array_stream, 3},
{"nanoarrow_c_array_view", (DL_FUNC)&nanoarrow_c_array_view, 2},
diff --git a/r/src/materialize_blob.h b/r/src/materialize_blob.h
index 0038b39..6371420 100644
--- a/r/src/materialize_blob.h
+++ b/r/src/materialize_blob.h
@@ -47,8 +47,8 @@ static inline int nanoarrow_materialize_blob(struct ArrayViewSlice* src,
for (R_xlen_t i = 0; i < dst->length; i++) {
if (!ArrowArrayViewIsNull(src->array_view, src->offset + i)) {
item = ArrowArrayViewGetBytesUnsafe(src->array_view, src->offset + i);
- item_sexp = PROTECT(Rf_allocVector(RAWSXP, item.n_bytes));
- memcpy(RAW(item_sexp), item.data.data, item.n_bytes);
+ item_sexp = PROTECT(Rf_allocVector(RAWSXP, item.size_bytes));
+ memcpy(RAW(item_sexp), item.data.data, item.size_bytes);
SET_VECTOR_ELT(dst->vec_sexp, dst->offset + i, item_sexp);
UNPROTECT(1);
}
diff --git a/r/src/materialize_chr.h b/r/src/materialize_chr.h
index c4316c0..b8f1beb 100644
--- a/r/src/materialize_chr.h
+++ b/r/src/materialize_chr.h
@@ -51,7 +51,7 @@ static inline int nanoarrow_materialize_chr(struct ArrayViewSlice* src,
} else {
item = ArrowArrayViewGetStringUnsafe(src->array_view, src->offset + i);
SET_STRING_ELT(dst->vec_sexp, dst->offset + i,
- Rf_mkCharLenCE(item.data, item.n_bytes, CE_UTF8));
+ Rf_mkCharLenCE(item.data, item.size_bytes, CE_UTF8));
}
}
diff --git a/r/src/materialize_date.h b/r/src/materialize_date.h
index 0ef443c..9995e0e 100644
--- a/r/src/materialize_date.h
+++ b/r/src/materialize_date.h
@@ -28,7 +28,7 @@
static int nanoarrow_materialize_date(struct RConverter* converter) {
if (converter->ptype_view.sexp_type == REALSXP) {
- switch (converter->schema_view.data_type) {
+ switch (converter->schema_view.type) {
case NANOARROW_TYPE_NA:
case NANOARROW_TYPE_DATE32:
return nanoarrow_materialize_dbl(converter);
diff --git a/r/src/materialize_difftime.h b/r/src/materialize_difftime.h
index 6f91db6..b8a23ca 100644
--- a/r/src/materialize_difftime.h
+++ b/r/src/materialize_difftime.h
@@ -27,7 +27,7 @@
static inline int nanoarrow_materialize_difftime(struct RConverter* converter) {
if (converter->ptype_view.sexp_type == REALSXP) {
- switch (converter->schema_view.data_type) {
+ switch (converter->schema_view.type) {
case NANOARROW_TYPE_NA:
NANOARROW_RETURN_NOT_OK(nanoarrow_materialize_dbl(converter));
return NANOARROW_OK;
diff --git a/r/src/materialize_posixct.h b/r/src/materialize_posixct.h
index e8641e1..ed0986d 100644
--- a/r/src/materialize_posixct.h
+++ b/r/src/materialize_posixct.h
@@ -28,7 +28,7 @@
static inline int nanoarrow_materialize_posixct(struct RConverter* converter) {
if (converter->ptype_view.sexp_type == REALSXP) {
enum ArrowTimeUnit time_unit;
- switch (converter->schema_view.data_type) {
+ switch (converter->schema_view.type) {
case NANOARROW_TYPE_NA:
time_unit = NANOARROW_TIME_UNIT_SECOND;
NANOARROW_RETURN_NOT_OK(nanoarrow_materialize_dbl(converter));
diff --git a/r/src/pointers.c b/r/src/pointers.c
index f55cd38..5124c62 100644
--- a/r/src/pointers.c
+++ b/r/src/pointers.c
@@ -54,12 +54,12 @@ SEXP nanoarrow_c_pointer(SEXP obj_sexp) {
}
SEXP nanoarrow_c_pointer_addr_dbl(SEXP ptr) {
- uintptr_t ptr_int = (uintptr_t) R_ExternalPtrAddr(nanoarrow_c_pointer(ptr));
+ uintptr_t ptr_int = (uintptr_t)R_ExternalPtrAddr(nanoarrow_c_pointer(ptr));
return Rf_ScalarReal(ptr_int);
}
SEXP nanoarrow_c_pointer_addr_chr(SEXP ptr) {
- intptr_t ptr_int = (intptr_t) R_ExternalPtrAddr(nanoarrow_c_pointer(ptr));
+ intptr_t ptr_int = (intptr_t)R_ExternalPtrAddr(nanoarrow_c_pointer(ptr));
char addr_chars[100];
memset(addr_chars, 0, 100);
intptr_as_string(ptr_int, addr_chars);
@@ -69,7 +69,8 @@ SEXP nanoarrow_c_pointer_addr_chr(SEXP ptr) {
SEXP nanoarrow_c_pointer_addr_pretty(SEXP ptr) {
char addr_chars[100];
memset(addr_chars, 0, 100);
- snprintf(addr_chars, sizeof(addr_chars), "%p", R_ExternalPtrAddr(nanoarrow_c_pointer(ptr)));
+ snprintf(addr_chars, sizeof(addr_chars), "%p",
+ R_ExternalPtrAddr(nanoarrow_c_pointer(ptr)));
return Rf_mkString(addr_chars);
}
@@ -137,7 +138,7 @@ SEXP nanoarrow_c_pointer_move(SEXP ptr_src, SEXP ptr_dst) {
if (obj_src == NULL || obj_src->release == NULL) {
Rf_error("`ptr_src` is not a valid struct ArrowSchema");
}
-
+
ArrowSchemaMove(obj_src, obj_dst);
} else if (Rf_inherits(ptr_dst, "nanoarrow_array")) {
struct ArrowArray* obj_dst = (struct ArrowArray*)R_ExternalPtrAddr(ptr_dst);
@@ -203,7 +204,7 @@ SEXP nanoarrow_c_export_schema(SEXP schema_xptr, SEXP ptr_dst) {
struct ArrowSchema* obj_src = schema_from_xptr(schema_xptr);
SEXP xptr_dst = PROTECT(nanoarrow_c_pointer(ptr_dst));
- struct ArrowSchema* obj_dst = (struct ArrowSchema*) R_ExternalPtrAddr(xptr_dst);
+ struct ArrowSchema* obj_dst = (struct ArrowSchema*)R_ExternalPtrAddr(xptr_dst);
if (obj_dst == NULL) {
Rf_error("`ptr_dst` is a pointer to NULL");
}
@@ -224,7 +225,7 @@ SEXP nanoarrow_c_export_schema(SEXP schema_xptr, SEXP ptr_dst) {
SEXP nanoarrow_c_export_array(SEXP array_xptr, SEXP ptr_dst) {
SEXP xptr_dst = PROTECT(nanoarrow_c_pointer(ptr_dst));
- struct ArrowArray* obj_dst = (struct ArrowArray*) R_ExternalPtrAddr(xptr_dst);
+ struct ArrowArray* obj_dst = (struct ArrowArray*)R_ExternalPtrAddr(xptr_dst);
if (obj_dst == NULL) {
Rf_error("`ptr_dst` is a pointer to NULL");
}
diff --git a/r/src/pointers_cpp.cc b/r/src/pointers_cpp.cc
index 8834d06..0cc50f4 100644
--- a/r/src/pointers_cpp.cc
+++ b/r/src/pointers_cpp.cc
@@ -1,6 +1,6 @@
-#include <string>
#include <cstring>
+#include <string>
extern "C" void intptr_as_string(intptr_t ptr_int, char* buf) {
std::string ptr_str = std::to_string(ptr_int);
diff --git a/r/src/schema.c b/r/src/schema.c
index 9877d81..7bae675 100644
--- a/r/src/schema.c
+++ b/r/src/schema.c
@@ -49,9 +49,9 @@ static SEXP schema_metadata_to_list(const char* metadata) {
R_xlen_t i = 0;
while (reader.remaining_keys > 0) {
ArrowMetadataReaderRead(&reader, &key, &value);
- SET_STRING_ELT(names, i, Rf_mkCharLenCE(key.data, key.n_bytes, CE_UTF8));
- SEXP value_raw = PROTECT(Rf_allocVector(RAWSXP, value.n_bytes));
- memcpy(RAW(value_raw), value.data, value.n_bytes);
+ SET_STRING_ELT(names, i, Rf_mkCharLenCE(key.data, key.size_bytes, CE_UTF8));
+ SEXP value_raw = PROTECT(Rf_allocVector(RAWSXP, value.size_bytes));
+ memcpy(RAW(value_raw), value.data, value.size_bytes);
SET_VECTOR_ELT(values, i, value_raw);
UNPROTECT(1);
i++;
@@ -136,7 +136,7 @@ static SEXP mkStringView(struct ArrowStringView* view) {
return R_NilValue;
}
- SEXP chr = PROTECT(Rf_mkCharLenCE(view->data, view->n_bytes, CE_UTF8));
+ SEXP chr = PROTECT(Rf_mkCharLenCE(view->data, view->size_bytes, CE_UTF8));
SEXP str = PROTECT(Rf_allocVector(STRSXP, 1));
SET_STRING_ELT(str, 0, chr);
UNPROTECT(2);
@@ -159,9 +159,9 @@ SEXP nanoarrow_c_schema_parse(SEXP schema_xptr) {
"time_unit", "timezone", "union_type_ids", ""};
SEXP result = PROTECT(Rf_mkNamed(VECSXP, names));
- SET_VECTOR_ELT(result, 0, Rf_mkString(ArrowTypeString((schema_view.data_type))));
+ SET_VECTOR_ELT(result, 0, Rf_mkString(ArrowTypeString((schema_view.type))));
SET_VECTOR_ELT(result, 1,
- Rf_mkString(ArrowTypeString((schema_view.storage_data_type))));
+ Rf_mkString(ArrowTypeString((schema_view.storage_type))));
if (schema_view.extension_name.data != NULL) {
SET_VECTOR_ELT(result, 2, mkStringView(&schema_view.extension_name));
@@ -169,38 +169,38 @@ SEXP nanoarrow_c_schema_parse(SEXP schema_xptr) {
if (schema_view.extension_metadata.data != NULL) {
SEXP metadata_sexp =
- PROTECT(Rf_allocVector(RAWSXP, schema_view.extension_metadata.n_bytes));
+ PROTECT(Rf_allocVector(RAWSXP, schema_view.extension_metadata.size_bytes));
memcpy(RAW(metadata_sexp), schema_view.extension_metadata.data,
- schema_view.extension_metadata.n_bytes);
+ schema_view.extension_metadata.size_bytes);
SET_VECTOR_ELT(result, 3, metadata_sexp);
UNPROTECT(1);
}
- if (schema_view.data_type == NANOARROW_TYPE_FIXED_SIZE_LIST ||
- schema_view.data_type == NANOARROW_TYPE_FIXED_SIZE_BINARY) {
+ if (schema_view.type == NANOARROW_TYPE_FIXED_SIZE_LIST ||
+ schema_view.type == NANOARROW_TYPE_FIXED_SIZE_BINARY) {
SET_VECTOR_ELT(result, 4, Rf_ScalarInteger(schema_view.fixed_size));
}
- if (schema_view.data_type == NANOARROW_TYPE_DECIMAL128 ||
- schema_view.data_type == NANOARROW_TYPE_DECIMAL256) {
+ if (schema_view.type == NANOARROW_TYPE_DECIMAL128 ||
+ schema_view.type == NANOARROW_TYPE_DECIMAL256) {
SET_VECTOR_ELT(result, 5, Rf_ScalarInteger(schema_view.decimal_bitwidth));
SET_VECTOR_ELT(result, 6, Rf_ScalarInteger(schema_view.decimal_precision));
SET_VECTOR_ELT(result, 7, Rf_ScalarInteger(schema_view.decimal_scale));
}
- if (schema_view.data_type == NANOARROW_TYPE_TIME32 ||
- schema_view.data_type == NANOARROW_TYPE_TIME64 ||
- schema_view.data_type == NANOARROW_TYPE_TIMESTAMP ||
- schema_view.data_type == NANOARROW_TYPE_DURATION) {
+ if (schema_view.type == NANOARROW_TYPE_TIME32 ||
+ schema_view.type == NANOARROW_TYPE_TIME64 ||
+ schema_view.type == NANOARROW_TYPE_TIMESTAMP ||
+ schema_view.type == NANOARROW_TYPE_DURATION) {
SET_VECTOR_ELT(result, 8, Rf_mkString(ArrowTimeUnitString((schema_view.time_unit))));
}
- if (schema_view.data_type == NANOARROW_TYPE_TIMESTAMP) {
- SET_VECTOR_ELT(result, 9, mkStringView(&schema_view.timezone));
+ if (schema_view.type == NANOARROW_TYPE_TIMESTAMP) {
+ SET_VECTOR_ELT(result, 9, Rf_mkString(schema_view.timezone));
}
- if (schema_view.data_type == NANOARROW_TYPE_DENSE_UNION ||
- schema_view.data_type == NANOARROW_TYPE_SPARSE_UNION) {
+ if (schema_view.type == NANOARROW_TYPE_DENSE_UNION ||
+ schema_view.type == NANOARROW_TYPE_SPARSE_UNION) {
int8_t type_ids[128];
int num_type_ids = _ArrowParseUnionTypeIds(schema_view.union_type_ids, type_ids);
if (num_type_ids == -1) {
diff --git a/r/src/util.c b/r/src/util.c
index 1f71a06..46fc545 100644
--- a/r/src/util.c
+++ b/r/src/util.c
@@ -32,12 +32,12 @@ SEXP nanoarrow_cls_array_stream = NULL;
void nanoarrow_init_cached_sexps(void) {
SEXP nanoarrow_str = PROTECT(Rf_mkString("nanoarrow"));
nanoarrow_ns_pkg = PROTECT(R_FindNamespace(nanoarrow_str));
- nanoarrow_cls_array = PROTECT(Rf_mkString("nanoarrow_array"));
- nanoarrow_cls_altrep_chr = PROTECT(Rf_mkString("nanoarrow::altrep_chr"));
- nanoarrow_cls_array_view = PROTECT(Rf_mkString("nanoarrow_array_view"));
- nanoarrow_cls_data_frame = PROTECT(Rf_mkString("data.frame"));
- nanoarrow_cls_schema = PROTECT(Rf_mkString("nanoarrow_schema"));
- nanoarrow_cls_array_stream = PROTECT(Rf_mkString("nanoarrow_array_stream"));
+ nanoarrow_cls_array = PROTECT(Rf_mkString("nanoarrow_array"));
+ nanoarrow_cls_altrep_chr = PROTECT(Rf_mkString("nanoarrow::altrep_chr"));
+ nanoarrow_cls_array_view = PROTECT(Rf_mkString("nanoarrow_array_view"));
+ nanoarrow_cls_data_frame = PROTECT(Rf_mkString("data.frame"));
+ nanoarrow_cls_schema = PROTECT(Rf_mkString("nanoarrow_schema"));
+ nanoarrow_cls_array_stream = PROTECT(Rf_mkString("nanoarrow_array_stream"));
R_PreserveObject(nanoarrow_ns_pkg);
R_PreserveObject(nanoarrow_cls_array);
diff --git a/r/src/version.c b/r/src/version.c
index 0318cae..6509c01 100644
--- a/r/src/version.c
+++ b/r/src/version.c
@@ -21,10 +21,6 @@
#include "nanoarrow.h"
-SEXP nanoarrow_c_version() {
- return Rf_mkString(NANOARROW_VERSION);
-}
+SEXP nanoarrow_c_version() { return Rf_mkString(NANOARROW_VERSION); }
-SEXP nanoarrow_c_version_runtime() {
- return Rf_mkString(ArrowNanoarrowVersion());
-}
+SEXP nanoarrow_c_version_runtime() { return Rf_mkString(ArrowNanoarrowVersion()); }
diff --git a/src/nanoarrow/array.c b/src/nanoarrow/array.c
index 6443ae0..068122f 100644
--- a/src/nanoarrow/array.c
+++ b/src/nanoarrow/array.c
@@ -327,7 +327,7 @@ static ArrowErrorCode ArrowArrayReserveInternal(struct ArrowArray* array,
}
int64_t additional_size_bytes =
- array_view->buffer_views[i].n_bytes - ArrowArrayBuffer(array, i)->size_bytes;
+ array_view->buffer_views[i].size_bytes - ArrowArrayBuffer(array, i)->size_bytes;
if (additional_size_bytes > 0) {
NANOARROW_RETURN_NOT_OK(
@@ -414,7 +414,7 @@ static ArrowErrorCode ArrowArrayCheckInternalBufferSizes(
continue;
}
- int64_t expected_size = array_view->buffer_views[i].n_bytes;
+ int64_t expected_size = array_view->buffer_views[i].size_bytes;
int64_t actual_size = ArrowArrayBuffer(array, i)->size_bytes;
if (actual_size < expected_size) {
@@ -515,7 +515,7 @@ ArrowErrorCode ArrowArrayViewInitFromSchema(struct ArrowArrayView* array_view,
return result;
}
- ArrowArrayViewInitFromType(array_view, schema_view.storage_data_type);
+ ArrowArrayViewInitFromType(array_view, schema_view.storage_type);
array_view->layout = schema_view.layout;
result = ArrowArrayViewAllocateChildren(array_view, schema->n_children);
@@ -578,25 +578,25 @@ void ArrowArrayViewSetLength(struct ArrowArrayView* array_view, int64_t length)
switch (array_view->layout.buffer_type[i]) {
case NANOARROW_BUFFER_TYPE_VALIDITY:
- array_view->buffer_views[i].n_bytes = _ArrowBytesForBits(length);
+ array_view->buffer_views[i].size_bytes = _ArrowBytesForBits(length);
continue;
case NANOARROW_BUFFER_TYPE_DATA_OFFSET:
// Probably don't want/need to rely on the producer to have allocated an
// offsets buffer of length 1 for a zero-size array
- array_view->buffer_views[i].n_bytes =
+ array_view->buffer_views[i].size_bytes =
(length != 0) * element_size_bytes * (length + 1);
continue;
case NANOARROW_BUFFER_TYPE_DATA:
- array_view->buffer_views[i].n_bytes =
+ array_view->buffer_views[i].size_bytes =
_ArrowRoundUpToMultipleOf8(array_view->layout.element_size_bits[i] * length) /
8;
continue;
case NANOARROW_BUFFER_TYPE_TYPE_ID:
case NANOARROW_BUFFER_TYPE_UNION_OFFSET:
- array_view->buffer_views[i].n_bytes = element_size_bytes * length;
+ array_view->buffer_views[i].size_bytes = element_size_bytes * length;
continue;
case NANOARROW_BUFFER_TYPE_NONE:
- array_view->buffer_views[i].n_bytes = 0;
+ array_view->buffer_views[i].size_bytes = 0;
continue;
}
}
@@ -635,7 +635,7 @@ ArrowErrorCode ArrowArrayViewSetArray(struct ArrowArrayView* array_view,
// If the null_count is 0, the validity buffer can be NULL
if (array_view->layout.buffer_type[i] == NANOARROW_BUFFER_TYPE_VALIDITY &&
array->null_count == 0 && array->buffers[i] == NULL) {
- array_view->buffer_views[i].n_bytes = 0;
+ array_view->buffer_views[i].size_bytes = 0;
}
array_view->buffer_views[i].data.data = array->buffers[i];
@@ -656,18 +656,18 @@ ArrowErrorCode ArrowArrayViewSetArray(struct ArrowArrayView* array_view,
switch (array_view->storage_type) {
case NANOARROW_TYPE_STRING:
case NANOARROW_TYPE_BINARY:
- if (array_view->buffer_views[1].n_bytes != 0) {
+ if (array_view->buffer_views[1].size_bytes != 0) {
last_offset =
array_view->buffer_views[1].data.as_int32[array->offset + array->length];
- array_view->buffer_views[2].n_bytes = last_offset;
+ array_view->buffer_views[2].size_bytes = last_offset;
}
break;
case NANOARROW_TYPE_LARGE_STRING:
case NANOARROW_TYPE_LARGE_BINARY:
- if (array_view->buffer_views[1].n_bytes != 0) {
+ if (array_view->buffer_views[1].size_bytes != 0) {
last_offset =
array_view->buffer_views[1].data.as_int64[array->offset + array->length];
- array_view->buffer_views[2].n_bytes = last_offset;
+ array_view->buffer_views[2].size_bytes = last_offset;
}
break;
case NANOARROW_TYPE_STRUCT:
@@ -693,7 +693,7 @@ ArrowErrorCode ArrowArrayViewSetArray(struct ArrowArrayView* array_view,
return EINVAL;
}
- if (array_view->buffer_views[1].n_bytes != 0) {
+ if (array_view->buffer_views[1].size_bytes != 0) {
last_offset =
array_view->buffer_views[1].data.as_int32[array->offset + array->length];
if (array->children[0]->length < last_offset) {
@@ -715,7 +715,7 @@ ArrowErrorCode ArrowArrayViewSetArray(struct ArrowArrayView* array_view,
return EINVAL;
}
- if (array_view->buffer_views[1].n_bytes != 0) {
+ if (array_view->buffer_views[1].size_bytes != 0) {
last_offset =
array_view->buffer_views[1].data.as_int64[array->offset + array->length];
if (array->children[0]->length < last_offset) {
diff --git a/src/nanoarrow/array_inline.h b/src/nanoarrow/array_inline.h
index d2517cc..c6f569a 100644
--- a/src/nanoarrow/array_inline.h
+++ b/src/nanoarrow/array_inline.h
@@ -455,33 +455,33 @@ static inline ArrowErrorCode ArrowArrayAppendBytes(struct ArrowArray* array,
case NANOARROW_TYPE_STRING:
case NANOARROW_TYPE_BINARY:
offset = ((int32_t*)offset_buffer->data)[array->length];
- if ((offset + value.n_bytes) > INT32_MAX) {
+ if ((offset + value.size_bytes) > INT32_MAX) {
return EINVAL;
}
- offset += value.n_bytes;
+ offset += value.size_bytes;
NANOARROW_RETURN_NOT_OK(ArrowBufferAppend(offset_buffer, &offset, sizeof(int32_t)));
NANOARROW_RETURN_NOT_OK(
- ArrowBufferAppend(data_buffer, value.data.data, value.n_bytes));
+ ArrowBufferAppend(data_buffer, value.data.data, value.size_bytes));
break;
case NANOARROW_TYPE_LARGE_STRING:
case NANOARROW_TYPE_LARGE_BINARY:
large_offset = ((int64_t*)offset_buffer->data)[array->length];
- large_offset += value.n_bytes;
+ large_offset += value.size_bytes;
NANOARROW_RETURN_NOT_OK(
ArrowBufferAppend(offset_buffer, &large_offset, sizeof(int64_t)));
NANOARROW_RETURN_NOT_OK(
- ArrowBufferAppend(data_buffer, value.data.data, value.n_bytes));
+ ArrowBufferAppend(data_buffer, value.data.data, value.size_bytes));
break;
case NANOARROW_TYPE_FIXED_SIZE_BINARY:
- if (value.n_bytes != fixed_size_bytes) {
+ if (value.size_bytes != fixed_size_bytes) {
return EINVAL;
}
NANOARROW_RETURN_NOT_OK(
- ArrowBufferAppend(data_buffer, value.data.data, value.n_bytes));
+ ArrowBufferAppend(data_buffer, value.data.data, value.size_bytes));
break;
default:
return EINVAL;
@@ -502,7 +502,7 @@ static inline ArrowErrorCode ArrowArrayAppendString(struct ArrowArray* array,
struct ArrowBufferView buffer_view;
buffer_view.data.data = value.data;
- buffer_view.n_bytes = value.n_bytes;
+ buffer_view.size_bytes = value.size_bytes;
switch (private_data->storage_type) {
case NANOARROW_TYPE_STRING:
@@ -766,20 +766,22 @@ static inline struct ArrowStringView ArrowArrayViewGetStringUnsafe(
case NANOARROW_TYPE_STRING:
case NANOARROW_TYPE_BINARY:
view.data = data_view + offsets_view->data.as_int32[i];
- view.n_bytes = offsets_view->data.as_int32[i + 1] - offsets_view->data.as_int32[i];
+ view.size_bytes =
+ offsets_view->data.as_int32[i + 1] - offsets_view->data.as_int32[i];
break;
case NANOARROW_TYPE_LARGE_STRING:
case NANOARROW_TYPE_LARGE_BINARY:
view.data = data_view + offsets_view->data.as_int64[i];
- view.n_bytes = offsets_view->data.as_int64[i + 1] - offsets_view->data.as_int64[i];
+ view.size_bytes =
+ offsets_view->data.as_int64[i + 1] - offsets_view->data.as_int64[i];
break;
case NANOARROW_TYPE_FIXED_SIZE_BINARY:
- view.n_bytes = array_view->layout.element_size_bits[1] / 8;
- view.data = array_view->buffer_views[1].data.as_char + (i * view.n_bytes);
+ view.size_bytes = array_view->layout.element_size_bits[1] / 8;
+ view.data = array_view->buffer_views[1].data.as_char + (i * view.size_bytes);
break;
default:
view.data = NULL;
- view.n_bytes = 0;
+ view.size_bytes = 0;
break;
}
@@ -796,21 +798,24 @@ static inline struct ArrowBufferView ArrowArrayViewGetBytesUnsafe(
switch (array_view->storage_type) {
case NANOARROW_TYPE_STRING:
case NANOARROW_TYPE_BINARY:
- view.n_bytes = offsets_view->data.as_int32[i + 1] - offsets_view->data.as_int32[i];
+ view.size_bytes =
+ offsets_view->data.as_int32[i + 1] - offsets_view->data.as_int32[i];
view.data.as_uint8 = data_view + offsets_view->data.as_int32[i];
break;
case NANOARROW_TYPE_LARGE_STRING:
case NANOARROW_TYPE_LARGE_BINARY:
- view.n_bytes = offsets_view->data.as_int64[i + 1] - offsets_view->data.as_int64[i];
+ view.size_bytes =
+ offsets_view->data.as_int64[i + 1] - offsets_view->data.as_int64[i];
view.data.as_uint8 = data_view + offsets_view->data.as_int64[i];
break;
case NANOARROW_TYPE_FIXED_SIZE_BINARY:
- view.n_bytes = array_view->layout.element_size_bits[1] / 8;
- view.data.as_uint8 = array_view->buffer_views[1].data.as_uint8 + (i * view.n_bytes);
+ view.size_bytes = array_view->layout.element_size_bits[1] / 8;
+ view.data.as_uint8 =
+ array_view->buffer_views[1].data.as_uint8 + (i * view.size_bytes);
break;
default:
view.data.data = NULL;
- view.n_bytes = 0;
+ view.size_bytes = 0;
break;
}
diff --git a/src/nanoarrow/array_test.cc b/src/nanoarrow/array_test.cc
index a028b10..f3fa86e 100644
--- a/src/nanoarrow/array_test.cc
+++ b/src/nanoarrow/array_test.cc
@@ -261,7 +261,7 @@ TEST(ArrayTest, ArrayTestAppendToNullArray) {
EXPECT_EQ(ArrowArrayAppendDouble(&array, 0), EINVAL);
struct ArrowBufferView buffer_view;
buffer_view.data.data = nullptr;
- buffer_view.n_bytes = 0;
+ buffer_view.size_bytes = 0;
EXPECT_EQ(ArrowArrayAppendBytes(&array, buffer_view), EINVAL);
EXPECT_EQ(ArrowArrayAppendString(&array, ArrowCharView("")), EINVAL);
array.release(&array);
@@ -1252,8 +1252,8 @@ TEST(ArrayTest, ArrayViewTestBasic) {
EXPECT_EQ(array_view.layout.element_size_bits[1], 32);
ArrowArrayViewSetLength(&array_view, 5);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 1);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, 5 * sizeof(int32_t));
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 1);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, 5 * sizeof(int32_t));
struct ArrowArray array;
@@ -1267,8 +1267,8 @@ TEST(ArrayTest, ArrayViewTestBasic) {
ASSERT_EQ(ArrowArrayFinishBuilding(&array, nullptr), NANOARROW_OK);
EXPECT_EQ(ArrowArrayViewSetArray(&array_view, &array, &error), NANOARROW_OK);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 0);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, 3 * sizeof(int32_t));
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, 3 * sizeof(int32_t));
EXPECT_EQ(array_view.buffer_views[1].data.as_int32[0], 11);
EXPECT_EQ(array_view.buffer_views[1].data.as_int32[1], 12);
EXPECT_EQ(array_view.buffer_views[1].data.as_int32[2], 13);
@@ -1279,8 +1279,8 @@ TEST(ArrayTest, ArrayViewTestBasic) {
ASSERT_EQ(ArrowArrayFinishBuilding(&array, nullptr), NANOARROW_OK);
EXPECT_EQ(ArrowArrayViewSetArray(&array_view, &array, &error), NANOARROW_OK);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 1);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, 3 * sizeof(int32_t));
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 1);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, 3 * sizeof(int32_t));
// Expect error for the wrong number of buffers
ArrowArrayViewReset(&array_view);
@@ -1323,14 +1323,14 @@ TEST(ArrayTest, ArrayViewTestString) {
// Can't assume offset buffer size > 0 if length == 0
ArrowArrayViewSetLength(&array_view, 0);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 0);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, 0);
- EXPECT_EQ(array_view.buffer_views[2].n_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[2].size_bytes, 0);
ArrowArrayViewSetLength(&array_view, 5);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 1);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, (5 + 1) * sizeof(int32_t));
- EXPECT_EQ(array_view.buffer_views[2].n_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 1);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, (5 + 1) * sizeof(int32_t));
+ EXPECT_EQ(array_view.buffer_views[2].size_bytes, 0);
struct ArrowArray array;
@@ -1338,9 +1338,9 @@ TEST(ArrayTest, ArrayViewTestString) {
ASSERT_EQ(ArrowArrayInitFromType(&array, NANOARROW_TYPE_STRING), NANOARROW_OK);
array.null_count = 0;
EXPECT_EQ(ArrowArrayViewSetArray(&array_view, &array, &error), NANOARROW_OK);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 0);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, 0);
- EXPECT_EQ(array_view.buffer_views[2].n_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[2].size_bytes, 0);
// Build non-zero length (the array ["abcd"])
ASSERT_EQ(ArrowBufferAppendInt32(ArrowArrayBuffer(&array, 1), 0), NANOARROW_OK);
@@ -1351,9 +1351,9 @@ TEST(ArrayTest, ArrayViewTestString) {
ASSERT_EQ(ArrowArrayFinishBuilding(&array, nullptr), NANOARROW_OK);
EXPECT_EQ(ArrowArrayViewSetArray(&array_view, &array, &error), NANOARROW_OK);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 0);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, (1 + 1) * sizeof(int32_t));
- EXPECT_EQ(array_view.buffer_views[2].n_bytes, 4);
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, (1 + 1) * sizeof(int32_t));
+ EXPECT_EQ(array_view.buffer_views[2].size_bytes, 4);
array.release(&array);
ArrowArrayViewReset(&array_view);
@@ -1375,14 +1375,14 @@ TEST(ArrayTest, ArrayViewTestLargeString) {
// Can't assume offset buffer size > 0 if length == 0
ArrowArrayViewSetLength(&array_view, 0);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 0);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, 0);
- EXPECT_EQ(array_view.buffer_views[2].n_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[2].size_bytes, 0);
ArrowArrayViewSetLength(&array_view, 5);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 1);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, (5 + 1) * sizeof(int64_t));
- EXPECT_EQ(array_view.buffer_views[2].n_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 1);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, (5 + 1) * sizeof(int64_t));
+ EXPECT_EQ(array_view.buffer_views[2].size_bytes, 0);
struct ArrowArray array;
@@ -1390,9 +1390,9 @@ TEST(ArrayTest, ArrayViewTestLargeString) {
ASSERT_EQ(ArrowArrayInitFromType(&array, NANOARROW_TYPE_STRING), NANOARROW_OK);
array.null_count = 0;
EXPECT_EQ(ArrowArrayViewSetArray(&array_view, &array, &error), NANOARROW_OK);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 0);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, 0);
- EXPECT_EQ(array_view.buffer_views[2].n_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[2].size_bytes, 0);
// Build non-zero length (the array ["abcd"])
ASSERT_EQ(ArrowBufferAppendInt64(ArrowArrayBuffer(&array, 1), 0), NANOARROW_OK);
@@ -1403,9 +1403,9 @@ TEST(ArrayTest, ArrayViewTestLargeString) {
ASSERT_EQ(ArrowArrayFinishBuilding(&array, nullptr), NANOARROW_OK);
EXPECT_EQ(ArrowArrayViewSetArray(&array_view, &array, &error), NANOARROW_OK);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 0);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, (1 + 1) * sizeof(int64_t));
- EXPECT_EQ(array_view.buffer_views[2].n_bytes, 4);
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 0);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, (1 + 1) * sizeof(int64_t));
+ EXPECT_EQ(array_view.buffer_views[2].size_bytes, 4);
array.release(&array);
ArrowArrayViewReset(&array_view);
@@ -1433,8 +1433,8 @@ TEST(ArrayTest, ArrayViewTestStruct) {
EXPECT_EQ(array_view.children[1]->storage_type, NANOARROW_TYPE_NA);
ArrowArrayViewSetLength(&array_view, 5);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 1);
- EXPECT_EQ(array_view.children[0]->buffer_views[1].n_bytes, 5 * sizeof(int32_t));
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 1);
+ EXPECT_EQ(array_view.children[0]->buffer_views[1].size_bytes, 5 * sizeof(int32_t));
// Exepct error for attempting to allocate a children array that already exists
EXPECT_EQ(ArrowArrayViewAllocateChildren(&array_view, 1), EINVAL);
@@ -1459,8 +1459,8 @@ TEST(ArrayTest, ArrayViewTestList) {
EXPECT_EQ(array_view.children[0]->storage_type, NANOARROW_TYPE_INT32);
ArrowArrayViewSetLength(&array_view, 5);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 1);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, (5 + 1) * sizeof(int32_t));
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 1);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, (5 + 1) * sizeof(int32_t));
ArrowArrayViewReset(&array_view);
}
@@ -1482,8 +1482,8 @@ TEST(ArrayTest, ArrayViewTestLargeList) {
EXPECT_EQ(array_view.children[0]->storage_type, NANOARROW_TYPE_INT32);
ArrowArrayViewSetLength(&array_view, 5);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 1);
- EXPECT_EQ(array_view.buffer_views[1].n_bytes, (5 + 1) * sizeof(int64_t));
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 1);
+ EXPECT_EQ(array_view.buffer_views[1].size_bytes, (5 + 1) * sizeof(int64_t));
ArrowArrayViewReset(&array_view);
}
@@ -1504,8 +1504,8 @@ TEST(ArrayTest, ArrayViewTestFixedSizeList) {
EXPECT_EQ(array_view.children[0]->storage_type, NANOARROW_TYPE_INT32);
ArrowArrayViewSetLength(&array_view, 5);
- EXPECT_EQ(array_view.buffer_views[0].n_bytes, 1);
- EXPECT_EQ(array_view.children[0]->buffer_views[1].n_bytes, 15 * sizeof(int32_t));
+ EXPECT_EQ(array_view.buffer_views[0].size_bytes, 1);
+ EXPECT_EQ(array_view.children[0]->buffer_views[1].size_bytes, 15 * sizeof(int32_t));
ArrowArrayViewReset(&array_view);
}
@@ -1544,7 +1544,7 @@ TEST(ArrayTest, ArrayViewTestStructArray) {
ASSERT_EQ(ArrowArrayFinishBuilding(&array, nullptr), NANOARROW_OK);
EXPECT_EQ(ArrowArrayViewSetArray(&array_view, &array, &error), NANOARROW_OK);
- EXPECT_EQ(array_view.children[0]->buffer_views[1].n_bytes, sizeof(int32_t));
+ EXPECT_EQ(array_view.children[0]->buffer_views[1].size_bytes, sizeof(int32_t));
EXPECT_EQ(array_view.children[0]->buffer_views[1].data.as_int32[0], 123);
ArrowArrayViewReset(&array_view);
@@ -1586,7 +1586,7 @@ TEST(ArrayTest, ArrayViewTestFixedSizeListArray) {
ASSERT_EQ(ArrowArrayFinishBuilding(&array, &error), NANOARROW_OK);
EXPECT_EQ(ArrowArrayViewSetArray(&array_view, &array, &error), NANOARROW_OK);
- EXPECT_EQ(array_view.children[0]->buffer_views[1].n_bytes, 3 * sizeof(int32_t));
+ EXPECT_EQ(array_view.children[0]->buffer_views[1].size_bytes, 3 * sizeof(int32_t));
EXPECT_EQ(array_view.children[0]->buffer_views[1].data.as_int32[0], 123);
ArrowArrayViewReset(&array_view);
@@ -1762,7 +1762,7 @@ void TestGetFromNumericArrayView() {
struct ArrowArrayView array_view;
struct ArrowError error;
- auto data_type = TypeTraits<TypeClass>::type_singleton();
+ auto type = TypeTraits<TypeClass>::type_singleton();
// Array with nulls
auto builder = NumericBuilder<TypeClass>();
@@ -1786,10 +1786,10 @@ void TestGetFromNumericArrayView() {
auto string_view = ArrowArrayViewGetStringUnsafe(&array_view, 0);
EXPECT_EQ(string_view.data, nullptr);
- EXPECT_EQ(string_view.n_bytes, 0);
+ EXPECT_EQ(string_view.size_bytes, 0);
auto buffer_view = ArrowArrayViewGetBytesUnsafe(&array_view, 0);
EXPECT_EQ(buffer_view.data.data, nullptr);
- EXPECT_EQ(buffer_view.n_bytes, 0);
+ EXPECT_EQ(buffer_view.size_bytes, 0);
ArrowArrayViewReset(&array_view);
array.release(&array);
@@ -1841,7 +1841,7 @@ void TestGetFromBinary(BuilderClass& builder) {
struct ArrowArrayView array_view;
struct ArrowError error;
- auto data_type = builder.type();
+ auto type = builder.type();
ARROW_EXPECT_OK(builder.Append("1234"));
ARROW_EXPECT_OK(builder.AppendNulls(2));
ARROW_EXPECT_OK(builder.Append("four"));
@@ -1857,12 +1857,12 @@ void TestGetFromBinary(BuilderClass& builder) {
EXPECT_EQ(ArrowArrayViewIsNull(&array_view, 3), 0);
auto string_view = ArrowArrayViewGetStringUnsafe(&array_view, 3);
- EXPECT_EQ(string_view.n_bytes, strlen("four"));
- EXPECT_EQ(memcmp(string_view.data, "four", string_view.n_bytes), 0);
+ EXPECT_EQ(string_view.size_bytes, strlen("four"));
+ EXPECT_EQ(memcmp(string_view.data, "four", string_view.size_bytes), 0);
auto buffer_view = ArrowArrayViewGetBytesUnsafe(&array_view, 3);
- EXPECT_EQ(buffer_view.n_bytes, strlen("four"));
- EXPECT_EQ(memcmp(buffer_view.data.as_char, "four", buffer_view.n_bytes), 0);
+ EXPECT_EQ(buffer_view.size_bytes, strlen("four"));
+ EXPECT_EQ(memcmp(buffer_view.data.as_char, "four", buffer_view.size_bytes), 0);
ArrowArrayViewReset(&array_view);
array.release(&array);
diff --git a/src/nanoarrow/buffer_inline.h b/src/nanoarrow/buffer_inline.h
index 9a83ceb..92a3c83 100644
--- a/src/nanoarrow/buffer_inline.h
+++ b/src/nanoarrow/buffer_inline.h
@@ -177,12 +177,12 @@ static inline ArrowErrorCode ArrowBufferAppendFloat(struct ArrowBuffer* buffer,
static inline ArrowErrorCode ArrowBufferAppendStringView(struct ArrowBuffer* buffer,
struct ArrowStringView value) {
- return ArrowBufferAppend(buffer, value.data, value.n_bytes);
+ return ArrowBufferAppend(buffer, value.data, value.size_bytes);
}
static inline ArrowErrorCode ArrowBufferAppendBufferView(struct ArrowBuffer* buffer,
struct ArrowBufferView value) {
- return ArrowBufferAppend(buffer, value.data.data, value.n_bytes);
+ return ArrowBufferAppend(buffer, value.data.data, value.size_bytes);
}
static inline ArrowErrorCode ArrowBufferAppendFill(struct ArrowBuffer* buffer,
diff --git a/src/nanoarrow/buffer_test.cc b/src/nanoarrow/buffer_test.cc
index 78c5bdc..80c6c39 100644
--- a/src/nanoarrow/buffer_test.cc
+++ b/src/nanoarrow/buffer_test.cc
@@ -230,7 +230,7 @@ TEST(BufferTest, BufferTestAppendHelpers) {
struct ArrowBufferView buffer_view;
buffer_view.data.data = "a";
- buffer_view.n_bytes = 1;
+ buffer_view.size_bytes = 1;
EXPECT_EQ(ArrowBufferAppendBufferView(&buffer, buffer_view), NANOARROW_OK);
EXPECT_EQ(reinterpret_cast<char*>(buffer.data)[0], 'a');
EXPECT_EQ(buffer.size_bytes, 1);
diff --git a/src/nanoarrow/nanoarrow.h b/src/nanoarrow/nanoarrow.h
index daa9c32..0c2b790 100644
--- a/src/nanoarrow/nanoarrow.h
+++ b/src/nanoarrow/nanoarrow.h
@@ -267,44 +267,42 @@ ArrowErrorCode ArrowSchemaSetTypeStruct(struct ArrowSchema* schema, int64_t n_ch
/// \brief Set the format field of a fixed-size schema
///
-/// Returns EINVAL for fixed_size <= 0 or for data_type that is not
+/// Returns EINVAL for fixed_size <= 0 or for type that is not
/// NANOARROW_TYPE_FIXED_SIZE_BINARY or NANOARROW_TYPE_FIXED_SIZE_LIST.
/// For NANOARROW_TYPE_FIXED_SIZE_LIST, the appropriate number of children are
/// allocated, initialized, and named; however, the caller must
/// ArrowSchemaSetType() the first child. Schema must have been initialized using
/// ArrowSchemaInit() or ArrowSchemaDeepCopy().
ArrowErrorCode ArrowSchemaSetTypeFixedSize(struct ArrowSchema* schema,
- enum ArrowType data_type, int32_t fixed_size);
+ enum ArrowType type, int32_t fixed_size);
/// \brief Set the format field of a decimal schema
///
-/// Returns EINVAL for scale <= 0 or for data_type that is not
+/// Returns EINVAL for scale <= 0 or for type that is not
/// NANOARROW_TYPE_DECIMAL128 or NANOARROW_TYPE_DECIMAL256. Schema must have been
/// initialized using ArrowSchemaInit() or ArrowSchemaDeepCopy().
-ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema,
- enum ArrowType data_type,
+ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema, enum ArrowType type,
int32_t decimal_precision,
int32_t decimal_scale);
/// \brief Set the format field of a time, timestamp, or duration schema
///
-/// Returns EINVAL for data_type that is not
+/// Returns EINVAL for type that is not
/// NANOARROW_TYPE_TIME32, NANOARROW_TYPE_TIME64,
/// NANOARROW_TYPE_TIMESTAMP, or NANOARROW_TYPE_DURATION. The
-/// timezone parameter must be NULL for a non-timestamp data_type. Schema must have been
+/// timezone parameter must be NULL for a non-timestamp type. Schema must have been
/// initialized using ArrowSchemaInit() or ArrowSchemaDeepCopy().
-ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema,
- enum ArrowType data_type,
+ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema, enum ArrowType type,
enum ArrowTimeUnit time_unit,
const char* timezone);
/// \brief Seet the format field of a union schema
///
-/// Returns EINVAL for a data_type that is not NANOARROW_TYPE_DENSE_UNION
+/// Returns EINVAL for a type that is not NANOARROW_TYPE_DENSE_UNION
/// or NANOARROW_TYPE_SPARSE_UNION. The specified number of children are
/// allocated, and initialized.
-ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema,
- enum ArrowType data_type, int64_t n_children);
+ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema, enum ArrowType type,
+ int64_t n_children);
/// \brief Make a (recursive) copy of a schema
///
@@ -433,14 +431,14 @@ struct ArrowSchemaView {
/// This value will never be NANOARROW_TYPE_EXTENSION (see
/// extension_name and/or extension_metadata to check for
/// an extension type).
- enum ArrowType data_type;
+ enum ArrowType type;
/// \brief The storage data type represented by the schema
///
/// This value will never be NANOARROW_TYPE_DICTIONARY, NANOARROW_TYPE_EXTENSION
/// or any datetime type. This value represents only the type required to
/// interpret the buffers in the array.
- enum ArrowType storage_data_type;
+ enum ArrowType storage_type;
/// \brief The storage layout represented by the schema
struct ArrowLayout layout;
@@ -493,15 +491,15 @@ struct ArrowSchemaView {
/// \brief Format timezone parameter
///
/// This value is set when parsing a timestamp type and represents
- /// the timezone format parameter. The ArrowStrintgView points to
- /// data within the schema and the value is undefined for other types.
- struct ArrowStringView timezone;
+ /// the timezone format parameter. This value points to
+ /// data within the schema and is undefined for other types.
+ const char* timezone;
/// \brief Union type ids parameter
///
/// This value is set when parsing a union type and represents
- /// type ids parameter. The ArrowStringView points to
- /// data within the schema and the value is undefined for other types.
+ /// type ids parameter. This value points to
+ /// data within the schema and is undefined for other types.
const char* union_type_ids;
};
@@ -906,10 +904,12 @@ void ArrowArrayViewReset(struct ArrowArrayView* array_view);
static inline int8_t ArrowArrayViewIsNull(struct ArrowArrayView* array_view, int64_t i);
/// \brief Get the type id of a union array element
-static inline int8_t ArrowArrayViewUnionTypeId(struct ArrowArrayView* array_view, int64_t i);
+static inline int8_t ArrowArrayViewUnionTypeId(struct ArrowArrayView* array_view,
+ int64_t i);
/// \brief Get the child index of a union array element
-static inline int8_t ArrowArrayViewUnionChildIndex(struct ArrowArrayView* array_view, int64_t i);
+static inline int8_t ArrowArrayViewUnionChildIndex(struct ArrowArrayView* array_view,
+ int64_t i);
/// \brief Get the index to use into the relevant union child array
static inline int64_t ArrowArrayViewUnionChildOffset(struct ArrowArrayView* array_view,
diff --git a/src/nanoarrow/nanoarrow_types.h b/src/nanoarrow/nanoarrow_types.h
index 291cfba..85f68c0 100644
--- a/src/nanoarrow/nanoarrow_types.h
+++ b/src/nanoarrow/nanoarrow_types.h
@@ -354,13 +354,13 @@ enum ArrowBufferType {
struct ArrowStringView {
/// \brief A pointer to the start of the string
///
- /// If n_bytes is 0, this value may be NULL.
+ /// If size_bytes is 0, this value may be NULL.
const char* data;
/// \brief The size of the string in bytes,
///
/// (Not including the null terminator.)
- int64_t n_bytes;
+ int64_t size_bytes;
};
/// \brief Return a view of a const C string
@@ -370,9 +370,9 @@ static inline struct ArrowStringView ArrowCharView(const char* value) {
out.data = value;
if (value) {
- out.n_bytes = (int64_t)strlen(value);
+ out.size_bytes = (int64_t)strlen(value);
} else {
- out.n_bytes = 0;
+ out.size_bytes = 0;
}
return out;
@@ -383,7 +383,7 @@ static inline struct ArrowStringView ArrowCharView(const char* value) {
struct ArrowBufferView {
/// \brief A pointer to the start of the buffer
///
- /// If n_bytes is 0, this value may be NULL.
+ /// If size_bytes is 0, this value may be NULL.
union {
const void* data;
const int8_t* as_int8;
@@ -400,7 +400,7 @@ struct ArrowBufferView {
} data;
/// \brief The size of the buffer in bytes
- int64_t n_bytes;
+ int64_t size_bytes;
};
/// \brief Array buffer allocation and deallocation
diff --git a/src/nanoarrow/schema.c b/src/nanoarrow/schema.c
index 664481c..115d270 100644
--- a/src/nanoarrow/schema.c
+++ b/src/nanoarrow/schema.c
@@ -63,8 +63,8 @@ static void ArrowSchemaRelease(struct ArrowSchema* schema) {
schema->release = NULL;
}
-static const char* ArrowSchemaFormatTemplate(enum ArrowType data_type) {
- switch (data_type) {
+static const char* ArrowSchemaFormatTemplate(enum ArrowType type) {
+ switch (type) {
case NANOARROW_TYPE_UNINITIALIZED:
return NULL;
case NANOARROW_TYPE_NA:
@@ -131,8 +131,8 @@ static const char* ArrowSchemaFormatTemplate(enum ArrowType data_type) {
}
static int ArrowSchemaInitChildrenIfNeeded(struct ArrowSchema* schema,
- enum ArrowType data_type) {
- switch (data_type) {
+ enum ArrowType type) {
+ switch (type) {
case NANOARROW_TYPE_LIST:
case NANOARROW_TYPE_LARGE_LIST:
case NANOARROW_TYPE_FIXED_SIZE_LIST:
@@ -172,22 +172,22 @@ void ArrowSchemaInit(struct ArrowSchema* schema) {
schema->release = &ArrowSchemaRelease;
}
-ArrowErrorCode ArrowSchemaSetType(struct ArrowSchema* schema, enum ArrowType data_type) {
+ArrowErrorCode ArrowSchemaSetType(struct ArrowSchema* schema, enum ArrowType type) {
// We don't allocate the dictionary because it has to be nullptr
// for non-dictionary-encoded arrays.
- // Set the format to a valid format string for data_type
- const char* template_format = ArrowSchemaFormatTemplate(data_type);
+ // Set the format to a valid format string for type
+ const char* template_format = ArrowSchemaFormatTemplate(type);
- // If data_type isn't recognized and not explicitly unset
- if (template_format == NULL && data_type != NANOARROW_TYPE_UNINITIALIZED) {
+ // If type isn't recognized and not explicitly unset
+ if (template_format == NULL && type != NANOARROW_TYPE_UNINITIALIZED) {
return EINVAL;
}
NANOARROW_RETURN_NOT_OK(ArrowSchemaSetFormat(schema, template_format));
// For types with an umabiguous child structure, allocate children
- return ArrowSchemaInitChildrenIfNeeded(schema, data_type);
+ return ArrowSchemaInitChildrenIfNeeded(schema, type);
}
ArrowErrorCode ArrowSchemaSetTypeStruct(struct ArrowSchema* schema, int64_t n_children) {
@@ -200,11 +200,10 @@ ArrowErrorCode ArrowSchemaSetTypeStruct(struct ArrowSchema* schema, int64_t n_ch
return NANOARROW_OK;
}
-ArrowErrorCode ArrowSchemaInitFromType(struct ArrowSchema* schema,
- enum ArrowType data_type) {
+ArrowErrorCode ArrowSchemaInitFromType(struct ArrowSchema* schema, enum ArrowType type) {
ArrowSchemaInit(schema);
- int result = ArrowSchemaSetType(schema, data_type);
+ int result = ArrowSchemaSetType(schema, type);
if (result != NANOARROW_OK) {
schema->release(schema);
return result;
@@ -214,14 +213,14 @@ ArrowErrorCode ArrowSchemaInitFromType(struct ArrowSchema* schema,
}
ArrowErrorCode ArrowSchemaSetTypeFixedSize(struct ArrowSchema* schema,
- enum ArrowType data_type, int32_t fixed_size) {
+ enum ArrowType type, int32_t fixed_size) {
if (fixed_size <= 0) {
return EINVAL;
}
char buffer[64];
int n_chars;
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_FIXED_SIZE_BINARY:
n_chars = snprintf(buffer, sizeof(buffer), "w:%d", (int)fixed_size);
break;
@@ -235,15 +234,14 @@ ArrowErrorCode ArrowSchemaSetTypeFixedSize(struct ArrowSchema* schema,
buffer[n_chars] = '\0';
NANOARROW_RETURN_NOT_OK(ArrowSchemaSetFormat(schema, buffer));
- if (data_type == NANOARROW_TYPE_FIXED_SIZE_LIST) {
- NANOARROW_RETURN_NOT_OK(ArrowSchemaInitChildrenIfNeeded(schema, data_type));
+ if (type == NANOARROW_TYPE_FIXED_SIZE_LIST) {
+ NANOARROW_RETURN_NOT_OK(ArrowSchemaInitChildrenIfNeeded(schema, type));
}
return NANOARROW_OK;
}
-ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema,
- enum ArrowType data_type,
+ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema, enum ArrowType type,
int32_t decimal_precision,
int32_t decimal_scale) {
if (decimal_precision <= 0) {
@@ -252,7 +250,7 @@ ArrowErrorCode ArrowSchemaSetTypeDecimal(struct ArrowSchema* schema,
char buffer[64];
int n_chars;
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_DECIMAL128:
n_chars =
snprintf(buffer, sizeof(buffer), "d:%d,%d", decimal_precision, decimal_scale);
@@ -284,8 +282,7 @@ static const char* ArrowTimeUnitFormatString(enum ArrowTimeUnit time_unit) {
}
}
-ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema,
- enum ArrowType data_type,
+ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema, enum ArrowType type,
enum ArrowTimeUnit time_unit,
const char* timezone) {
const char* time_unit_str = ArrowTimeUnitFormatString(time_unit);
@@ -295,7 +292,7 @@ ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema,
char buffer[128];
int n_chars;
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_TIME32:
case NANOARROW_TYPE_TIME64:
if (timezone != NULL) {
@@ -328,8 +325,8 @@ ArrowErrorCode ArrowSchemaSetTypeDateTime(struct ArrowSchema* schema,
return ArrowSchemaSetFormat(schema, buffer);
}
-ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema,
- enum ArrowType data_type, int64_t n_children) {
+ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema, enum ArrowType type,
+ int64_t n_children) {
if (n_children < 0 || n_children > 127) {
return EINVAL;
}
@@ -341,7 +338,7 @@ ArrowErrorCode ArrowSchemaSetTypeUnion(struct ArrowSchema* schema,
int n_chars;
char* format_cursor = format_out;
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_SPARSE_UNION:
n_chars = snprintf(format_cursor, format_out_size, "+us:");
format_cursor += n_chars;
@@ -540,9 +537,9 @@ ArrowErrorCode ArrowSchemaDeepCopy(struct ArrowSchema* schema,
}
static void ArrowSchemaViewSetPrimitive(struct ArrowSchemaView* schema_view,
- enum ArrowType data_type) {
- schema_view->data_type = data_type;
- schema_view->storage_data_type = data_type;
+ enum ArrowType type) {
+ schema_view->type = type;
+ schema_view->storage_type = type;
}
static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
@@ -557,8 +554,8 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
switch (format[0]) {
case 'n':
- schema_view->data_type = NANOARROW_TYPE_NA;
- schema_view->storage_data_type = NANOARROW_TYPE_NA;
+ schema_view->type = NANOARROW_TYPE_NA;
+ schema_view->storage_type = NANOARROW_TYPE_NA;
*format_end_out = format + 1;
return NANOARROW_OK;
case 'b':
@@ -658,8 +655,8 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
// validity + data
case 'w':
- schema_view->data_type = NANOARROW_TYPE_FIXED_SIZE_BINARY;
- schema_view->storage_data_type = NANOARROW_TYPE_FIXED_SIZE_BINARY;
+ schema_view->type = NANOARROW_TYPE_FIXED_SIZE_BINARY;
+ schema_view->storage_type = NANOARROW_TYPE_FIXED_SIZE_BINARY;
if (format[1] != ':' || format[2] == '\0') {
ArrowErrorSet(error, "Expected ':<width>' following 'w'");
return EINVAL;
@@ -670,25 +667,25 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
// validity + offset + data
case 'z':
- schema_view->data_type = NANOARROW_TYPE_BINARY;
- schema_view->storage_data_type = NANOARROW_TYPE_BINARY;
+ schema_view->type = NANOARROW_TYPE_BINARY;
+ schema_view->storage_type = NANOARROW_TYPE_BINARY;
*format_end_out = format + 1;
return NANOARROW_OK;
case 'u':
- schema_view->data_type = NANOARROW_TYPE_STRING;
- schema_view->storage_data_type = NANOARROW_TYPE_STRING;
+ schema_view->type = NANOARROW_TYPE_STRING;
+ schema_view->storage_type = NANOARROW_TYPE_STRING;
*format_end_out = format + 1;
return NANOARROW_OK;
// validity + large_offset + data
case 'Z':
- schema_view->data_type = NANOARROW_TYPE_LARGE_BINARY;
- schema_view->storage_data_type = NANOARROW_TYPE_LARGE_BINARY;
+ schema_view->type = NANOARROW_TYPE_LARGE_BINARY;
+ schema_view->storage_type = NANOARROW_TYPE_LARGE_BINARY;
*format_end_out = format + 1;
return NANOARROW_OK;
case 'U':
- schema_view->data_type = NANOARROW_TYPE_LARGE_STRING;
- schema_view->storage_data_type = NANOARROW_TYPE_LARGE_STRING;
+ schema_view->type = NANOARROW_TYPE_LARGE_STRING;
+ schema_view->storage_type = NANOARROW_TYPE_LARGE_STRING;
*format_end_out = format + 1;
return NANOARROW_OK;
@@ -697,15 +694,15 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
switch (format[1]) {
// list has validity + offset or offset
case 'l':
- schema_view->storage_data_type = NANOARROW_TYPE_LIST;
- schema_view->data_type = NANOARROW_TYPE_LIST;
+ schema_view->storage_type = NANOARROW_TYPE_LIST;
+ schema_view->type = NANOARROW_TYPE_LIST;
*format_end_out = format + 2;
return NANOARROW_OK;
// large list has validity + large_offset or large_offset
case 'L':
- schema_view->storage_data_type = NANOARROW_TYPE_LARGE_LIST;
- schema_view->data_type = NANOARROW_TYPE_LARGE_LIST;
+ schema_view->storage_type = NANOARROW_TYPE_LARGE_LIST;
+ schema_view->type = NANOARROW_TYPE_LARGE_LIST;
*format_end_out = format + 2;
return NANOARROW_OK;
@@ -716,19 +713,19 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
return EINVAL;
}
- schema_view->storage_data_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
- schema_view->data_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
+ schema_view->storage_type = NANOARROW_TYPE_FIXED_SIZE_LIST;
+ schema_view->type = NANOARROW_TYPE_FIXED_SIZE_LIST;
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;
- schema_view->data_type = NANOARROW_TYPE_STRUCT;
+ schema_view->storage_type = NANOARROW_TYPE_STRUCT;
+ schema_view->type = NANOARROW_TYPE_STRUCT;
*format_end_out = format + 2;
return NANOARROW_OK;
case 'm':
- schema_view->storage_data_type = NANOARROW_TYPE_MAP;
- schema_view->data_type = NANOARROW_TYPE_MAP;
+ schema_view->storage_type = NANOARROW_TYPE_MAP;
+ schema_view->type = NANOARROW_TYPE_MAP;
*format_end_out = format + 2;
return NANOARROW_OK;
@@ -736,12 +733,12 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
case 'u':
switch (format[2]) {
case 'd':
- schema_view->storage_data_type = NANOARROW_TYPE_DENSE_UNION;
- schema_view->data_type = NANOARROW_TYPE_DENSE_UNION;
+ schema_view->storage_type = NANOARROW_TYPE_DENSE_UNION;
+ schema_view->type = NANOARROW_TYPE_DENSE_UNION;
break;
case 's':
- schema_view->storage_data_type = NANOARROW_TYPE_SPARSE_UNION;
- schema_view->data_type = NANOARROW_TYPE_SPARSE_UNION;
+ schema_view->storage_type = NANOARROW_TYPE_SPARSE_UNION;
+ schema_view->type = NANOARROW_TYPE_SPARSE_UNION;
break;
default:
ArrowErrorSet(error,
@@ -787,12 +784,12 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
switch (format[2]) {
case 'D':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_DATE32;
+ schema_view->type = NANOARROW_TYPE_DATE32;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'm':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_DATE64;
+ schema_view->type = NANOARROW_TYPE_DATE64;
*format_end_out = format + 3;
return NANOARROW_OK;
default:
@@ -806,25 +803,25 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
switch (format[2]) {
case 's':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_TIME32;
+ schema_view->type = NANOARROW_TYPE_TIME32;
schema_view->time_unit = NANOARROW_TIME_UNIT_SECOND;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'm':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_TIME32;
+ schema_view->type = NANOARROW_TYPE_TIME32;
schema_view->time_unit = NANOARROW_TIME_UNIT_MILLI;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'u':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_TIME64;
+ schema_view->type = NANOARROW_TYPE_TIME64;
schema_view->time_unit = NANOARROW_TIME_UNIT_MICRO;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'n':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_TIME64;
+ schema_view->type = NANOARROW_TYPE_TIME64;
schema_view->time_unit = NANOARROW_TIME_UNIT_NANO;
*format_end_out = format + 3;
return NANOARROW_OK;
@@ -840,22 +837,22 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
switch (format[2]) {
case 's':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_TIMESTAMP;
+ schema_view->type = NANOARROW_TYPE_TIMESTAMP;
schema_view->time_unit = NANOARROW_TIME_UNIT_SECOND;
break;
case 'm':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_TIMESTAMP;
+ schema_view->type = NANOARROW_TYPE_TIMESTAMP;
schema_view->time_unit = NANOARROW_TIME_UNIT_MILLI;
break;
case 'u':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_TIMESTAMP;
+ schema_view->type = NANOARROW_TYPE_TIMESTAMP;
schema_view->time_unit = NANOARROW_TIME_UNIT_MICRO;
break;
case 'n':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_TIMESTAMP;
+ schema_view->type = NANOARROW_TYPE_TIMESTAMP;
schema_view->time_unit = NANOARROW_TIME_UNIT_NANO;
break;
default:
@@ -871,8 +868,7 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
return EINVAL;
}
- schema_view->timezone.data = format + 4;
- schema_view->timezone.n_bytes = strlen(format + 4);
+ schema_view->timezone = format + 4;
*format_end_out = format + strlen(format);
return NANOARROW_OK;
@@ -881,25 +877,25 @@ static ArrowErrorCode ArrowSchemaViewParse(struct ArrowSchemaView* schema_view,
switch (format[2]) {
case 's':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_DURATION;
+ schema_view->type = NANOARROW_TYPE_DURATION;
schema_view->time_unit = NANOARROW_TIME_UNIT_SECOND;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'm':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT32);
- schema_view->data_type = NANOARROW_TYPE_DURATION;
+ schema_view->type = NANOARROW_TYPE_DURATION;
schema_view->time_unit = NANOARROW_TIME_UNIT_MILLI;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'u':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_DURATION;
+ schema_view->type = NANOARROW_TYPE_DURATION;
schema_view->time_unit = NANOARROW_TIME_UNIT_MICRO;
*format_end_out = format + 3;
return NANOARROW_OK;
case 'n':
ArrowSchemaViewSetPrimitive(schema_view, NANOARROW_TYPE_INT64);
- schema_view->data_type = NANOARROW_TYPE_DURATION;
+ schema_view->type = NANOARROW_TYPE_DURATION;
schema_view->time_unit = NANOARROW_TIME_UNIT_NANO;
*format_end_out = format + 3;
return NANOARROW_OK;
@@ -1001,7 +997,7 @@ static ArrowErrorCode ArrowSchemaViewValidateMap(struct ArrowSchemaView* schema_
static ArrowErrorCode ArrowSchemaViewValidateDictionary(
struct ArrowSchemaView* schema_view, struct ArrowError* error) {
// check for valid index type
- switch (schema_view->storage_data_type) {
+ switch (schema_view->storage_type) {
case NANOARROW_TYPE_UINT8:
case NANOARROW_TYPE_INT8:
case NANOARROW_TYPE_UINT16:
@@ -1025,9 +1021,9 @@ static ArrowErrorCode ArrowSchemaViewValidateDictionary(
}
static ArrowErrorCode ArrowSchemaViewValidate(struct ArrowSchemaView* schema_view,
- enum ArrowType data_type,
+ enum ArrowType type,
struct ArrowError* error) {
- switch (data_type) {
+ switch (type) {
case NANOARROW_TYPE_NA:
case NANOARROW_TYPE_BOOL:
case NANOARROW_TYPE_UINT8:
@@ -1086,7 +1082,7 @@ static ArrowErrorCode ArrowSchemaViewValidate(struct ArrowSchemaView* schema_vie
default:
ArrowErrorSet(error, "Expected a valid enum ArrowType value but found %d",
- (int)schema_view->data_type);
+ (int)schema_view->type);
return EINVAL;
}
@@ -1131,7 +1127,7 @@ ArrowErrorCode ArrowSchemaViewInit(struct ArrowSchemaView* schema_view,
memcpy(child_error, ArrowErrorMessage(error), 1024);
ArrowErrorSet(error, "Error parsing schema->format: %s", child_error);
}
-
+
return result;
}
@@ -1142,25 +1138,25 @@ ArrowErrorCode ArrowSchemaViewInit(struct ArrowSchemaView* schema_view,
}
if (schema->dictionary != NULL) {
- schema_view->data_type = NANOARROW_TYPE_DICTIONARY;
+ schema_view->type = NANOARROW_TYPE_DICTIONARY;
}
- result = ArrowSchemaViewValidate(schema_view, schema_view->storage_data_type, error);
+ result = ArrowSchemaViewValidate(schema_view, schema_view->storage_type, error);
if (result != NANOARROW_OK) {
return result;
}
- if (schema_view->storage_data_type != schema_view->data_type) {
- result = ArrowSchemaViewValidate(schema_view, schema_view->data_type, error);
+ if (schema_view->storage_type != schema_view->type) {
+ result = ArrowSchemaViewValidate(schema_view, schema_view->type, error);
if (result != NANOARROW_OK) {
return result;
}
}
- ArrowLayoutInit(&schema_view->layout, schema_view->storage_data_type);
- if (schema_view->storage_data_type == NANOARROW_TYPE_FIXED_SIZE_BINARY) {
+ ArrowLayoutInit(&schema_view->layout, schema_view->storage_type);
+ if (schema_view->storage_type == NANOARROW_TYPE_FIXED_SIZE_BINARY) {
schema_view->layout.element_size_bits[1] = schema_view->fixed_size * 8;
- } else if (schema_view->storage_data_type == NANOARROW_TYPE_FIXED_SIZE_LIST) {
+ } else if (schema_view->storage_type == NANOARROW_TYPE_FIXED_SIZE_LIST) {
schema_view->layout.child_size_elements = schema_view->fixed_size;
}
@@ -1176,17 +1172,16 @@ ArrowErrorCode ArrowSchemaViewInit(struct ArrowSchemaView* schema_view,
static int64_t ArrowSchemaTypeToStringInternal(struct ArrowSchemaView* schema_view,
char* out, int64_t n) {
- const char* type_string = ArrowTypeString(schema_view->data_type);
- switch (schema_view->data_type) {
+ const char* type_string = ArrowTypeString(schema_view->type);
+ switch (schema_view->type) {
case NANOARROW_TYPE_DECIMAL128:
case NANOARROW_TYPE_DECIMAL256:
return snprintf(out, n, "%s(%d, %d)", type_string,
(int)schema_view->decimal_precision,
(int)schema_view->decimal_scale);
case NANOARROW_TYPE_TIMESTAMP:
- return snprintf(out, n, "%s('%s', '%.*s')", type_string,
- ArrowTimeUnitString(schema_view->time_unit),
- (int)schema_view->timezone.n_bytes, schema_view->timezone.data);
+ return snprintf(out, n, "%s('%s', '%s')", type_string,
+ ArrowTimeUnitString(schema_view->time_unit), schema_view->timezone);
case NANOARROW_TYPE_TIME32:
case NANOARROW_TYPE_TIME64:
case NANOARROW_TYPE_DURATION:
@@ -1222,23 +1217,24 @@ int64_t ArrowSchemaToString(struct ArrowSchema* schema, char* out, int64_t n,
// Extension type and dictionary should include both the top-level type
// and the storage type.
- int is_extension = schema_view.extension_name.n_bytes > 0;
+ int is_extension = schema_view.extension_name.size_bytes > 0;
int is_dictionary = schema->dictionary != NULL;
int64_t n_chars = 0;
int64_t n_chars_last = 0;
// Uncommon but not technically impossible that both are true
if (is_extension && is_dictionary) {
- n_chars_last = snprintf(
- out + n_chars, n, "%.*s{dictionary(%s)<", (int)schema_view.extension_name.n_bytes,
- schema_view.extension_name.data, ArrowTypeString(schema_view.storage_data_type));
+ n_chars_last = snprintf(out + n_chars, n, "%.*s{dictionary(%s)<",
+ (int)schema_view.extension_name.size_bytes,
+ schema_view.extension_name.data,
+ ArrowTypeString(schema_view.storage_type));
} else if (is_extension) {
n_chars_last =
- snprintf(out + n_chars, n, "%.*s{", (int)schema_view.extension_name.n_bytes,
+ snprintf(out + n_chars, n, "%.*s{", (int)schema_view.extension_name.size_bytes,
schema_view.extension_name.data);
} else if (is_dictionary) {
n_chars_last = snprintf(out + n_chars, n, "dictionary(%s)<",
- ArrowTypeString(schema_view.storage_data_type));
+ ArrowTypeString(schema_view.storage_type));
}
n_chars += n_chars_last;
@@ -1346,7 +1342,7 @@ ArrowErrorCode ArrowMetadataReaderRead(struct ArrowMetadataReader* reader,
pos += sizeof(int32_t);
key_out->data = reader->metadata + reader->offset + pos;
- key_out->n_bytes = key_size;
+ key_out->size_bytes = key_size;
pos += key_size;
int32_t value_size;
@@ -1354,7 +1350,7 @@ ArrowErrorCode ArrowMetadataReaderRead(struct ArrowMetadataReader* reader,
pos += sizeof(int32_t);
value_out->data = reader->metadata + reader->offset + pos;
- value_out->n_bytes = value_size;
+ value_out->size_bytes = value_size;
pos += value_size;
reader->offset += pos;
@@ -1374,7 +1370,7 @@ int64_t ArrowMetadataSizeOf(const char* metadata) {
int64_t size = sizeof(int32_t);
while (ArrowMetadataReaderRead(&reader, &key, &value) == NANOARROW_OK) {
- size += sizeof(int32_t) + key.n_bytes + sizeof(int32_t) + value.n_bytes;
+ size += sizeof(int32_t) + key.size_bytes + sizeof(int32_t) + value.size_bytes;
}
return size;
@@ -1390,11 +1386,11 @@ static ArrowErrorCode ArrowMetadataGetValueInternal(const char* metadata,
while (ArrowMetadataReaderRead(&reader, &existing_key, &existing_value) ==
NANOARROW_OK) {
- int key_equal = key->n_bytes == existing_key.n_bytes &&
- strncmp(key->data, existing_key.data, existing_key.n_bytes) == 0;
+ int key_equal = key->size_bytes == existing_key.size_bytes &&
+ strncmp(key->data, existing_key.data, existing_key.size_bytes) == 0;
if (key_equal) {
value_out->data = existing_value.data;
- value_out->n_bytes = existing_value.n_bytes;
+ value_out->size_bytes = existing_value.size_bytes;
break;
}
}
@@ -1441,8 +1437,8 @@ static ArrowErrorCode ArrowMetadataBuilderAppendInternal(struct ArrowBuffer* buf
int32_t n_keys;
memcpy(&n_keys, buffer->data, sizeof(int32_t));
- int32_t key_size = (int32_t)key->n_bytes;
- int32_t value_size = (int32_t)value->n_bytes;
+ int32_t key_size = (int32_t)key->size_bytes;
+ int32_t value_size = (int32_t)value->size_bytes;
NANOARROW_RETURN_NOT_OK(ArrowBufferReserve(
buffer, sizeof(int32_t) + key_size + sizeof(int32_t) + value_size));
@@ -1490,9 +1486,9 @@ static ArrowErrorCode ArrowMetadataBuilderSetInternal(struct ArrowBuffer* buffer
return result;
}
- if (key->n_bytes == existing_key.n_bytes &&
+ if (key->size_bytes == existing_key.size_bytes &&
strncmp((const char*)key->data, (const char*)existing_key.data,
- existing_key.n_bytes) == 0) {
+ existing_key.size_bytes) == 0) {
result = ArrowMetadataBuilderAppendInternal(&new_buffer, key, value);
value = NULL;
} else {
diff --git a/src/nanoarrow/schema_test.cc b/src/nanoarrow/schema_test.cc
index 211715d..1f8573d 100644
--- a/src/nanoarrow/schema_test.cc
+++ b/src/nanoarrow/schema_test.cc
@@ -56,10 +56,10 @@ TEST(SchemaTest, SchemaInit) {
schema.release(&schema);
}
-static void ExpectSchemaInitOk(enum ArrowType data_type,
+static void ExpectSchemaInitOk(enum ArrowType type,
std::shared_ptr<DataType> expected_arrow_type) {
struct ArrowSchema schema;
- EXPECT_EQ(ArrowSchemaInitFromType(&schema, data_type), NANOARROW_OK);
+ EXPECT_EQ(ArrowSchemaInitFromType(&schema, type), NANOARROW_OK);
auto arrow_type = ImportType(&schema);
ARROW_EXPECT_OK(arrow_type);
EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(expected_arrow_type));
@@ -548,8 +548,8 @@ void ExpectSimpleTypeOk(std::shared_ptr<DataType> arrow_t, enum ArrowType nanoar
ARROW_EXPECT_OK(ExportType(*arrow_t, &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, nanoarrow_t);
- EXPECT_EQ(schema_view.storage_data_type, nanoarrow_t);
+ EXPECT_EQ(schema_view.type, nanoarrow_t);
+ EXPECT_EQ(schema_view.storage_type, nanoarrow_t);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_DATA);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_NONE);
@@ -569,8 +569,8 @@ TEST(SchemaViewTest, SchemaViewInitSimple) {
ARROW_EXPECT_OK(ExportType(*null(), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_NA);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_NA);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_NA);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_NA);
EXPECT_EQ(schema_view.extension_name.data, nullptr);
EXPECT_EQ(schema_view.extension_metadata.data, nullptr);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "na");
@@ -611,8 +611,8 @@ TEST(SchemaViewTest, SchemaViewInitDecimal) {
ARROW_EXPECT_OK(ExportType(*decimal128(5, 6), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_DECIMAL128);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_DECIMAL128);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DECIMAL128);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_DECIMAL128);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_DATA);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_NONE);
@@ -627,8 +627,8 @@ TEST(SchemaViewTest, SchemaViewInitDecimal) {
ARROW_EXPECT_OK(ExportType(*decimal256(5, 6), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_DECIMAL256);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_DECIMAL256);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DECIMAL256);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_DECIMAL256);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_DATA);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_NONE);
@@ -694,8 +694,8 @@ TEST(SchemaViewTest, SchemaViewInitBinaryAndString) {
ARROW_EXPECT_OK(ExportType(*fixed_size_binary(123), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_FIXED_SIZE_BINARY);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_FIXED_SIZE_BINARY);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_FIXED_SIZE_BINARY);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_FIXED_SIZE_BINARY);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_DATA);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_NONE);
@@ -708,8 +708,8 @@ TEST(SchemaViewTest, SchemaViewInitBinaryAndString) {
ARROW_EXPECT_OK(ExportType(*utf8(), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_STRING);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_STRING);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_STRING);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_STRING);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_DATA_OFFSET);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_DATA);
@@ -721,8 +721,8 @@ TEST(SchemaViewTest, SchemaViewInitBinaryAndString) {
ARROW_EXPECT_OK(ExportType(*binary(), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_BINARY);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_BINARY);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_BINARY);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_BINARY);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_DATA_OFFSET);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_DATA);
@@ -734,8 +734,8 @@ TEST(SchemaViewTest, SchemaViewInitBinaryAndString) {
ARROW_EXPECT_OK(ExportType(*large_binary(), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_LARGE_BINARY);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_LARGE_BINARY);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_LARGE_BINARY);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_LARGE_BINARY);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_DATA_OFFSET);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_DATA);
@@ -747,8 +747,8 @@ TEST(SchemaViewTest, SchemaViewInitBinaryAndString) {
ARROW_EXPECT_OK(ExportType(*large_utf8(), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_LARGE_STRING);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_LARGE_STRING);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_LARGE_STRING);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_LARGE_STRING);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_DATA_OFFSET);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_DATA);
@@ -795,15 +795,15 @@ TEST(SchemaViewTest, SchemaViewInitTimeDate) {
ARROW_EXPECT_OK(ExportType(*date32(), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_DATE32);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT32);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DATE32);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT32);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "date32");
schema.release(&schema);
ARROW_EXPECT_OK(ExportType(*date64(), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_DATE64);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT64);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DATE64);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT64);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "date64");
schema.release(&schema);
}
@@ -815,32 +815,32 @@ TEST(SchemaViewTest, SchemaViewInitTimeTime) {
ARROW_EXPECT_OK(ExportType(*time32(TimeUnit::SECOND), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_TIME32);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT32);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_TIME32);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT32);
EXPECT_EQ(schema_view.time_unit, NANOARROW_TIME_UNIT_SECOND);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "time32('s')");
schema.release(&schema);
ARROW_EXPECT_OK(ExportType(*time32(TimeUnit::MILLI), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_TIME32);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT32);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_TIME32);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT32);
EXPECT_EQ(schema_view.time_unit, NANOARROW_TIME_UNIT_MILLI);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "time32('ms')");
schema.release(&schema);
ARROW_EXPECT_OK(ExportType(*time64(TimeUnit::MICRO), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_TIME64);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT64);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_TIME64);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT64);
EXPECT_EQ(schema_view.time_unit, NANOARROW_TIME_UNIT_MICRO);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "time64('us')");
schema.release(&schema);
ARROW_EXPECT_OK(ExportType(*time64(TimeUnit::NANO), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_TIME64);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT64);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_TIME64);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT64);
EXPECT_EQ(schema_view.time_unit, NANOARROW_TIME_UNIT_NANO);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "time64('ns')");
schema.release(&schema);
@@ -853,33 +853,37 @@ TEST(SchemaViewTest, SchemaViewInitTimeTimestamp) {
ARROW_EXPECT_OK(ExportType(*timestamp(TimeUnit::SECOND, "America/Halifax"), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_TIMESTAMP);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT32);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_TIMESTAMP);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT32);
EXPECT_EQ(schema_view.time_unit, NANOARROW_TIME_UNIT_SECOND);
+ EXPECT_STREQ(schema_view.timezone, "America/Halifax");
EXPECT_EQ(ArrowSchemaToStdString(&schema), "timestamp('s', 'America/Halifax')");
schema.release(&schema);
ARROW_EXPECT_OK(ExportType(*timestamp(TimeUnit::MILLI, "America/Halifax"), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_TIMESTAMP);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT32);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_TIMESTAMP);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT32);
EXPECT_EQ(schema_view.time_unit, NANOARROW_TIME_UNIT_MILLI);
+ EXPECT_STREQ(schema_view.timezone, "America/Halifax");
EXPECT_EQ(ArrowSchemaToStdString(&schema), "timestamp('ms', 'America/Halifax')");
schema.release(&schema);
ARROW_EXPECT_OK(ExportType(*timestamp(TimeUnit::MICRO, "America/Halifax"), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_TIMESTAMP);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT64);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_TIMESTAMP);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT64);
EXPECT_EQ(schema_view.time_unit, NANOARROW_TIME_UNIT_MICRO);
+ EXPECT_STREQ(schema_view.timezone, "America/Halifax");
EXPECT_EQ(ArrowSchemaToStdString(&schema), "timestamp('us', 'America/Halifax')");
schema.release(&schema);
ARROW_EXPECT_OK(ExportType(*timestamp(TimeUnit::NANO, "America/Halifax"), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_TIMESTAMP);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT64);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_TIMESTAMP);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT64);
EXPECT_EQ(schema_view.time_unit, NANOARROW_TIME_UNIT_NANO);
+ EXPECT_STREQ(schema_view.timezone, "America/Halifax");
EXPECT_EQ(ArrowSchemaToStdString(&schema), "timestamp('ns', 'America/Halifax')");
schema.release(&schema);
}
@@ -891,32 +895,32 @@ TEST(SchemaViewTest, SchemaViewInitTimeDuration) {
ARROW_EXPECT_OK(ExportType(*duration(TimeUnit::SECOND), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_DURATION);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT32);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DURATION);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT32);
EXPECT_EQ(schema_view.time_unit, NANOARROW_TIME_UNIT_SECOND);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "duration('s')");
schema.release(&schema);
ARROW_EXPECT_OK(ExportType(*duration(TimeUnit::MILLI), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_DURATION);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT32);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DURATION);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT32);
EXPECT_EQ(schema_view.time_unit, NANOARROW_TIME_UNIT_MILLI);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "duration('ms')");
schema.release(&schema);
ARROW_EXPECT_OK(ExportType(*duration(TimeUnit::MICRO), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_DURATION);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT64);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DURATION);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT64);
EXPECT_EQ(schema_view.time_unit, NANOARROW_TIME_UNIT_MICRO);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "duration('us')");
schema.release(&schema);
ARROW_EXPECT_OK(ExportType(*duration(TimeUnit::NANO), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_DURATION);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT64);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DURATION);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT64);
EXPECT_EQ(schema_view.time_unit, NANOARROW_TIME_UNIT_NANO);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "duration('ns')");
schema.release(&schema);
@@ -929,22 +933,22 @@ TEST(SchemaViewTest, SchemaViewInitTimeInterval) {
ARROW_EXPECT_OK(ExportType(*month_interval(), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_INTERVAL_MONTHS);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INTERVAL_MONTHS);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_INTERVAL_MONTHS);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INTERVAL_MONTHS);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "interval_months");
schema.release(&schema);
ARROW_EXPECT_OK(ExportType(*day_time_interval(), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_INTERVAL_DAY_TIME);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INTERVAL_DAY_TIME);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_INTERVAL_DAY_TIME);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INTERVAL_DAY_TIME);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "interval_day_time");
schema.release(&schema);
ARROW_EXPECT_OK(ExportType(*month_day_nano_interval(), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "interval_month_day_nano");
schema.release(&schema);
}
@@ -1006,8 +1010,8 @@ TEST(SchemaViewTest, SchemaViewInitNestedList) {
ARROW_EXPECT_OK(ExportType(*list(int32()), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_LIST);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_LIST);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_LIST);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_LIST);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_DATA_OFFSET);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_NONE);
@@ -1019,8 +1023,8 @@ TEST(SchemaViewTest, SchemaViewInitNestedList) {
ARROW_EXPECT_OK(ExportType(*large_list(int32()), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_LARGE_LIST);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_LARGE_LIST);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_LARGE_LIST);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_LARGE_LIST);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_DATA_OFFSET);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_NONE);
@@ -1032,8 +1036,8 @@ TEST(SchemaViewTest, SchemaViewInitNestedList) {
ARROW_EXPECT_OK(ExportType(*fixed_size_list(int32(), 123), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_FIXED_SIZE_LIST);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_FIXED_SIZE_LIST);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_FIXED_SIZE_LIST);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_FIXED_SIZE_LIST);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_NONE);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_NONE);
@@ -1078,8 +1082,8 @@ TEST(SchemaViewTest, SchemaViewInitNestedStruct) {
ARROW_EXPECT_OK(
ExportType(*struct_({field("col1", int32()), field("col2", int64())}), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_STRUCT);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_STRUCT);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_STRUCT);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_STRUCT);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_NONE);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_NONE);
@@ -1189,8 +1193,8 @@ TEST(SchemaViewTest, SchemaViewInitNestedUnion) {
ARROW_EXPECT_OK(ExportType(*dense_union({field("col", int32())}), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_DENSE_UNION);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_DENSE_UNION);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DENSE_UNION);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_DENSE_UNION);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_TYPE_ID);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_UNION_OFFSET);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_NONE);
@@ -1203,8 +1207,8 @@ TEST(SchemaViewTest, SchemaViewInitNestedUnion) {
ARROW_EXPECT_OK(ExportType(*sparse_union({field("col", int32())}), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_SPARSE_UNION);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_SPARSE_UNION);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_SPARSE_UNION);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_SPARSE_UNION);
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_TYPE_ID);
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_NONE);
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_NONE);
@@ -1274,8 +1278,8 @@ TEST(SchemaViewTest, SchemaViewInitDictionary) {
ARROW_EXPECT_OK(ExportType(*dictionary(int32(), utf8()), &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT32);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_DICTIONARY);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT32);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DICTIONARY);
EXPECT_EQ(ArrowSchemaToStdString(&schema), "dictionary(int32)<string>");
schema.release(&schema);
}
@@ -1315,10 +1319,10 @@ TEST(SchemaViewTest, SchemaViewInitExtension) {
ARROW_EXPECT_OK(ExportField(*int_field, &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
EXPECT_EQ(
- std::string(schema_view.extension_name.data, schema_view.extension_name.n_bytes),
+ std::string(schema_view.extension_name.data, schema_view.extension_name.size_bytes),
"arrow.test.ext_name");
EXPECT_EQ(std::string(schema_view.extension_metadata.data,
- schema_view.extension_metadata.n_bytes),
+ schema_view.extension_metadata.size_bytes),
"test metadata");
EXPECT_EQ(ArrowSchemaToStdString(&schema), "arrow.test.ext_name{int32}");
@@ -1337,13 +1341,13 @@ TEST(SchemaViewTest, SchemaViewInitExtensionDictionary) {
auto int_field = field("field_name", dictionary(int32(), utf8()), arrow_meta);
ARROW_EXPECT_OK(ExportField(*int_field, &schema));
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
- EXPECT_EQ(schema_view.data_type, NANOARROW_TYPE_DICTIONARY);
- EXPECT_EQ(schema_view.storage_data_type, NANOARROW_TYPE_INT32);
+ EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DICTIONARY);
+ EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_INT32);
EXPECT_EQ(
- std::string(schema_view.extension_name.data, schema_view.extension_name.n_bytes),
+ std::string(schema_view.extension_name.data, schema_view.extension_name.size_bytes),
"arrow.test.ext_name");
EXPECT_EQ(std::string(schema_view.extension_metadata.data,
- schema_view.extension_metadata.n_bytes),
+ schema_view.extension_metadata.size_bytes),
"test metadata");
EXPECT_EQ(ArrowSchemaToStdString(&schema),
"arrow.test.ext_name{dictionary(int32)<string>}");
@@ -1397,12 +1401,12 @@ TEST(MetadataTest, Metadata) {
struct ArrowStringView value = ArrowCharView("default_val");
EXPECT_EQ(ArrowMetadataGetValue(simple_metadata, ArrowCharView("key"), &value),
NANOARROW_OK);
- EXPECT_EQ(std::string(value.data, value.n_bytes), "value");
+ EXPECT_EQ(std::string(value.data, value.size_bytes), "value");
value = ArrowCharView("default_val");
EXPECT_EQ(ArrowMetadataGetValue(simple_metadata, ArrowCharView("not_a_key"), &value),
NANOARROW_OK);
- EXPECT_EQ(std::string(value.data, value.n_bytes), "default_val");
+ EXPECT_EQ(std::string(value.data, value.size_bytes), "default_val");
}
TEST(MetadataTest, MetadataBuild) {
@@ -1449,7 +1453,7 @@ TEST(MetadataTest, MetadataBuild) {
ASSERT_EQ(ArrowMetadataGetValue((const char*)metadata_builder.data,
ArrowCharView("key2"), &value),
NANOARROW_OK);
- EXPECT_EQ(std::string(value.data, value.n_bytes), "value2");
+ EXPECT_EQ(std::string(value.data, value.size_bytes), "value2");
// Set an existing key
ASSERT_EQ(ArrowMetadataBuilderSet(&metadata_builder, ArrowCharView("key"),
@@ -1459,12 +1463,12 @@ TEST(MetadataTest, MetadataBuild) {
ASSERT_EQ(ArrowMetadataGetValue((const char*)metadata_builder.data,
ArrowCharView("key"), &value),
NANOARROW_OK);
- EXPECT_EQ(std::string(value.data, value.n_bytes), "value3");
+ EXPECT_EQ(std::string(value.data, value.size_bytes), "value3");
value = ArrowCharView(nullptr);
ASSERT_EQ(ArrowMetadataGetValue((const char*)metadata_builder.data,
ArrowCharView("key2"), &value),
NANOARROW_OK);
- EXPECT_EQ(std::string(value.data, value.n_bytes), "value2");
+ EXPECT_EQ(std::string(value.data, value.size_bytes), "value2");
// Remove a key that does exist
ASSERT_EQ(ArrowMetadataBuilderRemove(&metadata_builder, ArrowCharView("key")),
@@ -1475,7 +1479,7 @@ TEST(MetadataTest, MetadataBuild) {
ASSERT_EQ(ArrowMetadataGetValue((const char*)metadata_builder.data,
ArrowCharView("key2"), &value),
NANOARROW_OK);
- EXPECT_EQ(std::string(value.data, value.n_bytes), "value2");
+ EXPECT_EQ(std::string(value.data, value.size_bytes), "value2");
ArrowBufferReset(&metadata_builder);
}