Skip to content

Commit 2d97757

Browse files
zeroshadezeroshade
committed
first round of tests
1 parent 61c74d6 commit 2d97757

File tree

4 files changed

+222
-2
lines changed

4 files changed

+222
-2
lines changed

‎src/nanoarrow/common/array_test.cc

Lines changed: 154 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1182,6 +1182,86 @@ TEST(ArrayTest, ArrayTestAppendToIntervalArrayMonthDayNano) {
11821182
EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe()));
11831183
}
11841184

1185+
TEST(ArrayTest, ArrayTestAppendToDecimal32Array) {
1186+
struct ArrowArray array;
1187+
struct ArrowDecimal decimal;
1188+
1189+
ArrowDecimalInit(&decimal, 32, 8, 3);
1190+
ASSERT_EQ(ArrowArrayInitFromType(&array, NANOARROW_TYPE_DECIMAL32), NANOARROW_OK);
1191+
EXPECT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
1192+
1193+
ArrowDecimalSetInt(&decimal, 12345);
1194+
EXPECT_EQ(ArrowArrayAppendDecimal(&array, &decimal), NANOARROW_OK);
1195+
1196+
EXPECT_EQ(ArrowArrayAppendNull(&array, 2), NANOARROW_OK);
1197+
1198+
ArrowDecimalSetInt(&decimal, -67890);
1199+
EXPECT_EQ(ArrowArrayAppendDecimal(&array, &decimal), NANOARROW_OK);
1200+
1201+
EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
1202+
EXPECT_EQ(array.length, 4);
1203+
EXPECT_EQ(array.null_count, 2);
1204+
auto validity_buffer = reinterpret_cast<const uint8_t*>(array.buffers[0]);
1205+
auto data_buffer = reinterpret_cast<const uint8_t*>(array.buffers[1]);
1206+
EXPECT_EQ(validity_buffer[0], 0b00001001);
1207+
1208+
ArrowDecimalSetInt(&decimal, 12345);
1209+
EXPECT_EQ(memcmp(data_buffer, decimal.words, 4), 0);
1210+
ArrowDecimalSetInt(&decimal, -67890);
1211+
EXPECT_EQ(memcmp(data_buffer + 3 * 4, decimal.words, 4), 0);
1212+
1213+
auto arrow_array = ImportArray(&array, decimal32(8, 3));
1214+
ARROW_EXPECT_OK(arrow_array);
1215+
1216+
auto builder = Decimal32Builder(decimal32(8, 3));
1217+
ARROW_EXPECT_OK(builder.Append(*Decimal32::FromString("12.345")));
1218+
ARROW_EXPECT_OK(builder.AppendNulls(2));
1219+
ARROW_EXPECT_OK(builder.Append(*Decimal32::FromString("-67.890")));
1220+
auto expected_array = builder.Finish();
1221+
1222+
EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe()));
1223+
}
1224+
1225+
TEST(ArrayTest, ArrayTestAppendToDecimal64Array) {
1226+
struct ArrowArray array;
1227+
struct ArrowDecimal decimal;
1228+
1229+
ArrowDecimalInit(&decimal, 64, 10, 3);
1230+
ASSERT_EQ(ArrowArrayInitFromType(&array, NANOARROW_TYPE_DECIMAL64), NANOARROW_OK);
1231+
EXPECT_EQ(ArrowArrayStartAppending(&array), NANOARROW_OK);
1232+
1233+
ArrowDecimalSetInt(&decimal, 12345);
1234+
EXPECT_EQ(ArrowArrayAppendDecimal(&array, &decimal), NANOARROW_OK);
1235+
1236+
EXPECT_EQ(ArrowArrayAppendNull(&array, 2), NANOARROW_OK);
1237+
1238+
ArrowDecimalSetInt(&decimal, -67890);
1239+
EXPECT_EQ(ArrowArrayAppendDecimal(&array, &decimal), NANOARROW_OK);
1240+
1241+
EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
1242+
EXPECT_EQ(array.length, 4);
1243+
EXPECT_EQ(array.null_count, 2);
1244+
auto validity_buffer = reinterpret_cast<const uint8_t*>(array.buffers[0]);
1245+
auto data_buffer = reinterpret_cast<const uint8_t*>(array.buffers[1]);
1246+
EXPECT_EQ(validity_buffer[0], 0b00001001);
1247+
1248+
ArrowDecimalSetInt(&decimal, 12345);
1249+
EXPECT_EQ(memcmp(data_buffer, decimal.words, 8), 0);
1250+
ArrowDecimalSetInt(&decimal, -67890);
1251+
EXPECT_EQ(memcmp(data_buffer + 3 * 8, decimal.words, 8), 0);
1252+
1253+
auto arrow_array = ImportArray(&array, decimal64(10, 3));
1254+
ARROW_EXPECT_OK(arrow_array);
1255+
1256+
auto builder = Decimal64Builder(decimal64(10, 3));
1257+
ARROW_EXPECT_OK(builder.Append(*Decimal64::FromString("12.345")));
1258+
ARROW_EXPECT_OK(builder.AppendNulls(2));
1259+
ARROW_EXPECT_OK(builder.Append(*Decimal64::FromString("-67.890")));
1260+
auto expected_array = builder.Finish();
1261+
1262+
EXPECT_TRUE(arrow_array.ValueUnsafe()->Equals(expected_array.ValueUnsafe()));
1263+
}
1264+
11851265
TEST(ArrayTest, ArrayTestAppendToDecimal128Array) {
11861266
struct ArrowArray array;
11871267
struct ArrowDecimal decimal;
@@ -3707,6 +3787,80 @@ TEST(ArrayViewTest, ArrayViewTestGetIntervalMonthDayNano) {
37073787
ArrowArrayRelease(&array);
37083788
}
37093789

3790+
TEST(ArrayViewTest, ArrayViewTestGetDecimal32) {
3791+
struct ArrowArray array;
3792+
struct ArrowSchema schema;
3793+
struct ArrowArrayView array_view;
3794+
struct ArrowError error;
3795+
3796+
auto type = decimal32(8, 3);
3797+
3798+
// Array with nulls
3799+
auto builder = Decimal32Builder(type);
3800+
ARROW_EXPECT_OK(builder.Append(*Decimal32::FromReal(1.234, 8, 3)));
3801+
ARROW_EXPECT_OK(builder.AppendNulls(2));
3802+
ARROW_EXPECT_OK(builder.Append(*Decimal32::FromReal(-5.678, 8, 3)));
3803+
auto maybe_arrow_array = builder.Finish();
3804+
ARROW_EXPECT_OK(maybe_arrow_array);
3805+
auto arrow_array = maybe_arrow_array.ValueUnsafe();
3806+
3807+
ARROW_EXPECT_OK(ExportArray(*arrow_array, &array, &schema));
3808+
ASSERT_EQ(ArrowArrayViewInitFromSchema(&array_view, &schema, &error), NANOARROW_OK);
3809+
ASSERT_EQ(ArrowArrayViewSetArray(&array_view, &array, &error), NANOARROW_OK);
3810+
EXPECT_EQ(ArrowArrayViewValidate(&array_view, NANOARROW_VALIDATION_LEVEL_FULL, &error),
3811+
NANOARROW_OK);
3812+
3813+
ArrowDecimal decimal;
3814+
ArrowDecimalInit(&decimal, 32, 8, 3);
3815+
3816+
ArrowArrayViewGetDecimalUnsafe(&array_view, 0, &decimal);
3817+
EXPECT_EQ(ArrowDecimalGetIntUnsafe(&decimal), 1234);
3818+
3819+
ArrowArrayViewGetDecimalUnsafe(&array_view, 3, &decimal);
3820+
EXPECT_EQ(ArrowDecimalGetIntUnsafe(&decimal), -5678);
3821+
3822+
ArrowArrayViewReset(&array_view);
3823+
ArrowSchemaRelease(&schema);
3824+
ArrowArrayRelease(&array);
3825+
}
3826+
3827+
TEST(ArrayViewTest, ArrayViewTestGetDecimal64) {
3828+
struct ArrowArray array;
3829+
struct ArrowSchema schema;
3830+
struct ArrowArrayView array_view;
3831+
struct ArrowError error;
3832+
3833+
auto type = decimal64(10, 3);
3834+
3835+
// Array with nulls
3836+
auto builder = Decimal64Builder(type);
3837+
ARROW_EXPECT_OK(builder.Append(*Decimal64::FromReal(1.234, 10, 3)));
3838+
ARROW_EXPECT_OK(builder.AppendNulls(2));
3839+
ARROW_EXPECT_OK(builder.Append(*Decimal64::FromReal(-5.678, 10, 3)));
3840+
auto maybe_arrow_array = builder.Finish();
3841+
ARROW_EXPECT_OK(maybe_arrow_array);
3842+
auto arrow_array = maybe_arrow_array.ValueUnsafe();
3843+
3844+
ARROW_EXPECT_OK(ExportArray(*arrow_array, &array, &schema));
3845+
ASSERT_EQ(ArrowArrayViewInitFromSchema(&array_view, &schema, &error), NANOARROW_OK);
3846+
ASSERT_EQ(ArrowArrayViewSetArray(&array_view, &array, &error), NANOARROW_OK);
3847+
EXPECT_EQ(ArrowArrayViewValidate(&array_view, NANOARROW_VALIDATION_LEVEL_FULL, &error),
3848+
NANOARROW_OK);
3849+
3850+
ArrowDecimal decimal;
3851+
ArrowDecimalInit(&decimal, 64, 10, 3);
3852+
3853+
ArrowArrayViewGetDecimalUnsafe(&array_view, 0, &decimal);
3854+
EXPECT_EQ(ArrowDecimalGetIntUnsafe(&decimal), 1234);
3855+
3856+
ArrowArrayViewGetDecimalUnsafe(&array_view, 3, &decimal);
3857+
EXPECT_EQ(ArrowDecimalGetIntUnsafe(&decimal), -5678);
3858+
3859+
ArrowArrayViewReset(&array_view);
3860+
ArrowSchemaRelease(&schema);
3861+
ArrowArrayRelease(&array);
3862+
}
3863+
37103864
TEST(ArrayViewTest, ArrayViewTestGetDecimal128) {
37113865
struct ArrowArray array;
37123866
struct ArrowSchema schema;

‎src/nanoarrow/common/inline_array.h

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1283,6 +1283,12 @@ static inline void ArrowArrayViewGetDecimalUnsafe(const struct ArrowArrayView* a
12831283
i += array_view->offset;
12841284
const uint8_t* data_view = array_view->buffer_views[1].data.as_uint8;
12851285
switch (array_view->storage_type) {
1286+
case NANOARROW_TYPE_DECIMAL32:
1287+
memcpy(out->words, data_view + (i * 4), 4);
1288+
break;
1289+
case NANOARROW_TYPE_DECIMAL64:
1290+
memcpy(out->words, data_view + (i * 8), 8);
1291+
break;
12861292
case NANOARROW_TYPE_DECIMAL128:
12871293
ArrowDecimalSetBytes(out, data_view + (i * 16));
12881294
break;

‎src/nanoarrow/common/inline_types.h

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -512,6 +512,10 @@ static inline const char* ArrowTypeString(enum ArrowType type) {
512512
return "interval_months";
513513
case NANOARROW_TYPE_INTERVAL_DAY_TIME:
514514
return "interval_day_time";
515+
case NANOARROW_TYPE_DECIMAL32:
516+
return "decimal32";
517+
case NANOARROW_TYPE_DECIMAL64:
518+
return "decimal64";
515519
case NANOARROW_TYPE_DECIMAL128:
516520
return "decimal128";
517521
case NANOARROW_TYPE_DECIMAL256:
@@ -954,7 +958,7 @@ static inline void ArrowDecimalGetBytes(const struct ArrowDecimal* decimal,
954958
/// \ingroup nanoarrow-utils
955959
static inline int64_t ArrowDecimalSign(const struct ArrowDecimal* decimal) {
956960
if (decimal->n_words == 0) {
957-
return 1 | ((int32_t)decimal->words[0] >> 31);
961+
return (int64_t)(1 | ((int32_t)(decimal->words[0]) >> 31));
958962
}
959963

960964
return 1 | ((int64_t)(decimal->words[decimal->high_word_index]) >> 63);
@@ -981,7 +985,9 @@ static inline void ArrowDecimalSetInt(struct ArrowDecimal* decimal, int64_t valu
981985
/// \ingroup nanoarrow-utils
982986
static inline void ArrowDecimalNegate(struct ArrowDecimal* decimal) {
983987
if (decimal->n_words == 0) {
984-
decimal->words[0] = -(int32_t)decimal->words[0];
988+
uint32_t elem = (uint32_t)decimal->words[0];
989+
elem = ~elem + 1;
990+
decimal->words[0] = (int32_t)elem;
985991
return;
986992
}
987993

‎src/nanoarrow/common/schema_test.cc

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -224,6 +224,22 @@ TEST(SchemaTest, SchemaInitDecimal) {
224224
arrow_type = ImportType(&schema);
225225
ARROW_EXPECT_OK(arrow_type);
226226
EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(decimal256(3, 4)));
227+
228+
ArrowSchemaInit(&schema);
229+
EXPECT_EQ(ArrowSchemaSetTypeDecimal(&schema, NANOARROW_TYPE_DECIMAL32, 3, 4),
230+
NANOARROW_OK);
231+
EXPECT_STREQ(schema.format, "d:3,4,32");
232+
arrow_type = ImportType(&schema);
233+
ARROW_EXPECT_OK(arrow_type);
234+
EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(decimal32(3, 4)));
235+
236+
ArrowSchemaInit(&schema);
237+
EXPECT_EQ(ArrowSchemaSetTypeDecimal(&schema, NANOARROW_TYPE_DECIMAL64, 3, 4),
238+
NANOARROW_OK);
239+
EXPECT_STREQ(schema.format, "d:3,4,64");
240+
arrow_type = ImportType(&schema);
241+
ARROW_EXPECT_OK(arrow_type);
242+
EXPECT_TRUE(arrow_type.ValueUnsafe()->Equals(decimal64(3, 4)));
227243
}
228244

229245
TEST(SchemaTest, SchemaInitRunEndEncoded) {
@@ -743,6 +759,44 @@ TEST(SchemaViewTest, SchemaViewInitDecimal) {
743759
struct ArrowSchemaView schema_view;
744760
struct ArrowError error;
745761

762+
ARROW_EXPECT_OK(ExportType(*decimal32(5, 6), &schema));
763+
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
764+
EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DECIMAL32);
765+
EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_DECIMAL32);
766+
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
767+
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_DATA);
768+
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_NONE);
769+
EXPECT_EQ(schema_view.layout.buffer_data_type[0], NANOARROW_TYPE_BOOL);
770+
EXPECT_EQ(schema_view.layout.buffer_data_type[1], NANOARROW_TYPE_DECIMAL32);
771+
EXPECT_EQ(schema_view.layout.buffer_data_type[2], NANOARROW_TYPE_UNINITIALIZED);
772+
EXPECT_EQ(schema_view.layout.element_size_bits[0], 1);
773+
EXPECT_EQ(schema_view.layout.element_size_bits[1], 32);
774+
EXPECT_EQ(schema_view.layout.element_size_bits[2], 0);
775+
EXPECT_EQ(schema_view.decimal_bitwidth, 32);
776+
EXPECT_EQ(schema_view.decimal_precision, 5);
777+
EXPECT_EQ(schema_view.decimal_scale, 6);
778+
EXPECT_EQ(ArrowSchemaToStdString(&schema), "decimal32(5, 6)");
779+
ArrowSchemaRelease(&schema);
780+
781+
ARROW_EXPECT_OK(ExportType(*decimal64(5, 6), &schema));
782+
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
783+
EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DECIMAL64);
784+
EXPECT_EQ(schema_view.storage_type, NANOARROW_TYPE_DECIMAL64);
785+
EXPECT_EQ(schema_view.layout.buffer_type[0], NANOARROW_BUFFER_TYPE_VALIDITY);
786+
EXPECT_EQ(schema_view.layout.buffer_type[1], NANOARROW_BUFFER_TYPE_DATA);
787+
EXPECT_EQ(schema_view.layout.buffer_type[2], NANOARROW_BUFFER_TYPE_NONE);
788+
EXPECT_EQ(schema_view.layout.buffer_data_type[0], NANOARROW_TYPE_BOOL);
789+
EXPECT_EQ(schema_view.layout.buffer_data_type[1], NANOARROW_TYPE_DECIMAL64);
790+
EXPECT_EQ(schema_view.layout.buffer_data_type[2], NANOARROW_TYPE_UNINITIALIZED);
791+
EXPECT_EQ(schema_view.layout.element_size_bits[0], 1);
792+
EXPECT_EQ(schema_view.layout.element_size_bits[1], 64);
793+
EXPECT_EQ(schema_view.layout.element_size_bits[2], 0);
794+
EXPECT_EQ(schema_view.decimal_bitwidth, 64);
795+
EXPECT_EQ(schema_view.decimal_precision, 5);
796+
EXPECT_EQ(schema_view.decimal_scale, 6);
797+
EXPECT_EQ(ArrowSchemaToStdString(&schema), "decimal64(5, 6)");
798+
ArrowSchemaRelease(&schema);
799+
746800
ARROW_EXPECT_OK(ExportType(*decimal128(5, 6), &schema));
747801
EXPECT_EQ(ArrowSchemaViewInit(&schema_view, &schema, &error), NANOARROW_OK);
748802
EXPECT_EQ(schema_view.type, NANOARROW_TYPE_DECIMAL128);

0 commit comments

Comments
 (0)