This is an automated email from the ASF dual-hosted git repository.
todd pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/kudu.git
The following commit(s) were added to refs/heads/master by this push:
new ffef96b Replace 'null_bitmap' variable names with 'non_null_bitmap'
ffef96b is described below
commit ffef96b26c0c72b458b3be2c26437d1f95ecaf8f
Author: Todd Lipcon <[email protected]>
AuthorDate: Tue Mar 24 11:54:19 2020 -0700
Replace 'null_bitmap' variable names with 'non_null_bitmap'
These bitmaps have always had the semantics that a set bit indicated a
non-null entry. Thus the name 'null_bitmap' was misleading. This is a
simple find/replace to 'non_null_bitmap'.
Notably the code in CFileWriter::AppendNullableEntries now makes a lot
more sense.
Change-Id: Ie67dea54ce41ea42a7de5640845e402ac98ee3ce
Reviewed-on: http://gerrit.cloudera.org:8080/15548
Reviewed-by: Andrew Wong <[email protected]>
Tested-by: Todd Lipcon <[email protected]>
---
src/kudu/cfile/cfile-test-base.h | 14 ++++++-------
src/kudu/cfile/cfile-test.cc | 6 +++---
src/kudu/cfile/cfile_reader.cc | 10 ++++-----
src/kudu/cfile/cfile_writer.cc | 22 ++++++++++----------
src/kudu/cfile/cfile_writer.h | 2 +-
src/kudu/client/write_op.cc | 2 +-
src/kudu/common/column_predicate.cc | 8 +++----
src/kudu/common/columnblock.cc | 6 +++---
src/kudu/common/columnblock.h | 30 +++++++++++++++------------
src/kudu/common/partial_row.cc | 2 +-
src/kudu/common/row.h | 16 +++++++-------
src/kudu/common/row_operations.cc | 16 +++++++-------
src/kudu/common/row_operations.h | 2 +-
src/kudu/common/rowblock.cc | 6 +++---
src/kudu/common/rowblock.h | 8 +++----
src/kudu/common/wire_protocol-test.cc | 6 +++---
src/kudu/common/wire_protocol.cc | 12 +++++------
src/kudu/integration-tests/all_types-itest.cc | 6 +++---
src/kudu/tablet/multi_column_writer.cc | 2 +-
src/kudu/tablet/tablet-test-util.h | 3 ++-
20 files changed, 92 insertions(+), 87 deletions(-)
diff --git a/src/kudu/cfile/cfile-test-base.h b/src/kudu/cfile/cfile-test-base.h
index 8f3a0bd..64552b3 100644
--- a/src/kudu/cfile/cfile-test-base.h
+++ b/src/kudu/cfile/cfile-test-base.h
@@ -52,7 +52,7 @@ namespace cfile {
// StringDataGenerator<true> datagen;
// datagen.Build(10);
// for (int i = 0; i < datagen.block_entries(); ++i) {
-// bool is_null = BitmpTest(datagen.null_bitmap(), i);
+// bool is_null = !BitmapTest(datagen.non_null_bitmap(), i);
// Slice& v = datagen[i];
// }
template<DataType DATA_TYPE, bool HAS_NULLS>
@@ -82,14 +82,14 @@ class DataGenerator {
}
// Build "num_entries" using (offset + i) as value
- // You can get the data values and the null bitmap using values() and
null_bitmap()
+ // You can get the data values and the null bitmap using values() and
non_null_bitmap()
// both are valid until the class is destructed or until Build() is called
again.
void Build(size_t offset, size_t num_entries) {
Resize(num_entries);
for (size_t i = 0; i < num_entries; ++i) {
if (HAS_NULLS) {
- BitmapChange(null_bitmap_.get(), i, !TestValueShouldBeNull(offset +
i));
+ BitmapChange(non_null_bitmap_.get(), i, !TestValueShouldBeNull(offset
+ i));
}
values_[i] = BuildTestValue(i, offset + i);
}
@@ -129,7 +129,7 @@ class DataGenerator {
}
values_.reset(new cpp_type[num_entries]);
- null_bitmap_.reset(new uint8_t[BitmapSize(num_entries)]);
+ non_null_bitmap_.reset(new uint8_t[BitmapSize(num_entries)]);
block_entries_ = num_entries;
}
@@ -137,7 +137,7 @@ class DataGenerator {
size_t total_entries() const { return total_entries_; }
const cpp_type *values() const { return values_.get(); }
- const uint8_t *null_bitmap() const { return null_bitmap_.get(); }
+ const uint8_t *non_null_bitmap() const { return non_null_bitmap_.get(); }
const cpp_type& operator[](size_t index) const {
return values_[index];
@@ -147,7 +147,7 @@ class DataGenerator {
private:
std::unique_ptr<cpp_type[]> values_;
- std::unique_ptr<uint8_t[]> null_bitmap_;
+ std::unique_ptr<uint8_t[]> non_null_bitmap_;
size_t block_entries_;
size_t total_entries_;
};
@@ -396,7 +396,7 @@ class CFileTestBase : public KuduTest {
DCHECK_EQ(towrite, data_generator->block_entries());
if (DataGeneratorType::has_nulls()) {
- ASSERT_OK_FAST(w.AppendNullableEntries(data_generator->null_bitmap(),
+
ASSERT_OK_FAST(w.AppendNullableEntries(data_generator->non_null_bitmap(),
data_generator->values(),
towrite));
} else {
diff --git a/src/kudu/cfile/cfile-test.cc b/src/kudu/cfile/cfile-test.cc
index c2c3fac..dcffc3f 100644
--- a/src/kudu/cfile/cfile-test.cc
+++ b/src/kudu/cfile/cfile-test.cc
@@ -811,7 +811,7 @@ TEST_P(TestCFileBothCacheMemoryTypes,
TestDefaultColumnIter) {
RETURN_IF_NO_NVM_CACHE(GetParam());
const int kNumItems = 64;
- uint8_t null_bitmap[BitmapSize(kNumItems)];
+ uint8_t non_null_bitmap[BitmapSize(kNumItems)];
uint32_t data[kNumItems];
// Test Int Default Value
@@ -828,7 +828,7 @@ TEST_P(TestCFileBothCacheMemoryTypes,
TestDefaultColumnIter) {
// Test Int Nullable Default Value
int_value = 321;
DefaultColumnValueIterator nullable_iter(GetTypeInfo(UINT32), &int_value);
- ColumnBlock nullable_col(GetTypeInfo(UINT32), null_bitmap, data, kNumItems,
nullptr);
+ ColumnBlock nullable_col(GetTypeInfo(UINT32), non_null_bitmap, data,
kNumItems, nullptr);
ColumnMaterializationContext nullable_ctx =
CreateNonDecoderEvalContext(&nullable_col, &sel);
ASSERT_OK(nullable_iter.Scan(&nullable_ctx));
for (size_t i = 0; i < nullable_col.nrows(); ++i) {
@@ -838,7 +838,7 @@ TEST_P(TestCFileBothCacheMemoryTypes,
TestDefaultColumnIter) {
// Test NULL Default Value
DefaultColumnValueIterator null_iter(GetTypeInfo(UINT32), nullptr);
- ColumnBlock null_col(GetTypeInfo(UINT32), null_bitmap, data, kNumItems,
nullptr);
+ ColumnBlock null_col(GetTypeInfo(UINT32), non_null_bitmap, data, kNumItems,
nullptr);
ColumnMaterializationContext null_ctx =
CreateNonDecoderEvalContext(&null_col, &sel);
ASSERT_OK(null_iter.Scan(&null_ctx));
for (size_t i = 0; i < null_col.nrows(); ++i) {
diff --git a/src/kudu/cfile/cfile_reader.cc b/src/kudu/cfile/cfile_reader.cc
index d044a7e..a1d9c37 100644
--- a/src/kudu/cfile/cfile_reader.cc
+++ b/src/kudu/cfile/cfile_reader.cc
@@ -919,18 +919,18 @@ string CFileIterator::PreparedBlock::ToString() const {
}
// Decode the null header in the beginning of the data block
-Status DecodeNullInfo(Slice *data_block, uint32_t *num_rows_in_block, Slice
*null_bitmap) {
+Status DecodeNullInfo(Slice *data_block, uint32_t *num_rows_in_block, Slice
*non_null_bitmap) {
if (!GetVarint32(data_block, num_rows_in_block)) {
return Status::Corruption("bad null header, num elements in block");
}
- uint32_t null_bitmap_size;
- if (!GetVarint32(data_block, &null_bitmap_size)) {
+ uint32_t non_null_bitmap_size;
+ if (!GetVarint32(data_block, &non_null_bitmap_size)) {
return Status::Corruption("bad null header, bitmap size");
}
- *null_bitmap = Slice(data_block->data(), null_bitmap_size);
- data_block->remove_prefix(null_bitmap_size);
+ *non_null_bitmap = Slice(data_block->data(), non_null_bitmap_size);
+ data_block->remove_prefix(non_null_bitmap_size);
return Status::OK();
}
diff --git a/src/kudu/cfile/cfile_writer.cc b/src/kudu/cfile/cfile_writer.cc
index aa6f85d..2921bf1 100644
--- a/src/kudu/cfile/cfile_writer.cc
+++ b/src/kudu/cfile/cfile_writer.cc
@@ -185,7 +185,7 @@ Status CFileWriter::Start() {
if (is_nullable_) {
size_t nrows = ((options_.storage_attributes.cfile_block_size +
typeinfo_->size() - 1) /
typeinfo_->size());
- null_bitmap_builder_.reset(new NullBitmapBuilder(nrows * 8));
+ non_null_bitmap_builder_.reset(new NullBitmapBuilder(nrows * 8));
}
state_ = kWriterWriting;
@@ -328,16 +328,16 @@ Status CFileWriter::AppendNullableEntries(const uint8_t
*bitmap,
const uint8_t *ptr = reinterpret_cast<const uint8_t *>(entries);
size_t nitems;
- bool is_null = false;
+ bool is_non_null = false;
BitmapIterator bmap_iter(bitmap, count);
- while ((nitems = bmap_iter.Next(&is_null)) > 0) {
- if (is_null) {
+ while ((nitems = bmap_iter.Next(&is_non_null)) > 0) {
+ if (is_non_null) {
size_t rem = nitems;
do {
int n = data_block_->Add(ptr, rem);
DCHECK_GE(n, 0);
- null_bitmap_builder_->AddRun(true, n);
+ non_null_bitmap_builder_->AddRun(true, n);
ptr += n * typeinfo_->size();
value_count_ += n;
rem -= n;
@@ -348,7 +348,7 @@ Status CFileWriter::AppendNullableEntries(const uint8_t
*bitmap,
} while (rem > 0);
} else {
- null_bitmap_builder_->AddRun(false, nitems);
+ non_null_bitmap_builder_->AddRun(false, nitems);
ptr += nitems * typeinfo_->size();
value_count_ += nitems;
}
@@ -360,7 +360,7 @@ Status CFileWriter::AppendNullableEntries(const uint8_t
*bitmap,
Status CFileWriter::FinishCurDataBlock() {
uint32_t num_elems_in_block = data_block_->Count();
if (is_nullable_) {
- num_elems_in_block = null_bitmap_builder_->nitems();
+ num_elems_in_block = non_null_bitmap_builder_->nitems();
}
if (PREDICT_FALSE(num_elems_in_block == 0)) {
@@ -388,11 +388,11 @@ Status CFileWriter::FinishCurDataBlock() {
vector<Slice> v;
faststring null_headers;
if (is_nullable_) {
- Slice null_bitmap = null_bitmap_builder_->Finish();
+ Slice non_null_bitmap = non_null_bitmap_builder_->Finish();
PutVarint32(&null_headers, num_elems_in_block);
- PutVarint32(&null_headers, null_bitmap.size());
+ PutVarint32(&null_headers, non_null_bitmap.size());
v.emplace_back(null_headers.data(), null_headers.size());
- v.push_back(null_bitmap);
+ v.push_back(non_null_bitmap);
}
v.push_back(data);
Status s = AppendRawBlock(v, first_elem_ord,
@@ -401,7 +401,7 @@ Status CFileWriter::FinishCurDataBlock() {
"data block");
if (is_nullable_) {
- null_bitmap_builder_->Reset();
+ non_null_bitmap_builder_->Reset();
}
if (validx_builder_ != nullptr) {
diff --git a/src/kudu/cfile/cfile_writer.h b/src/kudu/cfile/cfile_writer.h
index 29391bb..f741e82 100644
--- a/src/kudu/cfile/cfile_writer.h
+++ b/src/kudu/cfile/cfile_writer.h
@@ -234,7 +234,7 @@ class CFileWriter {
std::unique_ptr<BlockBuilder> data_block_;
std::unique_ptr<IndexTreeBuilder> posidx_builder_;
std::unique_ptr<IndexTreeBuilder> validx_builder_;
- std::unique_ptr<NullBitmapBuilder> null_bitmap_builder_;
+ std::unique_ptr<NullBitmapBuilder> non_null_bitmap_builder_;
std::unique_ptr<CompressedBlockBuilder> block_compressor_;
enum State {
diff --git a/src/kudu/client/write_op.cc b/src/kudu/client/write_op.cc
index 5beed13..18b8581 100644
--- a/src/kudu/client/write_op.cc
+++ b/src/kudu/client/write_op.cc
@@ -83,7 +83,7 @@ int64_t KuduWriteOperation::SizeInBuffer() const {
// Add size of isset bitmap (always present).
size += BitmapSize(schema->num_columns());
// Add size of null bitmap (present if the schema has nullables)
- size += ContiguousRowHelper::null_bitmap_size(*schema);
+ size += ContiguousRowHelper::non_null_bitmap_size(*schema);
// The column data itself:
for (int i = 0; i < schema->num_columns(); i++) {
if (row_.IsColumnSet(i) && !row_.IsNull(i)) {
diff --git a/src/kudu/common/column_predicate.cc
b/src/kudu/common/column_predicate.cc
index 74f8c69..99c50e8 100644
--- a/src/kudu/common/column_predicate.cc
+++ b/src/kudu/common/column_predicate.cc
@@ -680,7 +680,7 @@ int ApplyPredicatePrimitive(const ColumnBlock& block,
uint8_t* __restrict__ sel_
}
if (block.is_nullable()) {
for (int i = 0; i < n_chunks; i++) {
- sel_bitmap[i] &= block.null_bitmap()[i];
+ sel_bitmap[i] &= block.non_null_bitmap()[i];
}
}
return n_chunks * 8;
@@ -722,9 +722,9 @@ template<bool IS_NOT_NULL>
void ApplyNullPredicate(const ColumnBlock& block, uint8_t* __restrict__
sel_vec) {
int n_bytes = KUDU_ALIGN_UP(block.nrows(), 8) / 8;
for (int i = 0; i < n_bytes; i++) {
- uint8_t null_byte = block.null_bitmap()[i];
- if (!IS_NOT_NULL) null_byte = ~null_byte;
- sel_vec[i] &= null_byte;
+ uint8_t non_null_byte = block.non_null_bitmap()[i];
+ if (!IS_NOT_NULL) non_null_byte = ~non_null_byte;
+ sel_vec[i] &= non_null_byte;
}
}
} // anonymous namespace
diff --git a/src/kudu/common/columnblock.cc b/src/kudu/common/columnblock.cc
index 68ce18c..63eda18 100644
--- a/src/kudu/common/columnblock.cc
+++ b/src/kudu/common/columnblock.cc
@@ -47,9 +47,9 @@ Status ColumnBlock::CopyTo(const SelectionVector& sel_vec,
memcpy(dst->data_ + (dst_cell_off * type_->size()),
data_ + (src_cell_off * type_->size()),
num_cells * type_->size());
- if (null_bitmap_) {
- BitmapCopy(dst->null_bitmap_, dst_cell_off,
- null_bitmap_, src_cell_off,
+ if (non_null_bitmap_) {
+ BitmapCopy(dst->non_null_bitmap_, dst_cell_off,
+ non_null_bitmap_, src_cell_off,
num_cells);
}
}
diff --git a/src/kudu/common/columnblock.h b/src/kudu/common/columnblock.h
index 0915cd6..fdaba37 100644
--- a/src/kudu/common/columnblock.h
+++ b/src/kudu/common/columnblock.h
@@ -46,12 +46,12 @@ class ColumnBlock {
typedef ColumnBlockCell Cell;
ColumnBlock(const TypeInfo* type,
- uint8_t *null_bitmap,
+ uint8_t *non_null_bitmap,
void *data,
size_t nrows,
Arena *arena)
: type_(type),
- null_bitmap_(null_bitmap),
+ non_null_bitmap_(non_null_bitmap),
data_(reinterpret_cast<uint8_t *>(data)),
nrows_(nrows),
arena_(arena) {
@@ -60,7 +60,7 @@ class ColumnBlock {
void SetCellIsNull(size_t idx, bool is_null) {
DCHECK(is_nullable());
- BitmapChange(null_bitmap_, idx, !is_null);
+ BitmapChange(non_null_bitmap_, idx, !is_null);
}
void SetCellValue(size_t idx, const void *new_val) {
@@ -87,18 +87,22 @@ class ColumnBlock {
Cell cell(size_t idx) const;
- uint8_t *null_bitmap() const {
- return null_bitmap_;
+ // Return the bitmap indicating whether each cell is non-NULL.
+ // A set bit indicates non-NULL.
+ //
+ // This returns nullptr for a non-nullable column.
+ uint8_t *non_null_bitmap() const {
+ return non_null_bitmap_;
}
bool is_nullable() const {
- return null_bitmap_ != NULL;
+ return non_null_bitmap_ != nullptr;
}
bool is_null(size_t idx) const {
DCHECK(is_nullable());
DCHECK_LT(idx, nrows_);
- return !BitmapTest(null_bitmap_, idx);
+ return !BitmapTest(non_null_bitmap_, idx);
}
const size_t stride() const { return type_->size(); }
@@ -154,7 +158,7 @@ class ColumnBlock {
}
const TypeInfo *type_;
- uint8_t *null_bitmap_;
+ uint8_t *non_null_bitmap_;
uint8_t *data_;
size_t nrows_;
@@ -175,7 +179,7 @@ inline bool operator==(const ColumnBlock& a, const
ColumnBlock& b) {
// 3. If nullable, same null bitmap contents.
if (a.is_nullable() &&
- !BitmapEquals(a.null_bitmap(), b.null_bitmap(), a.nrows())) {
+ !BitmapEquals(a.non_null_bitmap(), b.non_null_bitmap(), a.nrows())) {
return false;
}
@@ -245,7 +249,7 @@ class ColumnDataView {
// Set 'nrows' bits of the the null-bitmap to "value"
// true if not null, false if null.
void SetNullBits(size_t nrows, bool value) {
- BitmapChangeBits(column_block_->null_bitmap(), row_offset_, nrows, value);
+ BitmapChangeBits(column_block_->non_null_bitmap(), row_offset_, nrows,
value);
}
uint8_t *data() {
@@ -292,12 +296,12 @@ class ScopedColumnBlock : public ColumnBlock {
new cpp_type[n_rows],
n_rows,
new Arena(1024)),
- null_bitmap_(null_bitmap()),
+ non_null_bitmap_(non_null_bitmap()),
data_(reinterpret_cast<cpp_type *>(data())),
arena_(arena()) {
if (allow_nulls) {
// All rows begin null.
- BitmapChangeBits(null_bitmap(), /*offset=*/ 0, n_rows, /*value=*/ false);
+ BitmapChangeBits(non_null_bitmap(), /*offset=*/ 0, n_rows, /*value=*/
false);
}
}
@@ -310,7 +314,7 @@ class ScopedColumnBlock : public ColumnBlock {
}
private:
- std::unique_ptr<uint8_t[]> null_bitmap_;
+ std::unique_ptr<uint8_t[]> non_null_bitmap_;
std::unique_ptr<cpp_type[]> data_;
std::unique_ptr<Arena> arena_;
diff --git a/src/kudu/common/partial_row.cc b/src/kudu/common/partial_row.cc
index e72b9d6..5a10476 100644
--- a/src/kudu/common/partial_row.cc
+++ b/src/kudu/common/partial_row.cc
@@ -75,7 +75,7 @@ KuduPartialRow::KuduPartialRow(const Schema* schema)
row_size, "NEWNEWNEWNEWNEW");
#endif
ContiguousRowHelper::InitNullsBitmap(
- *schema_, row_data_, ContiguousRowHelper::null_bitmap_size(*schema_));
+ *schema_, row_data_, ContiguousRowHelper::non_null_bitmap_size(*schema_));
}
KuduPartialRow::~KuduPartialRow() {
diff --git a/src/kudu/common/row.h b/src/kudu/common/row.h
index 5ea8850..a2e3756 100644
--- a/src/kudu/common/row.h
+++ b/src/kudu/common/row.h
@@ -381,16 +381,16 @@ inline Status RelocateIndirectDataToArena(RowType *row,
ArenaType *dst_arena) {
class ContiguousRowHelper {
public:
- static size_t null_bitmap_size(const Schema& schema) {
+ static size_t non_null_bitmap_size(const Schema& schema) {
return schema.has_nullables() ? BitmapSize(schema.num_columns()) : 0;
}
- static uint8_t* null_bitmap_ptr(const Schema& schema, uint8_t* row_data) {
+ static uint8_t* non_null_bitmap_ptr(const Schema& schema, uint8_t* row_data)
{
return row_data + schema.byte_size();
}
static size_t row_size(const Schema& schema) {
- return schema.byte_size() + null_bitmap_size(schema);
+ return schema.byte_size() + non_null_bitmap_size(schema);
}
static void InitNullsBitmap(const Schema& schema, Slice& row_data) {
@@ -398,9 +398,9 @@ class ContiguousRowHelper {
}
static void InitNullsBitmap(const Schema& schema, uint8_t *row_data, size_t
bitmap_size) {
- uint8_t *null_bitmap = row_data + schema.byte_size();
+ uint8_t *non_null_bitmap = row_data + schema.byte_size();
for (size_t i = 0; i < bitmap_size; ++i) {
- null_bitmap[i] = 0x00;
+ non_null_bitmap[i] = 0x00;
}
}
@@ -410,8 +410,8 @@ class ContiguousRowHelper {
}
static void SetCellIsNull(const Schema& schema, uint8_t *row_data, size_t
col_idx, bool is_null) {
- uint8_t *null_bitmap = row_data + schema.byte_size();
- BitmapChange(null_bitmap, col_idx, is_null);
+ uint8_t *non_null_bitmap = row_data + schema.byte_size();
+ BitmapChange(non_null_bitmap, col_idx, is_null);
}
static const uint8_t *cell_ptr(const Schema& schema, const uint8_t
*row_data, size_t col_idx) {
@@ -577,7 +577,7 @@ class RowBuilder {
explicit RowBuilder(const Schema* schema)
: schema_(schema),
arena_(1024),
- bitmap_size_(ContiguousRowHelper::null_bitmap_size(*schema)) {
+ bitmap_size_(ContiguousRowHelper::non_null_bitmap_size(*schema)) {
Reset();
}
diff --git a/src/kudu/common/row_operations.cc
b/src/kudu/common/row_operations.cc
index 1788a17..b82ace6 100644
--- a/src/kudu/common/row_operations.cc
+++ b/src/kudu/common/row_operations.cc
@@ -123,9 +123,9 @@ size_t RowOperationsPBEncoder::Add(RowOperationsPB::Type
op_type,
// At the end of the function, we'll resize() the string back down to the
// right size.
size_t isset_bitmap_size;
- size_t null_bitmap_size;
+ size_t non_null_bitmap_size;
const size_t new_size_estimate = GetRowsFieldSizeEstimate(
- partial_row, &isset_bitmap_size, &null_bitmap_size);
+ partial_row, &isset_bitmap_size, &non_null_bitmap_size);
dst->resize(new_size_estimate);
uint8_t* dst_ptr = reinterpret_cast<uint8_t*>(&(*dst)[prev_rows_size_]);
@@ -134,9 +134,9 @@ size_t RowOperationsPBEncoder::Add(RowOperationsPB::Type
op_type,
dst_ptr += isset_bitmap_size;
memcpy(dst_ptr,
- ContiguousRowHelper::null_bitmap_ptr(*schema, partial_row.row_data_),
- null_bitmap_size);
- dst_ptr += null_bitmap_size;
+ ContiguousRowHelper::non_null_bitmap_ptr(*schema,
partial_row.row_data_),
+ non_null_bitmap_size);
+ dst_ptr += non_null_bitmap_size;
size_t indirect_data_size_delta = 0;
ContiguousRow row(schema, partial_row.row_data_);
@@ -185,19 +185,19 @@ void RowOperationsPBEncoder::RemoveLast() {
size_t RowOperationsPBEncoder::GetRowsFieldSizeEstimate(
const KuduPartialRow& partial_row,
size_t* isset_bitmap_size,
- size_t* isnull_bitmap_size) const {
+ size_t* isnon_null_bitmap_size) const {
const Schema* schema = partial_row.schema();
// See wire_protocol.proto for a description of the format.
const string* dst = pb_->mutable_rows();
auto isset_size = BitmapSize(schema->num_columns());
- auto isnull_size = ContiguousRowHelper::null_bitmap_size(*schema);
+ auto isnull_size = ContiguousRowHelper::non_null_bitmap_size(*schema);
constexpr auto type_size = 1; // type uses one byte
auto max_size = type_size + schema->byte_size() + isset_size + isnull_size;
*isset_bitmap_size = isset_size;
- *isnull_bitmap_size = isnull_size;
+ *isnon_null_bitmap_size = isnull_size;
return dst->size() + max_size;
}
diff --git a/src/kudu/common/row_operations.h b/src/kudu/common/row_operations.h
index 5835556..af3a7fd 100644
--- a/src/kudu/common/row_operations.h
+++ b/src/kudu/common/row_operations.h
@@ -63,7 +63,7 @@ class RowOperationsPBEncoder {
// after adding the extra row specified.
size_t GetRowsFieldSizeEstimate(const KuduPartialRow& partial_row,
size_t* isset_bitmap_size,
- size_t* isnull_bitmap_size) const;
+ size_t* isnon_null_bitmap_size) const;
RowOperationsPB* pb_;
std::string::size_type prev_indirect_data_size_;
diff --git a/src/kudu/common/rowblock.cc b/src/kudu/common/rowblock.cc
index f89b379..7e8b22b 100644
--- a/src/kudu/common/rowblock.cc
+++ b/src/kudu/common/rowblock.cc
@@ -146,7 +146,7 @@ RowBlock::RowBlock(const Schema* schema,
Arena *arena)
: schema_(schema),
columns_data_(schema->num_columns()),
- column_null_bitmaps_(schema->num_columns()),
+ column_non_null_bitmaps_(schema->num_columns()),
row_capacity_(nrows),
nrows_(nrows),
arena_(arena),
@@ -160,7 +160,7 @@ RowBlock::RowBlock(const Schema* schema,
columns_data_[i] = new uint8_t[col_size];
if (col_schema.is_nullable()) {
- column_null_bitmaps_[i] = new uint8_t[bitmap_size];
+ column_non_null_bitmaps_[i] = new uint8_t[bitmap_size];
}
}
}
@@ -169,7 +169,7 @@ RowBlock::~RowBlock() {
for (uint8_t* column_data : columns_data_) {
delete[] column_data;
}
- for (uint8_t* bitmap_data : column_null_bitmaps_) {
+ for (uint8_t* bitmap_data : column_non_null_bitmaps_) {
delete[] bitmap_data;
}
}
diff --git a/src/kudu/common/rowblock.h b/src/kudu/common/rowblock.h
index 52804b9..04fa419 100644
--- a/src/kudu/common/rowblock.h
+++ b/src/kudu/common/rowblock.h
@@ -268,7 +268,7 @@ class RowBlock {
const ColumnSchema& col_schema = schema_->column(col_idx);
uint8_t* col_data = columns_data_[col_idx];
- uint8_t* nulls_bitmap = column_null_bitmaps_[col_idx];
+ uint8_t* nulls_bitmap = column_non_null_bitmaps_[col_idx];
return ColumnBlock(col_schema.type_info(), nulls_bitmap, col_data, nrows,
arena_);
}
@@ -297,8 +297,8 @@ class RowBlock {
size_t col_size = col_schema.type_info()->size() * row_capacity_;
memset(columns_data_[i], '\0', col_size);
- if (column_null_bitmaps_[i] != NULL) {
- memset(column_null_bitmaps_[i], '\0', bitmap_size);
+ if (column_non_null_bitmaps_[i] != NULL) {
+ memset(column_non_null_bitmaps_[i], '\0', bitmap_size);
}
}
}
@@ -364,7 +364,7 @@ class RowBlock {
const Schema* schema_;
std::vector<uint8_t*> columns_data_;
- std::vector<uint8_t*> column_null_bitmaps_;
+ std::vector<uint8_t*> column_non_null_bitmaps_;
// The maximum number of rows that can be stored in our allocated buffer.
size_t row_capacity_;
diff --git a/src/kudu/common/wire_protocol-test.cc
b/src/kudu/common/wire_protocol-test.cc
index df00788..d85e947 100644
--- a/src/kudu/common/wire_protocol-test.cc
+++ b/src/kudu/common/wire_protocol-test.cc
@@ -399,7 +399,7 @@ TEST_F(WireProtocolTest,
TestColumnarRowBlockToPBWithPadding) {
base_data = direct_sidecar.data() + i * row_stride;
// With padding, the null bitmap is at offset 68.
// See the calculations below to understand why.
- const uint8_t* null_bitmap = base_data + 68;
+ const uint8_t* non_null_bitmap = base_data + 68;
// 'col1' comes at 0 bytes offset in the projection schema.
const Slice* col1 = reinterpret_cast<const Slice*>(base_data);
@@ -419,12 +419,12 @@ TEST_F(WireProtocolTest,
TestColumnarRowBlockToPBWithPadding) {
// 8 bytes padding.
const int64_t col4 = *reinterpret_cast<const int64_t*>(base_data + 48);
EXPECT_EQ(col4, 0);
- EXPECT_TRUE(BitmapTest(null_bitmap, 3));
+ EXPECT_TRUE(BitmapTest(non_null_bitmap, 3));
// 'col3' comes at 64 bytes offset: 48 bytes previous, 8 bytes 'col4', 8
bytes padding
const int32_t col3 = *reinterpret_cast<const int32_t*>(base_data + 64);
EXPECT_EQ(col3, i);
- EXPECT_FALSE(BitmapTest(null_bitmap, 4));
+ EXPECT_FALSE(BitmapTest(non_null_bitmap, 4));
}
}
diff --git a/src/kudu/common/wire_protocol.cc b/src/kudu/common/wire_protocol.cc
index e3101a4..533de57 100644
--- a/src/kudu/common/wire_protocol.cc
+++ b/src/kudu/common/wire_protocol.cc
@@ -733,7 +733,7 @@ Status RewriteRowBlockPointers(const Schema& schema, const
RowwiseRowBlockPB& ro
uint8_t* row_data = row_data_slice->mutable_data();
const uint8_t* indir_data = indirect_data_slice.data();
const size_t expected_data_size = rowblock_pb.num_rows() * row_stride;
- const size_t null_bitmap_offset = schema.byte_size() + total_padding;
+ const size_t non_null_bitmap_offset = schema.byte_size() + total_padding;
if (PREDICT_FALSE(row_data_slice->size() != expected_data_size)) {
return Status::Corruption(
@@ -779,7 +779,7 @@ Status RewriteRowBlockPointers(const Schema& schema, const
RowwiseRowBlockPB& ro
for (const auto& t : to_rewrite) {
uint8_t* cell_ptr = row_ptr + t.col_offset;
- if (t.nullable && BitmapTest(row_ptr + null_bitmap_offset, t.col_idx)) {
+ if (t.nullable && BitmapTest(row_ptr + non_null_bitmap_offset,
t.col_idx)) {
// No need to rewrite null values.
continue;
}
@@ -894,7 +894,7 @@ static void CopyColumn(
const vector<int>& row_idx_select) {
DCHECK(dst_schema);
uint8_t* dst = dst_base + column_offset;
- size_t offset_to_null_bitmap = schema_byte_size - column_offset;
+ size_t offset_to_non_null_bitmap = schema_byte_size - column_offset;
size_t cell_size = column_block.stride();
const uint8_t* src = column_block.cell_ptr(0);
@@ -902,7 +902,7 @@ static void CopyColumn(
for (auto index : row_idx_select) {
src = column_block.cell_ptr(index);
if (IS_NULLABLE && column_block.is_null(index)) {
- BitmapChange(dst + offset_to_null_bitmap, dst_col_idx, true);
+ BitmapChange(dst + offset_to_non_null_bitmap, dst_col_idx, true);
} else if (IS_VARLEN) {
const Slice* slice = reinterpret_cast<const Slice *>(src);
size_t offset_in_indirect = indirect_data->size();
@@ -912,12 +912,12 @@ static void CopyColumn(
*dst_slice = Slice(reinterpret_cast<const uint8_t*>(offset_in_indirect),
slice->size());
if (IS_NULLABLE) {
- BitmapChange(dst + offset_to_null_bitmap, dst_col_idx, false);
+ BitmapChange(dst + offset_to_non_null_bitmap, dst_col_idx, false);
}
} else { // non-string, non-null
strings::memcpy_inlined(dst, src, cell_size);
if (IS_NULLABLE) {
- BitmapChange(dst + offset_to_null_bitmap, dst_col_idx, false);
+ BitmapChange(dst + offset_to_non_null_bitmap, dst_col_idx, false);
}
}
dst += row_stride;
diff --git a/src/kudu/integration-tests/all_types-itest.cc
b/src/kudu/integration-tests/all_types-itest.cc
index 2d9bb1d..6362589 100644
--- a/src/kudu/integration-tests/all_types-itest.cc
+++ b/src/kudu/integration-tests/all_types-itest.cc
@@ -713,8 +713,8 @@ TYPED_TEST(AllTypesItest, TestTimestampPadding) {
}
}
- int null_bitmap_size = BitmapSize(num_nullable_cols);
- row_stride += null_bitmap_size;
+ int non_null_bitmap_size = BitmapSize(num_nullable_cols);
+ row_stride += non_null_bitmap_size;
Slice direct_data = batch.direct_data();
@@ -793,7 +793,7 @@ TYPED_TEST(AllTypesItest, TestTimestampPadding) {
}
row_data += projection_offsets[j];
}
- row_data += null_bitmap_size;
+ row_data += non_null_bitmap_size;
}
*total_rows_in_tablet += batch.NumRows();
};
diff --git a/src/kudu/tablet/multi_column_writer.cc
b/src/kudu/tablet/multi_column_writer.cc
index 667aa3f..04efecb 100644
--- a/src/kudu/tablet/multi_column_writer.cc
+++ b/src/kudu/tablet/multi_column_writer.cc
@@ -105,7 +105,7 @@ Status MultiColumnWriter::AppendBlock(const RowBlock&
block) {
for (int i = 0; i < schema_->num_columns(); i++) {
ColumnBlock column = block.column_block(i);
if (column.is_nullable()) {
-
RETURN_NOT_OK(cfile_writers_[i]->AppendNullableEntries(column.null_bitmap(),
+
RETURN_NOT_OK(cfile_writers_[i]->AppendNullableEntries(column.non_null_bitmap(),
column.data(), column.nrows()));
} else {
RETURN_NOT_OK(cfile_writers_[i]->AppendEntries(column.data(),
column.nrows()));
diff --git a/src/kudu/tablet/tablet-test-util.h
b/src/kudu/tablet/tablet-test-util.h
index 8734a98..3962dd4 100644
--- a/src/kudu/tablet/tablet-test-util.h
+++ b/src/kudu/tablet/tablet-test-util.h
@@ -330,7 +330,8 @@ static inline Status DumpTablet(const Tablet& tablet,
template<class RowSetWriterClass>
static Status WriteRow(const Slice &row_slice, RowSetWriterClass *writer) {
const Schema &schema = writer->schema();
- DCHECK_EQ(row_slice.size(), schema.byte_size() +
ContiguousRowHelper::null_bitmap_size(schema));
+ DCHECK_EQ(row_slice.size(), schema.byte_size() +
+ ContiguousRowHelper::non_null_bitmap_size(schema));
RowBlock block(&schema, 1, nullptr);
ConstContiguousRow row(&schema, row_slice.data());
