Skip to content

Commit df32882

Browse files
committed
[fix](datalake) Address nanosecond backport review findings
1 parent 5977846 commit df32882

20 files changed

Lines changed: 315 additions & 86 deletions

File tree

‎be/src/core/data_type_serde/data_type_varbinary_serde.cpp‎

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@
2424
#include "core/column/column_varbinary.h"
2525
#include "core/data_type/data_type_varbinary.h"
2626
#include "core/data_type_serde/arrow_validation.h"
27+
#include "core/data_type_serde/orc_serde_utils.h"
2728
#include "core/data_type_serde/parquet_decode_source.h"
2829
#include "exprs/function/string_hex_util.h"
2930
#include "util/url_coding.h"
@@ -291,6 +292,47 @@ Status DataTypeVarbinarySerDe::read_column_from_arrow(IColumn& column,
291292
return Status::OK();
292293
}
293294

295+
Status DataTypeVarbinarySerDe::read_column_from_orc(IColumn& column,
296+
const OrcDecodedColumnView& view) const {
297+
// Keep binary payloads intact; selected rows and NULL placeholders must stay aligned.
298+
DORIS_CHECK(view.file_type != nullptr);
299+
DORIS_CHECK(view.file_type->getKind() == orc::BINARY);
300+
const auto* batch = dynamic_cast<const orc::StringVectorBatch*>(view.batch);
301+
DORIS_CHECK(batch != nullptr);
302+
const auto* encoded_batch = dynamic_cast<const orc::EncodedStringVectorBatch*>(batch);
303+
const bool is_encoded = encoded_batch != nullptr && encoded_batch->isEncoded;
304+
if (is_encoded) {
305+
DORIS_CHECK(encoded_batch->dictionary != nullptr);
306+
}
307+
auto& binary_column = assert_cast<ColumnVarbinary&>(column);
308+
const auto rows = orc_serde_utils::orc_decode_row_count(view.rows, view.selected_rows);
309+
binary_column.reserve(binary_column.size() + rows);
310+
for (size_t row = 0; row < rows; ++row) {
311+
const auto source_row = orc_serde_utils::orc_source_row_at(row, view.selected_rows);
312+
if (orc_serde_utils::orc_row_is_null(*batch, source_row)) {
313+
binary_column.insert_default();
314+
continue;
315+
}
316+
char* data = nullptr;
317+
int64_t length = 0;
318+
if (is_encoded) {
319+
encoded_batch->dictionary->getValueByIndex(encoded_batch->index[source_row], data,
320+
length);
321+
} else {
322+
data = batch->data[source_row];
323+
length = batch->length[source_row];
324+
}
325+
if (length < 0) {
326+
return Status::Corruption("Invalid negative ORC binary length {}", length);
327+
}
328+
if (length > 0 && data == nullptr) {
329+
return Status::Corruption("Missing ORC binary payload");
330+
}
331+
binary_column.insert_data(length == 0 ? "" : data, cast_set<size_t>(length));
332+
}
333+
return Status::OK();
334+
}
335+
294336
Status DataTypeVarbinarySerDe::write_column_to_orc(const std::string& timezone,
295337
const IColumn& column, const NullMap* null_map,
296338
orc::ColumnVectorBatch* orc_col_batch,

‎be/src/core/data_type_serde/data_type_varbinary_serde.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -107,6 +107,8 @@ class DataTypeVarbinarySerDe : public DataTypeSerDe {
107107
int64_t row_idx, bool col_const,
108108
const FormatOptions& options) const override;
109109

110+
Status read_column_from_orc(IColumn& column, const OrcDecodedColumnView& view) const override;
111+
110112
Status write_column_to_orc(const std::string& timezone, const IColumn& column,
111113
const NullMap* null_map, orc::ColumnVectorBatch* orc_col_batch,
112114
int64_t start, int64_t end, Arena& arena,

‎be/src/format_v2/orc/orc_reader.cpp‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -65,6 +65,7 @@
6565
#include "core/data_type/data_type_struct.h"
6666
#include "core/data_type/data_type_timestamp_ns.h"
6767
#include "core/data_type/data_type_timestamptz.h"
68+
#include "core/data_type/data_type_varbinary.h"
6869
#include "core/data_type_serde/data_type_serde.h"
6970
#include "core/data_type_serde/orc_serde_utils.h"
7071
#include "core/data_type_serde/orc_timestamp_decode_context.h"
@@ -1229,9 +1230,12 @@ DataTypePtr OrcReader::_convert_to_doris_type(const ::orc::Type& type) const {
12291230
data_type = std::make_shared<DataTypeFloat64>();
12301231
break;
12311232
case ::orc::TypeKind::STRING:
1232-
case ::orc::TypeKind::BINARY:
12331233
data_type = std::make_shared<DataTypeString>();
12341234
break;
1235+
case ::orc::TypeKind::BINARY:
1236+
// File annotations define binary semantics, including nested leaves, without a session flag.
1237+
data_type = std::make_shared<DataTypeVarbinary>();
1238+
break;
12351239
case ::orc::TypeKind::VARCHAR:
12361240
data_type = std::make_shared<DataTypeString>(cast_set<int>(type.getMaximumLength()),
12371241
PrimitiveType::TYPE_VARCHAR);

‎be/src/format_v2/parquet/native_schema_desc.cpp‎

Lines changed: 4 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -820,16 +820,9 @@ std::pair<DataTypePtr, bool> NativeFieldDescriptor::get_doris_type(
820820
ans.first = DataTypeFactory::instance().create_data_type(TYPE_DOUBLE, nullable);
821821
break;
822822
case tparquet::Type::BYTE_ARRAY:
823-
if (_enable_mapping_varbinary) {
824-
// if physical_schema not set logicalType and converted_type,
825-
// we treat BYTE_ARRAY as VARBINARY by default, so that we can read all data directly.
826-
ans.first = DataTypeFactory::instance().create_data_type(TYPE_VARBINARY, nullable);
827-
} else {
828-
ans.first = DataTypeFactory::instance().create_data_type(TYPE_STRING, nullable);
829-
}
830-
break;
831823
case tparquet::Type::FIXED_LEN_BYTE_ARRAY:
832-
ans.first = DataTypeFactory::instance().create_data_type(TYPE_STRING, nullable);
824+
// Text annotations are handled above; unannotated bytes always retain binary semantics.
825+
ans.first = DataTypeFactory::instance().create_data_type(TYPE_VARBINARY, nullable);
833826
break;
834827
default:
835828
throw Exception(Status::InternalError("Not supported parquet logicalType{}",
@@ -899,12 +892,8 @@ std::pair<DataTypePtr, bool> NativeFieldDescriptor::convert_to_doris_type(
899892
ans.first = DataTypeFactory::instance().create_data_type(
900893
TYPE_DATETIMEV2, nullable, 0, logicalType.TIMESTAMP.unit.__isset.MILLIS ? 3 : 6);
901894
} else if (logicalType.__isset.UUID) {
902-
if (_enable_mapping_varbinary) {
903-
ans.first = DataTypeFactory::instance().create_data_type(TYPE_VARBINARY, nullable, -1,
904-
-1, 16);
905-
} else {
906-
ans.first = DataTypeFactory::instance().create_data_type(TYPE_STRING, nullable);
907-
}
895+
ans.first =
896+
DataTypeFactory::instance().create_data_type(TYPE_VARBINARY, nullable, -1, -1, 16);
908897
} else if (logicalType.__isset.FLOAT16) {
909898
ans.first = DataTypeFactory::instance().create_data_type(TYPE_FLOAT, nullable);
910899
} else {

‎be/src/format_v2/parquet/native_schema_desc.h‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -105,8 +105,6 @@ class NativeFieldDescriptor {
105105
std::unordered_map<std::string, NativeFieldSchema*> _name_to_field;
106106
// Used in from_thrift, marking the next schema position that should be parsed
107107
size_t _next_schema_pos;
108-
// useful for parse_node_field to decide whether to convert byte_array to VARBINARY type
109-
bool _enable_mapping_varbinary = false;
110108
bool _enable_mapping_timestamp_tz = false;
111109

112110
private:
@@ -188,7 +186,8 @@ class NativeFieldDescriptor {
188186
void assign_ids();
189187

190188
const NativeFieldSchema* find_column_by_id(uint64_t column_id) const;
191-
void set_enable_mapping_varbinary(bool enable) { _enable_mapping_varbinary = enable; }
189+
// Retain the legacy caller API; V2 infers binary versus text solely from file annotations.
190+
void set_enable_mapping_varbinary(bool /*enable*/) {}
192191
void set_enable_mapping_timestamp_tz(bool enable) { _enable_mapping_timestamp_tz = enable; }
193192
};
194193

‎be/src/format_v2/parquet/parquet_reader.h‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -103,7 +103,8 @@ class ParquetReader : public format::FileReader {
103103
std::optional<format::GlobalRowIdContext> _global_rowid_context; // global RowId context
104104
size_t _batch_size = ParquetScanScheduler::DEFAULT_READ_BATCH_SIZE;
105105
bool _enable_mapping_timestamp_tz = false; // whether UTC timestamps are mapped to TIMESTAMPTZ
106-
bool _enable_mapping_varbinary = false; // whether raw BYTE_ARRAY is mapped to VARBINARY
106+
bool _enable_mapping_varbinary =
107+
false; // Legacy API option; V2 binary mapping is unconditional.
107108
std::shared_ptr<const FileContext> _file_context;
108109
int64_t _format_split_id = -1;
109110
int64_t _format_split_id_end = -1;

‎be/test/core/data_type_serde/data_type_serde_varbinary_test.cpp‎

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -510,4 +510,36 @@ TEST_F(DataTypeVarbinarySerDeTest, DeserializeOneCellFromJsonWithRawBytes) {
510510
}
511511
}
512512

513+
TEST_F(DataTypeVarbinarySerDeTest, OrcBinaryPreservesSelectedNullAndEmptyValues) {
514+
auto type = ::orc::createPrimitiveType(::orc::BINARY);
515+
::orc::StringVectorBatch batch(4, *::orc::getDefaultPool());
516+
batch.numElements = 4;
517+
batch.hasNulls = true;
518+
std::string bytes("a\0b\xff", 4);
519+
for (size_t i = 0; i < 4; ++i) {
520+
batch.notNull[i] = i != 1;
521+
batch.data[i] = bytes.data();
522+
batch.length[i] = bytes.size();
523+
}
524+
batch.data[1] = nullptr;
525+
batch.length[1] = -1; // NULL payloads must never be inspected.
526+
batch.data[2] = nullptr;
527+
batch.length[2] = 0;
528+
std::vector<size_t> selected {3, 1, 2, 0};
529+
OrcDecodedColumnView view {
530+
.file_type = type.get(), .batch = &batch, .rows = 4, .selected_rows = &selected};
531+
DataTypeVarbinarySerDe serde;
532+
auto column = ColumnVarbinary::create();
533+
for (int repeat = 0; repeat < 2; ++repeat) {
534+
ASSERT_TRUE(serde.read_column_from_orc(*column, view).ok());
535+
}
536+
ASSERT_EQ(column->size(), 8);
537+
for (size_t i = 0; i < column->size(); ++i) {
538+
EXPECT_EQ(column->get_data_at(i).to_string(), (i % 4 == 0 || i % 4 == 3) ? bytes : "");
539+
}
540+
batch.length[3] = -1;
541+
auto invalid = ColumnVarbinary::create();
542+
EXPECT_FALSE(serde.read_column_from_orc(*invalid, view).ok());
543+
}
544+
513545
} // namespace doris

‎be/test/format_v2/orc/orc_reader_test.cpp‎

Lines changed: 37 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,7 @@
5151
#include "core/column/column_nullable.h"
5252
#include "core/column/column_string.h"
5353
#include "core/column/column_struct.h"
54+
#include "core/column/column_varbinary.h"
5455
#include "core/column/column_vector.h"
5556
#include "core/data_type/data_type_array.h"
5657
#include "core/data_type/data_type_date.h"
@@ -1693,7 +1694,8 @@ class NullableStringEqualsExpr final : public VExpr {
16931694
size_t count, ColumnPtr& result_column) const override {
16941695
const auto& nullable_column =
16951696
assert_cast<const ColumnNullable&>(*block->get_by_position(_column_id).column);
1696-
const auto& input = assert_cast<const ColumnString&>(nullable_column.get_nested_column());
1697+
// Residual test comparisons apply to raw bytes in both string and binary columns.
1698+
const auto& input = nullable_column.get_nested_column();
16971699
auto result = ColumnUInt8::create();
16981700
auto& result_data = result->get_data();
16991701
result_data.resize(count);
@@ -8059,7 +8061,7 @@ TEST_F(NewOrcReaderTest, SargBinaryVarbinaryLiteralConjunctPrunesRowGroups) {
80598061
std::vector<format::ColumnDefinition> schema;
80608062
ASSERT_TRUE(reader->get_schema(&schema).ok());
80618063
ASSERT_EQ(schema.size(), 2);
8062-
EXPECT_EQ(remove_nullable(schema[0].type)->get_primitive_type(), TYPE_STRING);
8064+
EXPECT_EQ(remove_nullable(schema[0].type)->get_primitive_type(), TYPE_VARBINARY);
80638065

80648066
auto request = std::make_shared<format::FileScanRequest>();
80658067
request->predicate_columns = {field_projection(0)};
@@ -8117,7 +8119,7 @@ TEST_F(NewOrcReaderTest, SargExceptionsFallBackToResidualScan) {
81178119
if (add_real_residual_filter) {
81188120
request->conjuncts.push_back(
81198121
VExprContext::create_shared(std::make_shared<NullableStringEqualsExpr>(
8120-
0, std::make_shared<DataTypeString>(), "aaa_1050", "value")));
8122+
0, std::make_shared<DataTypeVarbinary>(), "aaa_1050", "value")));
81218123
}
81228124
*open_status = reader->open(request);
81238125
if (!open_status->ok()) {
@@ -8135,7 +8137,7 @@ TEST_F(NewOrcReaderTest, SargExceptionsFallBackToResidualScan) {
81358137
const auto& values_nullable =
81368138
assert_cast<const ColumnNullable&>(*block.get_by_position(0).column);
81378139
const auto& values =
8138-
assert_cast<const ColumnString&>(values_nullable.get_nested_column());
8140+
assert_cast<const ColumnVarbinary&>(values_nullable.get_nested_column());
81398141
for (size_t row = 0; row < rows; ++row) {
81408142
ASSERT_FALSE(values_nullable.is_null_at(row));
81418143
result_values->push_back(values.get_data_at(row).to_string());
@@ -8228,7 +8230,7 @@ TEST_F(NewOrcReaderTest, SargBinaryCastFromVarbinaryToStringConjunctPrunesRowGro
82288230
std::vector<format::ColumnDefinition> schema;
82298231
ASSERT_TRUE(reader->get_schema(&schema).ok());
82308232
ASSERT_EQ(schema.size(), 2);
8231-
EXPECT_EQ(remove_nullable(schema[0].type)->get_primitive_type(), TYPE_STRING);
8233+
EXPECT_EQ(remove_nullable(schema[0].type)->get_primitive_type(), TYPE_VARBINARY);
82328234

82338235
auto request = std::make_shared<format::FileScanRequest>();
82348236
request->predicate_columns = {field_projection(0)};
@@ -10401,6 +10403,34 @@ TEST_F(NewOrcReaderTest, ReadsOnlyRequestedAbsoluteFileRows) {
1040110403
EXPECT_EQ(ids, std::vector<int32_t>({1, 3, 5}));
1040210404
}
1040310405

10406+
TEST_F(NewOrcReaderTest, NestedBinarySchemaRetainsBinarySemantics) {
10407+
auto type = ::orc::Type::buildTypeFromString(
10408+
"struct<b:binary,s:string,a:array<binary>,m:map<string,binary>,r:struct<b:binary>>");
10409+
MemoryOutputStream stream(1024);
10410+
::orc::WriterOptions options;
10411+
auto writer = ::orc::createWriter(*type, &stream, options);
10412+
writer->close();
10413+
const auto path = (_test_dir / "nested_binary.orc").string();
10414+
std::ofstream out(path, std::ios::binary);
10415+
out.write(stream.getData(), static_cast<std::streamsize>(stream.getLength()));
10416+
out.close();
10417+
auto reader = create_reader_for_path(path);
10418+
RuntimeState state {TQueryOptions(), TQueryGlobals()};
10419+
ASSERT_TRUE(reader->init(&state).ok());
10420+
std::vector<format::ColumnDefinition> schema;
10421+
ASSERT_TRUE(reader->get_schema(&schema).ok());
10422+
ASSERT_EQ(schema.size(), 5);
10423+
EXPECT_EQ(schema[0].type->get_primitive_type(), TYPE_VARBINARY);
10424+
EXPECT_EQ(schema[1].type->get_primitive_type(), TYPE_STRING);
10425+
const auto& array = assert_cast<const DataTypeArray&>(*remove_nullable(schema[2].type));
10426+
EXPECT_EQ(array.get_nested_type()->get_primitive_type(), TYPE_VARBINARY);
10427+
const auto& map = assert_cast<const DataTypeMap&>(*remove_nullable(schema[3].type));
10428+
EXPECT_EQ(map.get_key_type()->get_primitive_type(), TYPE_STRING);
10429+
EXPECT_EQ(map.get_value_type()->get_primitive_type(), TYPE_VARBINARY);
10430+
const auto& structure = assert_cast<const DataTypeStruct&>(*remove_nullable(schema[4].type));
10431+
EXPECT_EQ(structure.get_elements()[0]->get_primitive_type(), TYPE_VARBINARY);
10432+
}
10433+
1040410434
TEST_F(NewOrcReaderTest, ReadPrimitiveTypesWithNulls) {
1040510435
const auto primitive_file_path = (_test_dir / "primitive.orc").string();
1040610436
write_primitive_orc_file(primitive_file_path);
@@ -10420,7 +10450,7 @@ TEST_F(NewOrcReaderTest, ReadPrimitiveTypesWithNulls) {
1042010450
EXPECT_EQ(remove_nullable(schema[5].type)->get_primitive_type(), TYPE_FLOAT);
1042110451
EXPECT_EQ(remove_nullable(schema[6].type)->get_primitive_type(), TYPE_DOUBLE);
1042210452
EXPECT_EQ(remove_nullable(schema[7].type)->get_primitive_type(), TYPE_STRING);
10423-
EXPECT_EQ(remove_nullable(schema[8].type)->get_primitive_type(), TYPE_STRING);
10453+
ASSERT_EQ(remove_nullable(schema[8].type)->get_primitive_type(), TYPE_VARBINARY);
1042410454
EXPECT_EQ(remove_nullable(schema[9].type)->get_primitive_type(), TYPE_VARCHAR);
1042510455
EXPECT_EQ(remove_nullable(schema[10].type)->get_primitive_type(), TYPE_CHAR);
1042610456
EXPECT_EQ(remove_nullable(schema[11].type)->get_primitive_type(), TYPE_DATEV2);
@@ -10475,7 +10505,7 @@ TEST_F(NewOrcReaderTest, ReadPrimitiveTypesWithNulls) {
1047510505
const auto& string_values = assert_cast<const ColumnString&>(
1047610506
assert_cast<const ColumnNullable&>(*block.get_by_position(7).column)
1047710507
.get_nested_column());
10478-
const auto& binary_values = assert_cast<const ColumnString&>(
10508+
const auto& binary_values = assert_cast<const ColumnVarbinary&>(
1047910509
assert_cast<const ColumnNullable&>(*block.get_by_position(8).column)
1048010510
.get_nested_column());
1048110511
const auto& varchar_values = assert_cast<const ColumnString&>(

‎be/test/format_v2/parquet/parquet_reader_test.cpp‎

Lines changed: 14 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,7 @@
4949
#include "core/column/column_nullable.h"
5050
#include "core/column/column_string.h"
5151
#include "core/column/column_struct.h"
52+
#include "core/column/column_varbinary.h"
5253
#include "core/column/column_vector.h"
5354
#include "core/column/variant_v2/column_variant_v2.h"
5455
#include "core/data_type/data_type_array.h"
@@ -2239,17 +2240,17 @@ TEST_F(NewParquetReaderTest, GetSchemaReturnsFileLocalColumns) {
22392240
EXPECT_EQ(remove_nullable(schema[1].type)->get_primitive_type(), TYPE_STRING);
22402241
}
22412242

2242-
TEST_F(NewParquetReaderTest, RawByteArrayMappingFollowsV2ScanOption) {
2243+
TEST_F(NewParquetReaderTest, RawByteArrayMappingIgnoresLegacyOption) {
22432244
write_unannotated_binary_parquet_file(_file_path);
22442245
RuntimeState state {TQueryOptions(), TQueryGlobals()};
22452246

2246-
auto string_reader = create_reader();
2247-
const auto string_init_status = string_reader->init(&state);
2248-
ASSERT_TRUE(string_init_status.ok()) << string_init_status;
2249-
std::vector<format::ColumnDefinition> string_schema;
2250-
ASSERT_TRUE(string_reader->get_schema(&string_schema).ok());
2251-
ASSERT_EQ(string_schema.size(), 1);
2252-
EXPECT_EQ(remove_nullable(string_schema[0].type)->get_primitive_type(), TYPE_STRING);
2247+
auto default_reader = create_reader();
2248+
const auto default_init_status = default_reader->init(&state);
2249+
ASSERT_TRUE(default_init_status.ok()) << default_init_status;
2250+
std::vector<format::ColumnDefinition> default_schema;
2251+
ASSERT_TRUE(default_reader->get_schema(&default_schema).ok());
2252+
ASSERT_EQ(default_schema.size(), 1);
2253+
EXPECT_EQ(remove_nullable(default_schema[0].type)->get_primitive_type(), TYPE_VARBINARY);
22532254

22542255
RuntimeProfile binary_profile("raw_binary_mapping_profile");
22552256
auto binary_reader =
@@ -2259,7 +2260,7 @@ TEST_F(NewParquetReaderTest, RawByteArrayMappingFollowsV2ScanOption) {
22592260
std::vector<format::ColumnDefinition> binary_schema;
22602261
ASSERT_TRUE(binary_reader->get_schema(&binary_schema).ok());
22612262
ASSERT_EQ(binary_schema.size(), 1);
2262-
// The explicit VARBINARY mapping must remain available for scans whose table contract asks for it.
2263+
// The legacy option cannot reinterpret raw bytes as text.
22632264
EXPECT_EQ(remove_nullable(binary_schema[0].type)->get_primitive_type(), TYPE_VARBINARY);
22642265

22652266
auto request = std::make_shared<format::FileScanRequest>();
@@ -3615,7 +3616,7 @@ TEST_F(NewParquetReaderTest, NativeDecimalAndFixedBinaryMaterializeDirectly) {
36153616
EXPECT_EQ(decimals.get_element(1), Decimal128V3(-1));
36163617
EXPECT_EQ(decimals.get_element(3), Decimal128V3(-987654321));
36173618

3618-
const auto& fixed_values = assert_cast<const ColumnString&>(
3619+
const auto& fixed_values = assert_cast<const ColumnVarbinary&>(
36193620
assert_cast<const ColumnNullable&>(*output[1]).get_nested_column());
36203621
ASSERT_EQ(fixed_values.size(), ROW_COUNT);
36213622
EXPECT_EQ(fixed_values.get_data_at(0).to_string(), "ABCD");
@@ -5026,8 +5027,9 @@ TEST_F(NewParquetReaderTest, AllFixedWidthDictionaryTypesDecodeThroughDictionary
50265027
EXPECT_EQ(total_rows, 6);
50275028
EXPECT_EQ(profile.get_counter("RowsFilteredByDictFilter")->value(), 0);
50285029
EXPECT_EQ(profile.get_counter("DictFilterCandidateColumns")->value(), 5);
5029-
EXPECT_EQ(profile.get_counter("DictFilterColumns")->value(), 5);
5030-
EXPECT_EQ(profile.get_counter("DictFilterUnsupportedColumns")->value(), 0);
5030+
// The fixed binary file leaf now has VARBINARY semantics and stays on residual filtering.
5031+
EXPECT_EQ(profile.get_counter("DictFilterColumns")->value(), 4);
5032+
EXPECT_EQ(profile.get_counter("DictFilterUnsupportedColumns")->value(), 1);
50315033
EXPECT_EQ(profile.get_counter("DictFilterReadFailures")->value(), 0);
50325034
}
50335035

0 commit comments

Comments
 (0)