optimize ColumnString Append

clickhouse/columns/string.cpp

@@ -4,7 +4,6 @@
 #include "../base/wire_format.h"
 
 namespace {
-const size_t DEFAULT_BLOCK_SIZE = 4096;
 
 template <typename Container>
 size_t ComputeTotalSize(const Container & strings, size_t begin = 0, size_t len = -1)
@@ -126,8 +125,8 @@ struct ColumnString::Block
 
     explicit Block(size_t starting_capacity)
         : size(0),
-          capacity(starting_capacity),
-          data_(new CharT[capacity])
+        capacity(starting_capacity),
+        data_(new CharT[capacity])
     {}
 
     inline auto GetAvailable() const
@@ -179,10 +178,22 @@ ColumnString::ColumnString(const std::vector<std::string> & data)
     }
 }
 
+ColumnString::ColumnString(std::vector<std::string>&& data)
+    : Column(Type::CreateString())
+{
+    items_.reserve(data.size());
+
+    for (auto&& d : data) {
+        append_data_.emplace_back(std::move(d));
+        auto& last_data = append_data_.back();
+        items_.emplace_back(std::string_view{ last_data.data(),last_data.length() });
+    }
+}
+
 ColumnString::~ColumnString()
 {}
 
-void ColumnString::Append(std::string_view str) {
+void ColumnString::Append(const std::string_view& str) {
     if (blocks_.size() == 0 || blocks_.back().GetAvailable() < str.length())
     {
         blocks_.emplace_back(std::max(DEFAULT_BLOCK_SIZE, str.size()));
@@ -191,6 +202,18 @@ void ColumnString::Append(std::string_view str) {
     items_.emplace_back(blocks_.back().AppendUnsafe(str));
 }
 
+void ColumnString::Append(std::string&& steal_value)
+{
+    append_data_.emplace_back(std::move(steal_value));
+    auto& last_data = append_data_.back();
+    items_.emplace_back(std::string_view{ last_data.data(),last_data.length() });
+}
+
+void ColumnString::AppendNoManagedLifetime(std::string_view str)
+{
+    items_.emplace_back(str);
+}
+
 void ColumnString::AppendUnsafe(std::string_view str)
 {
     items_.emplace_back(blocks_.back().AppendUnsafe(str));
@@ -199,6 +222,8 @@ void ColumnString::AppendUnsafe(std::string_view str)
 void ColumnString::Clear() {
     items_.clear();
     blocks_.clear();
+    append_data_.clear();
+    append_data_.shrink_to_fit();
 }
 
 std::string_view ColumnString::At(size_t n) const {
@@ -283,6 +308,7 @@ void ColumnString::Swap(Column& other) {
     auto & col = dynamic_cast<ColumnString &>(other);
     items_.swap(col.items_);
     blocks_.swap(col.blocks_);
+    append_data_.swap(col.append_data_);
 }
 
 ItemView ColumnString::GetItem(size_t index) const {

clickhouse/columns/string.h

@@ -6,9 +6,17 @@
 #include <string_view>
 #include <utility>
 #include <vector>
+#include <algorithm>
+#include <type_traits>
+#include <deque>
 
 namespace clickhouse {
 
+constexpr size_t DEFAULT_BLOCK_SIZE = 4096;
+
+template <typename>
+inline constexpr bool always_false_v = false;
+
 /**
  * Represents column of fixed-length strings.
  */
@@ -78,11 +86,19 @@ class ColumnString : public Column {
     ~ColumnString();
 
     explicit ColumnString(const std::vector<std::string> & data);
+    explicit ColumnString(std::vector<std::string>&& data);
     ColumnString& operator=(const ColumnString&) = delete;
     ColumnString(const ColumnString&) = delete;
 
     /// Appends one element to the column.
-    void Append(std::string_view str);
+    void Append(const std::string_view& str);
+
+    /// Appends one element to the column.
+    void Append(std::string&& steal_value);
+
+    /// Appends one element to the column.
+    /// If str lifetime is managed elsewhere and guaranteed to outlive the Block sent to the server
+    void AppendNoManagedLifetime(std::string_view str);
 
     /// Returns element at given row number.
     std::string_view At(size_t n) const;
@@ -120,6 +136,7 @@ class ColumnString : public Column {
 
     std::vector<std::string_view> items_;
     std::vector<Block> blocks_;
+    std::deque<std::string> append_data_;
 };
 
 }

ut/columns_ut.cpp

@@ -111,6 +111,19 @@ TEST(ColumnsCase, StringInit) {
     ASSERT_EQ(col->At(3), "abcd");
 }
 
+TEST(ColumnsCase, StringAppend) {
+    auto col = std::make_shared<ColumnString>();
+    const char* expected = "ufiudhf3493fyiudferyer3yrifhdflkdjfeuroe";
+    std::string data(expected);
+    col->Append(data);
+    col->Append(std::move(data));
+    col->Append("11");
+
+    ASSERT_EQ(col->Size(), 3u);
+    ASSERT_EQ(col->At(0), expected);
+    ASSERT_EQ(col->At(1), expected);
+    ASSERT_EQ(col->At(2), "11");
+}
 
 TEST(ColumnsCase, TupleAppend){
     auto tuple1 = std::make_shared<ColumnTuple>(std::vector<ColumnRef>({