database/doris
2
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity
Files
51beba6796cf8186221fdffc19a161ca82dae287
doris/be/test/olap/column_reader_test.cpp
李超勇 6486be64c3 fix license statement (#29) 
* change picture to word

* change picture to word

* SHOW FULL TABLES WHERE Table_type != VIEW sql can not execute

* change license description
2017-08-18 19:16:23 +08:00

3050 lines
99 KiB
C++
Executable File
Raw Blame History

// Copyright (c) 2017, Baidu.com, Inc. All Rights Reserved
// Licensed 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 <gtest/gtest.h>
#include "olap/column_file/byte_buffer.h"
#include "olap/column_file/stream_name.h"
#include "olap/column_file/column_reader.h"
#include "olap/column_file/column_writer.h"
#include "olap/field.h"
#include "olap/olap_define.h"
#include "olap/olap_common.h"
#include "olap/row_cursor.h"
#include "util/logging.h"
using std::string;
namespace palo {
namespace column_file {
class TestColumn : public testing::Test {
public:
TestColumn() :
_column_writer(NULL),
_column_reader(NULL),
_stream_factory(NULL) {
_offsets.clear();
_map_in_streams.clear();
_present_buffers.clear();
_data_buffers.clear();
_second_buffers.clear();
_dictionary_buffers.clear();
_length_buffers.clear();
}
virtual ~TestColumn() {
SAFE_DELETE(_column_writer);
SAFE_DELETE(_column_reader);
SAFE_DELETE(_stream_factory);
}
virtual void SetUp() {
_offsets.push_back(0);
_stream_factory =
new(std::nothrow) OutStreamFactory(COMPRESS_LZO,
OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE);
ASSERT_TRUE(_stream_factory != NULL);
config::column_dictionary_key_ration_threshold = 30;
config::column_dictionary_key_size_threshold = 1000;
}
virtual void TearDown() {
SAFE_DELETE(_column_writer);
SAFE_DELETE(_column_reader);
SAFE_DELETE(_stream_factory);
SAFE_DELETE(_shared_buffer);
_offsets.clear();
_map_in_streams.clear();
_present_buffers.clear();
_data_buffers.clear();
_second_buffers.clear();
_dictionary_buffers.clear();
_length_buffers.clear();
}
void CreateColumnWriter(const std::vector<FieldInfo> &tablet_schema) {
_column_writer = ColumnWriter::create(
0, tablet_schema, _stream_factory, 1024, BLOOM_FILTER_DEFAULT_FPP);
ASSERT_TRUE(_column_writer != NULL);
ASSERT_EQ(_column_writer->init(), OLAP_SUCCESS);
}
void CreateColumnReader(const std::vector<FieldInfo> &tablet_schema) {
UniqueIdEncodingMap encodings;
encodings[0] = ColumnEncodingMessage();
encodings[0].set_kind(ColumnEncodingMessage::DIRECT);
encodings[0].set_dictionary_size(1);
CreateColumnReader(tablet_schema, encodings);
}
void CreateColumnReader(
const std::vector<FieldInfo> &tablet_schema,
UniqueIdEncodingMap &encodings) {
UniqueIdToColumnIdMap included;
included[0] = 0;
UniqueIdToColumnIdMap segment_included;
segment_included[0] = 0;
//UniqueIdSet segment_columns;
//segment_columns.insert(0);
_column_reader = ColumnReader::create(0,
tablet_schema,
included,
segment_included,
encodings);
ASSERT_TRUE(_column_reader != NULL);
system("rm ./tmp_file");
ASSERT_EQ(OLAP_SUCCESS,
helper.open_with_mode("tmp_file",
O_CREAT | O_EXCL | O_WRONLY,
S_IRUSR | S_IWUSR));
std::vector<int> off;
std::vector<int> length;
std::vector<int> buffer_size;
std::vector<StreamName> name;
for (std::map<StreamName, OutStream*>::const_iterator it = _stream_factory->streams().begin();
it != _stream_factory->streams().end(); ++it) {
StreamName stream_name = it->first;
OutStream *out_stream = it->second;
std::vector<ByteBuffer*> *buffers;
if (out_stream->is_suppressed()) {
continue;
}
if (stream_name.kind() == StreamInfoMessage::ROW_INDEX) {
continue;
} else if (stream_name.kind() == StreamInfoMessage::PRESENT) {
buffers = &_present_buffers;
} else if (stream_name.kind() == StreamInfoMessage::DATA) {
buffers = &_data_buffers;
} else if (stream_name.kind() == StreamInfoMessage::SECONDARY) {
buffers = &_second_buffers;
} else if (stream_name.kind() == StreamInfoMessage::DICTIONARY_DATA) {
buffers = &_dictionary_buffers;
} else if (stream_name.kind() == StreamInfoMessage::LENGTH) {
buffers = &_length_buffers;
} else {
ASSERT_TRUE(false);
}
ASSERT_TRUE(buffers != NULL);
off.push_back(helper.tell());
out_stream->write_to_file(&helper, 0);
length.push_back(out_stream->get_stream_length());
buffer_size.push_back(out_stream->get_total_buffer_size());
name.push_back(stream_name);
}
helper.close();
ASSERT_EQ(OLAP_SUCCESS, helper.open_with_mode("tmp_file",
O_RDONLY, S_IRUSR | S_IWUSR));
_shared_buffer = ByteBuffer::create(
OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE + sizeof(StreamHead));
ASSERT_TRUE(_shared_buffer != NULL);
for (int i = 0; i < off.size(); ++i) {
ReadOnlyFileStream* in_stream = new (std::nothrow) ReadOnlyFileStream(
&helper,
&_shared_buffer,
off[i],
length[i],
lzo_decompress,
buffer_size[i]);
ASSERT_EQ(OLAP_SUCCESS, in_stream->init());
_map_in_streams[name[i]] = in_stream;
}
ASSERT_EQ(_column_reader->init(&_map_in_streams), OLAP_SUCCESS);
}
void SetFieldInfo(FieldInfo &field_info,
std::string name,
FieldType type,
FieldAggregationMethod aggregation,
uint32_t length,
bool is_allow_null,
bool is_key) {
field_info.name = name;
field_info.type = type;
field_info.aggregation = aggregation;
field_info.length = length;
field_info.is_allow_null = is_allow_null;
field_info.is_key = is_key;
field_info.precision = 1000;
field_info.frac = 10000;
field_info.unique_id = 0;
field_info.is_bf_column = false;
}
void create_and_save_last_position() {
ASSERT_EQ(_column_writer->create_row_index_entry(), OLAP_SUCCESS);
}
ColumnWriter *_column_writer;
ColumnReader *_column_reader;
OutStreamFactory *_stream_factory;
std::vector<size_t> _offsets;
std::vector<ByteBuffer*> _present_buffers;
std::vector<ByteBuffer*> _data_buffers;
std::vector<ByteBuffer*> _second_buffers;
std::vector<ByteBuffer*> _dictionary_buffers;
std::vector<ByteBuffer*> _length_buffers;
ByteBuffer* _shared_buffer;
std::map<StreamName, ReadOnlyFileStream *> _map_in_streams;
FileHandler helper;
};
TEST_F(TestColumn, TinyColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("TinyColumn"),
OLAP_FIELD_TYPE_TINYINT,
OLAP_FIELD_AGGREGATION_REPLACE,
1,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
char value = 1;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(&value);
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(&value);
ASSERT_EQ(value, 3);
ASSERT_NE(_column_reader->next(), OLAP_SUCCESS);
}
TEST_F(TestColumn, SeekTinyColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("TinyColumn"),
OLAP_FIELD_TYPE_TINYINT,
OLAP_FIELD_AGGREGATION_REPLACE,
1,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
char value = 1;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 2;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
value = 3;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
PositionEntryReader entry1;
entry1._positions = _column_writer->index()->mutable_entry(0)->_positions;
entry1._positions_count = _column_writer->index()->mutable_entry(0)->_positions_count;
entry1._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionEntryReader entry2;
entry2._positions = _column_writer->index()->mutable_entry(1)->_positions;
entry2._positions_count = _column_writer->index()->mutable_entry(1)->_positions_count;
entry2._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionProvider position0(&entry1);
PositionProvider position1(&entry2);
ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(&value);
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(&value);
ASSERT_EQ(value, 3);
ASSERT_NE(_column_reader->next(), OLAP_SUCCESS);
}
TEST_F(TestColumn, SkipTinyColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("TinyColumn"),
OLAP_FIELD_TYPE_TINYINT,
OLAP_FIELD_AGGREGATION_REPLACE,
1,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
char value = 1;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 2;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->skip(2), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(&value);
ASSERT_EQ(value, 3);
ASSERT_NE(_column_reader->next(), OLAP_SUCCESS);
}
TEST_F(TestColumn, TinyColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("TinyColumn"),
OLAP_FIELD_TYPE_TINYINT,
OLAP_FIELD_AGGREGATION_REPLACE,
1,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
char value = 1;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(&value);
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(&value);
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, TinyColumnIndex) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("TinyColumn"),
OLAP_FIELD_TYPE_TINYINT,
OLAP_FIELD_AGGREGATION_REPLACE,
1,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
char value = 1;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(&value);
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(&value);
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, SeekTinyColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("TinyColumn"),
OLAP_FIELD_TYPE_TINYINT,
OLAP_FIELD_AGGREGATION_REPLACE,
1,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
char value = 1;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 2;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
value = 3;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
PositionEntryReader entry1;
entry1._positions = _column_writer->index()->mutable_entry(0)->_positions;
entry1._positions_count = _column_writer->index()->mutable_entry(0)->_positions_count;
entry1._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionEntryReader entry2;
entry2._positions = _column_writer->index()->mutable_entry(1)->_positions;
entry2._positions_count = _column_writer->index()->mutable_entry(1)->_positions_count;
entry2._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionProvider position1(&entry1);
PositionProvider position2(&entry2);
ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(&value);
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->seek(&position2), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(&value);
ASSERT_EQ(value, 3);
ASSERT_NE(_column_reader->next(), OLAP_SUCCESS);
}
TEST_F(TestColumn, SkipTinyColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("TinyColumn"),
OLAP_FIELD_TYPE_TINYINT,
OLAP_FIELD_AGGREGATION_REPLACE,
1,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
char value = 1;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 2;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(&value, sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->skip(2), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(&value);
ASSERT_EQ(value, 3);
ASSERT_NE(_column_reader->next(), OLAP_SUCCESS);
}
TEST_F(TestColumn, ShortColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("ShortColumn"),
OLAP_FIELD_TYPE_SMALLINT,
OLAP_FIELD_AGGREGATION_REPLACE,
2,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
int16_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, SeekShortColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("ShortColumn"),
OLAP_FIELD_TYPE_SMALLINT,
OLAP_FIELD_AGGREGATION_REPLACE,
2,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
int16_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 2;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
PositionEntryReader entry1;
entry1._positions = _column_writer->index()->mutable_entry(0)->_positions;
entry1._positions_count = _column_writer->index()->mutable_entry(0)->_positions_count;
entry1._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionEntryReader entry2;
entry2._positions = _column_writer->index()->mutable_entry(1)->_positions;
entry2._positions_count = _column_writer->index()->mutable_entry(1)->_positions_count;
entry2._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionProvider position0(&entry1);
PositionProvider position1(&entry2);
ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, SkipShortColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("ShortColumn"),
OLAP_FIELD_TYPE_SMALLINT,
OLAP_FIELD_AGGREGATION_REPLACE,
2,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
int16_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 2;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->skip(2), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, ShortColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("ShortColumn"),
OLAP_FIELD_TYPE_SMALLINT,
OLAP_FIELD_AGGREGATION_REPLACE,
2,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
int16_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, SeekShortColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("ShortColumn"),
OLAP_FIELD_TYPE_SMALLINT,
OLAP_FIELD_AGGREGATION_REPLACE,
2,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
int16_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 2;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
PositionEntryReader entry1;
entry1._positions = _column_writer->index()->mutable_entry(0)->_positions;
entry1._positions_count = _column_writer->index()->mutable_entry(0)->_positions_count;
entry1._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionEntryReader entry2;
entry2._positions = _column_writer->index()->mutable_entry(1)->_positions;
entry2._positions_count = _column_writer->index()->mutable_entry(1)->_positions_count;
entry2._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionProvider position0(&entry1);
PositionProvider position1(&entry2);
ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, SkipShortColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("ShortColumn"),
OLAP_FIELD_TYPE_SMALLINT,
OLAP_FIELD_AGGREGATION_REPLACE,
2,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
int16_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 2;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->skip(2), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, UnsignedShortColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("UnsignedShortColumn"),
OLAP_FIELD_TYPE_UNSIGNED_SMALLINT,
OLAP_FIELD_AGGREGATION_REPLACE,
2,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
uint16_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, UnsignedShortColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("UnsignedShortColumn"),
OLAP_FIELD_TYPE_UNSIGNED_SMALLINT,
OLAP_FIELD_AGGREGATION_REPLACE,
2,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
uint16_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, IntColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("UnsignedShortColumn"),
OLAP_FIELD_TYPE_INT,
OLAP_FIELD_AGGREGATION_REPLACE,
4,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
int32_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, IntColumnMassWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("UnsignedShortColumn"),
OLAP_FIELD_TYPE_INT,
OLAP_FIELD_AGGREGATION_REPLACE,
4,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
for (int32_t i = 0; i < 10000; i++) {
write_row.read(reinterpret_cast<char *>(&i), sizeof(i));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
}
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
for (int32_t i = 0; i < 10000; i++) {
int32_t value;
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, i);
}
}
TEST_F(TestColumn, IntColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("UnsignedShortColumn"),
OLAP_FIELD_TYPE_INT,
OLAP_FIELD_AGGREGATION_REPLACE,
4,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
int32_t value = -1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, -1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, UnsignedIntColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("UnsignedShortColumn"),
OLAP_FIELD_TYPE_UNSIGNED_INT,
OLAP_FIELD_AGGREGATION_REPLACE,
4,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
uint32_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, UnsignedIntColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("UnsignedShortColumn"),
OLAP_FIELD_TYPE_UNSIGNED_INT,
OLAP_FIELD_AGGREGATION_REPLACE,
4,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
uint32_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, LongColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("LongColumnWithoutPresent"),
OLAP_FIELD_TYPE_BIGINT,
OLAP_FIELD_AGGREGATION_REPLACE,
8,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
int64_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, LongColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("LongColumnWithPresent"),
OLAP_FIELD_TYPE_BIGINT,
OLAP_FIELD_AGGREGATION_REPLACE,
8,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
int64_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, UnsignedLongColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("UnsignedLongColumnWithoutPresent"),
OLAP_FIELD_TYPE_UNSIGNED_BIGINT,
OLAP_FIELD_AGGREGATION_REPLACE,
8,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
uint64_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, UnsignedLongColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("UnsignedLongColumnWithoutPresent"),
OLAP_FIELD_TYPE_UNSIGNED_BIGINT,
OLAP_FIELD_AGGREGATION_REPLACE,
8,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
uint64_t value = 1;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 1);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_EQ(value, 3);
}
TEST_F(TestColumn, FloatColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("UnsignedLongColumnWithoutPresent"),
OLAP_FIELD_TYPE_FLOAT,
OLAP_FIELD_AGGREGATION_REPLACE,
4,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
float value = 1.234;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3.234;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_FLOAT_EQ(value, 1.234);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_FLOAT_EQ(value, 3.234);
}
TEST_F(TestColumn, FloatColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("FloatColumnWithPresent"),
OLAP_FIELD_TYPE_FLOAT,
OLAP_FIELD_AGGREGATION_REPLACE,
4,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
float value = 1.234;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3.234;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_FLOAT_EQ(value, 1.234);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_FLOAT_EQ(value, 3.234);
}
TEST_F(TestColumn, SeekFloatColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("FloatColumnWithPresent"),
OLAP_FIELD_TYPE_FLOAT,
OLAP_FIELD_AGGREGATION_REPLACE,
4,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
float value = 1.234;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
value = 3.234;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
PositionEntryReader entry1;
entry1._positions = _column_writer->index()->mutable_entry(0)->_positions;
entry1._positions_count = _column_writer->index()->mutable_entry(0)->_positions_count;
entry1._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionEntryReader entry2;
entry2._positions = _column_writer->index()->mutable_entry(1)->_positions;
entry2._positions_count = _column_writer->index()->mutable_entry(1)->_positions_count;
entry2._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionProvider position0(&entry1);
PositionProvider position1(&entry2);
ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_FLOAT_EQ(value, 1.234);
ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_FLOAT_EQ(value, 3.234);
}
TEST_F(TestColumn, SkipFloatColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("FloatColumnWithPresent"),
OLAP_FIELD_TYPE_FLOAT,
OLAP_FIELD_AGGREGATION_REPLACE,
4,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
float value = 1.234;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3.234;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->skip(1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_FLOAT_EQ(value, 3.234);
}
TEST_F(TestColumn, DoubleColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DoubleColumnWithoutPresent"),
OLAP_FIELD_TYPE_DOUBLE,
OLAP_FIELD_AGGREGATION_REPLACE,
8,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
double value = 1.23456789;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3.23456789;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_DOUBLE_EQ(value, 1.23456789);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_DOUBLE_EQ(value, 3.23456789);
}
TEST_F(TestColumn, DoubleColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DoubleColumnWithPresent"),
OLAP_FIELD_TYPE_DOUBLE,
OLAP_FIELD_AGGREGATION_REPLACE,
8,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
double value = 1.23456789;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
value = 3.23456789;
write_row.read(reinterpret_cast<char *>(&value), sizeof(value));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_DOUBLE_EQ(value, 1.23456789);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
read_row.write(reinterpret_cast<char *>(&value));
ASSERT_DOUBLE_EQ(value, 3.23456789);
}
TEST_F(TestColumn, DiscreteDoubleColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DoubleColumnWithoutPresent"),
OLAP_FIELD_TYPE_DISCRETE_DOUBLE,
OLAP_FIELD_AGGREGATION_REPLACE,
8,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("1234.5678");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&1234.5678", strlen("0&1234.5678")) == 0);
}
TEST_F(TestColumn, DiscreteDoubleColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DiscreteDoubleColumnWithPresent"),
OLAP_FIELD_TYPE_DISCRETE_DOUBLE,
OLAP_FIELD_AGGREGATION_REPLACE,
8,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("1234.5678");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back("5678.1234");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&1234.5678", strlen("0&1234.5678")) == 0);
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0);
}
TEST_F(TestColumn, SeekDiscreteDoubleColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DiscreteDoubleColumnWithPresent"),
OLAP_FIELD_TYPE_DISCRETE_DOUBLE,
OLAP_FIELD_AGGREGATION_REPLACE,
8,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("1234.5678");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
val_string_array.clear();
val_string_array.push_back("5678.1234");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
PositionEntryReader entry1;
entry1._positions = _column_writer->index()->mutable_entry(0)->_positions;
entry1._positions_count = _column_writer->index()->mutable_entry(0)->_positions_count;
entry1._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionEntryReader entry2;
entry2._positions = _column_writer->index()->mutable_entry(1)->_positions;
entry2._positions_count = _column_writer->index()->mutable_entry(1)->_positions_count;
entry2._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionProvider position0(&entry1);
PositionProvider position1(&entry2);
ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&1234.5678", strlen("0&1234.5678")) == 0);
ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0);
}
TEST_F(TestColumn, SkipDiscreteDoubleColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DiscreteDoubleColumnWithPresent"),
OLAP_FIELD_TYPE_DISCRETE_DOUBLE,
OLAP_FIELD_AGGREGATION_REPLACE,
8,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("1234.5678");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back("5678.1234");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
PositionEntryReader entry2;
entry2._positions = _column_writer->index_entry()->_positions;
entry2._positions_count = _column_writer->index_entry()->_positions_count;
entry2._statistics.init(OLAP_FIELD_TYPE_NONE, false);
UniqueIdPositionProviderMap positions_map;
positions_map[0] = PositionProvider(&entry2);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->skip(1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0);
}
TEST_F(TestColumn, DatetimeColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DatetimeColumnWithoutPresent"),
OLAP_FIELD_TYPE_DATETIME,
OLAP_FIELD_AGGREGATION_REPLACE,
8,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("2000-10-10 10:10:10");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10 10:10:10", strlen("0&2000-10-10 10:10:10")) == 0);
}
TEST_F(TestColumn, DatetimeColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DatetimeColumnWithoutPresent"),
OLAP_FIELD_TYPE_DATETIME,
OLAP_FIELD_AGGREGATION_REPLACE,
8,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("2000-10-10 10:10:10");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10 10:10:10", strlen("0&2000-10-10 10:10:10")) == 0);
ASSERT_NE(_column_reader->next(), OLAP_SUCCESS);
}
TEST_F(TestColumn, DateColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DateColumnWithoutoutPresent"),
OLAP_FIELD_TYPE_DATE,
OLAP_FIELD_AGGREGATION_REPLACE,
3,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("2000-10-10");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10", strlen("0&2000-10-10")) == 0);
}
TEST_F(TestColumn, DateColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DateColumnWithoutoutPresent"),
OLAP_FIELD_TYPE_DATE,
OLAP_FIELD_AGGREGATION_REPLACE,
3,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("2000-10-10");
write_row.from_string(val_string_array);
for (uint32_t i = 0; i < 100; ++i) {
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
}
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
for (uint32_t i = 0; i < 100; ++i) {
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&2000-10-10", strlen("0&2000-10-10")) == 0);
}
ASSERT_NE(_column_reader->next(), OLAP_SUCCESS);
}
TEST_F(TestColumn, DecimalColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DecimalColumnWithoutoutPresent"),
OLAP_FIELD_TYPE_DECIMAL,
OLAP_FIELD_AGGREGATION_REPLACE,
12,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("1234.5678");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back("5678.1234");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&1234.5678", strlen("0&1234.5678")) == 0);
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0);
}
TEST_F(TestColumn, DecimalColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DecimalColumnWithoutoutPresent"),
OLAP_FIELD_TYPE_DECIMAL,
OLAP_FIELD_AGGREGATION_REPLACE,
12,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("1234.5678");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back("5678.1234");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&1234.5678", strlen("0&1234.5678")) == 0);
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0);
}
TEST_F(TestColumn, SkipDecimalColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DecimalColumnWithPresent"),
OLAP_FIELD_TYPE_DECIMAL,
OLAP_FIELD_AGGREGATION_REPLACE,
12,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("1234.5678");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back("5678.1234");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->skip(1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0);
}
TEST_F(TestColumn, SeekDecimalColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DecimalColumnWithPresent"),
OLAP_FIELD_TYPE_DECIMAL,
OLAP_FIELD_AGGREGATION_REPLACE,
12,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("1234.5678");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
val_string_array.clear();
val_string_array.push_back("5678.1234");
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
create_and_save_last_position();
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
PositionEntryReader entry1;
entry1._positions = _column_writer->index()->mutable_entry(0)->_positions;
entry1._positions_count = _column_writer->index()->mutable_entry(0)->_positions_count;
entry1._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionEntryReader entry2;
entry2._positions = _column_writer->index()->mutable_entry(1)->_positions;
entry2._positions_count = _column_writer->index()->mutable_entry(1)->_positions_count;
entry2._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionProvider position0(&entry1);
PositionProvider position1(&entry2);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&1234.5678", strlen("0&1234.5678")) == 0);
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), "0&5678.1234", strlen("0&5678.1234")) == 0);
}
TEST_F(TestColumn, LargeIntColumnWithoutPresent) {
// init table schema
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("LargeIntColumnWithoutoutPresent"),
OLAP_FIELD_TYPE_LARGEINT,
OLAP_FIELD_AGGREGATION_SUM,
16,
false,
true);
tablet_schema.push_back(field_info);
// test data
string value1 = "100000000000000000000000000000000000000";
string value2 = "-170141183460469231731687303715884105728";
// write data
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back(value1);
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back(value2);
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
value1 = "0&" + value1;
value2 = "0&" + value2;
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), value1.c_str(), value1.size()) == 0);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), value2.c_str(), value2.size()) == 0);
}
TEST_F(TestColumn, LargeIntColumnWithPresent) {
// init table schema
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("LargeIntColumnWithoutoutPresent"),
OLAP_FIELD_TYPE_LARGEINT,
OLAP_FIELD_AGGREGATION_SUM,
16,
true,
true);
tablet_schema.push_back(field_info);
// test data
string value1 = "100000000000000000000000000000000000000";
string value2 = "-170141183460469231731687303715884105728";
// write data
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back(value1);
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back(value2);
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
value1 = "0&" + value1;
value2 = "0&" + value2;
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), value1.c_str(), value1.size()) == 0);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), value2.c_str(), value2.size()) == 0);
}
TEST_F(TestColumn, SkipLargeIntColumnWithPresent) {
// init table schema
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("LargeIntColumnWithPresent"),
OLAP_FIELD_TYPE_LARGEINT,
OLAP_FIELD_AGGREGATION_SUM,
16,
true,
true);
tablet_schema.push_back(field_info);
// test data
string value1 = "100000000000000000000000000000000000000";
string value2 = "-170141183460469231731687303715884105728";
// write data
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back(value1);
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back(value2);
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
value2 = "0&" + value2;
ASSERT_EQ(_column_reader->skip(1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strncmp(read_row.to_string().c_str(), value2.c_str(), value2.size()) == 0);
}
// TODO(jiangguoqiang): this test has a problem. Need to fix it.
// TEST_F(TestColumn, SeekLargeIntColumnWithPresent) {
// // init table schema
// std::vector<FieldInfo> tablet_schema;
// FieldInfo field_info;
// SetFieldInfo(field_info,
// std::string("LargeIntColumnWithPresent"),
// OLAP_FIELD_TYPE_LARGEINT,
// OLAP_FIELD_AGGREGATION_SUM,
// 16,
// true,
// true);
// tablet_schema.push_back(field_info);
// // test data
// string value1 = "100000000000000000000000000000000000000";
// string value2 = "-170141183460469231731687303715884105728";
// string value3 = "65535";
// // write data
// CreateColumnWriter(tablet_schema);
// RowCursor write_row;
// write_row.init(tablet_schema);
// std::vector<string> val_string_array;
// val_string_array.push_back(value1);
// write_row.from_string(val_string_array);
// ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
// val_string_array.clear();
// val_string_array.push_back(value2);
// write_row.from_string(val_string_array);
// ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
// create_and_save_last_position();
// val_string_array.clear();
// val_string_array.push_back(value3);
// write_row.from_string(val_string_array);
// ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
// create_and_save_last_position();
// ColumnDataHeaderMessage header;
// ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// // read data
// CreateColumnReader(tablet_schema);
// RowCursor read_row;
// read_row.init(tablet_schema);
// PositionEntryReader entry0;
// entry0._positions = _column_writer->index()->mutable_entry(0)->_positions;
// entry0._positions_count = _column_writer->index()->mutable_entry(0)->_positions_count;
// entry0._statistics.init(OLAP_FIELD_TYPE_NONE);
// PositionEntryReader entry1;
// entry1._positions = _column_writer->index()->mutable_entry(1)->_positions;
// entry1._positions_count = _column_writer->index()->mutable_entry(1)->_positions_count;
// entry1._statistics.init(OLAP_FIELD_TYPE_NONE);
// PositionProvider position0(&entry0);
// PositionProvider position1(&entry1);
// ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS);
// ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
// ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
// ASSERT_TRUE(strncmp(read_row.to_string().c_str(), value1.c_str(), value1.size()) == 0);
// ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS);
// ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
// ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
// ASSERT_TRUE(strncmp(read_row.to_string().c_str(), value3.c_str(), value3.size()) == 0);
// }
TEST_F(TestColumn, DirectVarcharColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DirectVarcharColumnWithoutoutPresent"),
OLAP_FIELD_TYPE_VARCHAR,
OLAP_FIELD_AGGREGATION_REPLACE,
10,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("YWJjZGU="); //"abcde" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
for (uint32_t i = 0; i < 2; i++) {
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
}
val_string_array.clear();
val_string_array.push_back("ZWRjYmE="); //"edcba" base_64_encode is "ZWRjYmE="
write_row.from_string(val_string_array);
for (uint32_t i = 0; i < 2; i++) {
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
}
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&YWJjZGU=") == 0);
for (uint32_t i = 0; i < 2; i++) {
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&YWJjZGU=") == 0);
}
for (uint32_t i = 0; i < 2; i++) {
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&ZWRjYmE=") == 0);
}
ASSERT_NE(_column_reader->next(), OLAP_SUCCESS);
}
TEST_F(TestColumn, DirectVarcharColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DirectVarcharColumnWithoutoutPresent"),
OLAP_FIELD_TYPE_VARCHAR,
OLAP_FIELD_AGGREGATION_REPLACE,
10,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("YWJjZGU="); //"abcde" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&YWJjZGU=") == 0);
}
TEST_F(TestColumn, SkipDirectVarcharColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DirectVarcharColumnWithPresent"),
OLAP_FIELD_TYPE_VARCHAR,
OLAP_FIELD_AGGREGATION_REPLACE,
10,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("YWJjZGU="); //"abcde" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back("YWFhYWE="); //"aaaaa" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->skip(1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&YWFhYWE=") == 0);
}
TEST_F(TestColumn, SeekDirectVarcharColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DirectVarcharColumnWithPresent"),
OLAP_FIELD_TYPE_VARCHAR,
OLAP_FIELD_AGGREGATION_REPLACE,
10,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("YWJjZGU="); //"abcde" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
_column_writer->create_row_index_entry();
val_string_array.clear();
val_string_array.push_back("YWFhYWE="); //"aaaaa" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
_column_writer->create_row_index_entry();
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
PositionEntryReader entry1;
entry1._positions = _column_writer->index()->mutable_entry(0)->_positions;
entry1._positions_count = _column_writer->index()->mutable_entry(0)->_positions_count;
entry1._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionEntryReader entry2;
entry2._positions = _column_writer->index()->mutable_entry(1)->_positions;
entry2._positions_count = _column_writer->index()->mutable_entry(1)->_positions_count;
entry2._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionProvider position0(&entry1);
PositionProvider position1(&entry2);
ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&YWJjZGU=") == 0);
ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&YWFhYWE=") == 0);
ASSERT_NE(_column_reader->next(), OLAP_SUCCESS);
}
TEST_F(TestColumn, SeekDirectVarcharColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DirectVarcharColumnWithPresent"),
OLAP_FIELD_TYPE_VARCHAR,
OLAP_FIELD_AGGREGATION_REPLACE,
10,
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("YWJjZGU="); //"abcde" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
_column_writer->create_row_index_entry();
val_string_array.clear();
val_string_array.push_back("YWFhYWE="); //"aaaaa" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
_column_writer->create_row_index_entry();
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
PositionEntryReader entry1;
entry1._positions = _column_writer->index()->mutable_entry(0)->_positions;
entry1._positions_count = _column_writer->index()->mutable_entry(0)->_positions_count;
entry1._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionEntryReader entry2;
entry2._positions = _column_writer->index()->mutable_entry(1)->_positions;
entry2._positions_count = _column_writer->index()->mutable_entry(1)->_positions_count;
entry2._statistics.init(OLAP_FIELD_TYPE_NONE, false);
PositionProvider position0(&entry1);
PositionProvider position1(&entry2);
ASSERT_EQ(_column_reader->seek(&position0), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&YWJjZGU=") == 0);
ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&YWFhYWE=") == 0);
ASSERT_NE(_column_reader->next(), OLAP_SUCCESS);
}
TEST_F(TestColumn, StringColumnWithoutPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("VarcharColumnWithoutoutPresent"),
OLAP_FIELD_TYPE_CHAR,
OLAP_FIELD_AGGREGATION_REPLACE,
strlen("abcde"),
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("abcde"); //"abcde" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
for (uint32_t i = 0; i < 2; i++) {
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
}
val_string_array.clear();
val_string_array.push_back("edcba"); //"edcba" base_64_encode is "ZWRjYmE="
write_row.from_string(val_string_array);
for (uint32_t i = 0; i < 2; i++) {
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
}
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&abcde") == 0);
for (uint32_t i = 0; i < 2; i++) {
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&abcde") == 0);
}
for (uint32_t i = 0; i < 2; i++) {
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&edcba") == 0);
}
ASSERT_NE(_column_reader->next(), OLAP_SUCCESS);
}
TEST_F(TestColumn, StringColumnWithPresent) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("VarcharColumnWithoutoutPresent"),
OLAP_FIELD_TYPE_CHAR,
OLAP_FIELD_AGGREGATION_REPLACE,
strlen("abcde"),
true,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("abcde"); //"abcde" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&abcde") == 0);
}
TEST_F(TestColumn, StringColumnWithoutoutPresent2) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("VarcharColumnWithoutoutPresent"),
OLAP_FIELD_TYPE_CHAR,
OLAP_FIELD_AGGREGATION_REPLACE,
20,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back("abcde"); //"abcde" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back("aaaaa"); //"abcde" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back("bbbbb"); //"abcde" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back("ccccc"); //"abcde" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back("ddddd"); //"abcde" base_64_encode is "YWJjZGU="
write_row.from_string(val_string_array);
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
char read_value[20];
memset(read_value, 0, 20);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_STREQ(read_row._field_array[0]->_buf, "abcde");
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_STREQ(read_row._field_array[0]->_buf, "aaaaa");
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_STREQ(read_row._field_array[0]->_buf, "bbbbb");
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_STREQ(read_row._field_array[0]->_buf, "ccccc");
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_STREQ(read_row._field_array[0]->_buf, "ddddd");
}
TEST_F(TestColumn, DirectVarcharColumnWith65533) {
// write data
std::vector<FieldInfo> tablet_schema;
FieldInfo field_info;
SetFieldInfo(field_info,
std::string("DirectVarcharColumnWithoutoutPresent"),
OLAP_FIELD_TYPE_VARCHAR,
OLAP_FIELD_AGGREGATION_REPLACE,
65535,
false,
true);
tablet_schema.push_back(field_info);
CreateColumnWriter(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
std::vector<string> val_string_array;
val_string_array.push_back(std::string(65533, 'a'));
ASSERT_EQ(OLAP_SUCCESS, write_row.from_string(val_string_array));
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
val_string_array.clear();
val_string_array.push_back("edcba"); //"edcba" base_64_encode is "ZWRjYmE="
write_row.from_string(val_string_array);
for (uint32_t i = 0; i < 2; i++) {
ASSERT_EQ(_column_writer->write(&write_row), OLAP_SUCCESS);
}
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
CreateColumnReader(tablet_schema);
RowCursor read_row;
read_row.init(tablet_schema);
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
for (uint32_t i = 0; i < 65533 + 2; i++) {
if (0 == i) {
ASSERT_EQ(read_row.to_string().c_str()[i], '0');
} else if (1 == i) {
ASSERT_EQ(read_row.to_string().c_str()[i], '&');
} else {
ASSERT_EQ(read_row.to_string().c_str()[i], 'a');
}
}
for (uint32_t i = 0; i < 2; i++) {
ASSERT_EQ(_column_reader->next(), OLAP_SUCCESS);
ASSERT_EQ(_column_reader->attach(&read_row), OLAP_SUCCESS);
ASSERT_TRUE(strcmp(read_row.to_string().c_str(), "0&edcba") == 0);
}
}
}
}
int main(int argc, char** argv) {
std::string conffile = std::string(getenv("PALO_HOME")) + "/conf/be.conf";
if (!palo::config::init(conffile.c_str(), false)) {
fprintf(stderr, "error read config file. \n");
return -1;
}
palo::init_glog("be-test");
int ret = palo::OLAP_SUCCESS;
testing::InitGoogleTest(&argc, argv);
ret = RUN_ALL_TESTS();
google::protobuf::ShutdownProtobufLibrary();
return ret;
}
Reference in New Issue View Git Blame Copy Permalink