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/05/11 12:13:20 UTC
[arrow-nanoarrow] branch main updated: Fix Windows build for newer MSVC (#191)
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 cc4041a Fix Windows build for newer MSVC (#191)
cc4041a is described below
commit cc4041a57f2e8db5907c128e21c72947fdd539ce
Author: Dewey Dunnington <de...@dunnington.ca>
AuthorDate: Thu May 11 08:13:15 2023 -0400
Fix Windows build for newer MSVC (#191)
...and also fix the MSVC warnings, while I have an MSVC build on hand.
---
CMakeLists.txt | 18 ++++++++++--------
src/nanoarrow/array.c | 2 +-
src/nanoarrow/array_inline.h | 24 ++++++++++++------------
src/nanoarrow/array_test.cc | 24 ++++++++++++------------
4 files changed, 35 insertions(+), 33 deletions(-)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4a72f2c..a6849fd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -168,6 +168,16 @@ if(NANOARROW_BUILD_TESTS)
cmake_policy(SET CMP0135 NEW)
endif()
+ # On Windows, dynamically linking Arrow is difficult to get right,
+ # so use static linking by default. GTest needs to use shared C runtime
+ # when using MSVC.
+ if (MSVC)
+ set(gtest_force_shared_crt on)
+ set(NANOARROW_ARROW_TARGET arrow_static)
+ else()
+ set(NANOARROW_ARROW_TARGET arrow_shared)
+ endif()
+
# Use an old version of googletest if we have to to support gcc 4.8
if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR
CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "5.0.0")
@@ -199,14 +209,6 @@ if(NANOARROW_BUILD_TESTS)
target_link_libraries(nanoarrow coverage_config)
endif()
- # On Windows, dynamically linking Arrow is difficult to get right,
- # so use static linking by default.
- if (MSVC)
- set(NANOARROW_ARROW_TARGET arrow_static)
- else()
- set(NANOARROW_ARROW_TARGET arrow_shared)
- endif()
-
target_link_libraries(utils_test nanoarrow gtest_main ${NANOARROW_ARROW_TARGET} coverage_config)
target_link_libraries(buffer_test nanoarrow gtest_main coverage_config)
target_link_libraries(array_test nanoarrow gtest_main ${NANOARROW_ARROW_TARGET} coverage_config)
diff --git a/src/nanoarrow/array.c b/src/nanoarrow/array.c
index 403b4b0..cd6a639 100644
--- a/src/nanoarrow/array.c
+++ b/src/nanoarrow/array.c
@@ -938,7 +938,7 @@ ArrowErrorCode ArrowArrayViewValidateFull(struct ArrowArrayView* array_view,
array_view->union_type_id_map, array_view->n_children,
array_view->n_children)) {
NANOARROW_RETURN_NOT_OK(ArrowAssertRangeInt8(array_view->buffer_views[0], 0,
- array_view->n_children - 1, error));
+ (int8_t)(array_view->n_children - 1), error));
} else {
NANOARROW_RETURN_NOT_OK(ArrowAssertInt8In(array_view->buffer_views[0],
array_view->union_type_id_map + 128,
diff --git a/src/nanoarrow/array_inline.h b/src/nanoarrow/array_inline.h
index 397c7ce..27bd738 100644
--- a/src/nanoarrow/array_inline.h
+++ b/src/nanoarrow/array_inline.h
@@ -76,7 +76,7 @@ static inline int8_t _ArrowParseUnionTypeIds(const char* type_ids, int8_t* out)
}
if (out != NULL) {
- out[i] = type_id;
+ out[i] = (int8_t)type_id;
}
i++;
@@ -349,10 +349,10 @@ static inline ArrowErrorCode ArrowArrayAppendInt(struct ArrowArray* array,
_NANOARROW_CHECK_RANGE(value, 0, INT64_MAX);
return ArrowArrayAppendUInt(array, value);
case NANOARROW_TYPE_DOUBLE:
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendDouble(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendDouble(data_buffer, (double)value));
break;
case NANOARROW_TYPE_FLOAT:
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendFloat(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendFloat(data_buffer, (float)value));
break;
case NANOARROW_TYPE_BOOL:
NANOARROW_RETURN_NOT_OK(_ArrowArrayAppendBits(array, 1, value != 0, 1));
@@ -399,10 +399,10 @@ static inline ArrowErrorCode ArrowArrayAppendUInt(struct ArrowArray* array,
_NANOARROW_CHECK_RANGE(value, 0, INT64_MAX);
return ArrowArrayAppendInt(array, value);
case NANOARROW_TYPE_DOUBLE:
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendDouble(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendDouble(data_buffer, (double)value));
break;
case NANOARROW_TYPE_FLOAT:
- NANOARROW_RETURN_NOT_OK(ArrowBufferAppendFloat(data_buffer, value));
+ NANOARROW_RETURN_NOT_OK(ArrowBufferAppendFloat(data_buffer, (float)value));
break;
case NANOARROW_TYPE_BOOL:
NANOARROW_RETURN_NOT_OK(_ArrowArrayAppendBits(array, 1, value != 0, 1));
@@ -465,7 +465,7 @@ static inline ArrowErrorCode ArrowArrayAppendBytes(struct ArrowArray* array,
return EINVAL;
}
- offset += value.size_bytes;
+ offset += (int32_t)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.size_bytes));
@@ -722,9 +722,9 @@ static inline int64_t ArrowArrayViewGetIntUnsafe(struct ArrowArrayView* array_vi
case NANOARROW_TYPE_UINT8:
return data_view->data.as_uint8[i];
case NANOARROW_TYPE_DOUBLE:
- return data_view->data.as_double[i];
+ return (int64_t)data_view->data.as_double[i];
case NANOARROW_TYPE_FLOAT:
- return data_view->data.as_float[i];
+ return (int64_t)data_view->data.as_float[i];
case NANOARROW_TYPE_BOOL:
return ArrowBitGet(data_view->data.as_uint8, i);
default:
@@ -754,9 +754,9 @@ static inline uint64_t ArrowArrayViewGetUIntUnsafe(struct ArrowArrayView* array_
case NANOARROW_TYPE_UINT8:
return data_view->data.as_uint8[i];
case NANOARROW_TYPE_DOUBLE:
- return data_view->data.as_double[i];
+ return (uint64_t)data_view->data.as_double[i];
case NANOARROW_TYPE_FLOAT:
- return data_view->data.as_float[i];
+ return (uint64_t)data_view->data.as_float[i];
case NANOARROW_TYPE_BOOL:
return ArrowBitGet(data_view->data.as_uint8, i);
default:
@@ -770,9 +770,9 @@ static inline double ArrowArrayViewGetDoubleUnsafe(struct ArrowArrayView* array_
struct ArrowBufferView* data_view = &array_view->buffer_views[1];
switch (array_view->storage_type) {
case NANOARROW_TYPE_INT64:
- return data_view->data.as_int64[i];
+ return (double)data_view->data.as_int64[i];
case NANOARROW_TYPE_UINT64:
- return data_view->data.as_uint64[i];
+ return (double)data_view->data.as_uint64[i];
case NANOARROW_TYPE_INT32:
return data_view->data.as_int32[i];
case NANOARROW_TYPE_UINT32:
diff --git a/src/nanoarrow/array_test.cc b/src/nanoarrow/array_test.cc
index 4b27bda..149a9e3 100644
--- a/src/nanoarrow/array_test.cc
+++ b/src/nanoarrow/array_test.cc
@@ -651,7 +651,7 @@ TEST(ArrayTest, ArrayTestAppendToDoubleArray) {
EXPECT_EQ(ArrowArrayAppendNull(&array, 2), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendUInt(&array, 3), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendDouble(&array, 3.14), NANOARROW_OK);
- EXPECT_EQ(ArrowArrayAppendDouble(&array, std::numeric_limits<double>::max()),
+ EXPECT_EQ(ArrowArrayAppendDouble(&array, std::numeric_limits<float>::max()),
NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendDouble(&array, NAN), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendDouble(&array, INFINITY), NANOARROW_OK);
@@ -671,13 +671,13 @@ TEST(ArrayTest, ArrayTestAppendToDoubleArray) {
EXPECT_EQ(data_buffer[2], 0);
EXPECT_EQ(data_buffer[3], 3);
EXPECT_DOUBLE_EQ(data_buffer[4], 3.14);
- EXPECT_FLOAT_EQ(data_buffer[4], 3.14);
- EXPECT_FLOAT_EQ(data_buffer[5], std::numeric_limits<double>::max());
+ EXPECT_FLOAT_EQ(static_cast<float>(data_buffer[4]), static_cast<float>(3.14));
+ EXPECT_FLOAT_EQ(static_cast<float>(data_buffer[5]), std::numeric_limits<float>::max());
EXPECT_TRUE(std::isnan(data_buffer[6])) << data_buffer[6];
- EXPECT_FLOAT_EQ(data_buffer[7], INFINITY);
- EXPECT_FLOAT_EQ(data_buffer[8], -INFINITY);
- EXPECT_FLOAT_EQ(data_buffer[9], -1);
- EXPECT_FLOAT_EQ(data_buffer[10], 0);
+ EXPECT_FLOAT_EQ(static_cast<float>(data_buffer[7]), INFINITY);
+ EXPECT_FLOAT_EQ(static_cast<float>(data_buffer[8]), -INFINITY);
+ EXPECT_FLOAT_EQ(static_cast<float>(data_buffer[9]), -1);
+ EXPECT_FLOAT_EQ(static_cast<float>(data_buffer[10]), 0);
auto arrow_array = ImportArray(&array, float64());
ARROW_EXPECT_OK(arrow_array);
@@ -687,7 +687,7 @@ TEST(ArrayTest, ArrayTestAppendToDoubleArray) {
ARROW_EXPECT_OK(builder.AppendNulls(2));
ARROW_EXPECT_OK(builder.Append(3));
ARROW_EXPECT_OK(builder.Append(3.14));
- ARROW_EXPECT_OK(builder.Append(std::numeric_limits<double>::max()));
+ ARROW_EXPECT_OK(builder.Append(std::numeric_limits<float>::max()));
ARROW_EXPECT_OK(builder.Append(NAN));
ARROW_EXPECT_OK(builder.Append(INFINITY));
ARROW_EXPECT_OK(builder.Append(-INFINITY));
@@ -708,7 +708,7 @@ TEST(ArrayTest, ArrayTestAppendToFloatArray) {
EXPECT_EQ(ArrowArrayAppendNull(&array, 2), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendUInt(&array, 3), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendDouble(&array, 3.14), NANOARROW_OK);
- EXPECT_EQ(ArrowArrayAppendDouble(&array, std::numeric_limits<double>::max()),
+ EXPECT_EQ(ArrowArrayAppendDouble(&array, std::numeric_limits<float>::max()),
NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendDouble(&array, NAN), NANOARROW_OK);
EXPECT_EQ(ArrowArrayAppendDouble(&array, INFINITY), NANOARROW_OK);
@@ -727,7 +727,7 @@ TEST(ArrayTest, ArrayTestAppendToFloatArray) {
EXPECT_EQ(data_buffer[1], 0);
EXPECT_EQ(data_buffer[2], 0);
EXPECT_EQ(data_buffer[3], 3);
- EXPECT_FLOAT_EQ(data_buffer[4], 3.14);
+ EXPECT_FLOAT_EQ(data_buffer[4], static_cast<float>(3.14));
EXPECT_FLOAT_EQ(data_buffer[5], std::numeric_limits<float>::max());
EXPECT_TRUE(std::isnan(data_buffer[6])) << data_buffer[6];
EXPECT_FLOAT_EQ(data_buffer[7], INFINITY);
@@ -742,8 +742,8 @@ TEST(ArrayTest, ArrayTestAppendToFloatArray) {
ARROW_EXPECT_OK(builder.Append(1));
ARROW_EXPECT_OK(builder.AppendNulls(2));
ARROW_EXPECT_OK(builder.Append(3));
- ARROW_EXPECT_OK(builder.Append(3.14));
- ARROW_EXPECT_OK(builder.Append(std::numeric_limits<double>::max()));
+ ARROW_EXPECT_OK(builder.Append(static_cast<float>(3.14)));
+ ARROW_EXPECT_OK(builder.Append(std::numeric_limits<float>::max()));
ARROW_EXPECT_OK(builder.Append(NAN));
ARROW_EXPECT_OK(builder.Append(INFINITY));
ARROW_EXPECT_OK(builder.Append(-INFINITY));