Merge branch 'main' into AddJammyBuild

Author: leborchuk

.github/workflows/sonarqube.yml

@@ -74,7 +74,7 @@ jobs:
         fi
 
     - name: Install Build Wrapper
-      uses: SonarSource/sonarqube-scan-action/install-build-wrapper@v5
+      uses: SonarSource/sonarqube-scan-action/install-build-wrapper@v6
 
     - name: Run Build Wrapper
       run: |
@@ -112,7 +112,7 @@ jobs:
         build-wrapper-linux-x86-64 --out-dir ${{ env.BUILD_WRAPPER_OUT_DIR }} make -j$(nproc)
 
     - name: SonarQube Scan
-      uses: SonarSource/sonarqube-scan-action@v5
+      uses: SonarSource/sonarqube-scan-action@v6
       env:
         SONAR_TOKEN: ${{ secrets.SONARCLOUD_TOKEN }}
       with:

contrib/pax_storage/src/cpp/access/pax_dml_state.cc

@@ -104,7 +104,7 @@ void CPaxDmlStateLocal::Reset() { cbdb::pax_memory_context = nullptr; }
 CPaxDmlStateLocal::CPaxDmlStateLocal()
     : last_oid_(InvalidOid), cb_{.func = DmlStateResetCallback, .arg = NULL} {}
 
