ORC-1677: [C++] Remove `m` prefix of class member variables
### What changes were proposed in this pull request?
Remove the `m` prefix of identifiers.
### Why are the changes needed?
To unify naming style of identifiers.
### How was this patch tested?
UT passed.
### Was this patch authored or co-authored using generative AI tooling?
NO
Closes #1877 from ffacs/NamingStyle.
Lead-authored-by: ffacs <ffacs@ffacs.top>
Co-authored-by: ffacs <ffacs520@gmail.com>
Signed-off-by: Gang Wu <ustcwg@gmail.com>
diff --git a/c++/include/orc/sargs/Literal.hh b/c++/include/orc/sargs/Literal.hh
index a681bc6..f7d3700 100644
--- a/c++/include/orc/sargs/Literal.hh
+++ b/c++/include/orc/sargs/Literal.hh
@@ -130,15 +130,15 @@
* Check if a literal is null
*/
bool isNull() const {
- return mIsNull_;
+ return isNull_;
}
PredicateDataType getType() const {
- return mType_;
+ return type_;
}
std::string toString() const;
size_t getHashCode() const {
- return mHashCode_;
+ return hashCode_;
}
private:
@@ -158,13 +158,13 @@
};
private:
- LiteralVal mValue_; // data value for this literal if not null
- PredicateDataType mType_; // data type of the literal
- size_t mSize_; // size of mValue if it is Buffer
- int32_t mPrecision_; // precision of decimal type
- int32_t mScale_; // scale of decimal type
- bool mIsNull_; // whether this literal is null
- size_t mHashCode_; // precomputed hash code for the literal
+ LiteralVal value_; // data value for this literal if not null
+ PredicateDataType type_; // data type of the literal
+ size_t size_; // size of mValue if it is Buffer
+ int32_t precision_; // precision of decimal type
+ int32_t scale_; // scale of decimal type
+ bool isNull_; // whether this literal is null
+ size_t hashCode_; // precomputed hash code for the literal
};
} // namespace orc
diff --git a/c++/src/BloomFilter.cc b/c++/src/BloomFilter.cc
index faaa8bb..8876372 100644
--- a/c++/src/BloomFilter.cc
+++ b/c++/src/BloomFilter.cc
@@ -37,50 +37,50 @@
* Implementation of BitSet
*/
BitSet::BitSet(uint64_t numBits) {
- mData_.resize(static_cast<size_t>(ceil(static_cast<double>(numBits) / BITS_OF_LONG)), 0);
+ data_.resize(static_cast<size_t>(ceil(static_cast<double>(numBits) / BITS_OF_LONG)), 0);
}
BitSet::BitSet(const uint64_t* bits, uint64_t numBits) {
// caller should make sure numBits is multiple of 64
- mData_.resize(numBits >> SHIFT_6_BITS, 0);
- memcpy(mData_.data(), bits, numBits >> SHIFT_3_BITS);
+ data_.resize(numBits >> SHIFT_6_BITS, 0);
+ memcpy(data_.data(), bits, numBits >> SHIFT_3_BITS);
}
void BitSet::set(uint64_t index) {
- mData_[index >> SHIFT_6_BITS] |= (1ULL << (index % BITS_OF_LONG));
+ data_[index >> SHIFT_6_BITS] |= (1ULL << (index % BITS_OF_LONG));
}
bool BitSet::get(uint64_t index) {
- return (mData_[index >> SHIFT_6_BITS] & (1ULL << (index % BITS_OF_LONG))) != 0;
+ return (data_[index >> SHIFT_6_BITS] & (1ULL << (index % BITS_OF_LONG))) != 0;
}
uint64_t BitSet::bitSize() {
- return mData_.size() << SHIFT_6_BITS;
+ return data_.size() << SHIFT_6_BITS;
}
void BitSet::merge(const BitSet& other) {
- if (mData_.size() != other.mData_.size()) {
+ if (data_.size() != other.data_.size()) {
std::stringstream ss;
- ss << "BitSet must be of equal length (" << mData_.size() << " != " << other.mData_.size()
+ ss << "BitSet must be of equal length (" << data_.size() << " != " << other.data_.size()
<< ")";
throw std::logic_error(ss.str());
}
- for (size_t i = 0; i != mData_.size(); i++) {
- mData_[i] |= other.mData_[i];
+ for (size_t i = 0; i != data_.size(); i++) {
+ data_[i] |= other.data_[i];
}
}
void BitSet::clear() {
- memset(mData_.data(), 0, sizeof(uint64_t) * mData_.size());
+ memset(data_.data(), 0, sizeof(uint64_t) * data_.size());
}
const uint64_t* BitSet::getData() const {
- return mData_.data();
+ return data_.data();
}
bool BitSet::operator==(const BitSet& other) const {
- return mData_ == other.mData_;
+ return data_ == other.data_;
}
/**
@@ -127,9 +127,9 @@
uint64_t nb = static_cast<uint64_t>(optimalNumOfBits(expectedEntries, fpp));
// make 'mNumBits' multiple of 64
- mNumBits_ = nb + (BITS_OF_LONG - (nb % BITS_OF_LONG));
- mNumHashFunctions_ = optimalNumOfHashFunctions(expectedEntries, mNumBits_);
- mBitSet_.reset(new BitSet(mNumBits_));
+ numBits_ = nb + (BITS_OF_LONG - (nb % BITS_OF_LONG));
+ numHashFunctions_ = optimalNumOfHashFunctions(expectedEntries, numBits_);
+ bitSet_.reset(new BitSet(numBits_));
}
void BloomFilterImpl::addBytes(const char* data, int64_t length) {
@@ -155,11 +155,11 @@
}
uint64_t BloomFilterImpl::getBitSize() const {
- return mBitSet_->bitSize();
+ return bitSet_->bitSize();
}
int32_t BloomFilterImpl::getNumHashFunctions() const {
- return mNumHashFunctions_;
+ return numHashFunctions_;
}
DIAGNOSTIC_PUSH
@@ -175,17 +175,17 @@
// caller should make sure input proto::BloomFilter is valid since
// no check will be performed in the following constructor
BloomFilterImpl::BloomFilterImpl(const proto::BloomFilter& bloomFilter) {
- mNumHashFunctions_ = static_cast<int32_t>(bloomFilter.num_hash_functions());
+ numHashFunctions_ = static_cast<int32_t>(bloomFilter.num_hash_functions());
const std::string& bitsetStr = bloomFilter.utf8bitset();
- mNumBits_ = bitsetStr.size() << SHIFT_3_BITS;
- checkArgument(mNumBits_ % BITS_OF_LONG == 0, "numBits should be multiple of 64!");
+ numBits_ = bitsetStr.size() << SHIFT_3_BITS;
+ checkArgument(numBits_ % BITS_OF_LONG == 0, "numBits should be multiple of 64!");
const uint64_t* bitset = reinterpret_cast<const uint64_t*>(bitsetStr.data());
if (isLittleEndian()) {
- mBitSet_.reset(new BitSet(bitset, mNumBits_));
+ bitSet_.reset(new BitSet(bitset, numBits_));
} else {
- std::vector<uint64_t> longs(mNumBits_ >> SHIFT_6_BITS);
+ std::vector<uint64_t> longs(numBits_ >> SHIFT_6_BITS);
for (size_t i = 0; i != longs.size(); ++i) {
// convert little-endian to big-endian
const uint64_t src = bitset[i];
@@ -195,7 +195,7 @@
}
}
- mBitSet_.reset(new BitSet(longs.data(), mNumBits_));
+ bitSet_.reset(new BitSet(longs.data(), numBits_));
}
}
@@ -215,14 +215,14 @@
// So we cast hash64 to uint64_t here for an unsigned right shift.
int32_t hash2 = static_cast<int32_t>(static_cast<uint64_t>(hash64) >> 32);
- for (int32_t i = 1; i <= mNumHashFunctions_; ++i) {
+ for (int32_t i = 1; i <= numHashFunctions_; ++i) {
int32_t combinedHash = hash1 + i * hash2;
// hashcode should be positive, flip all the bits if it's negative
if (combinedHash < 0) {
combinedHash = ~combinedHash;
}
- uint64_t pos = static_cast<uint64_t>(combinedHash) % mNumBits_;
- mBitSet_->set(pos);
+ uint64_t pos = static_cast<uint64_t>(combinedHash) % numBits_;
+ bitSet_->set(pos);
}
}
@@ -232,14 +232,14 @@
// So we cast hash64 to uint64_t here for an unsigned right shift.
int32_t hash2 = static_cast<int32_t>(static_cast<uint64_t>(hash64) >> 32);
- for (int32_t i = 1; i <= mNumHashFunctions_; ++i) {
+ for (int32_t i = 1; i <= numHashFunctions_; ++i) {
int32_t combinedHash = hash1 + i * hash2;
// hashcode should be positive, flip all the bits if it's negative
if (combinedHash < 0) {
combinedHash = ~combinedHash;
}
- uint64_t pos = static_cast<uint64_t>(combinedHash) % mNumBits_;
- if (!mBitSet_->get(pos)) {
+ uint64_t pos = static_cast<uint64_t>(combinedHash) % numBits_;
+ if (!bitSet_->get(pos)) {
return false;
}
}
@@ -247,34 +247,33 @@
}
void BloomFilterImpl::merge(const BloomFilterImpl& other) {
- if (mNumBits_ != other.mNumBits_ || mNumHashFunctions_ != other.mNumHashFunctions_) {
+ if (numBits_ != other.numBits_ || numHashFunctions_ != other.numHashFunctions_) {
std::stringstream ss;
ss << "BloomFilters are not compatible for merging: "
- << "this: numBits:" << mNumBits_ << ",numHashFunctions:" << mNumHashFunctions_
- << ", that: numBits:" << other.mNumBits_
- << ",numHashFunctions:" << other.mNumHashFunctions_;
+ << "this: numBits:" << numBits_ << ",numHashFunctions:" << numHashFunctions_
+ << ", that: numBits:" << other.numBits_ << ",numHashFunctions:" << other.numHashFunctions_;
throw std::logic_error(ss.str());
}
- mBitSet_->merge(*other.mBitSet_);
+ bitSet_->merge(*other.bitSet_);
}
void BloomFilterImpl::reset() {
- mBitSet_->clear();
+ bitSet_->clear();
}
void BloomFilterImpl::serialize(proto::BloomFilter& bloomFilter) const {
- bloomFilter.set_num_hash_functions(static_cast<uint32_t>(mNumHashFunctions_));
+ bloomFilter.set_num_hash_functions(static_cast<uint32_t>(numHashFunctions_));
// According to ORC standard, the encoding is a sequence of bytes with
// a little endian encoding in the utf8bitset field.
if (isLittleEndian()) {
// bytes are already organized in little endian; thus no conversion needed
- const char* bitset = reinterpret_cast<const char*>(mBitSet_->getData());
+ const char* bitset = reinterpret_cast<const char*>(bitSet_->getData());
bloomFilter.set_utf8bitset(bitset, sizeInBytes());
} else {
std::vector<uint64_t> bitset(sizeInBytes() / sizeof(uint64_t), 0);
- const uint64_t* longs = mBitSet_->getData();
+ const uint64_t* longs = bitSet_->getData();
for (size_t i = 0; i != bitset.size(); ++i) {
uint64_t& dst = bitset[i];
const uint64_t src = longs[i];
@@ -288,8 +287,8 @@
}
bool BloomFilterImpl::operator==(const BloomFilterImpl& other) const {
- return mNumBits_ == other.mNumBits_ && mNumHashFunctions_ == other.mNumHashFunctions_ &&
- *mBitSet_ == *other.mBitSet_;
+ return numBits_ == other.numBits_ && numHashFunctions_ == other.numHashFunctions_ &&
+ *bitSet_ == *other.bitSet_;
}
BloomFilter::~BloomFilter() {
diff --git a/c++/src/BloomFilter.hh b/c++/src/BloomFilter.hh
index e8d7866..ebc4a5e 100644
--- a/c++/src/BloomFilter.hh
+++ b/c++/src/BloomFilter.hh
@@ -90,7 +90,7 @@
bool operator==(const BitSet& other) const;
private:
- std::vector<uint64_t> mData_;
+ std::vector<uint64_t> data_;
};
/**
@@ -174,9 +174,9 @@
private:
static constexpr double DEFAULT_FPP = 0.05;
- uint64_t mNumBits_;
- int32_t mNumHashFunctions_;
- std::unique_ptr<BitSet> mBitSet_;
+ uint64_t numBits_;
+ int32_t numHashFunctions_;
+ std::unique_ptr<BitSet> bitSet_;
};
struct BloomFilterUTF8Utils {
diff --git a/c++/src/sargs/ExpressionTree.cc b/c++/src/sargs/ExpressionTree.cc
index e2186e9..e49bca4 100644
--- a/c++/src/sargs/ExpressionTree.cc
+++ b/c++/src/sargs/ExpressionTree.cc
@@ -24,42 +24,39 @@
namespace orc {
ExpressionTree::ExpressionTree(Operator op)
- : mOperator_(op), mLeaf_(UNUSED_LEAF), mConstant_(TruthValue::YES_NO_NULL) {}
+ : operator_(op), leaf_(UNUSED_LEAF), constant_(TruthValue::YES_NO_NULL) {}
ExpressionTree::ExpressionTree(Operator op, std::initializer_list<TreeNode> children)
- : mOperator_(op),
- mChildren_(children.begin(), children.end()),
- mLeaf_(UNUSED_LEAF),
- mConstant_(TruthValue::YES_NO_NULL) {
+ : operator_(op),
+ children_(children.begin(), children.end()),
+ leaf_(UNUSED_LEAF),
+ constant_(TruthValue::YES_NO_NULL) {
// PASS
}
ExpressionTree::ExpressionTree(size_t leaf)
- : mOperator_(Operator::LEAF),
- mChildren_(),
- mLeaf_(leaf),
- mConstant_(TruthValue::YES_NO_NULL) {
+ : operator_(Operator::LEAF), children_(), leaf_(leaf), constant_(TruthValue::YES_NO_NULL) {
// PASS
}
ExpressionTree::ExpressionTree(TruthValue constant)
- : mOperator_(Operator::CONSTANT), mChildren_(), mLeaf_(UNUSED_LEAF), mConstant_(constant) {
+ : operator_(Operator::CONSTANT), children_(), leaf_(UNUSED_LEAF), constant_(constant) {
// PASS
}
ExpressionTree::ExpressionTree(const ExpressionTree& other)
- : mOperator_(other.mOperator_), mLeaf_(other.mLeaf_), mConstant_(other.mConstant_) {
- for (TreeNode child : other.mChildren_) {
- mChildren_.emplace_back(std::make_shared<ExpressionTree>(*child));
+ : operator_(other.operator_), leaf_(other.leaf_), constant_(other.constant_) {
+ for (TreeNode child : other.children_) {
+ children_.emplace_back(std::make_shared<ExpressionTree>(*child));
}
}
ExpressionTree::Operator ExpressionTree::getOperator() const {
- return mOperator_;
+ return operator_;
}
const std::vector<TreeNode>& ExpressionTree::getChildren() const {
- return mChildren_;
+ return children_;
}
std::vector<TreeNode>& ExpressionTree::getChildren() {
@@ -68,7 +65,7 @@
}
const TreeNode ExpressionTree::getChild(size_t i) const {
- return mChildren_.at(i);
+ return children_.at(i);
}
TreeNode ExpressionTree::getChild(size_t i) {
@@ -77,47 +74,47 @@
}
TruthValue ExpressionTree::getConstant() const {
- assert(mOperator_ == Operator::CONSTANT);
- return mConstant_;
+ assert(operator_ == Operator::CONSTANT);
+ return constant_;
}
size_t ExpressionTree::getLeaf() const {
- assert(mOperator_ == Operator::LEAF);
- return mLeaf_;
+ assert(operator_ == Operator::LEAF);
+ return leaf_;
}
void ExpressionTree::setLeaf(size_t leaf) {
- assert(mOperator_ == Operator::LEAF);
- mLeaf_ = leaf;
+ assert(operator_ == Operator::LEAF);
+ leaf_ = leaf;
}
void ExpressionTree::addChild(TreeNode child) {
- mChildren_.push_back(child);
+ children_.push_back(child);
}
TruthValue ExpressionTree::evaluate(const std::vector<TruthValue>& leaves) const {
TruthValue result;
- switch (mOperator_) {
+ switch (operator_) {
case Operator::OR: {
- result = mChildren_.at(0)->evaluate(leaves);
- for (size_t i = 1; i < mChildren_.size() && !isNeeded(result); ++i) {
- result = mChildren_.at(i)->evaluate(leaves) || result;
+ result = children_.at(0)->evaluate(leaves);
+ for (size_t i = 1; i < children_.size() && !isNeeded(result); ++i) {
+ result = children_.at(i)->evaluate(leaves) || result;
}
return result;
}
case Operator::AND: {
- result = mChildren_.at(0)->evaluate(leaves);
- for (size_t i = 1; i < mChildren_.size() && isNeeded(result); ++i) {
- result = mChildren_.at(i)->evaluate(leaves) && result;
+ result = children_.at(0)->evaluate(leaves);
+ for (size_t i = 1; i < children_.size() && isNeeded(result); ++i) {
+ result = children_.at(i)->evaluate(leaves) && result;
}
return result;
}
case Operator::NOT:
- return !mChildren_.at(0)->evaluate(leaves);
+ return !children_.at(0)->evaluate(leaves);
case Operator::LEAF:
- return leaves[mLeaf_];
+ return leaves[leaf_];
case Operator::CONSTANT:
- return mConstant_;
+ return constant_;
default:
throw std::invalid_argument("Unknown operator!");
}
@@ -146,29 +143,29 @@
std::string ExpressionTree::toString() const {
std::ostringstream sstream;
- switch (mOperator_) {
+ switch (operator_) {
case Operator::OR:
sstream << "(or";
- for (const auto& child : mChildren_) {
+ for (const auto& child : children_) {
sstream << ' ' << child->toString();
}
sstream << ')';
break;
case Operator::AND:
sstream << "(and";
- for (const auto& child : mChildren_) {
+ for (const auto& child : children_) {
sstream << ' ' << child->toString();
}
sstream << ')';
break;
case Operator::NOT:
- sstream << "(not " << mChildren_.at(0)->toString() << ')';
+ sstream << "(not " << children_.at(0)->toString() << ')';
break;
case Operator::LEAF:
- sstream << "leaf-" << mLeaf_;
+ sstream << "leaf-" << leaf_;
break;
case Operator::CONSTANT:
- sstream << to_string(mConstant_);
+ sstream << to_string(constant_);
break;
default:
throw std::invalid_argument("unknown operator!");
diff --git a/c++/src/sargs/ExpressionTree.hh b/c++/src/sargs/ExpressionTree.hh
index 39d7567..0f80185 100644
--- a/c++/src/sargs/ExpressionTree.hh
+++ b/c++/src/sargs/ExpressionTree.hh
@@ -74,10 +74,10 @@
TruthValue evaluate(const std::vector<TruthValue>& leaves) const;
private:
- Operator mOperator_;
- std::vector<TreeNode> mChildren_;
- size_t mLeaf_;
- TruthValue mConstant_;
+ Operator operator_;
+ std::vector<TreeNode> children_;
+ size_t leaf_;
+ TruthValue constant_;
};
} // namespace orc
diff --git a/c++/src/sargs/Literal.cc b/c++/src/sargs/Literal.cc
index ac14f6c..f36db79 100644
--- a/c++/src/sargs/Literal.cc
+++ b/c++/src/sargs/Literal.cc
@@ -26,196 +26,196 @@
namespace orc {
Literal::Literal(PredicateDataType type) {
- mType_ = type;
- mValue_.DecimalVal = 0;
- mSize_ = 0;
- mIsNull_ = true;
- mPrecision_ = 0;
- mScale_ = 0;
- mHashCode_ = 0;
+ type_ = type;
+ value_.DecimalVal = 0;
+ size_ = 0;
+ isNull_ = true;
+ precision_ = 0;
+ scale_ = 0;
+ hashCode_ = 0;
}
Literal::Literal(int64_t val) {
- mType_ = PredicateDataType::LONG;
- mValue_.IntVal = val;
- mSize_ = sizeof(val);
- mIsNull_ = false;
- mPrecision_ = 0;
- mScale_ = 0;
- mHashCode_ = hashCode();
+ type_ = PredicateDataType::LONG;
+ value_.IntVal = val;
+ size_ = sizeof(val);
+ isNull_ = false;
+ precision_ = 0;
+ scale_ = 0;
+ hashCode_ = hashCode();
}
Literal::Literal(double val) {
- mType_ = PredicateDataType::FLOAT;
- mValue_.DoubleVal = val;
- mSize_ = sizeof(val);
- mIsNull_ = false;
- mPrecision_ = 0;
- mScale_ = 0;
- mHashCode_ = hashCode();
+ type_ = PredicateDataType::FLOAT;
+ value_.DoubleVal = val;
+ size_ = sizeof(val);
+ isNull_ = false;
+ precision_ = 0;
+ scale_ = 0;
+ hashCode_ = hashCode();
}
Literal::Literal(bool val) {
- mType_ = PredicateDataType::BOOLEAN;
- mValue_.BooleanVal = val;
- mSize_ = sizeof(val);
- mIsNull_ = false;
- mPrecision_ = 0;
- mScale_ = 0;
- mHashCode_ = hashCode();
+ type_ = PredicateDataType::BOOLEAN;
+ value_.BooleanVal = val;
+ size_ = sizeof(val);
+ isNull_ = false;
+ precision_ = 0;
+ scale_ = 0;
+ hashCode_ = hashCode();
}
Literal::Literal(PredicateDataType type, int64_t val) {
if (type != PredicateDataType::DATE) {
throw std::invalid_argument("only DATE is supported here!");
}
- mType_ = type;
- mValue_.IntVal = val;
- mSize_ = sizeof(val);
- mIsNull_ = false;
- mPrecision_ = 0;
- mScale_ = 0;
- mHashCode_ = hashCode();
+ type_ = type;
+ value_.IntVal = val;
+ size_ = sizeof(val);
+ isNull_ = false;
+ precision_ = 0;
+ scale_ = 0;
+ hashCode_ = hashCode();
}
Literal::Literal(const char* str, size_t size) {
- mType_ = PredicateDataType::STRING;
- mValue_.Buffer = new char[size];
- memcpy(mValue_.Buffer, str, size);
- mSize_ = size;
- mIsNull_ = false;
- mPrecision_ = 0;
- mScale_ = 0;
- mHashCode_ = hashCode();
+ type_ = PredicateDataType::STRING;
+ value_.Buffer = new char[size];
+ memcpy(value_.Buffer, str, size);
+ size_ = size;
+ isNull_ = false;
+ precision_ = 0;
+ scale_ = 0;
+ hashCode_ = hashCode();
}
Literal::Literal(Int128 val, int32_t precision, int32_t scale) {
- mType_ = PredicateDataType::DECIMAL;
- mValue_.DecimalVal = val;
- mPrecision_ = precision;
- mScale_ = scale;
- mSize_ = sizeof(Int128);
- mIsNull_ = false;
- mHashCode_ = hashCode();
+ type_ = PredicateDataType::DECIMAL;
+ value_.DecimalVal = val;
+ precision_ = precision;
+ scale_ = scale;
+ size_ = sizeof(Int128);
+ isNull_ = false;
+ hashCode_ = hashCode();
}
Literal::Literal(int64_t second, int32_t nanos) {
- mType_ = PredicateDataType::TIMESTAMP;
- mValue_.TimeStampVal.second = second;
- mValue_.TimeStampVal.nanos = nanos;
- mPrecision_ = 0;
- mScale_ = 0;
- mSize_ = sizeof(Timestamp);
- mIsNull_ = false;
- mHashCode_ = hashCode();
+ type_ = PredicateDataType::TIMESTAMP;
+ value_.TimeStampVal.second = second;
+ value_.TimeStampVal.nanos = nanos;
+ precision_ = 0;
+ scale_ = 0;
+ size_ = sizeof(Timestamp);
+ isNull_ = false;
+ hashCode_ = hashCode();
}
Literal::Literal(const Literal& r)
- : mType_(r.mType_), mSize_(r.mSize_), mIsNull_(r.mIsNull_), mHashCode_(r.mHashCode_) {
- if (mType_ == PredicateDataType::STRING) {
- mValue_.Buffer = new char[r.mSize_];
- memcpy(mValue_.Buffer, r.mValue_.Buffer, r.mSize_);
- mPrecision_ = 0;
- mScale_ = 0;
- } else if (mType_ == PredicateDataType::DECIMAL) {
- mPrecision_ = r.mPrecision_;
- mScale_ = r.mScale_;
- mValue_ = r.mValue_;
- } else if (mType_ == PredicateDataType::TIMESTAMP) {
- mValue_.TimeStampVal = r.mValue_.TimeStampVal;
+ : type_(r.type_), size_(r.size_), isNull_(r.isNull_), hashCode_(r.hashCode_) {
+ if (type_ == PredicateDataType::STRING) {
+ value_.Buffer = new char[r.size_];
+ memcpy(value_.Buffer, r.value_.Buffer, r.size_);
+ precision_ = 0;
+ scale_ = 0;
+ } else if (type_ == PredicateDataType::DECIMAL) {
+ precision_ = r.precision_;
+ scale_ = r.scale_;
+ value_ = r.value_;
+ } else if (type_ == PredicateDataType::TIMESTAMP) {
+ value_.TimeStampVal = r.value_.TimeStampVal;
} else {
- mValue_ = r.mValue_;
- mPrecision_ = 0;
- mScale_ = 0;
+ value_ = r.value_;
+ precision_ = 0;
+ scale_ = 0;
}
}
Literal::~Literal() {
- if (mType_ == PredicateDataType::STRING && mValue_.Buffer) {
- delete[] mValue_.Buffer;
- mValue_.Buffer = nullptr;
+ if (type_ == PredicateDataType::STRING && value_.Buffer) {
+ delete[] value_.Buffer;
+ value_.Buffer = nullptr;
}
}
Literal& Literal::operator=(const Literal& r) {
if (this != &r) {
- if (mType_ == PredicateDataType::STRING && mValue_.Buffer) {
- delete[] mValue_.Buffer;
- mValue_.Buffer = nullptr;
+ if (type_ == PredicateDataType::STRING && value_.Buffer) {
+ delete[] value_.Buffer;
+ value_.Buffer = nullptr;
}
- mType_ = r.mType_;
- mSize_ = r.mSize_;
- mIsNull_ = r.mIsNull_;
- mPrecision_ = r.mPrecision_;
- mScale_ = r.mScale_;
- if (mType_ == PredicateDataType::STRING) {
- mValue_.Buffer = new char[r.mSize_];
- memcpy(mValue_.Buffer, r.mValue_.Buffer, r.mSize_);
- } else if (mType_ == PredicateDataType::TIMESTAMP) {
- mValue_.TimeStampVal = r.mValue_.TimeStampVal;
+ type_ = r.type_;
+ size_ = r.size_;
+ isNull_ = r.isNull_;
+ precision_ = r.precision_;
+ scale_ = r.scale_;
+ if (type_ == PredicateDataType::STRING) {
+ value_.Buffer = new char[r.size_];
+ memcpy(value_.Buffer, r.value_.Buffer, r.size_);
+ } else if (type_ == PredicateDataType::TIMESTAMP) {
+ value_.TimeStampVal = r.value_.TimeStampVal;
} else {
- mValue_ = r.mValue_;
+ value_ = r.value_;
}
- mHashCode_ = r.mHashCode_;
+ hashCode_ = r.hashCode_;
}
return *this;
}
std::string Literal::toString() const {
- if (mIsNull_) {
+ if (isNull_) {
return "null";
}
std::ostringstream sstream;
- switch (mType_) {
+ switch (type_) {
case PredicateDataType::LONG:
- sstream << mValue_.IntVal;
+ sstream << value_.IntVal;
break;
case PredicateDataType::DATE:
- sstream << mValue_.DateVal;
+ sstream << value_.DateVal;
break;
case PredicateDataType::TIMESTAMP:
- sstream << mValue_.TimeStampVal.second << "." << mValue_.TimeStampVal.nanos;
+ sstream << value_.TimeStampVal.second << "." << value_.TimeStampVal.nanos;
break;
case PredicateDataType::FLOAT:
- sstream << mValue_.DoubleVal;
+ sstream << value_.DoubleVal;
break;
case PredicateDataType::BOOLEAN:
- sstream << (mValue_.BooleanVal ? "true" : "false");
+ sstream << (value_.BooleanVal ? "true" : "false");
break;
case PredicateDataType::STRING:
- sstream << std::string(mValue_.Buffer, mSize_);
+ sstream << std::string(value_.Buffer, size_);
break;
case PredicateDataType::DECIMAL:
- sstream << mValue_.DecimalVal.toDecimalString(mScale_);
+ sstream << value_.DecimalVal.toDecimalString(scale_);
break;
}
return sstream.str();
}
size_t Literal::hashCode() const {
- if (mIsNull_) {
+ if (isNull_) {
return 0;
}
- switch (mType_) {
+ switch (type_) {
case PredicateDataType::LONG:
- return std::hash<int64_t>{}(mValue_.IntVal);
+ return std::hash<int64_t>{}(value_.IntVal);
case PredicateDataType::DATE:
- return std::hash<int64_t>{}(mValue_.DateVal);
+ return std::hash<int64_t>{}(value_.DateVal);
case PredicateDataType::TIMESTAMP:
- return std::hash<int64_t>{}(mValue_.TimeStampVal.second) * 17 +
- std::hash<int32_t>{}(mValue_.TimeStampVal.nanos);
+ return std::hash<int64_t>{}(value_.TimeStampVal.second) * 17 +
+ std::hash<int32_t>{}(value_.TimeStampVal.nanos);
case PredicateDataType::FLOAT:
- return std::hash<double>{}(mValue_.DoubleVal);
+ return std::hash<double>{}(value_.DoubleVal);
case PredicateDataType::BOOLEAN:
- return std::hash<bool>{}(mValue_.BooleanVal);
+ return std::hash<bool>{}(value_.BooleanVal);
case PredicateDataType::STRING:
- return std::hash<std::string>{}(std::string(mValue_.Buffer, mSize_));
+ return std::hash<std::string>{}(std::string(value_.Buffer, size_));
case PredicateDataType::DECIMAL:
// current glibc does not support hash<int128_t>
- return std::hash<int64_t>{}(mValue_.IntVal);
+ return std::hash<int64_t>{}(value_.IntVal);
default:
return 0;
}
@@ -225,30 +225,30 @@
if (this == &r) {
return true;
}
- if (mHashCode_ != r.mHashCode_ || mType_ != r.mType_ || mIsNull_ != r.mIsNull_) {
+ if (hashCode_ != r.hashCode_ || type_ != r.type_ || isNull_ != r.isNull_) {
return false;
}
- if (mIsNull_) {
+ if (isNull_) {
return true;
}
- switch (mType_) {
+ switch (type_) {
case PredicateDataType::LONG:
- return mValue_.IntVal == r.mValue_.IntVal;
+ return value_.IntVal == r.value_.IntVal;
case PredicateDataType::DATE:
- return mValue_.DateVal == r.mValue_.DateVal;
+ return value_.DateVal == r.value_.DateVal;
case PredicateDataType::TIMESTAMP:
- return mValue_.TimeStampVal == r.mValue_.TimeStampVal;
+ return value_.TimeStampVal == r.value_.TimeStampVal;
case PredicateDataType::FLOAT:
- return std::fabs(mValue_.DoubleVal - r.mValue_.DoubleVal) <
+ return std::fabs(value_.DoubleVal - r.value_.DoubleVal) <
std::numeric_limits<double>::epsilon();
case PredicateDataType::BOOLEAN:
- return mValue_.BooleanVal == r.mValue_.BooleanVal;
+ return value_.BooleanVal == r.value_.BooleanVal;
case PredicateDataType::STRING:
- return mSize_ == r.mSize_ && memcmp(mValue_.Buffer, r.mValue_.Buffer, mSize_) == 0;
+ return size_ == r.size_ && memcmp(value_.Buffer, r.value_.Buffer, size_) == 0;
case PredicateDataType::DECIMAL:
- return mValue_.DecimalVal == r.mValue_.DecimalVal;
+ return value_.DecimalVal == r.value_.DecimalVal;
default:
return true;
}
@@ -269,38 +269,38 @@
}
int64_t Literal::getLong() const {
- validate(mIsNull_, mType_, PredicateDataType::LONG);
- return mValue_.IntVal;
+ validate(isNull_, type_, PredicateDataType::LONG);
+ return value_.IntVal;
}
int64_t Literal::getDate() const {
- validate(mIsNull_, mType_, PredicateDataType::DATE);
- return mValue_.DateVal;
+ validate(isNull_, type_, PredicateDataType::DATE);
+ return value_.DateVal;
}
Literal::Timestamp Literal::getTimestamp() const {
- validate(mIsNull_, mType_, PredicateDataType::TIMESTAMP);
- return mValue_.TimeStampVal;
+ validate(isNull_, type_, PredicateDataType::TIMESTAMP);
+ return value_.TimeStampVal;
}
double Literal::getFloat() const {
- validate(mIsNull_, mType_, PredicateDataType::FLOAT);
- return mValue_.DoubleVal;
+ validate(isNull_, type_, PredicateDataType::FLOAT);
+ return value_.DoubleVal;
}
std::string Literal::getString() const {
- validate(mIsNull_, mType_, PredicateDataType::STRING);
- return std::string(mValue_.Buffer, mSize_);
+ validate(isNull_, type_, PredicateDataType::STRING);
+ return std::string(value_.Buffer, size_);
}
bool Literal::getBool() const {
- validate(mIsNull_, mType_, PredicateDataType::BOOLEAN);
- return mValue_.BooleanVal;
+ validate(isNull_, type_, PredicateDataType::BOOLEAN);
+ return value_.BooleanVal;
}
Decimal Literal::getDecimal() const {
- validate(mIsNull_, mType_, PredicateDataType::DECIMAL);
- return Decimal(mValue_.DecimalVal, mScale_);
+ validate(isNull_, type_, PredicateDataType::DECIMAL);
+ return Decimal(value_.DecimalVal, scale_);
}
} // namespace orc
diff --git a/c++/src/sargs/PredicateLeaf.cc b/c++/src/sargs/PredicateLeaf.cc
index c26c0a9..d9df1c5 100644
--- a/c++/src/sargs/PredicateLeaf.cc
+++ b/c++/src/sargs/PredicateLeaf.cc
@@ -30,77 +30,77 @@
PredicateLeaf::PredicateLeaf(Operator op, PredicateDataType type, const std::string& colName,
Literal literal)
- : mOperator_(op), mType_(type), mColumnName_(colName), mHasColumnName_(true), mColumnId_(0) {
- mLiterals_.emplace_back(literal);
- mHashCode_ = hashCode();
+ : operator_(op), type_(type), columnName_(colName), hasColumnName_(true), columnId_(0) {
+ literals_.emplace_back(literal);
+ hashCode_ = hashCode();
validate();
}
PredicateLeaf::PredicateLeaf(Operator op, PredicateDataType type, uint64_t columnId,
Literal literal)
- : mOperator_(op), mType_(type), mHasColumnName_(false), mColumnId_(columnId) {
- mLiterals_.emplace_back(literal);
- mHashCode_ = hashCode();
+ : operator_(op), type_(type), hasColumnName_(false), columnId_(columnId) {
+ literals_.emplace_back(literal);
+ hashCode_ = hashCode();
validate();
}
PredicateLeaf::PredicateLeaf(Operator op, PredicateDataType type, const std::string& colName,
const std::initializer_list<Literal>& literals)
- : mOperator_(op),
- mType_(type),
- mColumnName_(colName),
- mHasColumnName_(true),
- mLiterals_(literals.begin(), literals.end()) {
- mHashCode_ = hashCode();
+ : operator_(op),
+ type_(type),
+ columnName_(colName),
+ hasColumnName_(true),
+ literals_(literals.begin(), literals.end()) {
+ hashCode_ = hashCode();
validate();
}
PredicateLeaf::PredicateLeaf(Operator op, PredicateDataType type, uint64_t columnId,
const std::initializer_list<Literal>& literals)
- : mOperator_(op),
- mType_(type),
- mHasColumnName_(false),
- mColumnId_(columnId),
- mLiterals_(literals.begin(), literals.end()) {
- mHashCode_ = hashCode();
+ : operator_(op),
+ type_(type),
+ hasColumnName_(false),
+ columnId_(columnId),
+ literals_(literals.begin(), literals.end()) {
+ hashCode_ = hashCode();
validate();
}
PredicateLeaf::PredicateLeaf(Operator op, PredicateDataType type, const std::string& colName,
const std::vector<Literal>& literals)
- : mOperator_(op),
- mType_(type),
- mColumnName_(colName),
- mHasColumnName_(true),
- mLiterals_(literals.begin(), literals.end()) {
- mHashCode_ = hashCode();
+ : operator_(op),
+ type_(type),
+ columnName_(colName),
+ hasColumnName_(true),
+ literals_(literals.begin(), literals.end()) {
+ hashCode_ = hashCode();
validate();
}
PredicateLeaf::PredicateLeaf(Operator op, PredicateDataType type, uint64_t columnId,
const std::vector<Literal>& literals)
- : mOperator_(op),
- mType_(type),
- mHasColumnName_(false),
- mColumnId_(columnId),
- mLiterals_(literals.begin(), literals.end()) {
- mHashCode_ = hashCode();
+ : operator_(op),
+ type_(type),
+ hasColumnName_(false),
+ columnId_(columnId),
+ literals_(literals.begin(), literals.end()) {
+ hashCode_ = hashCode();
validate();
}
void PredicateLeaf::validateColumn() const {
- if (mHasColumnName_ && mColumnName_.empty()) {
+ if (hasColumnName_ && columnName_.empty()) {
throw std::invalid_argument("column name should not be empty");
- } else if (!mHasColumnName_ && mColumnId_ == INVALID_COLUMN_ID) {
+ } else if (!hasColumnName_ && columnId_ == INVALID_COLUMN_ID) {
throw std::invalid_argument("invalid column id");
}
}
void PredicateLeaf::validate() const {
- switch (mOperator_) {
+ switch (operator_) {
case Operator::IS_NULL:
validateColumn();
- if (!mLiterals_.empty()) {
+ if (!literals_.empty()) {
throw std::invalid_argument("No literal is required!");
}
break;
@@ -109,28 +109,28 @@
case Operator::LESS_THAN:
case Operator::LESS_THAN_EQUALS:
validateColumn();
- if (mLiterals_.size() != 1) {
+ if (literals_.size() != 1) {
throw std::invalid_argument("One literal is required!");
}
- if (static_cast<int>(mLiterals_.at(0).getType()) != static_cast<int>(mType_)) {
+ if (static_cast<int>(literals_.at(0).getType()) != static_cast<int>(type_)) {
throw std::invalid_argument("leaf and literal types do not match!");
}
break;
case Operator::IN:
validateColumn();
- if (mLiterals_.size() < 2) {
+ if (literals_.size() < 2) {
throw std::invalid_argument("At least two literals are required!");
}
- for (auto literal : mLiterals_) {
- if (static_cast<int>(literal.getType()) != static_cast<int>(mType_)) {
+ for (auto literal : literals_) {
+ if (static_cast<int>(literal.getType()) != static_cast<int>(type_)) {
throw std::invalid_argument("leaf and literal types do not match!");
}
}
break;
case Operator::BETWEEN:
validateColumn();
- for (auto literal : mLiterals_) {
- if (static_cast<int>(literal.getType()) != static_cast<int>(mType_)) {
+ for (auto literal : literals_) {
+ if (static_cast<int>(literal.getType()) != static_cast<int>(type_)) {
throw std::invalid_argument("leaf and literal types do not match!");
}
}
@@ -141,40 +141,40 @@
}
PredicateLeaf::Operator PredicateLeaf::getOperator() const {
- return mOperator_;
+ return operator_;
}
PredicateDataType PredicateLeaf::getType() const {
- return mType_;
+ return type_;
}
bool PredicateLeaf::hasColumnName() const {
- return mHasColumnName_;
+ return hasColumnName_;
}
/**
* Get the simple column name.
*/
const std::string& PredicateLeaf::getColumnName() const {
- return mColumnName_;
+ return columnName_;
}
uint64_t PredicateLeaf::getColumnId() const {
- return mColumnId_;
+ return columnId_;
}
/**
* Get the literal half of the predicate leaf.
*/
Literal PredicateLeaf::getLiteral() const {
- return mLiterals_.at(0);
+ return literals_.at(0);
}
/**
* For operators with multiple literals (IN and BETWEEN), get the literals.
*/
const std::vector<Literal>& PredicateLeaf::getLiteralList() const {
- return mLiterals_;
+ return literals_;
}
static std::string getLiteralString(const std::vector<Literal>& literals) {
@@ -195,40 +195,40 @@
}
std::string PredicateLeaf::columnDebugString() const {
- if (mHasColumnName_) return mColumnName_;
+ if (hasColumnName_) return columnName_;
std::ostringstream sstream;
- sstream << "column(id=" << mColumnId_ << ')';
+ sstream << "column(id=" << columnId_ << ')';
return sstream.str();
}
std::string PredicateLeaf::toString() const {
std::ostringstream sstream;
sstream << '(';
- switch (mOperator_) {
+ switch (operator_) {
case Operator::IS_NULL:
sstream << columnDebugString() << " is null";
break;
case Operator::EQUALS:
- sstream << columnDebugString() << " = " << getLiteralString(mLiterals_);
+ sstream << columnDebugString() << " = " << getLiteralString(literals_);
break;
case Operator::NULL_SAFE_EQUALS:
- sstream << columnDebugString() << " null_safe_= " << getLiteralString(mLiterals_);
+ sstream << columnDebugString() << " null_safe_= " << getLiteralString(literals_);
break;
case Operator::LESS_THAN:
- sstream << columnDebugString() << " < " << getLiteralString(mLiterals_);
+ sstream << columnDebugString() << " < " << getLiteralString(literals_);
break;
case Operator::LESS_THAN_EQUALS:
- sstream << columnDebugString() << " <= " << getLiteralString(mLiterals_);
+ sstream << columnDebugString() << " <= " << getLiteralString(literals_);
break;
case Operator::IN:
- sstream << columnDebugString() << " in " << getLiteralsString(mLiterals_);
+ sstream << columnDebugString() << " in " << getLiteralsString(literals_);
break;
case Operator::BETWEEN:
- sstream << columnDebugString() << " between " << getLiteralsString(mLiterals_);
+ sstream << columnDebugString() << " between " << getLiteralsString(literals_);
break;
default:
sstream << "unknown operator, column: " << columnDebugString()
- << ", literals: " << getLiteralsString(mLiterals_);
+ << ", literals: " << getLiteralsString(literals_);
}
sstream << ')';
return sstream.str();
@@ -236,25 +236,25 @@
size_t PredicateLeaf::hashCode() const {
size_t value = 0;
- std::for_each(mLiterals_.cbegin(), mLiterals_.cend(),
+ std::for_each(literals_.cbegin(), literals_.cend(),
[&](const Literal& literal) { value = value * 17 + literal.getHashCode(); });
- auto colHash = mHasColumnName_ ? std::hash<std::string>{}(mColumnName_)
- : std::hash<uint64_t>{}(mColumnId_);
- return value * 103 * 101 * 3 * 17 + std::hash<int>{}(static_cast<int>(mOperator_)) +
- std::hash<int>{}(static_cast<int>(mType_)) * 17 + colHash * 3 * 17;
+ auto colHash =
+ hasColumnName_ ? std::hash<std::string>{}(columnName_) : std::hash<uint64_t>{}(columnId_);
+ return value * 103 * 101 * 3 * 17 + std::hash<int>{}(static_cast<int>(operator_)) +
+ std::hash<int>{}(static_cast<int>(type_)) * 17 + colHash * 3 * 17;
}
bool PredicateLeaf::operator==(const PredicateLeaf& r) const {
if (this == &r) {
return true;
}
- if (mHashCode_ != r.mHashCode_ || mType_ != r.mType_ || mOperator_ != r.mOperator_ ||
- mHasColumnName_ != r.mHasColumnName_ || mColumnName_ != r.mColumnName_ ||
- mColumnId_ != r.mColumnId_ || mLiterals_.size() != r.mLiterals_.size()) {
+ if (hashCode_ != r.hashCode_ || type_ != r.type_ || operator_ != r.operator_ ||
+ hasColumnName_ != r.hasColumnName_ || columnName_ != r.columnName_ ||
+ columnId_ != r.columnId_ || literals_.size() != r.literals_.size()) {
return false;
}
- for (size_t i = 0; i != mLiterals_.size(); ++i) {
- if (mLiterals_[i] != r.mLiterals_[i]) {
+ for (size_t i = 0; i != literals_.size(); ++i) {
+ if (literals_[i] != r.literals_[i]) {
return false;
}
}
@@ -507,12 +507,12 @@
TruthValue PredicateLeaf::evaluatePredicateMinMax(const proto::ColumnStatistics& colStats) const {
TruthValue result = TruthValue::YES_NO_NULL;
- switch (mType_) {
+ switch (type_) {
case PredicateDataType::LONG: {
if (colStats.has_int_statistics() && colStats.int_statistics().has_minimum() &&
colStats.int_statistics().has_maximum()) {
const auto& stats = colStats.int_statistics();
- result = evaluatePredicateRange(mOperator_, literal2Long(mLiterals_), stats.minimum(),
+ result = evaluatePredicateRange(operator_, literal2Long(literals_), stats.minimum(),
stats.maximum(), colStats.has_null());
}
break;
@@ -524,7 +524,7 @@
if (!std::isfinite(stats.sum())) {
result = colStats.has_null() ? TruthValue::YES_NO_NULL : TruthValue::YES_NO;
} else {
- result = evaluatePredicateRange(mOperator_, literal2Double(mLiterals_), stats.minimum(),
+ result = evaluatePredicateRange(operator_, literal2Double(literals_), stats.minimum(),
stats.maximum(), colStats.has_null());
}
}
@@ -535,7 +535,7 @@
if (colStats.has_string_statistics() && colStats.string_statistics().has_minimum() &&
colStats.string_statistics().has_maximum()) {
const auto& stats = colStats.string_statistics();
- result = evaluatePredicateRange(mOperator_, literal2String(mLiterals_), stats.minimum(),
+ result = evaluatePredicateRange(operator_, literal2String(literals_), stats.minimum(),
stats.maximum(), colStats.has_null());
}
break;
@@ -544,7 +544,7 @@
if (colStats.has_date_statistics() && colStats.date_statistics().has_minimum() &&
colStats.date_statistics().has_maximum()) {
const auto& stats = colStats.date_statistics();
- result = evaluatePredicateRange(mOperator_, literal2Date(mLiterals_), stats.minimum(),
+ result = evaluatePredicateRange(operator_, literal2Date(literals_), stats.minimum(),
stats.maximum(), colStats.has_null());
}
break;
@@ -566,7 +566,7 @@
Literal::Timestamp maxTimestamp(
stats.maximum_utc() / 1000,
static_cast<int32_t>((stats.maximum_utc() % 1000) * 1000000) + maxNano);
- result = evaluatePredicateRange(mOperator_, literal2Timestamp(mLiterals_), minTimestamp,
+ result = evaluatePredicateRange(operator_, literal2Timestamp(literals_), minTimestamp,
maxTimestamp, colStats.has_null());
}
break;
@@ -575,7 +575,7 @@
if (colStats.has_decimal_statistics() && colStats.decimal_statistics().has_minimum() &&
colStats.decimal_statistics().has_maximum()) {
const auto& stats = colStats.decimal_statistics();
- result = evaluatePredicateRange(mOperator_, literal2Decimal(mLiterals_),
+ result = evaluatePredicateRange(operator_, literal2Decimal(literals_),
Decimal(stats.minimum()), Decimal(stats.maximum()),
colStats.has_null());
}
@@ -583,7 +583,7 @@
}
case PredicateDataType::BOOLEAN: {
if (colStats.has_bucket_statistics()) {
- result = evaluateBoolPredicate(mOperator_, mLiterals_, colStats);
+ result = evaluateBoolPredicate(operator_, literals_, colStats);
}
break;
}
@@ -592,8 +592,8 @@
}
// make sure null literal is respected for IN operator
- if (mOperator_ == Operator::IN && colStats.has_null()) {
- for (const auto& literal : mLiterals_) {
+ if (operator_ == Operator::IN && colStats.has_null()) {
+ for (const auto& literal : literals_) {
if (literal.isNull()) {
result = TruthValue::YES_NO_NULL;
break;
@@ -664,18 +664,18 @@
}
TruthValue PredicateLeaf::evaluatePredicateBloomFiter(const BloomFilter* bf, bool hasNull) const {
- switch (mOperator_) {
+ switch (operator_) {
case Operator::NULL_SAFE_EQUALS:
// null safe equals does not return *_NULL variant.
// So set hasNull to false
- return checkInBloomFilter(mOperator_, mType_, mLiterals_.front(), bf, false);
+ return checkInBloomFilter(operator_, type_, literals_.front(), bf, false);
case Operator::EQUALS:
- return checkInBloomFilter(mOperator_, mType_, mLiterals_.front(), bf, hasNull);
+ return checkInBloomFilter(operator_, type_, literals_.front(), bf, hasNull);
case Operator::IN:
- for (const auto& literal : mLiterals_) {
+ for (const auto& literal : literals_) {
// if at least one value in IN list exist in bloom filter,
// qualify the row group/stripe
- TruthValue result = checkInBloomFilter(mOperator_, mType_, literal, bf, hasNull);
+ TruthValue result = checkInBloomFilter(operator_, type_, literal, bf, hasNull);
if (result == TruthValue::YES_NO_NULL || result == TruthValue::YES_NO) {
return result;
}
@@ -695,16 +695,16 @@
const BloomFilter* bloomFilter) const {
// files written before ORC-135 stores timestamp wrt to local timezone
// causing issues with PPD. disable PPD for timestamp for all old files
- if (mType_ == PredicateDataType::TIMESTAMP) {
+ if (type_ == PredicateDataType::TIMESTAMP) {
if (writerVersion < WriterVersion::WriterVersion_ORC_135) {
return TruthValue::YES_NO_NULL;
}
}
bool allNull = colStats.has_null() && colStats.number_of_values() == 0;
- if (mOperator_ == Operator::IS_NULL ||
- ((mOperator_ == Operator::EQUALS || mOperator_ == Operator::NULL_SAFE_EQUALS) &&
- mLiterals_.at(0).isNull())) {
+ if (operator_ == Operator::IS_NULL ||
+ ((operator_ == Operator::EQUALS || operator_ == Operator::NULL_SAFE_EQUALS) &&
+ literals_.at(0).isNull())) {
// IS_NULL operator does not need to check min/max stats and bloom filter
return allNull ? TruthValue::YES
: (colStats.has_null() ? TruthValue::YES_NO : TruthValue::NO);
@@ -714,7 +714,7 @@
}
TruthValue result = evaluatePredicateMinMax(colStats);
- if (shouldEvaluateBloomFilter(mOperator_, result, bloomFilter)) {
+ if (shouldEvaluateBloomFilter(operator_, result, bloomFilter)) {
return evaluatePredicateBloomFiter(bloomFilter, colStats.has_null());
} else {
return result;
diff --git a/c++/src/sargs/PredicateLeaf.hh b/c++/src/sargs/PredicateLeaf.hh
index a0da609..81fd6d9 100644
--- a/c++/src/sargs/PredicateLeaf.hh
+++ b/c++/src/sargs/PredicateLeaf.hh
@@ -127,7 +127,7 @@
bool operator==(const PredicateLeaf& r) const;
size_t getHashCode() const {
- return mHashCode_;
+ return hashCode_;
}
private:
@@ -143,13 +143,13 @@
TruthValue evaluatePredicateBloomFiter(const BloomFilter* bloomFilter, bool hasNull) const;
private:
- Operator mOperator_;
- PredicateDataType mType_;
- std::string mColumnName_;
- bool mHasColumnName_;
- uint64_t mColumnId_;
- std::vector<Literal> mLiterals_;
- size_t mHashCode_;
+ Operator operator_;
+ PredicateDataType type_;
+ std::string columnName_;
+ bool hasColumnName_;
+ uint64_t columnId_;
+ std::vector<Literal> literals_;
+ size_t hashCode_;
};
struct PredicateLeafHash {
diff --git a/c++/src/sargs/SargsApplier.cc b/c++/src/sargs/SargsApplier.cc
index a87289a..b308596 100644
--- a/c++/src/sargs/SargsApplier.cc
+++ b/c++/src/sargs/SargsApplier.cc
@@ -40,24 +40,24 @@
SargsApplier::SargsApplier(const Type& type, const SearchArgument* searchArgument,
uint64_t rowIndexStride, WriterVersion writerVersion,
ReaderMetrics* metrics, const SchemaEvolution* schemaEvolution)
- : mType_(type),
- mSearchArgument_(searchArgument),
- mSchemaEvolution_(schemaEvolution),
- mRowIndexStride_(rowIndexStride),
- mWriterVersion_(writerVersion),
- mHasEvaluatedFileStats_(false),
- mFileStatsEvalResult_(true),
- mMetrics_(metrics) {
- const SearchArgumentImpl* sargs = dynamic_cast<const SearchArgumentImpl*>(mSearchArgument_);
+ : type_(type),
+ searchArgument_(searchArgument),
+ schemaEvolution_(schemaEvolution),
+ rowIndexStride_(rowIndexStride),
+ writerVersion_(writerVersion),
+ hasEvaluatedFileStats_(false),
+ fileStatsEvalResult_(true),
+ metrics_(metrics) {
+ const SearchArgumentImpl* sargs = dynamic_cast<const SearchArgumentImpl*>(searchArgument_);
// find the mapping from predicate leaves to columns
const std::vector<PredicateLeaf>& leaves = sargs->getLeaves();
- mFilterColumns_.resize(leaves.size(), INVALID_COLUMN_ID);
- for (size_t i = 0; i != mFilterColumns_.size(); ++i) {
+ filterColumns_.resize(leaves.size(), INVALID_COLUMN_ID);
+ for (size_t i = 0; i != filterColumns_.size(); ++i) {
if (leaves[i].hasColumnName()) {
- mFilterColumns_[i] = findColumn(type, leaves[i].getColumnName());
+ filterColumns_[i] = findColumn(type, leaves[i].getColumnName());
} else {
- mFilterColumns_[i] = leaves[i].getColumnId();
+ filterColumns_[i] = leaves[i].getColumnId();
}
}
}
@@ -66,30 +66,30 @@
const std::unordered_map<uint64_t, proto::RowIndex>& rowIndexes,
const std::map<uint32_t, BloomFilterIndex>& bloomFilters) {
// init state of each row group
- uint64_t groupsInStripe = (rowsInStripe + mRowIndexStride_ - 1) / mRowIndexStride_;
- mNextSkippedRows_.resize(groupsInStripe);
- mTotalRowsInStripe_ = rowsInStripe;
+ uint64_t groupsInStripe = (rowsInStripe + rowIndexStride_ - 1) / rowIndexStride_;
+ nextSkippedRows_.resize(groupsInStripe);
+ totalRowsInStripe_ = rowsInStripe;
// row indexes do not exist, simply read all rows
if (rowIndexes.empty()) {
return true;
}
- const auto& leaves = dynamic_cast<const SearchArgumentImpl*>(mSearchArgument_)->getLeaves();
+ const auto& leaves = dynamic_cast<const SearchArgumentImpl*>(searchArgument_)->getLeaves();
std::vector<TruthValue> leafValues(leaves.size(), TruthValue::YES_NO_NULL);
- mHasSelected_ = false;
- mHasSkipped_ = false;
+ hasSelected_ = false;
+ hasSkipped_ = false;
uint64_t nextSkippedRowGroup = groupsInStripe;
size_t rowGroup = groupsInStripe;
do {
--rowGroup;
for (size_t pred = 0; pred != leaves.size(); ++pred) {
- uint64_t columnIdx = mFilterColumns_[pred];
+ uint64_t columnIdx = filterColumns_[pred];
auto rowIndexIter = rowIndexes.find(columnIdx);
if (columnIdx == INVALID_COLUMN_ID || rowIndexIter == rowIndexes.cend()) {
// this column does not exist in current file
leafValues[pred] = TruthValue::YES_NO_NULL;
- } else if (mSchemaEvolution_ && !mSchemaEvolution_->isSafePPDConversion(columnIdx)) {
+ } else if (schemaEvolution_ && !schemaEvolution_->isSafePPDConversion(columnIdx)) {
// cannot evaluate predicate when ppd is not safe
leafValues[pred] = TruthValue::YES_NO_NULL;
} else {
@@ -104,37 +104,37 @@
bloomFilter = iter->second.entries.at(rowGroup);
}
- leafValues[pred] = leaves[pred].evaluate(mWriterVersion_, statistics, bloomFilter.get());
+ leafValues[pred] = leaves[pred].evaluate(writerVersion_, statistics, bloomFilter.get());
}
}
- bool needed = isNeeded(mSearchArgument_->evaluate(leafValues));
+ bool needed = isNeeded(searchArgument_->evaluate(leafValues));
if (!needed) {
- mNextSkippedRows_[rowGroup] = 0;
+ nextSkippedRows_[rowGroup] = 0;
nextSkippedRowGroup = rowGroup;
} else {
- mNextSkippedRows_[rowGroup] = (nextSkippedRowGroup == groupsInStripe)
- ? rowsInStripe
- : (nextSkippedRowGroup * mRowIndexStride_);
+ nextSkippedRows_[rowGroup] = (nextSkippedRowGroup == groupsInStripe)
+ ? rowsInStripe
+ : (nextSkippedRowGroup * rowIndexStride_);
}
- mHasSelected_ |= needed;
- mHasSkipped_ |= !needed;
+ hasSelected_ |= needed;
+ hasSkipped_ |= !needed;
} while (rowGroup != 0);
// update stats
uint64_t selectedRGs = std::accumulate(
- mNextSkippedRows_.cbegin(), mNextSkippedRows_.cend(), 0UL,
+ nextSkippedRows_.cbegin(), nextSkippedRows_.cend(), 0UL,
[](uint64_t initVal, uint64_t rg) { return rg > 0 ? initVal + 1 : initVal; });
- if (mMetrics_ != nullptr) {
- mMetrics_->SelectedRowGroupCount.fetch_add(selectedRGs);
- mMetrics_->EvaluatedRowGroupCount.fetch_add(groupsInStripe);
+ if (metrics_ != nullptr) {
+ metrics_->SelectedRowGroupCount.fetch_add(selectedRGs);
+ metrics_->EvaluatedRowGroupCount.fetch_add(groupsInStripe);
}
- return mHasSelected_;
+ return hasSelected_;
}
bool SargsApplier::evaluateColumnStatistics(const PbColumnStatistics& colStats) const {
- const SearchArgumentImpl* sargs = dynamic_cast<const SearchArgumentImpl*>(mSearchArgument_);
+ const SearchArgumentImpl* sargs = dynamic_cast<const SearchArgumentImpl*>(searchArgument_);
if (sargs == nullptr) {
throw InvalidArgument("Failed to cast to SearchArgumentImpl");
}
@@ -143,14 +143,14 @@
std::vector<TruthValue> leafValues(leaves.size(), TruthValue::YES_NO_NULL);
for (size_t pred = 0; pred != leaves.size(); ++pred) {
- uint64_t columnId = mFilterColumns_[pred];
+ uint64_t columnId = filterColumns_[pred];
if (columnId != INVALID_COLUMN_ID && colStats.size() > static_cast<int>(columnId)) {
- leafValues[pred] = leaves[pred].evaluate(mWriterVersion_,
+ leafValues[pred] = leaves[pred].evaluate(writerVersion_,
colStats.Get(static_cast<int>(columnId)), nullptr);
}
}
- return isNeeded(mSearchArgument_->evaluate(leafValues));
+ return isNeeded(searchArgument_->evaluate(leafValues));
}
bool SargsApplier::evaluateStripeStatistics(const proto::StripeStatistics& stripeStats,
@@ -160,29 +160,29 @@
}
bool ret = evaluateColumnStatistics(stripeStats.col_stats());
- if (mMetrics_ != nullptr) {
- mMetrics_->EvaluatedRowGroupCount.fetch_add(stripeRowGroupCount);
+ if (metrics_ != nullptr) {
+ metrics_->EvaluatedRowGroupCount.fetch_add(stripeRowGroupCount);
}
if (!ret) {
// reset mNextSkippedRows when the current stripe does not satisfy the PPD
- mNextSkippedRows_.clear();
+ nextSkippedRows_.clear();
}
return ret;
}
bool SargsApplier::evaluateFileStatistics(const proto::Footer& footer,
uint64_t numRowGroupsInStripeRange) {
- if (!mHasEvaluatedFileStats_) {
+ if (!hasEvaluatedFileStats_) {
if (footer.statistics_size() == 0) {
- mFileStatsEvalResult_ = true;
+ fileStatsEvalResult_ = true;
} else {
- mFileStatsEvalResult_ = evaluateColumnStatistics(footer.statistics());
- if (mMetrics_ != nullptr) {
- mMetrics_->EvaluatedRowGroupCount.fetch_add(numRowGroupsInStripeRange);
+ fileStatsEvalResult_ = evaluateColumnStatistics(footer.statistics());
+ if (metrics_ != nullptr) {
+ metrics_->EvaluatedRowGroupCount.fetch_add(numRowGroupsInStripeRange);
}
}
- mHasEvaluatedFileStats_ = true;
+ hasEvaluatedFileStats_ = true;
}
- return mFileStatsEvalResult_;
+ return fileStatsEvalResult_;
}
} // namespace orc
diff --git a/c++/src/sargs/SargsApplier.hh b/c++/src/sargs/SargsApplier.hh
index d48dcfd..65c8dec 100644
--- a/c++/src/sargs/SargsApplier.hh
+++ b/c++/src/sargs/SargsApplier.hh
@@ -75,30 +75,30 @@
* Only valid after invoking pickRowGroups().
*/
const std::vector<uint64_t>& getNextSkippedRows() const {
- return mNextSkippedRows_;
+ return nextSkippedRows_;
}
/**
* Indicate whether any row group is selected in the last evaluation
*/
bool hasSelected() const {
- return mHasSelected_;
+ return hasSelected_;
}
/**
* Indicate whether any row group is skipped in the last evaluation
*/
bool hasSkipped() const {
- return mHasSkipped_;
+ return hasSkipped_;
}
/**
* Whether any row group from current row in the stripe matches PPD.
*/
bool hasSelectedFrom(uint64_t currentRowInStripe) const {
- uint64_t rg = currentRowInStripe / mRowIndexStride_;
- for (; rg < mNextSkippedRows_.size(); ++rg) {
- if (mNextSkippedRows_[rg]) {
+ uint64_t rg = currentRowInStripe / rowIndexStride_;
+ for (; rg < nextSkippedRows_.size(); ++rg) {
+ if (nextSkippedRows_[rg]) {
return true;
}
}
@@ -106,9 +106,9 @@
}
std::pair<uint64_t, uint64_t> getStats() const {
- if (mMetrics_ != nullptr) {
- return std::make_pair(mMetrics_->SelectedRowGroupCount.load(),
- mMetrics_->EvaluatedRowGroupCount.load());
+ if (metrics_ != nullptr) {
+ return std::make_pair(metrics_->SelectedRowGroupCount.load(),
+ metrics_->EvaluatedRowGroupCount.load());
} else {
return {0, 0};
}
@@ -125,27 +125,27 @@
static uint64_t findColumn(const Type& type, const std::string& colName);
private:
- const Type& mType_;
- const SearchArgument* mSearchArgument_;
- const SchemaEvolution* mSchemaEvolution_;
- uint64_t mRowIndexStride_;
- WriterVersion mWriterVersion_;
+ const Type& type_;
+ const SearchArgument* searchArgument_;
+ const SchemaEvolution* schemaEvolution_;
+ uint64_t rowIndexStride_;
+ WriterVersion writerVersion_;
// column ids for each predicate leaf in the search argument
- std::vector<uint64_t> mFilterColumns_;
+ std::vector<uint64_t> filterColumns_;
// Map from RowGroup index to the next skipped row of the selected range it
// locates. If the RowGroup is not selected, set the value to 0.
// Calculated in pickRowGroups().
- std::vector<uint64_t> mNextSkippedRows_;
- uint64_t mTotalRowsInStripe_;
- bool mHasSelected_;
- bool mHasSkipped_;
+ std::vector<uint64_t> nextSkippedRows_;
+ uint64_t totalRowsInStripe_;
+ bool hasSelected_;
+ bool hasSkipped_;
// store result of file stats evaluation
- bool mHasEvaluatedFileStats_;
- bool mFileStatsEvalResult_;
+ bool hasEvaluatedFileStats_;
+ bool fileStatsEvalResult_;
// use the SelectedRowGroupCount and EvaluatedRowGroupCount to
// keep stats of selected RGs and evaluated RGs
- ReaderMetrics* mMetrics_;
+ ReaderMetrics* metrics_;
};
} // namespace orc
diff --git a/c++/src/sargs/SearchArgument.cc b/c++/src/sargs/SearchArgument.cc
index 31fabae..83d4af2 100644
--- a/c++/src/sargs/SearchArgument.cc
+++ b/c++/src/sargs/SearchArgument.cc
@@ -30,23 +30,23 @@
}
const std::vector<PredicateLeaf>& SearchArgumentImpl::getLeaves() const {
- return mLeaves_;
+ return leaves_;
}
const ExpressionTree* SearchArgumentImpl::getExpression() const {
- return mExpressionTree_.get();
+ return expressionTree_.get();
}
TruthValue SearchArgumentImpl::evaluate(const std::vector<TruthValue>& leaves) const {
- return mExpressionTree_ == nullptr ? TruthValue::YES : mExpressionTree_->evaluate(leaves);
+ return expressionTree_ == nullptr ? TruthValue::YES : expressionTree_->evaluate(leaves);
}
std::string SearchArgumentImpl::toString() const {
std::ostringstream sstream;
- for (size_t i = 0; i != mLeaves_.size(); ++i) {
- sstream << "leaf-" << i << " = " << mLeaves_.at(i).toString() << ", ";
+ for (size_t i = 0; i != leaves_.size(); ++i) {
+ sstream << "leaf-" << i << " = " << leaves_.at(i).toString() << ", ";
}
- sstream << "expr = " << mExpressionTree_->toString();
+ sstream << "expr = " << expressionTree_->toString();
return sstream.str();
}
@@ -55,14 +55,14 @@
}
SearchArgumentBuilderImpl::SearchArgumentBuilderImpl() {
- mRoot_.reset(new ExpressionTree(ExpressionTree::Operator::AND));
- mCurrTree_.push_back(mRoot_);
+ root_.reset(new ExpressionTree(ExpressionTree::Operator::AND));
+ currTree_.push_back(root_);
}
SearchArgumentBuilder& SearchArgumentBuilderImpl::start(ExpressionTree::Operator op) {
TreeNode node = std::make_shared<ExpressionTree>(op);
- mCurrTree_.front()->addChild(node);
- mCurrTree_.push_front(node);
+ currTree_.front()->addChild(node);
+ currTree_.push_front(node);
return *this;
}
@@ -79,9 +79,9 @@
}
SearchArgumentBuilder& SearchArgumentBuilderImpl::end() {
- TreeNode& current = mCurrTree_.front();
+ TreeNode& current = currTree_.front();
if (current->getChildren().empty()) {
- throw std::invalid_argument("Cannot create expression " + mRoot_->toString() +
+ throw std::invalid_argument("Cannot create expression " + root_->toString() +
" with no children.");
}
if (current->getOperator() == ExpressionTree::Operator::NOT &&
@@ -89,13 +89,13 @@
throw std::invalid_argument("Can't create NOT expression " + current->toString() +
" with more than 1 child.");
}
- mCurrTree_.pop_front();
+ currTree_.pop_front();
return *this;
}
size_t SearchArgumentBuilderImpl::addLeaf(PredicateLeaf leaf) {
- size_t id = mLeaves_.size();
- const auto& result = mLeaves_.insert(std::make_pair(leaf, id));
+ size_t id = leaves_.size();
+ const auto& result = leaves_.insert(std::make_pair(leaf, id));
return result.first->second;
}
@@ -112,7 +112,7 @@
T column,
PredicateDataType type,
Literal literal) {
- TreeNode parent = mCurrTree_.front();
+ TreeNode parent = currTree_.front();
if (isInvalidColumn(column)) {
parent->addChild(std::make_shared<ExpressionTree>(TruthValue::YES_NO_NULL));
} else {
@@ -181,7 +181,7 @@
template <typename T, typename CONTAINER>
SearchArgumentBuilder& SearchArgumentBuilderImpl::addChildForIn(T column, PredicateDataType type,
const CONTAINER& literals) {
- TreeNode& parent = mCurrTree_.front();
+ TreeNode& parent = currTree_.front();
if (isInvalidColumn(column)) {
parent->addChild(std::make_shared<ExpressionTree>((TruthValue::YES_NO_NULL)));
} else {
@@ -219,7 +219,7 @@
template <typename T>
SearchArgumentBuilder& SearchArgumentBuilderImpl::addChildForIsNull(T column,
PredicateDataType type) {
- TreeNode& parent = mCurrTree_.front();
+ TreeNode& parent = currTree_.front();
if (isInvalidColumn(column)) {
parent->addChild(std::make_shared<ExpressionTree>(TruthValue::YES_NO_NULL));
} else {
@@ -244,7 +244,7 @@
PredicateDataType type,
Literal lower,
Literal upper) {
- TreeNode& parent = mCurrTree_.front();
+ TreeNode& parent = currTree_.front();
if (isInvalidColumn(column)) {
parent->addChild(std::make_shared<ExpressionTree>(TruthValue::YES_NO_NULL));
} else {
@@ -267,7 +267,7 @@
}
SearchArgumentBuilder& SearchArgumentBuilderImpl::literal(TruthValue truth) {
- TreeNode& parent = mCurrTree_.front();
+ TreeNode& parent = currTree_.front();
parent->addChild(std::make_shared<ExpressionTree>(truth));
return *this;
}
@@ -555,34 +555,34 @@
}
SearchArgumentImpl::SearchArgumentImpl(TreeNode root, const std::vector<PredicateLeaf>& leaves)
- : mExpressionTree_(root), mLeaves_(leaves) {
+ : expressionTree_(root), leaves_(leaves) {
// PASS
}
std::unique_ptr<SearchArgument> SearchArgumentBuilderImpl::build() {
- if (mCurrTree_.size() != 1) {
- throw std::invalid_argument("Failed to end " + std::to_string(mCurrTree_.size()) +
+ if (currTree_.size() != 1) {
+ throw std::invalid_argument("Failed to end " + std::to_string(currTree_.size()) +
" operations.");
}
- mRoot_ = pushDownNot(mRoot_);
- mRoot_ = foldMaybe(mRoot_);
- mRoot_ = flatten(mRoot_);
- mRoot_ = convertToCNF(mRoot_);
- mRoot_ = flatten(mRoot_);
- std::vector<size_t> leafReorder(mLeaves_.size(), UNUSED_LEAF);
- size_t newLeafCount = compactLeaves(mRoot_, 0, leafReorder.data());
- mRoot_ = rewriteLeaves(mRoot_, leafReorder.data());
+ root_ = pushDownNot(root_);
+ root_ = foldMaybe(root_);
+ root_ = flatten(root_);
+ root_ = convertToCNF(root_);
+ root_ = flatten(root_);
+ std::vector<size_t> leafReorder(leaves_.size(), UNUSED_LEAF);
+ size_t newLeafCount = compactLeaves(root_, 0, leafReorder.data());
+ root_ = rewriteLeaves(root_, leafReorder.data());
std::vector<PredicateLeaf> leafList(newLeafCount, PredicateLeaf());
// build the new list
- for (auto& leaf : mLeaves_) {
+ for (auto& leaf : leaves_) {
size_t newLoc = leafReorder[leaf.second];
if (newLoc != UNUSED_LEAF) {
leafList[newLoc] = leaf.first;
}
}
- return std::make_unique<SearchArgumentImpl>(mRoot_, leafList);
+ return std::make_unique<SearchArgumentImpl>(root_, leafList);
}
std::unique_ptr<SearchArgumentBuilder> SearchArgumentFactory::newBuilder() {
diff --git a/c++/src/sargs/SearchArgument.hh b/c++/src/sargs/SearchArgument.hh
index 095dc24..1963c99 100644
--- a/c++/src/sargs/SearchArgument.hh
+++ b/c++/src/sargs/SearchArgument.hh
@@ -66,8 +66,8 @@
std::string toString() const override;
private:
- std::shared_ptr<ExpressionTree> mExpressionTree_;
- std::vector<PredicateLeaf> mLeaves_;
+ std::shared_ptr<ExpressionTree> expressionTree_;
+ std::vector<PredicateLeaf> leaves_;
};
/**
@@ -304,9 +304,9 @@
static TreeNode convertToCNF(TreeNode root);
private:
- std::deque<TreeNode> mCurrTree_;
- std::unordered_map<PredicateLeaf, size_t, PredicateLeafHash, PredicateLeafComparator> mLeaves_;
- std::shared_ptr<ExpressionTree> mRoot_;
+ std::deque<TreeNode> currTree_;
+ std::unordered_map<PredicateLeaf, size_t, PredicateLeafHash, PredicateLeafComparator> leaves_;
+ std::shared_ptr<ExpressionTree> root_;
};
} // namespace orc
diff --git a/c++/test/TestBloomFilter.cc b/c++/test/TestBloomFilter.cc
index 77ccf6e..5f360e7 100644
--- a/c++/test/TestBloomFilter.cc
+++ b/c++/test/TestBloomFilter.cc
@@ -106,11 +106,11 @@
}
#define CheckBitSet(bf, p1, p2, p3, p4, p5) \
- EXPECT_TRUE(bf.mBitSet_->get(p1)); \
- EXPECT_TRUE(bf.mBitSet_->get(p2)); \
- EXPECT_TRUE(bf.mBitSet_->get(p3)); \
- EXPECT_TRUE(bf.mBitSet_->get(p4)); \
- EXPECT_TRUE(bf.mBitSet_->get(p5))
+ EXPECT_TRUE(bf.bitSet_->get(p1)); \
+ EXPECT_TRUE(bf.bitSet_->get(p2)); \
+ EXPECT_TRUE(bf.bitSet_->get(p3)); \
+ EXPECT_TRUE(bf.bitSet_->get(p4)); \
+ EXPECT_TRUE(bf.bitSet_->get(p5))
// Same test as TestBloomFilter#testBasicOperations() in Java codes. We also
// verifies the bitSet positions that are set, to make sure both the Java and C++ codes
