Skip to content

Commit 61906ce

Browse files
authored
[fix](be) Preserve signed decimal bounds in Iceberg ORC writes (#69888)
### What problem does this PR solve? Issue Number: N/A Related PR: N/A Problem Summary: ORC `Int128` statistics already contain two's-complement bits, but the Iceberg ORC writer negates negative values again before encoding them. A file containing `[-100, -1]` consequently reports bounds `[100, 1]`, so a negative predicate can prune a file that contains matching rows. ORC footer statistics also trim trailing fractional zeros. For example, `-1.00` is returned as `value=-1, scale=0`; a `DECIMAL(...,2)` manifest needs the unscaled value `-100`. Preserving the sign alone therefore leaves incorrect bounds. Restore each bound to the declared column scale with the existing ORC scaling utility, then serialize its original signed bits using minimal big-endian encoding. Preserve necessary sign prefixes such as `128 -> 00 80` and `-129 -> FF 7F`. The fix applies to newly collected bounds. Existing incorrect metrics require recomputation or data-file rewriting. ### Release note Correct decimal bounds emitted by Iceberg ORC writes to prevent incorrect predicate pruning for negative values and values with trailing fractional zeros. ### Check List (For Author) - Test <!-- At least one of them must be included. --> - [x] Regression test - [x] Unit Test - [x] Manual test (add detailed scripts or steps below) - [ ] No need to test or manual test. Explain why: - [ ] This is a refactor/code format and no logic has been changed. - [ ] Previous test can cover this change. - [ ] No code files have been changed. - [ ] Other reason Added BE tests cover 29 encoding cases, real ORC statistics at precisions 1/9/18/38, scale restoration through scale 38, nullable columns, and all-null columns. The external regression checks manifest pruning for negative and mixed decimal data across decimal32/64/128. Local validation: - An isolated codec harness built from the production function passed all 29 encoding cases. - Five real ORC files passed independent Iceberg 1.12.0 manifest write/read and predicate-pruning probes. - clang-format 16, build hygiene, changed-line clang-tidy, and Groovy 4.0.19 syntax checks passed. Static analysis used real ASAN UT compilation commands with PCH expanded as headers. - The full local BE-UT build was stopped during the monolithic dependency build before tests executed. - Regenerated `test_iceberg_write_stats2.out` with the standard regression runner after restoring decimal scales. Only `sql_4/5/7/9` changed, and the decimal bounds match both stored rows and the Parquet metrics. - Re-ran `test_iceberg_write_stats2` and `test_iceberg_orc_decimal_bounds` locally using this PR's CI FE/BE artifacts: 2 suites passed, 0 failed, 0 skipped. - Behavior changed: - [ ] No. - [x] Yes. Newly written ORC decimal bounds preserve the sign and the column scale. - Does this need documentation? - [x] No. - [ ] Yes. ### Check List (For Reviewer who merge this PR) - [ ] Confirm the release note - [ ] Confirm test cases - [ ] Confirm document - [ ] Add branch pick label
1 parent deb0794 commit 61906ce

5 files changed

Lines changed: 275 additions & 26 deletions

File tree

‎be/src/format/transformer/vorc_transformer.cpp‎

Lines changed: 17 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -677,32 +677,27 @@ bool VOrcTransformer::_collect_column_bounds(const orc::ColumnStatistics* col_st
677677
dynamic_cast<const orc::DecimalColumnStatistics*>(col_stats)) {
678678
if (decimal_stats->hasMinimum() && decimal_stats->hasMaximum()) {
679679
has_bounds = true;
680-
(*lower_bounds)[field_id] = _decimal_to_bytes(decimal_stats->getMinimum());
681-
(*upper_bounds)[field_id] = _decimal_to_bytes(decimal_stats->getMaximum());
680+
const auto scale = static_cast<int32_t>(remove_nullable(data_type)->get_scale());
681+
(*lower_bounds)[field_id] = _decimal_to_bytes(decimal_stats->getMinimum(), scale);
682+
(*upper_bounds)[field_id] = _decimal_to_bytes(decimal_stats->getMaximum(), scale);
682683
}
683684
}
684685

685686
return has_bounds;
686687
}
687688

