Better estimation for ColumnLowCardinality::Reserve and ColumnString::Reserve

ColumnLowCardinality assumes that not all items are unique,
  hence dictionary column can be reserved for smaller capacity;
ColumnString now allows to set average value size estimation
  in constructor or on existing instance.
  If estimation is close to real average value size, then memory is pre-allocations are close to optimum.

Author: Enmk

clickhouse/columns/array.cpp

@@ -110,6 +110,10 @@ size_t ColumnArray::Size() const {
     return offsets_->Size();
 }
 
+size_t ColumnArray::MemoryUsage() const {
+    return offsets_->MemoryUsage() + data_->MemoryUsage();
+}
+
 void ColumnArray::Swap(Column& other) {
     auto & col = dynamic_cast<ColumnArray &>(other);
     data_.swap(col.data_);

clickhouse/columns/array.h

@@ -71,6 +71,8 @@ class ColumnArray : public Column {
     /// Returns count of rows in the column.
     size_t Size() const override;
 
+    size_t MemoryUsage() const override;
+
     /// Makes slice of the current column.
     ColumnRef Slice(size_t, size_t) const override;
     ColumnRef CloneEmpty() const override;

clickhouse/columns/column.h

@@ -90,6 +90,9 @@ class Column : public std::enable_shared_from_this<Column> {
 
     virtual void Swap(Column&) = 0;
 
+    /// Estimated RAM usage by the column in bytes.
+    virtual size_t MemoryUsage() const = 0;
+
     /// Get a view on raw item data if it is supported by column, will throw an exception if index is out of range.
     /// Please note that view is invalidated once column items are added or deleted, column is loaded from strean or destroyed.
     virtual ItemView GetItem(size_t) const {

clickhouse/columns/date.cpp

@@ -67,6 +67,10 @@ size_t ColumnDate::Size() const {
     return data_->Size();
 }
 
+size_t ColumnDate::MemoryUsage() const {
+    return data_->MemoryUsage();
+}
+
 ColumnRef ColumnDate::Slice(size_t begin, size_t len) const {
     auto col = data_->Slice(begin, len)->As<ColumnUInt16>();
     auto result = std::make_shared<ColumnDate>();
@@ -154,6 +158,10 @@ size_t ColumnDate32::Size() const {
     return data_->Size();
 }
 
+size_t ColumnDate32::MemoryUsage() const {
+    return data_->MemoryUsage();
+}
+
 ColumnRef ColumnDate32::Slice(size_t begin, size_t len) const {
     auto col = data_->Slice(begin, len)->As<ColumnInt32>();
     auto result = std::make_shared<ColumnDate32>();
@@ -244,6 +252,10 @@ size_t ColumnDateTime::Size() const {
     return data_->Size();
 }
 
+size_t ColumnDateTime::MemoryUsage() const {
+    return data_->MemoryUsage();
+}
+
 void ColumnDateTime::Clear() {
     data_->Clear();
 }
@@ -330,6 +342,10 @@ size_t ColumnDateTime64::Size() const {
     return data_->Size();
 }
 
+size_t ColumnDateTime64::MemoryUsage() const {
+    return data_->MemoryUsage();
+}
+
 ItemView ColumnDateTime64::GetItem(size_t index) const {
     return ItemView(Type::DateTime64, data_->GetItem(index));
 }

clickhouse/columns/date.h

@@ -51,6 +51,7 @@ class ColumnDate : public Column {
 
     /// Returns count of rows in the column.
     size_t Size() const override;
+    size_t MemoryUsage() const override;
 
     /// Makes slice of the current column.
     ColumnRef Slice(size_t begin, size_t len) const override;
@@ -109,6 +110,7 @@ class ColumnDate32 : public Column {
 
     /// Returns count of rows in the column.
     size_t Size() const override;
+    size_t MemoryUsage() const override;
 
     /// Makes slice of the current column.
     ColumnRef Slice(size_t begin, size_t len) const override;
@@ -170,6 +172,7 @@ class ColumnDateTime : public Column {
 
     /// Returns count of rows in the column.
     size_t Size() const override;
+    size_t MemoryUsage() const override;
 
     /// Makes slice of the current column.
     ColumnRef Slice(size_t begin, size_t len) const override;
@@ -223,6 +226,7 @@ class ColumnDateTime64 : public Column {
 
     /// Returns count of rows in the column.
     size_t Size() const override;
+    size_t MemoryUsage() const override;
 
     /// Makes slice of the current column.
     ColumnRef Slice(size_t begin, size_t len) const override;

clickhouse/columns/decimal.cpp

@@ -217,6 +217,10 @@ size_t ColumnDecimal::Size() const {
     return data_->Size();
 }
 
+size_t ColumnDecimal::MemoryUsage() const {
+    return data_->MemoryUsage();
+}
+
 ColumnRef ColumnDecimal::Slice(size_t begin, size_t len) const {
     // coundn't use std::make_shared since this c-tor is private
     return ColumnRef{new ColumnDecimal(type_, data_->Slice(begin, len))};

clickhouse/columns/decimal.h

@@ -28,6 +28,7 @@ class ColumnDecimal : public Column {
     void SaveBody(OutputStream* output) override;
     void Clear() override;
     size_t Size() const override;
+    size_t MemoryUsage() const override;
     ColumnRef Slice(size_t begin, size_t len) const override;
     ColumnRef CloneEmpty() const override;
     void Swap(Column& other) override;

clickhouse/columns/enum.cpp

@@ -96,6 +96,11 @@ size_t ColumnEnum<T>::Size() const {
     return data_.size();
 }
 
+template <typename T>
+size_t ColumnEnum<T>::MemoryUsage() const {
+    return data_.capacity() * sizeof(*data_.begin());
+}
+
 template <typename T>
 ColumnRef ColumnEnum<T>::Slice(size_t begin, size_t len) const {
     return std::make_shared<ColumnEnum<T>>(type_, SliceVector(data_, begin, len));

clickhouse/columns/enum.h

@@ -47,6 +47,7 @@ class ColumnEnum : public Column {
 
     /// Returns count of rows in the column.
     size_t Size() const override;
+    size_t MemoryUsage() const override;
 
     /// Makes slice of the current column.
     ColumnRef Slice(size_t begin, size_t len) const override;

clickhouse/columns/geo.cpp

@@ -76,11 +76,17 @@ void ColumnGeo<NestedColumnType, type_code>::SaveBody(OutputStream* output) {
     data_->SaveBody(output);
 }
 
+
 template <typename NestedColumnType, Type::Code type_code>
 size_t ColumnGeo<NestedColumnType, type_code>::Size() const {
     return data_->Size();
 }
 
+template <typename NestedColumnType, Type::Code type_code>
+size_t ColumnGeo<NestedColumnType, type_code>::MemoryUsage() const {
+    return data_->MemoryUsage();
+}
+
 template <typename NestedColumnType, Type::Code type_code>
 ColumnRef ColumnGeo<NestedColumnType, type_code>::Slice(size_t begin, size_t len) const {
     return std::make_shared<ColumnGeo>(data_->Slice(begin, len));

clickhouse/columns/geo.h

@@ -46,6 +46,7 @@ class ColumnGeo : public Column {
 
     /// Returns count of rows in the column.
     size_t Size() const override;
+    size_t MemoryUsage() const override;
 
     /// Makes slice of the current column.
     ColumnRef Slice(size_t begin, size_t len) const override;

clickhouse/columns/ip4.cpp

@@ -96,6 +96,10 @@ size_t ColumnIPv4::Size() const {
     return data_->Size();
 }
 
+size_t ColumnIPv4::MemoryUsage() const {
+    return data_->MemoryUsage();
+}
+
 ColumnRef ColumnIPv4::Slice(size_t begin, size_t len) const {
     return std::make_shared<ColumnIPv4>(data_->Slice(begin, len));
 }

clickhouse/columns/ip4.h

@@ -56,6 +56,7 @@ class ColumnIPv4 : public Column {
 
     /// Returns count of rows in the column.
     size_t Size() const override;
+    size_t MemoryUsage() const override;
 
     /// Makes slice of the current column.
     ColumnRef Slice(size_t begin, size_t len) const override;

clickhouse/columns/ip6.cpp

@@ -87,6 +87,10 @@ size_t ColumnIPv6::Size() const {
     return data_->Size();
 }
 
+size_t ColumnIPv6::MemoryUsage() const {
+    return data_->MemoryUsage();
+}
+
 ColumnRef ColumnIPv6::Slice(size_t begin, size_t len) const {
     return std::make_shared<ColumnIPv6>(data_->Slice(begin, len));
 }

clickhouse/columns/ip6.h

@@ -52,6 +52,7 @@ class ColumnIPv6 : public Column {
 
     /// Returns count of rows in the column.
     size_t Size() const override;
+    size_t MemoryUsage() const override;
 
     /// Makes slice of the current column.
     ColumnRef Slice(size_t begin, size_t len) const override;

clickhouse/columns/lowcardinality.cpp

@@ -174,9 +174,39 @@ ColumnLowCardinality::ColumnLowCardinality(std::shared_ptr<ColumnNullable> dicti
 ColumnLowCardinality::~ColumnLowCardinality()
 {}
 
+namespace
+{
+    size_t EstimateDictionaryCapacity(size_t new_cap)
+    {
+        // Estimate capacity of the LC dictionary column.
+        // For small columns we assume there are higher relative number of unique items
+        //  hence the capacity of the dictionary column must be the same as capacity of index_column.
+        // For large columns we assume that there are at least 80% of duplicates,
+        //  hence the capacity of the dictionary column is 0.20 of the index_column.
+        // Medium-sized columns have dictionary capacity somewhere in-between.
+
+        const float max_ratio = 1.0;
+        const float min_ratio = 0.20;
+        const float min_ratio_at = 512;
+        const float max_ratio_at = 128;
+
+        if (new_cap < max_ratio_at)
+            return new_cap;
+
+        if (new_cap >= min_ratio_at)
+            return new_cap * min_ratio;
+
+        // Ratio of the dict capacity to the index column capacity,
+        // linearly falls down from `max_ratio` at `max_ratio_at` down to `min_ratio` at min_ratio_at;
+        const float ratio = max_ratio + (max_ratio_at - static_cast<int>(new_cap)) * (max_ratio - min_ratio) / (min_ratio_at - max_ratio_at);
+        return new_cap * ratio;
+    }
+}
+
 void ColumnLowCardinality::Reserve(size_t new_cap) {
-    dictionary_column_->Reserve(new_cap);
     index_column_->Reserve(new_cap);
+
+    dictionary_column_->Reserve(EstimateDictionaryCapacity(new_cap));
 }
 
 void ColumnLowCardinality::Setup(ColumnRef dictionary_column) {
@@ -379,6 +409,13 @@ size_t ColumnLowCardinality::Size() const {
     return index_column_->Size();
 }
 
+size_t ColumnLowCardinality::MemoryUsage() const {
+    return unique_items_map_.bucket_count() * unique_items_map_.max_load_factor()
+            * (sizeof(unique_items_map_.begin()->first) + sizeof(unique_items_map_.begin()->second))
+            + index_column_->MemoryUsage()
+            + dictionary_column_->MemoryUsage();
+}
+
 ColumnRef ColumnLowCardinality::Slice(size_t begin, size_t len) const {
     begin = std::min(begin, Size());
     len = std::min(len, Size() - begin);
@@ -451,15 +488,13 @@ void ColumnLowCardinality::AppendUnsafe(const ItemView & value) {
     }
 }
 
-void ColumnLowCardinality::AppendNullItem()
-{
+void ColumnLowCardinality::AppendNullItem() {
     const auto null_item = GetNullItemForDictionary(dictionary_column_);
     AppendToDictionary(*dictionary_column_, null_item);
     unique_items_map_.emplace(computeHashKey(null_item), 0);
 }
 
-void ColumnLowCardinality::AppendDefaultItem()
-{
+void ColumnLowCardinality::AppendDefaultItem() {
     const auto defaultItem = GetDefaultItemForDictionary(dictionary_column_);
     unique_items_map_.emplace(computeHashKey(defaultItem), dictionary_column_->Size());
     AppendToDictionary(*dictionary_column_, defaultItem);

clickhouse/columns/lowcardinality.h

@@ -87,6 +87,7 @@ class ColumnLowCardinality : public Column {
 
     /// Returns count of rows in the column.
     size_t Size() const override;
+    size_t MemoryUsage() const override;
 
     /// Makes slice of current column, with compacted dictionary
     ColumnRef Slice(size_t begin, size_t len) const override;

clickhouse/columns/map.cpp

@@ -67,6 +67,10 @@ size_t ColumnMap::Size() const {
     return data_->Size();
 }
 
+size_t ColumnMap::MemoryUsage() const {
+    return data_->MemoryUsage();
+}
+
 ColumnRef ColumnMap::Slice(size_t begin, size_t len) const {
     return std::make_shared<ColumnMap>(data_->Slice(begin, len));
 }

clickhouse/columns/map.h

@@ -48,6 +48,7 @@ class ColumnMap : public Column {
 
     /// Returns count of rows in the column.
     size_t Size() const override;
+    size_t MemoryUsage() const override;
 
     /// Makes slice of the current column.
     ColumnRef Slice(size_t, size_t) const override;

clickhouse/columns/nothing.h

@@ -75,6 +75,8 @@ class ColumnNothing : public Column {
     /// Returns count of rows in the column.
     size_t Size() const override { return size_; }
 
+    size_t MemoryUsage() const override { return 0; }
+
     void Swap(Column& other) override {
         auto & col = dynamic_cast<ColumnNothing &>(other);
         std::swap(size_, col.size_);

clickhouse/columns/nullable.cpp

@@ -82,6 +82,10 @@ size_t ColumnNullable::Size() const {
     return nulls_->Size();
 }
 
+size_t ColumnNullable::MemoryUsage() const {
+    return nested_->MemoryUsage() + nulls_->MemoryUsage();
+}
+
 ColumnRef ColumnNullable::Slice(size_t begin, size_t len) const {
     return std::make_shared<ColumnNullable>(nested_->Slice(begin, len), nulls_->Slice(begin, len));
 }

clickhouse/columns/nullable.h

@@ -50,6 +50,7 @@ class ColumnNullable : public Column {
 
     /// Returns count of rows in the column.
     size_t Size() const override;
+    size_t MemoryUsage() const override;
 
     /// Makes slice of the current column.
     ColumnRef Slice(size_t begin, size_t len) const override;

clickhouse/columns/numeric.cpp

@@ -87,6 +87,11 @@ size_t ColumnVector<T>::Size() const {
     return data_.size();
 }
 
+template <typename T>
+size_t ColumnVector<T>::MemoryUsage() const {
+    return data_.capacity() * sizeof(data_[0]);
+}
+
 template <typename T>
 ColumnRef ColumnVector<T>::Slice(size_t begin, size_t len) const {
     return std::make_shared<ColumnVector<T>>(SliceVector(data_, begin, len));

clickhouse/columns/numeric.h

@@ -57,6 +57,7 @@ class ColumnVector : public Column {
 
     /// Makes slice of the current column.
     ColumnRef Slice(size_t begin, size_t len) const override;
+    size_t MemoryUsage() const override;
     ColumnRef CloneEmpty() const override;
     void Swap(Column& other) override;