-std::shared_ptr<CPaxDmlStateLocal::DmlStateValue>
+pg_attribute_always_inline std::shared_ptr<CPaxDmlStateLocal::DmlStateValue>
 CPaxDmlStateLocal::RemoveDmlState(const Oid &oid) {
   std::shared_ptr<CPaxDmlStateLocal::DmlStateValue> value;
 
@@ -121,7 +121,7 @@ CPaxDmlStateLocal::RemoveDmlState(const Oid &oid) {
   return value;
 }
 
-std::shared_ptr<CPaxDmlStateLocal::DmlStateValue>
+pg_attribute_always_inline std::shared_ptr<CPaxDmlStateLocal::DmlStateValue>
 CPaxDmlStateLocal::FindDmlState(const Oid &oid) {
   Assert(OidIsValid(oid));
 

contrib/pax_storage/src/cpp/comm/bitmap.h

@@ -134,12 +134,28 @@ struct BitmapRaw final {
     static_assert(BM_WORD_BITS == (1 << BM_WORD_SHIFTS));
     return (index >> BM_WORD_SHIFTS) < size;
   }
-  inline bool Empty() const {
+
+  inline bool Empty(uint32 end_index) const {
     if (!bitmap) return true;
-    for (size_t i = 0; i < size; i++)
-      if (bitmap[i]) return false;
+
+    uint32 end_word = BM_INDEX_WORD_OFF(end_index);
+    uint32 end_bit_offset = BM_INDEX_BIT_OFF(end_index);
+
+    for (uint32 i = 0; i < end_word && i < size; i++) {
+      if (bitmap[i] != 0) return false;
+    }
+
+    // Check partial word at end
+    if (end_word < size && end_bit_offset > 0) {
+      T mask = (T(1) << end_bit_offset) - 1;
+      if (bitmap[end_word] & mask) return false;
+    }
+
     return true;
   }
+
+  inline bool Empty() const { return Empty(size * sizeof(T) * 8ULL); }
+
   BitmapRaw() = default;
   BitmapRaw(T *buffer, size_t size) : bitmap(buffer), size(size) {}
   BitmapRaw(const BitmapRaw &) = delete;
@@ -160,13 +176,14 @@ struct BitmapRaw final {
 template <typename T>
 class BitmapTpl final {
  public:
-  using BitmapMemoryPolicy = void (*)(BitmapRaw<T> &, uint32);
-  explicit BitmapTpl(uint32 initial_size = 16) {
+  using BitmapMemoryPolicy = void (*)(BitmapRaw<T> &, uint32, uint8);
+  explicit BitmapTpl(uint32 initial_size = 16, uint8 init_value = 0) {
     static_assert(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
                   sizeof(T) == 8);
     static_assert(BM_WORD_BITS == (1 << BM_WORD_SHIFTS));
     policy_ = DefaultBitmapMemoryPolicy;
-    policy_(raw_, Max(initial_size, 16));
+    policy_(raw_, Max(initial_size, 16), init_value);
+    init_value_ = init_value;
   }
   explicit BitmapTpl(const BitmapRaw<T> &raw) {
     static_assert(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
@@ -177,8 +194,7 @@ class BitmapTpl final {
     raw_.size = raw.size;
   }
   BitmapTpl(const BitmapTpl &tpl) = delete;
-  BitmapTpl(BitmapTpl &&tpl)
-      : raw_(std::move(tpl.raw_)), policy_(tpl.policy_) {
+  BitmapTpl(BitmapTpl &&tpl) : raw_(std::move(tpl.raw_)), policy_(tpl.policy_) {
     tpl.raw_.bitmap = nullptr;
     tpl.policy_ = ReadOnlyRefBitmap;
   }
@@ -188,8 +204,7 @@ class BitmapTpl final {
   BitmapTpl &operator=(BitmapTpl &&tpl) = delete;
   ~BitmapTpl() {
     // Reference doesn't free the memory
-    if (policy_ == DefaultBitmapMemoryPolicy)
-      PAX_DELETE_ARRAY(raw_.bitmap);
+    if (policy_ == DefaultBitmapMemoryPolicy) PAX_DELETE_ARRAY(raw_.bitmap);
     raw_.bitmap = nullptr;
   }
 
@@ -205,11 +220,13 @@ class BitmapTpl final {
 
   inline size_t WordBits() const { return BM_WORD_BITS; }
   inline void Set(uint32 index) {
-    if (unlikely(!raw_.HasEnoughSpace(index))) policy_(raw_, index);
+    if (unlikely(!raw_.HasEnoughSpace(index)))
+      policy_(raw_, index, init_value_);
     raw_.Set(index);
   }
   inline void SetN(uint32 index) {
-    if (unlikely(!raw_.HasEnoughSpace(index))) policy_(raw_, index);
+    if (unlikely(!raw_.HasEnoughSpace(index)))
+      policy_(raw_, index, init_value_);
     raw_.SetN(index);
   }
   inline void Clear(uint32 index) {
@@ -228,7 +245,8 @@ class BitmapTpl final {
   }
   // invert the bit and return the old value.
   inline bool Toggle(uint32 index) {
-    if (unlikely(!raw_.HasEnoughSpace(index))) policy_(raw_, index);
+    if (unlikely(!raw_.HasEnoughSpace(index)))
+      policy_(raw_, index, init_value_);
     return raw_.Toggle(index);
   }
   // count bits in range [0, index]
@@ -248,23 +266,28 @@ class BitmapTpl final {
 
   inline bool Empty() const { return raw_.Empty(); }
 
+  // check if the bitmap is empty in the range [0, end_index)
+  inline bool Empty(uint32 end_index) const { return raw_.Empty(end_index); }
+
   BitmapMemoryPolicy Policy() const { return policy_; }
 
   const BitmapRaw<T> &Raw() const { return raw_; }
   BitmapRaw<T> &Raw() { return raw_; }
 
-  static void DefaultBitmapMemoryPolicy(BitmapRaw<T> &raw, uint32 index) {
+  static void DefaultBitmapMemoryPolicy(BitmapRaw<T> &raw, uint32 index,
+                                        uint8 init_value = 0) {
     auto old_bitmap = raw.bitmap;
     auto old_size = raw.size;
     auto size = Max(BM_INDEX_WORD_OFF(index) + 1, old_size * 2);
     auto p = PAX_NEW_ARRAY<T>(size);
     if (old_size > 0) memcpy(p, old_bitmap, sizeof(T) * old_size);
-    memset(&p[old_size], 0, sizeof(T) * (size - old_size));
+    memset(&p[old_size], init_value, sizeof(T) * (size - old_size));
     raw.bitmap = p;
     raw.size = size;
     PAX_DELETE_ARRAY(old_bitmap);
   }
-  static void ReadOnlyRefBitmap(BitmapRaw<T> & /*raw*/, uint32 /*index*/) {
+  static void ReadOnlyRefBitmap(BitmapRaw<T> & /*raw*/, uint32 /*index*/,
+                                uint8 /*init_value*/) {
     // raise
     CBDB_RAISE(cbdb::CException::kExTypeInvalidMemoryOperation);
   }
@@ -280,12 +303,14 @@ class BitmapTpl final {
     return nwords * sizeof(T);
   }
 
-  static std::unique_ptr<BitmapTpl<T>> BitmapTplCopy(const BitmapTpl<T> *bitmap) {
+  static std::unique_ptr<BitmapTpl<T>> BitmapTplCopy(
+      const BitmapTpl<T> *bitmap) {
     if (bitmap == nullptr) return nullptr;
     return bitmap->Clone();
   }
 
-  static std::unique_ptr<BitmapTpl<T>> Union(const BitmapTpl<T> *a, const BitmapTpl<T> *b) {
+  static std::unique_ptr<BitmapTpl<T>> Union(const BitmapTpl<T> *a,
+                                             const BitmapTpl<T> *b) {
     std::unique_ptr<BitmapTpl<T>> result;
     const BitmapTpl<T> *large;
     const BitmapTpl<T> *small;
@@ -315,6 +340,7 @@ class BitmapTpl final {
 
   BitmapRaw<T> raw_;
   BitmapMemoryPolicy policy_;
+  uint8 init_value_ = 0;
 };
 
 using Bitmap8 = BitmapTpl<uint8>;

contrib/pax_storage/src/cpp/comm/cbdb_wrappers.cc

@@ -124,12 +124,6 @@ void cbdb::MemoryCtxRegisterResetCallback(MemoryContext context,
   CBDB_WRAP_END;
 }
 
-Oid cbdb::RelationGetRelationId(Relation rel) {
-  CBDB_WRAP_START;
-  { return RelationGetRelid(rel); }
-  CBDB_WRAP_END;
-}
-
 #ifdef RUN_GTEST
 Datum cbdb::DatumFromCString(const char *src, size_t length) {
   CBDB_WRAP_START;

contrib/pax_storage/src/cpp/comm/cbdb_wrappers.h

@@ -114,8 +114,6 @@ void MemoryCtxDelete(MemoryContext memory_context);
 void MemoryCtxRegisterResetCallback(MemoryContext context,
                                     MemoryContextCallback *cb);
 
-Oid RelationGetRelationId(Relation rel);
-
 static inline void *DatumToPointer(Datum d) noexcept {
   return DatumGetPointer(d);
 }
@@ -164,6 +162,10 @@ static inline float8 DatumToFloat8(Datum d) noexcept {
   return DatumGetFloat8(d);
 }
 
+static pg_attribute_always_inline Oid RelationGetRelationId(Relation rel) noexcept {
+  return RelationGetRelid(rel);
+}
+
 BpChar *BpcharInput(const char *s, size_t len, int32 atttypmod);
 VarChar *VarcharInput(const char *s, size_t len, int32 atttypmod);
 text *CstringToText(const char *s, size_t len);

contrib/pax_storage/src/cpp/storage/columns/pax_column.cc

@@ -83,13 +83,21 @@ size_t PaxColumn::GetRangeNonNullRows(size_t start_pos, size_t len) {
 
 void PaxColumn::CreateNulls(size_t cap) {
   Assert(!null_bitmap_);
-  null_bitmap_ = std::make_unique<Bitmap8>(cap);
-  null_bitmap_->SetN(total_rows_);
+  // By default, initialize every bit in the null bitmap to 1.
+  // This is based on the assumption that null values are much less frequent
+  // than non-null values in most datasets. As a result, when appending non-null
+  // values, we can simply skip setting the bit to 1, since it is already set.
+  // Only when appending a null value do we need to explicitly clear the
+  // corresponding bit.
+  null_bitmap_ = std::make_unique<Bitmap8>(cap, 0xff);
 }
 
 void PaxColumn::AppendNull() {
   if (!null_bitmap_) {
-    CreateNulls(DEFAULT_CAPACITY);
+    // Ensure that the capacity of null_bitmap_ is pax_max_tuples_per_group.
+    // This design allows the use of raw_bitmap in normal cases without
+    // incurring the overhead of checking the bitmap's capacity.
+    CreateNulls(pax::pax_max_tuples_per_group);
   }
   null_bitmap_->Clear(total_rows_);
   ++total_rows_;
@@ -111,7 +119,6 @@ void PaxColumn::AppendToast(char *buffer, size_t size) {
 }
 
 void PaxColumn::Append(char * /*buffer*/, size_t /*size*/) {
-  if (null_bitmap_) null_bitmap_->Set(total_rows_);
   ++total_rows_;
   ++non_null_rows_;
 }

contrib/pax_storage/src/cpp/storage/columns/pax_column.h

@@ -46,7 +46,8 @@
 
 namespace pax {
 
-#define DEFAULT_CAPACITY MIN(2048, MAX(16, MAXALIGN(pax::pax_max_tuples_per_group)))
+#define DEFAULT_CAPACITY \
+  MIN(2048, MAX(16, MAXALIGN(pax::pax_max_tuples_per_group)))
 
 // Used to mapping pg_type
 enum PaxColumnTypeInMem {
@@ -230,7 +231,14 @@ class PaxColumn {
   inline bool HasNull() { return null_bitmap_ != nullptr; }
 
   // Are all values null?
-  inline bool AllNull() const { return null_bitmap_ && null_bitmap_->Empty(); }
+  // Check whether all bits in the specified range are zero.
+  // In pax_column, to avoid checking the capacity of the null bitmap, we
+  // allocate memory based on pax_max_tuples_per_group. As a result, the last
+  // group may contain fewer tuples than pax_max_tuples_per_group, so we need to
+  // check whether all bits in the range [0, total_rows_) are zero.
+  inline bool AllNull() const {
+    return null_bitmap_ && null_bitmap_->Empty(total_rows_);
+  }
 
   // Set the null bitmap
   inline void SetBitmap(std::unique_ptr<Bitmap8> null_bitmap) {

contrib/pax_storage/src/cpp/storage/orc/orc_writer.cc

@@ -367,7 +367,11 @@ std::vector<std::pair<int, Datum>> OrcWriter::PrepareWriteTuple(
     // Numeric always need ensure that with the 4B header, otherwise it will
     // be converted twice in the vectorization path.
     if (required_stats_cols[i] || VARATT_IS_COMPRESSED(tts_value_vl) ||
-        VARATT_IS_EXTERNAL(tts_value_vl) || attrs->atttypid == NUMERICOID) {
+        VARATT_IS_EXTERNAL(tts_value_vl)
+#ifdef VEC_BUILD
+        || attrs->atttypid == NUMERICOID
+#endif
+    ) {
       // still detoast the origin toast
       detoast_vl = cbdb::PgDeToastDatum(tts_value_vl);
       Assert(detoast_vl != nullptr);

contrib/pax_storage/src/cpp/storage/pax.cc

@@ -49,6 +49,8 @@
 #include "storage/vec/pax_vec_reader.h"
 #endif
 
+#define PAX_SPLIT_STRATEGY_CHECK_INTERVAL (16)
+
 namespace paxc {
 class IndexUpdaterInternal {
  public:
@@ -280,14 +282,25 @@ void TableWriter::Open() {
   // insert tuple into the aux table before inserting any tuples.
   cbdb::InsertMicroPartitionPlaceHolder(RelationGetRelid(relation_),
                                         current_blockno_);
+  cur_physical_size_ = 0;
 }
 
 void TableWriter::WriteTuple(TupleTableSlot *slot) {
   Assert(writer_);
   Assert(strategy_);
-  // should check split strategy before write tuple
-  // otherwise, may got a empty file in the disk
-  if (strategy_->ShouldSplit(writer_->PhysicalSize(), num_tuples_)) {
+  // Because of the CTID constraint, we have to strictly enforce the accuracy of
+  // the tuple count and make sure it doesn't exceed
+  // PAX_MAX_NUM_TUPLES_PER_FILE. That's why we kept this precise check here.
+
+  // On the other hand,the biggest performance hit here is the PhysicalSize()
+  // function.So to reduce the overhead of calling it so often,
+  // we only update the file size every PAX_SPLIT_STRATEGY_CHECK_INTERVAL
+  // tuples.
+  if ((num_tuples_ % PAX_SPLIT_STRATEGY_CHECK_INTERVAL) == 0) {
+    cur_physical_size_ = writer_->PhysicalSize();
+  }
+
+  if (strategy_->ShouldSplit(cur_physical_size_, num_tuples_)) {
     writer_->Close();
     writer_ = nullptr;
     Open();

contrib/pax_storage/src/cpp/storage/pax.h

@@ -131,6 +131,7 @@ class TableWriter {
   std::vector<std::tuple<ColumnEncoding_Kind, int>> encoding_opts_;
 
   bool is_dfs_table_space_;
+  size_t cur_physical_size_ = 0;
 };
 
 class TableReader final {