688-
std::string VOrcTransformer::_decimal_to_bytes(const orc::Decimal& decimal) {
689-
orc::Int128 val = decimal.value;
690-
if (val == 0) {
691-
char zero = 0;
692-
return std::string(&zero, 1);
693-
}
694-
695-
// Convert Int128 -> signed big-endian minimal bytes
696-
bool negative = val < 0;
697-
auto high = static_cast<uint64_t>(val.getHighBits());
698-
auto low = val.getLowBits();
689+
std::string VOrcTransformer::_decimal_to_bytes(const orc::Decimal& decimal, int32_t scale) {
690+
// ORC footer statistics trim trailing zeros: -1.00 becomes value=-1, scale=0.
691+
// Iceberg requires the unscaled value at the column's declared scale, which is -100 here.
692+
DORIS_CHECK_GE(scale, decimal.scale);
693+
bool overflow = false;
694+
auto val = orc::scaleUpInt128ByPowerOfTen(decimal.value, scale - decimal.scale, overflow);
695+
DORIS_CHECK(!overflow);
699696

700-
// If negative, convert to two's complement explicitly
701-
if (negative) {
702-
// two's complement for 128-bit
703-
low = ~low + 1;
704-
high = ~high + (low == 0 ? 1 : 0);
705-
}
697+
// Int128 already exposes two's-complement bits; negating -1 again would encode +1.
698+
const bool negative = val < 0;
699+
const auto high = static_cast<uint64_t>(val.getHighBits());
700+
const auto low = val.getLowBits();
706701

707702
// Serialize to big-endian bytes
708703
uint8_t buf[16];
@@ -711,9 +706,10 @@ std::string VOrcTransformer::_decimal_to_bytes(const orc::Decimal& decimal) {
711706
buf[i + 8] = static_cast<uint8_t>(low >> (56 - i * 8));
712707
}
713708

714-
// Strip leading sign-extension bytes (Iceberg minimal encoding)
709+
// Strip redundant sign extension, retaining one byte for zero and the sign prefix
710+
// when the next byte has the opposite sign: 128 -> 00 80, -129 -> FF 7F.
715711
int start = 0;
716-
uint8_t sign_byte = negative ? 0xFF : 0x00;
712+
const uint8_t sign_byte = negative ? 0xFF : 0x00;
717713
while (start < 15 && buf[start] == sign_byte &&
718714
((buf[start + 1] & 0x80) == (sign_byte & 0x80))) {
719715
++start;

‎be/src/format/transformer/vorc_transformer.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -117,7 +117,7 @@ class VOrcTransformer final : public VFileFormatTransformer {
117117
const DataTypePtr& data_type,
118118
std::map<int32_t, std::string>* lower_bounds,
119119
std::map<int32_t, std::string>* upper_bounds);
120-
std::string _decimal_to_bytes(const orc::Decimal& decimal);
120+
static std::string _decimal_to_bytes(const orc::Decimal& decimal, int32_t scale);
121121
std::shared_ptr<io::FileSystem> _fs = nullptr;
122122
doris::io::FileWriter* _file_writer = nullptr;
123123
std::vector<std::string> _column_names;

‎be/test/format/transformer/vorc_transformer_test.cpp‎

Lines changed: 150 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@
1717

1818
#include "format/transformer/vorc_transformer.h"
1919

20+
#include <fmt/format.h>
2021
#include <gtest/gtest.h>
2122

2223
#include <orc/OrcFile.hh>
@@ -31,6 +32,7 @@
3132
#include "core/column/column_vector.h"
3233
#include "core/data_type/data_type_array.h"
3334
#include "core/data_type/data_type_date_or_datetime_v2.h"
35+
#include "core/data_type/data_type_decimal.h"
3436
#include "core/data_type/data_type_map.h"
3537
#include "core/data_type/data_type_nullable.h"
3638
#include "core/data_type/data_type_number.h"
@@ -48,6 +50,7 @@
4850
#include "io/fs/local_file_system.h"
4951
#include "runtime/runtime_state.h"
5052
#include "testutil/mock/mock_slot_ref.h"
53+
#include "util/slice.h"
5154
#include "util/timezone_utils.h"
5255
#include "util/uid_util.h"
5356

@@ -243,6 +246,153 @@ TEST_F(VOrcTransformerTest, CollectsBoundsForTopLevelFieldAfterStruct) {
243246
EXPECT_EQ("hello", stats.upper_bounds.at(3));
244247
}
245248

249+
TEST_F(VOrcTransformerTest, DecimalBoundsUseMinimalTwosComplement) {
250+
struct TestCase {
251+
const char* value;
252+
int32_t footer_scale;
253+
int32_t column_scale;
254+
std::string expected;
255+
};
256+
const std::vector<TestCase> cases = {
257+
{"-99999999999999999999999999999999999999", 0, 0,
258+
std::string("\xb4\xc4\xb3\x57\xa5\x79\x3b\x85\xf6\x75\xdd\xc0\x00\x00\x00\x01", 16)},
259+
{"-18446744073709551616", 0, 0, std::string("\xff\x00\x00\x00\x00\x00\x00\x00\x00", 9)},
260+
{"-9223372036854775808", 0, 0, std::string("\x80\x00\x00\x00\x00\x00\x00\x00", 8)},
261+
{"-32769", 0, 0, std::string("\xff\x7f\xff", 3)},
262+
{"-32768", 0, 0, std::string("\x80\x00", 2)},
263+
{"-256", 0, 0, std::string("\xff\x00", 2)},
264+
{"-255", 0, 0, std::string("\xff\x01", 2)},
265+
{"-129", 0, 0, std::string("\xff\x7f", 2)},
266+
{"-128", 0, 0, std::string("\x80", 1)},
267+
{"-100", 0, 0, std::string("\x9c", 1)},
268+
{"-1", 0, 0, std::string("\xff", 1)},
269+
{"0", 0, 0, std::string("\x00", 1)},
270+
{"1", 0, 0, std::string("\x01", 1)},
271+
{"127", 0, 0, std::string("\x7f", 1)},
272+
{"128", 0, 0, std::string("\x00\x80", 2)},
273+
{"255", 0, 0, std::string("\x00\xff", 2)},
274+
{"256", 0, 0, std::string("\x01\x00", 2)},
275+
{"9223372036854775807", 0, 0, std::string("\x7f\xff\xff\xff\xff\xff\xff\xff", 8)},
276+
{"18446744073709551616", 0, 0, std::string("\x01\x00\x00\x00\x00\x00\x00\x00\x00", 9)},
277+
{"99999999999999999999999999999999999999", 0, 0,
278+
std::string("\x4b\x3b\x4c\xa8\x5a\x86\xc4\x7a\x09\x8a\x22\x3f\xff\xff\xff\xff", 16)},
279+
{"-1", 0, 1, std::string("\xf6", 1)},
280+
{"-1", 0, 2, std::string("\x9c", 1)},
281+
{"-10", 1, 2, std::string("\x9c", 1)},
282+
{"1", 0, 2, std::string("\x64", 1)},
283+
{"128", 0, 2, std::string("\x32\x00", 2)},
284+
{"0", 0, 38, std::string("\x00", 1)},
285+
{"-1", 1, 38,
286+
std::string("\xf8\x7a\x11\xef\x2a\x25\xb9\x26\xff\x0b\xc9\x60\x00\x00\x00\x00", 16)},
287+
{"1", 38, 38, std::string("\x01", 1)},
288+
{"-1", 38, 38, std::string("\xff", 1)},
289+
};
290+
for (const auto& test : cases) {
291+
SCOPED_TRACE(test.value);
292+
SCOPED_TRACE(test.footer_scale);
293+
SCOPED_TRACE(test.column_scale);
294+
const orc::Decimal decimal(orc::Int128(test.value), test.footer_scale);
295+
EXPECT_EQ(test.expected, VOrcTransformer::_decimal_to_bytes(decimal, test.column_scale));
296+
}
297+
}
298+
299+
TEST_F(VOrcTransformerTest, CollectsDecimalBoundsAtColumnScale) {
300+
struct TestCase {
301+
int precision;
302+
int scale;
303+
std::vector<std::string> values;
304+
std::string lower;
305+
std::string upper;
306+
};
307+
const std::vector<TestCase> cases = {
308+
{1, 0, {"-9", "9"}, std::string("\xf7", 1), std::string("\x09", 1)},
309+
{9, 0, {"-100", "-1"}, std::string("\x9c", 1), std::string("\xff", 1)},
310+
{9, 0, {"-100", "128"}, std::string("\x9c", 1), std::string("\x00\x80", 2)},
311+
{9, 2, {"-100.00", "-1.00"}, std::string("\xd8\xf0", 2), std::string("\x9c", 1)},
312+
{18, 2, {"-100.00", "1.28"}, std::string("\xd8\xf0", 2), std::string("\x00\x80", 2)},
313+
{18, 2, {"1.00", "128.00"}, std::string("\x64", 1), std::string("\x32\x00", 2)},
314+
{38,
315+
0,
316+
{"-99999999999999999999999999999999999999", "99999999999999999999999999999999999999"},
317+
std::string("\xb4\xc4\xb3\x57\xa5\x79\x3b\x85\xf6\x75\xdd\xc0\x00\x00\x00\x01", 16),
318+
std::string("\x4b\x3b\x4c\xa8\x5a\x86\xc4\x7a\x09\x8a\x22\x3f\xff\xff\xff\xff", 16)},
319+
{38,
320+
38,
321+
{"-0.10000000000000000000000000000000000000",
322+
"0.00000000000000000000000000000000000001"},
323+
std::string("\xf8\x7a\x11\xef\x2a\x25\xb9\x26\xff\x0b\xc9\x60\x00\x00\x00\x00", 16),
324+
std::string("\x01", 1)},
325+
{38,
326+
38,
327+
{"0.00000000000000000000000000000000000000"},
328+
std::string("\x00", 1),
329+
std::string("\x00", 1)},
330+
};
331+
for (const auto& test : cases) {
332+
for (bool nullable : {false, true}) {
333+
SCOPED_TRACE(test.precision);
334+
SCOPED_TRACE(test.scale);
335+
SCOPED_TRACE(nullable);
336+
auto decimal_type = create_decimal(test.precision, test.scale, false);
337+
auto type = nullable ? make_nullable(decimal_type) : decimal_type;
338+
auto column = type->create_column();
339+
auto serde = type->get_serde();
340+
DataTypeSerDe::FormatOptions options;
341+
for (const auto& value : test.values) {
342+
Slice slice(value);
343+
ASSERT_TRUE(serde->deserialize_one_cell_from_json(*column, slice, options).ok());
344+
}
345+
// A null beside the extrema must not change either decimal bound.
346+
if (nullable) {
347+
column->insert_default();
348+
}
349+
auto exprs = MockSlotRef::create_mock_contexts(DataTypes {type});
350+
const auto json = fmt::format(
351+
R"json({{"type":"struct","fields":[{{"id":1,"name":"d","required":false,"type":"decimal({},{})"}}]}})json",
352+
test.precision, test.scale);
353+
auto schema = iceberg::SchemaParser::from_json(json);
354+
io::FileWriterPtr file_writer;
355+
ASSERT_TRUE(_fs->create_file(_file_path, &file_writer).ok());
356+
RuntimeState state;
357+
VOrcTransformer transformer(&state, file_writer.get(), exprs, "", {"d"}, false,
358+
TFileCompressType::PLAIN, schema.get(), _fs);
359+
ASSERT_TRUE(transformer.open().ok());
360+
ASSERT_TRUE(transformer.write(Block({{std::move(column), type, "d"}})).ok());
361+
ASSERT_TRUE(transformer.close().ok());
362+
TIcebergColumnStats stats;
363+
ASSERT_TRUE(transformer.collect_file_statistics_after_close(&stats).ok());
364+
ASSERT_TRUE(stats.lower_bounds.contains(1));
365+
ASSERT_TRUE(stats.upper_bounds.contains(1));
366+
EXPECT_EQ(test.lower, stats.lower_bounds.at(1));
367+
EXPECT_EQ(test.upper, stats.upper_bounds.at(1));
368+
}
369+
}
370+
}
371+
372+
TEST_F(VOrcTransformerTest, AllNullDecimalsHaveNoBounds) {
373+
auto type = make_nullable(create_decimal(38, 2, false));
374+
auto column = type->create_column();
375+
column->insert_default();
376+
column->insert_default();
377+
auto exprs = MockSlotRef::create_mock_contexts(DataTypes {type});
378+
const std::string json =
379+
R"json({"type":"struct","fields":[{"id":1,"name":"d","required":false,"type":"decimal(38,2)"}]})json";
380+
auto schema = iceberg::SchemaParser::from_json(json);
381+
io::FileWriterPtr file_writer;
382+
ASSERT_TRUE(_fs->create_file(_file_path, &file_writer).ok());
383+
RuntimeState state;
384+
VOrcTransformer transformer(&state, file_writer.get(), exprs, "", {"d"}, false,
385+
TFileCompressType::PLAIN, schema.get(), _fs);
386+
ASSERT_TRUE(transformer.open().ok());
387+
ASSERT_TRUE(transformer.write(Block({{std::move(column), type, "d"}})).ok());
388+
ASSERT_TRUE(transformer.close().ok());
389+
TIcebergColumnStats stats;
390+
ASSERT_TRUE(transformer.collect_file_statistics_after_close(&stats).ok());
391+
EXPECT_FALSE(stats.lower_bounds.contains(1));
392+
EXPECT_FALSE(stats.upper_bounds.contains(1));
393+
EXPECT_EQ(2, stats.null_value_counts.at(1));
394+
}
395+
246396
TEST_F(VOrcTransformerTest, IcebergBinaryTypesOverrideLegacyStringCarrier) {
247397
const std::string schema_json = R"({
248398
"type": "struct",

‎regression-test/data/external_table_p0/iceberg/write/test_iceberg_write_stats2.out‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -14,20 +14,20 @@ false 22 222 2.2 2.2 2222 8765.4321 8765.432100 987654321098765432.987654321099
1414
true 11 111 1.1 1.1 1111 1234.5678 1234.567890 123456789012345678.123456789012 aaa 2023-01-01 2023-01-01T12:34:56
1515

1616
-- !sql_4 --
17-
0 ORC 2 {1:2, 2:2, 3:2, 4:2, 5:2, 6:2, 7:2, 8:2, 9:2, 10:2, 11:2, 12:2} {} {1:0x00, 2:0x0B00000000000000, 3:0x6F00000000000000, 4:0xCDCC8C3F, 5:0x9A9999999999F13F, 6:0x0457, 7:0x00BC614E, 8:0x075BCD15, 9:0x018EE90FF6C373E0393713FA14, 10:0x616161, 11:0x9E4B0000, 12:0x005CE70F33F10500} {1:0x01, 2:0x1600000000000000, 3:0xDE00000000000000, 4:0xCDCC0C40, 5:0x9A99999999990140, 6:0x08AE, 7:0x05397FB1, 8:0x05397FB1, 9:0x0C7748819DFFB62505316873CB, 10:0x626262, 11:0x434C0000, 12:0x40D91FA833FE0500}
17+
0 ORC 2 {1:2, 2:2, 3:2, 4:2, 5:2, 6:2, 7:2, 8:2, 9:2, 10:2, 11:2, 12:2} {} {1:0x00, 2:0x0B00000000000000, 3:0x6F00000000000000, 4:0xCDCC8C3F, 5:0x9A9999999999F13F, 6:0x0457, 7:0x00BC614E, 8:0x499602D2, 9:0x018EE90FF6C373E0393713FA14, 10:0x616161, 11:0x9E4B0000, 12:0x005CE70F33F10500} {1:0x01, 2:0x1600000000000000, 3:0xDE00000000000000, 4:0xCDCC0C40, 5:0x9A99999999990140, 6:0x08AE, 7:0x05397FB1, 8:0x020A75E124, 9:0x0C7748819DFFB62505316873CB, 10:0x626262, 11:0x434C0000, 12:0x40D91FA833FE0500}
1818

1919
-- !sql_5 --
20-
{"bigint_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":111, "upper_bound":222}, "boolean_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":0, "upper_bound":1}, "date_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":"2023-01-01", "upper_bound":"2023-06-15"}, "datetime_col1":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":"2023-01-01 12:34:56.000000", "upper_bound":"2023-06-15 23:45:01.000000"}, "decimal_col1":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":1111, "upper_bound":2222}, "decimal_col2":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":1234.5678, "upper_bound":8765.4321}, "decimal_col3":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":123.456789, "upper_bound":87.654321}, "decimal_col4":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":123456789012345678.123456789012, "upper_bound":987654321098765432.987654321099}, "double_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":0, "lower_bound":1.1, "upper_bound":2.2}, "float_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":0, "lower_bound":1.1, "upper_bound":2.2}, "int_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":11, "upper_bound":22}, "string_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":"aaa", "upper_bound":"bbb"}}
20+
{"bigint_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":111, "upper_bound":222}, "boolean_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":0, "upper_bound":1}, "date_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":"2023-01-01", "upper_bound":"2023-06-15"}, "datetime_col1":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":"2023-01-01 12:34:56.000000", "upper_bound":"2023-06-15 23:45:01.000000"}, "decimal_col1":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":1111, "upper_bound":2222}, "decimal_col2":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":1234.5678, "upper_bound":8765.4321}, "decimal_col3":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":1234.567890, "upper_bound":8765.432100}, "decimal_col4":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":123456789012345678.123456789012, "upper_bound":987654321098765432.987654321099}, "double_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":0, "lower_bound":1.1, "upper_bound":2.2}, "float_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":0, "lower_bound":1.1, "upper_bound":2.2}, "int_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":11, "upper_bound":22}, "string_col":{"column_size":null, "value_count":2, "null_value_count":null, "nan_value_count":null, "lower_bound":"aaa", "upper_bound":"bbb"}}
2121

