patch 4.0

unittest/storage/blocksstable/test_sstable_generator.cpp

@@ -0,0 +1,148 @@
+/**
+ * Copyright (c) 2021 OceanBase
+ * OceanBase CE is licensed under Mulan PubL v2.
+ * You can use this software according to the terms and conditions of the Mulan PubL v2.
+ * You may obtain a copy of Mulan PubL v2 at:
+ *          http://license.coscl.org.cn/MulanPubL-2.0
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PubL v2 for more details.
+ */
+
+#include "test_sstable_generator.h"
+#include "storage/ob_i_store.h"
+#include "storage/blocksstable/ob_data_file.h"
+namespace oceanbase
+{
+using namespace common;
+using namespace blocksstable;
+using namespace storage;
+namespace unittest
+{
+TestSSTableGenerator::TestSSTableGenerator()
+  : desc_(),
+    data_file_(),
+    logger_(),
+    image_(),
+    writer_(),
+    marker_(),
+    row_count_(0),
+    mod_(ObModIds::TEST),
+    arena_(ModuleArena::DEFAULT_PAGE_SIZE, mod_)
+{
+  path_[0] = 0;
+}
+int TestSSTableGenerator::open(
+    ObDataStoreDesc &desc,
+    const char *path,
+    const int64_t row_count)
+{
+  int ret = OB_SUCCESS;
+  if (OB_SUCCESS != (ret = desc_.assign(desc))) {
+    STORAGE_LOG(WARN, "desc fail to assign.", K(ret));
+  } else {
+    row_count_ = row_count;
+    memcpy(path_, path, strlen(path));
+    char cmd[1024];
+    sprintf(cmd, "rm -rf %s", path_);
+    system(cmd);
+    sprintf(cmd, "mkdir -p %s", path_);
+    system(cmd);
+    ObBlockFile::FileLocation location;
+    location.disk_no_ = 1;
+    location.install_sequence_ = 0;
+    char file_name[1024];
+    sprintf(file_name, "%s/test.sst", path_);
+    memcpy(location.path_, file_name, strlen(file_name) + 1);
+
+    ObMacroDataSeq start_seq(0);
+    ObBlockFile::FileSpec spec;
+    spec.data_file_size_ = 64 * 1024 * 1024;
+    spec.macro_block_size_ = 2 * 1024 * 1024;
+
+    if (OB_SUCCESS != (ret = data_file_.format(location, spec))) {
+      STORAGE_LOG(WARN, "data file fail to format.", K(ret));
+    } else if (OB_SUCCESS != (ret = data_file_.open(location, &image_))) {
+      STORAGE_LOG(WARN, "data file fail to open.", K(ret));
+    } else if (OB_SUCCESS != (ret = image_.initialize(&data_file_, &logger_))) {
+      STORAGE_LOG(WARN, "image fail to initialize.", K(ret));
+    } else if (OB_SUCCESS != (ret = logger_.init(data_file_, path, 2 * 1024 * 1024))) {
+      STORAGE_LOG(WARN, "logger fail to init.", K(ret));
+    //} else if (OB_SUCCESS != (ret = logger_.replay())) {
+    //  STORAGE_LOG(WARN, "logger fail to replay.", K(ret));
+    } else if (OB_SUCCESS != (ret = marker_.initialize(&data_file_, &image_))) {
+      STORAGE_LOG(WARN, "marker fail to initialize.", K(ret));
+    } else if (OB_SUCCESS != (ret = marker_.register_storage_meta(&image_))) {
+      STORAGE_LOG(WARN, "marker failt to register.", K(ret));
+    } else if (OB_SUCCESS != (ret = marker_.mark_init())) {
+      STORAGE_LOG(WARN, "marker fail to mark init.", K(ret));
+    } else if (OB_SUCCESS != (ret = writer_.open(&data_file_, desc_, start_seq))) {
+      STORAGE_LOG(WARN, "macro block writer fail to open.", K(ret));
+    }
+  }
+  return ret;
+}
+
+int TestSSTableGenerator::generate()
+{
+  int ret = OB_SUCCESS;
+  for (int64_t i = 0; OB_SUCC(ret) && i < row_count_; ++ i) {
+    if (OB_SUCCESS != (ret = generate_row(i))) {
+      STORAGE_LOG(WARN, "sstable generator fail to generate row.", K(ret));
+    }
+  }
+  if (OB_SUCC(ret)) {
+    if (OB_SUCCESS != (ret = writer_.close())) {
+      STORAGE_LOG(WARN, "sstable generator fail to close.", K(ret));
+    }
+  }
+  return ret;
+}
+
+int TestSSTableGenerator::close()
+{
+  int ret = OB_SUCCESS;
+  char cmd[1024];
+  sprintf(cmd, "rm -rf %s", path_);
+  system(cmd);
+  return ret;
+}
+
+int TestSSTableGenerator::generate_row(const int64_t index)
+{
+  int ret = OB_SUCCESS;
+  arena_.reuse();
+  for (int64_t i = 0; OB_SUCC(ret) && i < desc_.column_cnt_; ++ i) {
+    switch (desc_.col_desc_array_.at(i).col_type_.get_type()) {
+      case ObIntType: {
+          cells_[i].set_int(index);
+          break;
+        }
+      case ObVarcharType: {
+          char *buf = arena_.alloc(1024);
+          sprintf(buf, "%ld", index);
+          ObString str(0, static_cast<int32_t>(strlen(buf)), buf);
+          cells_[i].set_collation_type(CS_TYPE_UTF8MB4_GENERAL_CI);
+          cells_[i].set_varchar(str);
+          break;
+        }
+      default:
+        STORAGE_LOG(WARN, "not supported");
+        ret = OB_NOT_SUPPORTED;
+    }
+  }
+
+  if (OB_SUCC(ret)) {
+    ObStoreRow row;
+    row.row_val_.cells_ = cells_;
+    row.row_val_.count_ = desc_.column_cnt_;
+    row.flag_.set_flag(ObDmlFlag::DF_INSERT);
+    if (OB_SUCCESS != (ret = writer_.append_row(row))) {
+      STORAGE_LOG(WARN, "macro block writer fail to append row.", K(ret));
+    }
+  }
+  return ret;
+}
+}//end namespace unittest
+}//end namespace oceanbase