in python/pyarrow/src/arrow/python/gdb.cc [74:506]
void TestSession() {
// We define local variables for all types for which we want to test
// pretty-printing.
// Then, at the end of this function, we trap to the debugger, so that
// test instrumentation can print values from this frame by interacting
// with the debugger.
// The test instrumentation is in pyarrow/tests/test_gdb.py
#ifdef __clang__
_Pragma("clang diagnostic push");
_Pragma("clang diagnostic ignored \"-Wunused-variable\"");
#elif defined(__GNUC__)
_Pragma("GCC diagnostic push");
_Pragma("GCC diagnostic ignored \"-Wunused-variable\"");
#endif
arrow::DummyFunction();
// Status & Result
auto ok_status = Status::OK();
auto error_status = Status::IOError("This is an error");
auto error_detail_status =
error_status.WithDetail(std::make_shared<CustomStatusDetail>());
auto ok_result = Result<int>(42);
auto error_result = Result<int>(error_status);
auto error_detail_result = Result<int>(error_detail_status);
// String views
std::string_view string_view_abc{"abc"};
std::string special_chars = std::string("foo\"bar") + '\x00' + "\r\n\t\x1f";
std::string_view string_view_special_chars(special_chars);
// Buffers
Buffer buffer_null{nullptr, 0};
Buffer buffer_abc{string_view_abc};
Buffer buffer_special_chars{string_view_special_chars};
char mutable_array[3] = {'a', 'b', 'c'};
MutableBuffer buffer_mutable{reinterpret_cast<uint8_t*>(mutable_array), 3};
auto heap_buffer = std::make_shared<Buffer>(string_view_abc);
auto heap_buffer_mutable = *AllocateBuffer(buffer_abc.size());
memcpy(heap_buffer_mutable->mutable_data(), buffer_abc.data(), buffer_abc.size());
// KeyValueMetadata
auto empty_metadata = key_value_metadata({}, {});
auto metadata = key_value_metadata(
{"key_text", "key_binary"}, {"some value", std::string("z") + '\x00' + "\x1f\xff"});
// Decimals
Decimal128 decimal128_zero{};
Decimal128 decimal128_pos{"98765432109876543210987654321098765432"};
Decimal128 decimal128_neg{"-98765432109876543210987654321098765432"};
BasicDecimal128 basic_decimal128_zero{};
BasicDecimal128 basic_decimal128_pos{decimal128_pos.native_endian_array()};
BasicDecimal128 basic_decimal128_neg{decimal128_neg.native_endian_array()};
Decimal256 decimal256_zero{};
Decimal256 decimal256_pos{
"9876543210987654321098765432109876543210987654321098765432109876543210987654"};
Decimal256 decimal256_neg{
"-9876543210987654321098765432109876543210987654321098765432109876543210987654"};
BasicDecimal256 basic_decimal256_zero{};
BasicDecimal256 basic_decimal256_pos{decimal256_pos.native_endian_array()};
BasicDecimal256 basic_decimal256_neg{decimal256_neg.native_endian_array()};
// Data types
NullType null_type;
auto heap_null_type = null();
BooleanType bool_type;
auto heap_bool_type = boolean();
Date32Type date32_type;
Date64Type date64_type;
Time32Type time_type_s(TimeUnit::SECOND);
Time32Type time_type_ms(TimeUnit::MILLI);
Time64Type time_type_us(TimeUnit::MICRO);
Time64Type time_type_ns(TimeUnit::NANO);
auto heap_time_type_ns = time64(TimeUnit::NANO);
TimestampType timestamp_type_s(TimeUnit::SECOND);
TimestampType timestamp_type_ms_timezone(TimeUnit::MILLI, "Europe/Paris");
TimestampType timestamp_type_us(TimeUnit::MICRO);
TimestampType timestamp_type_ns_timezone(TimeUnit::NANO, "Europe/Paris");
auto heap_timestamp_type_ns_timezone = timestamp(TimeUnit::NANO, "Europe/Paris");
DayTimeIntervalType day_time_interval_type;
MonthIntervalType month_interval_type;
MonthDayNanoIntervalType month_day_nano_interval_type;
DurationType duration_type_s(TimeUnit::SECOND);
DurationType duration_type_ns(TimeUnit::NANO);
BinaryType binary_type;
StringType string_type;
LargeBinaryType large_binary_type;
LargeStringType large_string_type;
FixedSizeBinaryType fixed_size_binary_type(10);
auto heap_fixed_size_binary_type = fixed_size_binary(10);
Decimal128Type decimal128_type(16, 5);
Decimal256Type decimal256_type(42, 12);
auto heap_decimal128_type = decimal128(16, 5);
ListType list_type(uint8());
LargeListType large_list_type(large_utf8());
auto heap_list_type = list(uint8());
auto heap_large_list_type = large_list(large_utf8());
FixedSizeListType fixed_size_list_type(float64(), 3);
auto heap_fixed_size_list_type = fixed_size_list(float64(), 3);
DictionaryType dict_type_unordered(int16(), utf8());
DictionaryType dict_type_ordered(int16(), utf8(), /*ordered=*/true);
auto heap_dict_type = dictionary(int16(), utf8());
MapType map_type_unsorted(utf8(), binary());
MapType map_type_sorted(utf8(), binary(), /*keys_sorted=*/true);
auto heap_map_type = map(utf8(), binary());
StructType struct_type_empty({});
StructType struct_type(
{field("ints", int8()), field("strs", utf8(), /*nullable=*/false)});
auto heap_struct_type =
struct_({field("ints", int8()), field("strs", utf8(), /*nullable=*/false)});
std::vector<int8_t> union_type_codes({7, 42});
FieldVector union_fields(
{field("ints", int8()), field("strs", utf8(), /*nullable=*/false)});
SparseUnionType sparse_union_type(union_fields, union_type_codes);
DenseUnionType dense_union_type(union_fields, union_type_codes);
UuidType uuid_type{};
std::shared_ptr<DataType> heap_uuid_type = std::make_shared<UuidType>();
// Schema
auto schema_empty = schema({});
auto schema_non_empty = schema({field("ints", int8()), field("strs", utf8())});
auto schema_with_metadata = schema_non_empty->WithMetadata(
key_value_metadata({"key1", "key2"}, {"value1", "value2"}));
// Fields
Field int_field("ints", int64());
Field float_field("floats", float32(), /*nullable=*/false);
auto heap_int_field = field("ints", int64());
// Scalars
NullScalar null_scalar;
auto heap_null_scalar = MakeNullScalar(null());
BooleanScalar bool_scalar_null{};
BooleanScalar bool_scalar{true};
auto heap_bool_scalar = *MakeScalar(boolean(), true);
Int8Scalar int8_scalar_null{};
UInt8Scalar uint8_scalar_null{};
Int64Scalar int64_scalar_null{};
UInt64Scalar uint64_scalar_null{};
Int8Scalar int8_scalar{-42};
UInt8Scalar uint8_scalar{234};
Int64Scalar int64_scalar{-9223372036854775807LL - 1};
UInt64Scalar uint64_scalar{18446744073709551615ULL};
HalfFloatScalar half_float_scalar{48640}; // -1.5
FloatScalar float_scalar{1.25f};
DoubleScalar double_scalar{2.5};
Time32Scalar time_scalar_s{100, TimeUnit::SECOND};
Time32Scalar time_scalar_ms{1000, TimeUnit::MILLI};
Time64Scalar time_scalar_us{10000, TimeUnit::MICRO};
Time64Scalar time_scalar_ns{100000, TimeUnit::NANO};
Time64Scalar time_scalar_null{time64(TimeUnit::NANO)};
DurationScalar duration_scalar_s{-100, TimeUnit::SECOND};
DurationScalar duration_scalar_ms{-1000, TimeUnit::MILLI};
DurationScalar duration_scalar_us{-10000, TimeUnit::MICRO};
DurationScalar duration_scalar_ns{-100000, TimeUnit::NANO};
DurationScalar duration_scalar_null{duration(TimeUnit::NANO)};
TimestampScalar timestamp_scalar_s{12345, timestamp(TimeUnit::SECOND)};
TimestampScalar timestamp_scalar_ms{-123456, timestamp(TimeUnit::MILLI)};
TimestampScalar timestamp_scalar_us{1234567, timestamp(TimeUnit::MICRO)};
TimestampScalar timestamp_scalar_ns{-12345678, timestamp(TimeUnit::NANO)};
TimestampScalar timestamp_scalar_null{timestamp(TimeUnit::NANO)};
TimestampScalar timestamp_scalar_s_tz{12345,
timestamp(TimeUnit::SECOND, "Europe/Paris")};
TimestampScalar timestamp_scalar_ms_tz{-123456,
timestamp(TimeUnit::MILLI, "Europe/Paris")};
TimestampScalar timestamp_scalar_us_tz{1234567,
timestamp(TimeUnit::MICRO, "Europe/Paris")};
TimestampScalar timestamp_scalar_ns_tz{-12345678,
timestamp(TimeUnit::NANO, "Europe/Paris")};
TimestampScalar timestamp_scalar_null_tz{timestamp(TimeUnit::NANO, "Europe/Paris")};
MonthIntervalScalar month_interval_scalar{23};
MonthIntervalScalar month_interval_scalar_null{};
DayTimeIntervalScalar day_time_interval_scalar{{23, -456}};
DayTimeIntervalScalar day_time_interval_scalar_null{};
MonthDayNanoIntervalScalar month_day_nano_interval_scalar{{1, 23, -456}};
MonthDayNanoIntervalScalar month_day_nano_interval_scalar_null{};
Date32Scalar date32_scalar{23};
Date32Scalar date32_scalar_null{};
Date64Scalar date64_scalar{45 * 86400000LL};
Date64Scalar date64_scalar_null{};
Decimal128Scalar decimal128_scalar_pos_scale_pos{Decimal128("1234567"),
decimal128(10, 4)};
Decimal128Scalar decimal128_scalar_pos_scale_neg{Decimal128("-1234567"),
decimal128(10, 4)};
Decimal128Scalar decimal128_scalar_neg_scale_pos{Decimal128("1234567"),
decimal128(10, -4)};
Decimal128Scalar decimal128_scalar_neg_scale_neg{Decimal128("-1234567"),
decimal128(10, -4)};
Decimal128Scalar decimal128_scalar_null{decimal128(10, 4)};
auto heap_decimal128_scalar = *MakeScalar(decimal128(10, 4), Decimal128("1234567"));
Decimal256Scalar decimal256_scalar_pos_scale_pos{
Decimal256("1234567890123456789012345678901234567890123456"), decimal256(50, 4)};
Decimal256Scalar decimal256_scalar_pos_scale_neg{
Decimal256("-1234567890123456789012345678901234567890123456"), decimal256(50, 4)};
Decimal256Scalar decimal256_scalar_neg_scale_pos{
Decimal256("1234567890123456789012345678901234567890123456"), decimal256(50, -4)};
Decimal256Scalar decimal256_scalar_neg_scale_neg{
Decimal256("-1234567890123456789012345678901234567890123456"), decimal256(50, -4)};
Decimal256Scalar decimal256_scalar_null{decimal256(50, 4)};
auto heap_decimal256_scalar = *MakeScalar(
decimal256(50, 4), Decimal256("1234567890123456789012345678901234567890123456"));
BinaryScalar binary_scalar_null{};
BinaryScalar binary_scalar_unallocated{std::shared_ptr<Buffer>{nullptr}};
BinaryScalar binary_scalar_empty{Buffer::FromString("")};
BinaryScalar binary_scalar_abc{Buffer::FromString("abc")};
BinaryScalar binary_scalar_bytes{
Buffer::FromString(std::string() + '\x00' + "\x1f\xff")};
StringScalar string_scalar_null{};
StringScalar string_scalar_unallocated{std::shared_ptr<Buffer>{nullptr}};
StringScalar string_scalar_empty{Buffer::FromString("")};
StringScalar string_scalar_hehe{Buffer::FromString("héhé")};
StringScalar string_scalar_invalid_chars{
Buffer::FromString(std::string("abc") + '\x00' + "def\xffghi")};
LargeBinaryScalar large_binary_scalar_abc{Buffer::FromString("abc")};
LargeStringScalar large_string_scalar_hehe{Buffer::FromString("héhé")};
FixedSizeBinaryScalar fixed_size_binary_scalar{Buffer::FromString("abc"),
fixed_size_binary(3)};
FixedSizeBinaryScalar fixed_size_binary_scalar_null{
Buffer::FromString(" "), fixed_size_binary(3), /*is_valid=*/false};
std::shared_ptr<Array> dict_array;
dict_array = *ArrayFromJSON(utf8(), R"(["foo", "bar", "quux"])");
DictionaryScalar dict_scalar{{std::make_shared<Int8Scalar>(42), dict_array},
dictionary(int8(), utf8())};
DictionaryScalar dict_scalar_null{dictionary(int8(), utf8())};
std::shared_ptr<Array> list_value_array = *ArrayFromJSON(int32(), R"([4, 5, 6])");
std::shared_ptr<Array> list_zero_length = *ArrayFromJSON(int32(), R"([])");
ListScalar list_scalar{list_value_array};
ListScalar list_scalar_null{list_zero_length, list(int32()), /*is_valid=*/false};
LargeListScalar large_list_scalar{list_value_array};
LargeListScalar large_list_scalar_null{list_zero_length, large_list(int32()),
/*is_valid=*/false};
FixedSizeListScalar fixed_size_list_scalar{list_value_array};
FixedSizeListScalar fixed_size_list_scalar_null{
list_value_array, fixed_size_list(int32(), 3), /*is_valid=*/false};
auto struct_scalar_type = struct_({field("ints", int32()), field("strs", utf8())});
StructScalar struct_scalar{
ScalarVector{MakeScalar(int32_t(42)), MakeScalar("some text")}, struct_scalar_type};
StructScalar struct_scalar_null{struct_scalar.value, struct_scalar_type,
/*is_valid=*/false};
auto sparse_union_scalar_type =
sparse_union(FieldVector{field("ints", int32()), field("strs", utf8())}, {7, 42});
auto dense_union_scalar_type =
dense_union(FieldVector{field("ints", int32()), field("strs", utf8())}, {7, 42});
std::vector<std::shared_ptr<Scalar>> union_values = {MakeScalar(int32_t(43)),
MakeNullScalar(utf8())};
SparseUnionScalar sparse_union_scalar{union_values, 7, sparse_union_scalar_type};
DenseUnionScalar dense_union_scalar{union_values[0], 7, dense_union_scalar_type};
union_values[0] = MakeNullScalar(int32());
SparseUnionScalar sparse_union_scalar_null{union_values, 7, sparse_union_scalar_type};
DenseUnionScalar dense_union_scalar_null{union_values[0], 7, dense_union_scalar_type};
auto extension_scalar_type = std::make_shared<UuidType>();
ExtensionScalar extension_scalar{
std::make_shared<FixedSizeBinaryScalar>(Buffer::FromString("0123456789abcdef"),
extension_scalar_type->storage_type()),
extension_scalar_type};
ExtensionScalar extension_scalar_null{extension_scalar.value, extension_scalar_type,
/*is_valid=*/false};
std::shared_ptr<Scalar> heap_map_scalar;
ARROW_CHECK_OK(
ScalarFromJSON(map(utf8(), int32()), R"([["a", 5], ["b", 6]])", &heap_map_scalar));
auto heap_map_scalar_null = MakeNullScalar(heap_map_scalar->type);
// Array and ArrayData
auto heap_null_array = SliceArrayFromJSON(null(), "[null, null]");
auto heap_int32_array = SliceArrayFromJSON(int32(), "[-5, 6, null, 42]");
ArrayData int32_array_data{*heap_int32_array->data()};
Int32Array int32_array{heap_int32_array->data()->Copy()};
auto heap_int32_array_no_nulls = SliceArrayFromJSON(int32(), "[-5, 6, 3, 42]");
const char* json_int32_array = "[-1, 2, -3, 4, null, -5, 6, -7, 8, null, -9, -10]";
auto heap_int32_array_sliced_1_9 = SliceArrayFromJSON(int32(), json_int32_array, 1, 9);
auto heap_int32_array_sliced_2_6 = SliceArrayFromJSON(int32(), json_int32_array, 2, 6);
auto heap_int32_array_sliced_8_4 = SliceArrayFromJSON(int32(), json_int32_array, 8, 4);
auto heap_int32_array_sliced_empty =
SliceArrayFromJSON(int32(), json_int32_array, 6, 0);
const char* json_bool_array =
"[false, false, true, true, null, null, false, false, true, true, "
"null, null, false, false, true, true, null, null]";
auto heap_bool_array = SliceArrayFromJSON(boolean(), json_bool_array);
auto heap_bool_array_sliced_1_9 = SliceArrayFromJSON(boolean(), json_bool_array, 1, 9);
auto heap_bool_array_sliced_2_6 = SliceArrayFromJSON(boolean(), json_bool_array, 2, 6);
auto heap_bool_array_sliced_empty =
SliceArrayFromJSON(boolean(), json_bool_array, 6, 0);
auto heap_list_array = SliceArrayFromJSON(list(int64()), "[[1, 2], null, []]");
ListArray list_array{heap_list_array->data()};
const char* json_double_array = "[-1.5, null]";
auto heap_double_array = SliceArrayFromJSON(float64(), json_double_array);
const char* json_float16_array = "[0, 48640]";
auto heap_float16_array =
*SliceArrayFromJSON(uint16(), json_float16_array)->View(float16());
auto heap_date32_array =
SliceArrayFromJSON(date32(), "[0, null, 18336, -9004, -719162, -719163]");
auto heap_date64_array = SliceArrayFromJSON(
date64(), "[1584230400000, -777945600000, -62135596800000, -62135683200000, 123]");
const char* json_time_array = "[null, -123, 456]";
auto heap_time32_array_s =
SliceArrayFromJSON(time32(TimeUnit::SECOND), json_time_array);
auto heap_time32_array_ms =
SliceArrayFromJSON(time32(TimeUnit::MILLI), json_time_array);
auto heap_time64_array_us =
SliceArrayFromJSON(time64(TimeUnit::MICRO), json_time_array);
auto heap_time64_array_ns = SliceArrayFromJSON(time64(TimeUnit::NANO), json_time_array);
auto heap_month_interval_array =
SliceArrayFromJSON(month_interval(), "[123, -456, null]");
auto heap_day_time_interval_array =
SliceArrayFromJSON(day_time_interval(), "[[1, -600], null]");
auto heap_month_day_nano_interval_array =
SliceArrayFromJSON(month_day_nano_interval(), "[[1, -600, 5000], null]");
const char* json_duration_array = "[null, -1234567890123456789]";
auto heap_duration_array_s =
SliceArrayFromJSON(duration(TimeUnit::SECOND), json_duration_array);
auto heap_duration_array_ns =
SliceArrayFromJSON(duration(TimeUnit::NANO), json_duration_array);
auto heap_timestamp_array_s = SliceArrayFromJSON(
timestamp(TimeUnit::SECOND),
R"([null, "1970-01-01 00:00:00", "1900-02-28 12:34:56", "3989-07-14 00:00:00"])");
auto heap_timestamp_array_ms = SliceArrayFromJSON(
timestamp(TimeUnit::MILLI),
R"([null, "1900-02-28 12:34:56.123", "3989-07-14 00:00:00.789"])");
auto heap_timestamp_array_us = SliceArrayFromJSON(
timestamp(TimeUnit::MICRO),
R"([null, "1900-02-28 12:34:56.654321", "3989-07-14 00:00:00.456789"])");
auto heap_timestamp_array_ns = SliceArrayFromJSON(
timestamp(TimeUnit::NANO), R"([null, "1900-02-28 12:34:56.987654321"])");
auto heap_decimal128_array = SliceArrayFromJSON(
decimal128(30, 6),
R"([null, "-1234567890123456789.012345", "1234567890123456789.012345"])");
auto heap_decimal256_array = SliceArrayFromJSON(
decimal256(50, 6), R"([null, "-123456789012345678901234567890123456789.012345"])");
auto heap_decimal128_array_sliced = heap_decimal128_array->Slice(1, 1);
auto heap_fixed_size_binary_array =
SliceArrayFromJSON(fixed_size_binary(3), "[null, \"abc\", \"\\u0000\\u001f\xff\"]");
auto heap_fixed_size_binary_array_zero_width =
SliceArrayFromJSON(fixed_size_binary(0), R"([null, ""])");
auto heap_fixed_size_binary_array_sliced = heap_fixed_size_binary_array->Slice(1, 1);
const char* json_binary_array = "[null, \"abcd\", \"\\u0000\\u001f\xff\"]";
auto heap_binary_array = SliceArrayFromJSON(binary(), json_binary_array);
auto heap_large_binary_array = SliceArrayFromJSON(large_binary(), json_binary_array);
const char* json_string_array = "[null, \"héhé\", \"invalid \xff char\"]";
auto heap_string_array = SliceArrayFromJSON(utf8(), json_string_array);
auto heap_large_string_array = SliceArrayFromJSON(large_utf8(), json_string_array);
auto heap_binary_array_sliced = heap_binary_array->Slice(1, 1);
// ChunkedArray
ArrayVector array_chunks(2);
array_chunks[0] = *ArrayFromJSON(int32(), "[1, 2]");
array_chunks[1] = *ArrayFromJSON(int32(), "[3, null, 4]");
ChunkedArray chunked_array{array_chunks};
// RecordBatch
auto batch_schema = schema({field("ints", int32()), field("strs", utf8())});
ArrayVector batch_columns{2};
batch_columns[0] = *ArrayFromJSON(int32(), "[1, 2, 3]");
batch_columns[1] = *ArrayFromJSON(utf8(), R"(["abc", null, "def"])");
auto batch = RecordBatch::Make(batch_schema, /*num_rows=*/3, batch_columns);
auto batch_with_metadata = batch->ReplaceSchemaMetadata(
key_value_metadata({"key1", "key2", "key3"}, {"value1", "value2", "value3"}));
// Table
ChunkedArrayVector table_columns{2};
ARROW_CHECK_OK(
ChunkedArrayFromJSON(int32(), {"[1, 2, 3]", "[4, 5]"}, &table_columns[0]));
ARROW_CHECK_OK(ChunkedArrayFromJSON(
utf8(), {R"(["abc", null])", R"(["def"])", R"(["ghi", "jkl"])"},
&table_columns[1]));
auto table = Table::Make(batch_schema, table_columns);
// Datum
Datum empty_datum{};
Datum scalar_datum{MakeNullScalar(boolean())};
Datum array_datum{heap_int32_array};
Datum chunked_array_datum{chunked_array};
Datum batch_datum{batch};
Datum table_datum{table};
#ifdef __clang__
_Pragma("clang diagnostic pop");
#elif defined(__GNUC__)
_Pragma("GCC diagnostic pop");
#endif
// Hook into debugger
::arrow::internal::DebugTrap();
}