620 lines
28 KiB
C++
620 lines
28 KiB
C++
// Licensed to the Apache Software Foundation (ASF) under one
|
|
// or more contributor license agreements. See the NOTICE file
|
|
// distributed with this work for additional information
|
|
// regarding copyright ownership. The ASF licenses this file
|
|
// to you under the Apache License, Version 2.0 (the
|
|
// "License"); you may not use this file except in compliance
|
|
// with the License. You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing,
|
|
// software distributed under the License is distributed on an
|
|
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
// KIND, either express or implied. See the License for the
|
|
// specific language governing permissions and limitations
|
|
// under the License.
|
|
|
|
#include "olap/null_predicate.h"
|
|
|
|
#include <google/protobuf/stubs/common.h>
|
|
#include <gtest/gtest.h>
|
|
#include <time.h>
|
|
|
|
#include "olap/column_predicate.h"
|
|
#include "olap/field.h"
|
|
#include "olap/row_block2.h"
|
|
#include "runtime/mem_pool.h"
|
|
#include "runtime/string_value.hpp"
|
|
#include "util/logging.h"
|
|
#include "vec/columns/column_nullable.h"
|
|
#include "vec/core/block.h"
|
|
|
|
using namespace doris::vectorized;
|
|
|
|
namespace doris {
|
|
|
|
namespace datetime {
|
|
|
|
static uint24_t to_date_timestamp(const char* date_string) {
|
|
tm time_tm;
|
|
strptime(date_string, "%Y-%m-%d", &time_tm);
|
|
|
|
int value = (time_tm.tm_year + 1900) * 16 * 32 + (time_tm.tm_mon + 1) * 32 + time_tm.tm_mday;
|
|
return uint24_t(value);
|
|
}
|
|
|
|
static uint32_t to_date_v2_timestamp(const char* date_string) {
|
|
tm time_tm;
|
|
strptime(date_string, "%Y-%m-%d", &time_tm);
|
|
|
|
return ((time_tm.tm_year + 1900) << 16) | ((time_tm.tm_mon + 1) << 8) | time_tm.tm_mday;
|
|
}
|
|
|
|
}; // namespace datetime
|
|
|
|
class TestNullPredicate : public testing::Test {
|
|
public:
|
|
TestNullPredicate() : _row_block(nullptr) {
|
|
_mem_tracker.reset(new MemTracker(-1));
|
|
_mem_pool.reset(new MemPool(_mem_tracker.get()));
|
|
}
|
|
|
|
~TestNullPredicate() {}
|
|
|
|
void SetTabletSchema(std::string name, std::string type, std::string aggregation,
|
|
uint32_t length, bool is_allow_null, bool is_key,
|
|
TabletSchema* tablet_schema) {
|
|
TabletSchemaPB tablet_schema_pb;
|
|
static int id = 0;
|
|
ColumnPB* column = tablet_schema_pb.add_column();
|
|
;
|
|
column->set_unique_id(++id);
|
|
column->set_name(name);
|
|
column->set_type(type);
|
|
column->set_is_key(is_key);
|
|
column->set_is_nullable(is_allow_null);
|
|
column->set_length(length);
|
|
column->set_aggregation(aggregation);
|
|
column->set_precision(1000);
|
|
column->set_frac(1000);
|
|
column->set_is_bf_column(false);
|
|
tablet_schema->init_from_pb(tablet_schema_pb);
|
|
}
|
|
|
|
void init_row_block(const TabletSchema* tablet_schema, int size) {
|
|
_schema = std::make_unique<Schema>(*tablet_schema);
|
|
_row_block.reset(new RowBlockV2(*_schema, size));
|
|
}
|
|
|
|
std::shared_ptr<MemTracker> _mem_tracker;
|
|
std::unique_ptr<MemPool> _mem_pool;
|
|
std::unique_ptr<RowBlockV2> _row_block;
|
|
std::unique_ptr<Schema> _schema;
|
|
};
|
|
|
|
#define TEST_IN_LIST_PREDICATE(TYPE, TYPE_NAME, FIELD_TYPE) \
|
|
TEST_F(TestNullPredicate, TYPE_NAME##_COLUMN) { \
|
|
TabletSchema tablet_schema; \
|
|
SetTabletSchema(std::string("TYPE_NAME##_COLUMN"), FIELD_TYPE, "REPLACE", 1, true, true, \
|
|
&tablet_schema); \
|
|
int size = 10; \
|
|
std::vector<uint32_t> return_columns; \
|
|
for (int i = 0; i < tablet_schema.num_columns(); ++i) { \
|
|
return_columns.push_back(i); \
|
|
} \
|
|
std::unique_ptr<ColumnPredicate> pred(new NullPredicate(0, true)); \
|
|
\
|
|
/* for ColumnBlock nulls */ \
|
|
init_row_block(&tablet_schema, size); \
|
|
ColumnBlock col_block = _row_block->column_block(0); \
|
|
auto select_size = _row_block->selected_size(); \
|
|
ColumnBlockView col_block_view(&col_block); \
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) { \
|
|
col_block_view.set_null_bits(1, false); \
|
|
*reinterpret_cast<TYPE*>(col_block_view.data()) = i; \
|
|
} \
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); \
|
|
EXPECT_EQ(select_size, 0); \
|
|
\
|
|
/* for vectorized::Block no null */ \
|
|
_row_block->clear(); \
|
|
select_size = _row_block->selected_size(); \
|
|
vectorized::Block vec_block = tablet_schema.create_block(return_columns); \
|
|
_row_block->convert_to_vec_block(&vec_block); \
|
|
ColumnPtr vec_col = vec_block.get_columns()[0]; \
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col), \
|
|
_row_block->selection_vector(), select_size); \
|
|
EXPECT_EQ(select_size, 0); \
|
|
\
|
|
/* for ColumnBlock has nulls */ \
|
|
col_block_view = ColumnBlockView(&col_block); \
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) { \
|
|
if (i % 2 == 0) { \
|
|
col_block_view.set_null_bits(1, true); \
|
|
} else { \
|
|
col_block_view.set_null_bits(1, false); \
|
|
*reinterpret_cast<TYPE*>(col_block_view.data()) = i; \
|
|
} \
|
|
} \
|
|
_row_block->clear(); \
|
|
select_size = _row_block->selected_size(); \
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size); \
|
|
EXPECT_EQ(select_size, 5); \
|
|
\
|
|
/* for vectorized::Block has nulls */ \
|
|
_row_block->clear(); \
|
|
select_size = _row_block->selected_size(); \
|
|
vec_block = tablet_schema.create_block(return_columns); \
|
|
_row_block->convert_to_vec_block(&vec_block); \
|
|
vec_col = vec_block.get_columns()[0]; \
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col), \
|
|
_row_block->selection_vector(), select_size); \
|
|
EXPECT_EQ(select_size, 5); \
|
|
pred.reset(); \
|
|
}
|
|
|
|
TEST_IN_LIST_PREDICATE(int8_t, TINYINT, "TINYINT")
|
|
TEST_IN_LIST_PREDICATE(int16_t, SMALLINT, "SMALLINT")
|
|
TEST_IN_LIST_PREDICATE(int32_t, INT, "INT")
|
|
TEST_IN_LIST_PREDICATE(int64_t, BIGINT, "BIGINT")
|
|
TEST_IN_LIST_PREDICATE(int128_t, LARGEINT, "LARGEINT")
|
|
|
|
TEST_F(TestNullPredicate, FLOAT_COLUMN) {
|
|
TabletSchema tablet_schema;
|
|
SetTabletSchema(std::string("FLOAT_COLUMN"), "FLOAT", "REPLACE", 1, true, true, &tablet_schema);
|
|
int size = 10;
|
|
std::vector<uint32_t> return_columns;
|
|
for (int i = 0; i < tablet_schema.num_columns(); ++i) {
|
|
return_columns.push_back(i);
|
|
}
|
|
std::unique_ptr<ColumnPredicate> pred(new NullPredicate(0, true));
|
|
|
|
// for ColumnBlock no nulls
|
|
init_row_block(&tablet_schema, size);
|
|
ColumnBlock col_block = _row_block->column_block(0);
|
|
auto select_size = _row_block->selected_size();
|
|
ColumnBlockView col_block_view(&col_block);
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
col_block_view.set_null_bits(1, false);
|
|
*reinterpret_cast<float*>(col_block_view.data()) = i + 0.1;
|
|
}
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for vectorized::Block no null
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vectorized::Block vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
ColumnPtr vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for ColumnBlock has nulls
|
|
col_block_view = ColumnBlockView(&col_block);
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
if (i % 2 == 0) {
|
|
col_block_view.set_null_bits(1, true);
|
|
} else {
|
|
col_block_view.set_null_bits(1, false);
|
|
*reinterpret_cast<float*>(col_block_view.data()) = i + 0.1;
|
|
}
|
|
}
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 5);
|
|
|
|
// for vectorized::Block has nulls
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 5);
|
|
}
|
|
|
|
TEST_F(TestNullPredicate, DOUBLE_COLUMN) {
|
|
TabletSchema tablet_schema;
|
|
SetTabletSchema(std::string("DOUBLE_COLUMN"), "DOUBLE", "REPLACE", 1, true, true,
|
|
&tablet_schema);
|
|
int size = 10;
|
|
std::vector<uint32_t> return_columns;
|
|
for (int i = 0; i < tablet_schema.num_columns(); ++i) {
|
|
return_columns.push_back(i);
|
|
}
|
|
std::unique_ptr<ColumnPredicate> pred(new NullPredicate(0, true));
|
|
|
|
// for ColumnBlock no nulls
|
|
init_row_block(&tablet_schema, size);
|
|
ColumnBlock col_block = _row_block->column_block(0);
|
|
auto select_size = _row_block->selected_size();
|
|
ColumnBlockView col_block_view(&col_block);
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
col_block_view.set_null_bits(1, false);
|
|
*reinterpret_cast<double*>(col_block_view.data()) = i + 0.1;
|
|
}
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for vectorized::Block no null
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vectorized::Block vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
ColumnPtr vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for ColumnBlock has nulls
|
|
col_block_view = ColumnBlockView(&col_block);
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
if (i % 2 == 0) {
|
|
col_block_view.set_null_bits(1, true);
|
|
} else {
|
|
col_block_view.set_null_bits(1, false);
|
|
*reinterpret_cast<double*>(col_block_view.data()) = i + 0.1;
|
|
}
|
|
}
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 5);
|
|
|
|
// for vectorized::Block has nulls
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 5);
|
|
}
|
|
|
|
TEST_F(TestNullPredicate, DECIMAL_COLUMN) {
|
|
TabletSchema tablet_schema;
|
|
SetTabletSchema(std::string("DECIMAL_COLUMN"), "DECIMAL", "REPLACE", 1, true, true,
|
|
&tablet_schema);
|
|
int size = 10;
|
|
std::vector<uint32_t> return_columns;
|
|
for (int i = 0; i < tablet_schema.num_columns(); ++i) {
|
|
return_columns.push_back(i);
|
|
}
|
|
std::unique_ptr<ColumnPredicate> pred(new NullPredicate(0, true));
|
|
|
|
// for ColumnBlock no nulls
|
|
init_row_block(&tablet_schema, size);
|
|
ColumnBlock col_block = _row_block->column_block(0);
|
|
auto select_size = _row_block->selected_size();
|
|
ColumnBlockView col_block_view(&col_block);
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
col_block_view.set_null_bits(1, false);
|
|
reinterpret_cast<decimal12_t*>(col_block_view.data())->integer = i;
|
|
reinterpret_cast<decimal12_t*>(col_block_view.data())->fraction = i;
|
|
}
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for vectorized::Block no null
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vectorized::Block vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
ColumnPtr vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for ColumnBlock has nulls
|
|
col_block_view = ColumnBlockView(&col_block);
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
if (i % 3 == 0) {
|
|
col_block_view.set_null_bits(1, true);
|
|
} else {
|
|
col_block_view.set_null_bits(1, false);
|
|
reinterpret_cast<decimal12_t*>(col_block_view.data())->integer = i;
|
|
reinterpret_cast<decimal12_t*>(col_block_view.data())->fraction = i;
|
|
}
|
|
}
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 4);
|
|
|
|
// for vectorized::Block has nulls
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 4);
|
|
}
|
|
|
|
TEST_F(TestNullPredicate, STRING_COLUMN) {
|
|
TabletSchema tablet_schema;
|
|
SetTabletSchema(std::string("STRING_COLUMN"), "VARCHAR", "REPLACE", 1, true, true,
|
|
&tablet_schema);
|
|
int size = 10;
|
|
std::vector<uint32_t> return_columns;
|
|
for (int i = 0; i < tablet_schema.num_columns(); ++i) {
|
|
return_columns.push_back(i);
|
|
}
|
|
std::unique_ptr<ColumnPredicate> pred(new NullPredicate(0, true));
|
|
|
|
// for ColumnBlock no nulls
|
|
init_row_block(&tablet_schema, size);
|
|
ColumnBlock col_block = _row_block->column_block(0);
|
|
auto select_size = _row_block->selected_size();
|
|
ColumnBlockView col_block_view(&col_block);
|
|
|
|
char* string_buffer = reinterpret_cast<char*>(_mem_pool->allocate(55));
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
col_block_view.set_null_bits(1, false);
|
|
for (int j = 0; j <= i; ++j) {
|
|
string_buffer[j] = 'a' + i;
|
|
}
|
|
reinterpret_cast<StringValue*>(col_block_view.data())->len = i + 1;
|
|
reinterpret_cast<StringValue*>(col_block_view.data())->ptr = string_buffer;
|
|
string_buffer += i + 1;
|
|
}
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for vectorized::Block no null
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vectorized::Block vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
ColumnPtr vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for ColumnBlock has nulls
|
|
col_block_view = ColumnBlockView(&col_block);
|
|
string_buffer = reinterpret_cast<char*>(_mem_pool->allocate(55));
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
if (i % 3 == 0) {
|
|
col_block_view.set_null_bits(1, true);
|
|
} else {
|
|
col_block_view.set_null_bits(1, false);
|
|
for (int j = 0; j <= i; ++j) {
|
|
string_buffer[j] = 'a' + i;
|
|
}
|
|
reinterpret_cast<StringValue*>(col_block_view.data())->len = i + 1;
|
|
reinterpret_cast<StringValue*>(col_block_view.data())->ptr = string_buffer;
|
|
string_buffer += i + 1;
|
|
}
|
|
}
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 4);
|
|
|
|
// for vectorized::Block has nulls
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 4);
|
|
}
|
|
|
|
TEST_F(TestNullPredicate, DATE_COLUMN) {
|
|
TabletSchema tablet_schema;
|
|
SetTabletSchema(std::string("DATE_COLUMN"), "DATE", "REPLACE", 1, true, true, &tablet_schema);
|
|
int size = 6;
|
|
std::vector<uint32_t> return_columns;
|
|
for (int i = 0; i < tablet_schema.num_columns(); ++i) {
|
|
return_columns.push_back(i);
|
|
}
|
|
std::unique_ptr<ColumnPredicate> pred(new NullPredicate(0, true));
|
|
|
|
std::vector<std::string> date_array;
|
|
date_array.push_back("2017-09-07");
|
|
date_array.push_back("2017-09-08");
|
|
date_array.push_back("2017-09-09");
|
|
date_array.push_back("2017-09-10");
|
|
date_array.push_back("2017-09-11");
|
|
date_array.push_back("2017-09-12");
|
|
|
|
// for ColumnBlock no nulls
|
|
init_row_block(&tablet_schema, size);
|
|
ColumnBlock col_block = _row_block->column_block(0);
|
|
auto select_size = _row_block->selected_size();
|
|
ColumnBlockView col_block_view(&col_block);
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
col_block_view.set_null_bits(1, false);
|
|
uint24_t timestamp = datetime::to_date_timestamp(date_array[i].c_str());
|
|
*reinterpret_cast<uint24_t*>(col_block_view.data()) = timestamp;
|
|
}
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for vectorized::Block no null
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vectorized::Block vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
ColumnPtr vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for ColumnBlock has nulls
|
|
col_block_view = ColumnBlockView(&col_block);
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
if (i % 3 == 0) {
|
|
col_block_view.set_null_bits(1, true);
|
|
} else {
|
|
col_block_view.set_null_bits(1, false);
|
|
uint24_t timestamp = datetime::to_date_timestamp(date_array[i].c_str());
|
|
*reinterpret_cast<uint24_t*>(col_block_view.data()) = timestamp;
|
|
}
|
|
}
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 2);
|
|
|
|
// for vectorized::Block has nulls
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 2);
|
|
}
|
|
|
|
TEST_F(TestNullPredicate, DATETIME_COLUMN) {
|
|
TabletSchema tablet_schema;
|
|
SetTabletSchema(std::string("DATETIME_COLUMN"), "DATETIME", "REPLACE", 1, true, true,
|
|
&tablet_schema);
|
|
int size = 6;
|
|
std::vector<uint32_t> return_columns;
|
|
for (int i = 0; i < tablet_schema.num_columns(); ++i) {
|
|
return_columns.push_back(i);
|
|
}
|
|
std::unique_ptr<ColumnPredicate> pred(new NullPredicate(0, true));
|
|
|
|
std::vector<std::string> date_array;
|
|
date_array.push_back("2017-09-07");
|
|
date_array.push_back("2017-09-08");
|
|
date_array.push_back("2017-09-09");
|
|
date_array.push_back("2017-09-10");
|
|
date_array.push_back("2017-09-11");
|
|
date_array.push_back("2017-09-12");
|
|
|
|
// for ColumnBlock no nulls
|
|
init_row_block(&tablet_schema, size);
|
|
ColumnBlock col_block = _row_block->column_block(0);
|
|
auto select_size = _row_block->selected_size();
|
|
ColumnBlockView col_block_view(&col_block);
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
col_block_view.set_null_bits(1, false);
|
|
uint64_t timestamp = datetime::to_date_timestamp(date_array[i].c_str());
|
|
*reinterpret_cast<uint64_t*>(col_block_view.data()) = timestamp;
|
|
}
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for vectorized::Block no null
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vectorized::Block vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
ColumnPtr vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for ColumnBlock has nulls
|
|
col_block_view = ColumnBlockView(&col_block);
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
if (i % 3 == 0) {
|
|
col_block_view.set_null_bits(1, true);
|
|
} else {
|
|
col_block_view.set_null_bits(1, false);
|
|
uint64_t timestamp = datetime::to_date_timestamp(date_array[i].c_str());
|
|
*reinterpret_cast<uint64_t*>(col_block_view.data()) = timestamp;
|
|
}
|
|
}
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 2);
|
|
|
|
// for vectorized::Block has nulls
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 2);
|
|
}
|
|
|
|
TEST_F(TestNullPredicate, DATEV2_COLUMN) {
|
|
TabletSchema tablet_schema;
|
|
SetTabletSchema(std::string("DATEV2_COLUMN"), "DATEV2", "REPLACE", 4, true, true,
|
|
&tablet_schema);
|
|
int size = 6;
|
|
std::vector<uint32_t> return_columns;
|
|
for (int i = 0; i < tablet_schema.num_columns(); ++i) {
|
|
return_columns.push_back(i);
|
|
}
|
|
std::unique_ptr<ColumnPredicate> pred(new NullPredicate(0, true));
|
|
|
|
std::vector<std::string> date_array;
|
|
date_array.push_back("2017-09-07");
|
|
date_array.push_back("2017-09-08");
|
|
date_array.push_back("2017-09-09");
|
|
date_array.push_back("2017-09-10");
|
|
date_array.push_back("2017-09-11");
|
|
date_array.push_back("2017-09-12");
|
|
|
|
// for ColumnBlock no nulls
|
|
init_row_block(&tablet_schema, size);
|
|
ColumnBlock col_block = _row_block->column_block(0);
|
|
auto select_size = _row_block->selected_size();
|
|
ColumnBlockView col_block_view(&col_block);
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
col_block_view.set_null_bits(1, false);
|
|
uint32_t timestamp = datetime::to_date_v2_timestamp(date_array[i].c_str());
|
|
*reinterpret_cast<uint32_t*>(col_block_view.data()) = timestamp;
|
|
}
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for vectorized::Block no null
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vectorized::Block vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
ColumnPtr vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 0);
|
|
|
|
// for ColumnBlock has nulls
|
|
col_block_view = ColumnBlockView(&col_block);
|
|
for (int i = 0; i < size; ++i, col_block_view.advance(1)) {
|
|
if (i % 3 == 0) {
|
|
col_block_view.set_null_bits(1, true);
|
|
} else {
|
|
col_block_view.set_null_bits(1, false);
|
|
uint32_t timestamp = datetime::to_date_v2_timestamp(date_array[i].c_str());
|
|
*reinterpret_cast<uint32_t*>(col_block_view.data()) = timestamp;
|
|
}
|
|
}
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
pred->evaluate(&col_block, _row_block->selection_vector(), &select_size);
|
|
EXPECT_EQ(select_size, 2);
|
|
|
|
// for vectorized::Block has nulls
|
|
_row_block->clear();
|
|
select_size = _row_block->selected_size();
|
|
vec_block = tablet_schema.create_block(return_columns);
|
|
_row_block->convert_to_vec_block(&vec_block);
|
|
vec_col = vec_block.get_columns()[0];
|
|
select_size = pred->evaluate(const_cast<doris::vectorized::IColumn&>(*vec_col),
|
|
_row_block->selection_vector(), select_size);
|
|
EXPECT_EQ(select_size, 2);
|
|
}
|
|
|
|
} // namespace doris
|