2222
-- !sql_6 --
2323
{1:0x00, 2:0x0B000000, 3:0x6F00000000000000, 4:0xCDCC8C3F, 5:0x9A9999999999F13F, 6:0x0457, 7:0x00BC614E, 8:0x499602D2, 9:0x018EE90FF6C373E0393713FA14, 10:0x616161, 11:0x9E4B0000, 12:0x005CE70F33F10500}
2424

2525
-- !sql_7 --
26-
{1:0x00, 2:0x0B00000000000000, 3:0x6F00000000000000, 4:0xCDCC8C3F, 5:0x9A9999999999F13F, 6:0x0457, 7:0x00BC614E, 8:0x075BCD15, 9:0x018EE90FF6C373E0393713FA14, 10:0x616161, 11:0x9E4B0000, 12:0x005CE70F33F10500}
26+
{1:0x00, 2:0x0B00000000000000, 3:0x6F00000000000000, 4:0xCDCC8C3F, 5:0x9A9999999999F13F, 6:0x0457, 7:0x00BC614E, 8:0x499602D2, 9:0x018EE90FF6C373E0393713FA14, 10:0x616161, 11:0x9E4B0000, 12:0x005CE70F33F10500}
2727

2828
-- !sql_8 --
2929
{1:0x01, 2:0x16000000, 3:0xDE00000000000000, 4:0xCDCC0C40, 5:0x9A99999999990140, 6:0x08AE, 7:0x05397FB1, 8:0x020A75E124, 9:0x0C7748819DFFB62505316873CB, 10:0x626262, 11:0x434C0000, 12:0x40D91FA833FE0500}
3030

3131
-- !sql_9 --
32-
{1:0x01, 2:0x1600000000000000, 3:0xDE00000000000000, 4:0xCDCC0C40, 5:0x9A99999999990140, 6:0x08AE, 7:0x05397FB1, 8:0x05397FB1, 9:0x0C7748819DFFB62505316873CB, 10:0x626262, 11:0x434C0000, 12:0x40D91FA833FE0500}
32+
{1:0x01, 2:0x1600000000000000, 3:0xDE00000000000000, 4:0xCDCC0C40, 5:0x9A99999999990140, 6:0x08AE, 7:0x05397FB1, 8:0x020A75E124, 9:0x0C7748819DFFB62505316873CB, 10:0x626262, 11:0x434C0000, 12:0x40D91FA833FE0500}
3333

0 commit comments

Comments
 (0)