&& - qualified IColumn::mutate

dbms/src/Columns/FilterDescription.cpp

@@ -57,7 +57,8 @@ FilterDescription::FilterDescription(const IColumn & column)
 
     if (const ColumnNullable * nullable_column = typeid_cast<const ColumnNullable *>(&column))
     {
-        MutableColumnPtr mutable_holder = nullable_column->getNestedColumn().mutate();
+        ColumnPtr nested_column = nullable_column->getNestedColumnPtr();
+        MutableColumnPtr mutable_holder = (*std::move(nested_column)).mutate();
 
         ColumnUInt8 * concrete_column = typeid_cast<ColumnUInt8 *>(mutable_holder.get());
         if (!concrete_column)

dbms/src/Columns/IColumn.h

@@ -247,10 +247,10 @@ public:
     virtual void forEachSubcolumn(ColumnCallback) {}
 
 
-    MutablePtr mutate() const
+    MutablePtr mutate() const &&
     {
         MutablePtr res = COWPtr<IColumn>::mutate();
-        res->forEachSubcolumn([](Ptr & subcolumn) { subcolumn = subcolumn->mutate(); });
+        res->forEachSubcolumn([](Ptr & subcolumn) { subcolumn = (*std::move(subcolumn)).mutate(); });
         return res;
     }
 

dbms/src/Common/COWPtr.h

@@ -80,12 +80,22 @@ private:
     Derived * derived() { return static_cast<Derived *>(this); }
     const Derived * derived() const { return static_cast<const Derived *>(this); }
 
+    template <typename T>
+    class IntrusivePtr : public boost::intrusive_ptr<T>
+    {
+    public:
+        using boost::intrusive_ptr<T>::intrusive_ptr;
+
+        T & operator*() const & { return boost::intrusive_ptr<T>::operator*(); }
+        T && operator*() const && { return const_cast<typename std::remove_const<T>::type &&>(*boost::intrusive_ptr<T>::get()); }
+    };
+
 protected:
     template <typename T>
-    class mutable_ptr : public boost::intrusive_ptr<T>
+    class mutable_ptr : public IntrusivePtr<T>
     {
     private:
-        using Base = boost::intrusive_ptr<T>;
+        using Base = IntrusivePtr<T>;
 
         template <typename> friend class COWPtr;
         template <typename, typename> friend class COWPtrHelper;
@@ -114,10 +124,10 @@ public:
 
 protected:
     template <typename T>
-    class immutable_ptr : public boost::intrusive_ptr<const T>
+    class immutable_ptr : public IntrusivePtr<const T>
     {
     private:
-        using Base = boost::intrusive_ptr<const T>;
+        using Base = IntrusivePtr<const T>;
 
         template <typename> friend class COWPtr;
         template <typename, typename> friend class COWPtrHelper;

dbms/src/Core/Block.cpp

@@ -312,7 +312,7 @@ MutableColumns Block::mutateColumns() const
     size_t num_columns = data.size();
     MutableColumns columns(num_columns);
     for (size_t i = 0; i < num_columns; ++i)
-        columns[i] = data[i].column ? data[i].column->mutate() : data[i].type->createColumn();
+        columns[i] = data[i].column ? (*std::move(data[i].column)).mutate() : data[i].type->createColumn();
     return columns;
 }
 

dbms/src/Core/Block.h

@@ -109,7 +109,7 @@ public:
     /** Get empty columns with the same types as in block. */
     MutableColumns cloneEmptyColumns() const;
 
-    /** Get columns from block for mutation. */
+    /** Get columns from block for mutation. Columns in block will be nullptr. */
     MutableColumns mutateColumns() const;
 
     /** Replace columns in a block */

dbms/src/DataStreams/ColumnGathererStream.cpp

@@ -76,10 +76,9 @@ Block ColumnGathererStream::readImpl()
         return Block();
 
     output_block = Block{column.cloneEmpty()};
-    MutableColumnPtr output_column = output_block.getByPosition(0).column->mutate();
+    MutableColumnPtr output_column = (*std::move(output_block.getByPosition(0).column)).mutate();
     output_column->gather(*this);
-    if (!output_column->empty())
-        output_block.getByPosition(0).column = std::move(output_column);
+    output_block.getByPosition(0).column = std::move(output_column);
 
     return output_block;
 }

dbms/src/DataStreams/MergingSortedBlockInputStream.cpp

@@ -221,7 +221,7 @@ void MergingSortedBlockInputStream::merge(MutableColumns & merged_columns, std::
                     throw Exception("Logical error in MergingSortedBlockInputStream", ErrorCodes::LOGICAL_ERROR);
 
                 for (size_t i = 0; i < num_columns; ++i)
-                    merged_columns[i] = source_blocks[source_num]->getByPosition(i).column->mutate();
+                    merged_columns[i] = (*std::move(source_blocks[source_num]->getByPosition(i).column)).mutate();
 
     //            std::cerr << "copied columns\n";
 

dbms/src/DataStreams/SquashingTransform.cpp

@@ -62,7 +62,7 @@ void SquashingTransform::append(Block && block)
 
     for (size_t i = 0; i < columns; ++i)
     {
-        MutableColumnPtr mutable_column = accumulated_block.getByPosition(i).column->mutate();
+        MutableColumnPtr mutable_column = (*std::move(accumulated_block.getByPosition(i).column)).mutate();
         mutable_column->insertRangeFrom(*block.getByPosition(i).column, 0, rows);
         accumulated_block.getByPosition(i).column = std::move(mutable_column);
     }

dbms/src/Dictionaries/ComplexKeyHashedDictionary.cpp

@@ -289,7 +289,7 @@ void ComplexKeyHashedDictionary::updateData()
             for (const auto attribute_idx : ext::range(0, keys_size + attributes_size))
             {
                 const IColumn & update_column = *block.getByPosition(attribute_idx).column.get();
-                MutableColumnPtr saved_column = saved_block->getByPosition(attribute_idx).column->mutate();
+                MutableColumnPtr saved_column = saved_block->getByPosition(attribute_idx).column->assumeMutable();
                 saved_column->insertRangeFrom(update_column, 0, update_column.size());
             }
         }

dbms/src/Dictionaries/ExternalResultDescription.cpp

@@ -66,7 +66,7 @@ void ExternalResultDescription::init(const Block & sample_block_)
         /// If default value for column was not provided, use default from data type.
         if (sample_columns.back()->empty())
         {
-            MutableColumnPtr mutable_column = sample_columns.back()->mutate();
+            MutableColumnPtr mutable_column = (*std::move(sample_columns.back())).mutate();
             column.type->insertDefaultInto(*mutable_column);
             sample_columns.back() = std::move(mutable_column);
         }

dbms/src/Dictionaries/FlatDictionary.cpp

@@ -316,7 +316,7 @@ void FlatDictionary::updateData()
             for (const auto attribute_idx : ext::range(0, attributes.size() + 1))
             {
                 const IColumn & update_column = *block.getByPosition(attribute_idx).column.get();
-                MutableColumnPtr saved_column = saved_block->getByPosition(attribute_idx).column->mutate();
+                MutableColumnPtr saved_column = saved_block->getByPosition(attribute_idx).column->assumeMutable();
                 saved_column->insertRangeFrom(update_column, 0, update_column.size());
             }
         }

dbms/src/Dictionaries/HashedDictionary.cpp

@@ -310,7 +310,7 @@ void HashedDictionary::updateData()
             for (const auto attribute_idx : ext::range(0, attributes.size() + 1))
             {
                 const IColumn & update_column = *block.getByPosition(attribute_idx).column.get();
-                MutableColumnPtr saved_column = saved_block->getByPosition(attribute_idx).column->mutate();
+                MutableColumnPtr saved_column = saved_block->getByPosition(attribute_idx).column->assumeMutable();
                 saved_column->insertRangeFrom(update_column, 0, update_column.size());
             }
         }

dbms/src/Functions/FunctionsConditional.h

@@ -592,7 +592,7 @@ private:
             const ColumnPtr & result_column = temporary_block.getByPosition(3).column;
             if (result_column->isColumnNullable())
             {
-                MutableColumnPtr mutable_result_column = result_column->mutate();
+                MutableColumnPtr mutable_result_column = (*std::move(result_column)).mutate();
                 static_cast<ColumnNullable &>(*mutable_result_column).applyNullMap(static_cast<const ColumnNullable &>(*arg_cond.column));
                 block.getByPosition(result).column = std::move(mutable_result_column);
                 return true;
@@ -744,7 +744,7 @@ private:
             {
                 if (arg_else.column->isColumnNullable())
                 {
-                    auto result_column = arg_else.column->mutate();
+                    auto result_column = (*std::move(arg_else.column)).mutate();
                     static_cast<ColumnNullable &>(*result_column).applyNullMap(static_cast<const ColumnUInt8 &>(*arg_cond.column));
                     block.getByPosition(result).column = std::move(result_column);
                 }
@@ -785,7 +785,8 @@ private:
 
                 if (arg_then.column->isColumnNullable())
                 {
-                    auto result_column = arg_then.column->mutate();
+                    auto arg_then_column = arg_then.column;
+                    auto result_column = (*std::move(arg_then_column)).mutate();
                     static_cast<ColumnNullable &>(*result_column).applyNegatedNullMap(static_cast<const ColumnUInt8 &>(*arg_cond.column));
                     block.getByPosition(result).column = std::move(result_column);
                 }

dbms/src/Functions/IFunction.cpp

@@ -63,7 +63,7 @@ ColumnPtr wrapInNullable(const ColumnPtr & src, Block & block, const ColumnNumbe
             }
             else
             {
-                MutableColumnPtr mutable_result_null_map_column = result_null_map_column->mutate();
+                MutableColumnPtr mutable_result_null_map_column = (*std::move(result_null_map_column)).mutate();
 
                 NullMap & result_null_map = static_cast<ColumnUInt8 &>(*mutable_result_null_map_column).getData();
                 const NullMap & src_null_map = static_cast<const ColumnUInt8 &>(*null_map_column).getData();

dbms/src/Interpreters/NullableUtils.cpp

@@ -31,7 +31,7 @@ void extractNestedColumnsAndNullMap(ColumnRawPtrs & key_columns, ColumnPtr & nul
                 }
                 else
                 {
-                    MutableColumnPtr mutable_null_map_holder = null_map_holder->mutate();
+                    MutableColumnPtr mutable_null_map_holder = (*std::move(null_map_holder)).mutate();
 
                     PaddedPODArray<UInt8> & mutable_null_map = static_cast<ColumnUInt8 &>(*mutable_null_map_holder).getData();
                     const PaddedPODArray<UInt8> & other_null_map = column_nullable.getNullMapData();

dbms/src/Storages/StorageBuffer.cpp

@@ -164,7 +164,7 @@ static void appendBlock(const Block & from, Block & to)
         for (size_t column_no = 0, columns = to.columns(); column_no < columns; ++column_no)
         {
             const IColumn & col_from = *from.getByPosition(column_no).column.get();
-            MutableColumnPtr col_to = to.getByPosition(column_no).column->mutate();
+            MutableColumnPtr col_to = (*std::move(to.getByPosition(column_no).column)).mutate();
 
             col_to->insertRangeFrom(col_from, 0, rows);
 
@@ -183,7 +183,7 @@ static void appendBlock(const Block & from, Block & to)
             {
                 ColumnPtr & col_to = to.getByPosition(column_no).column;
                 if (col_to->size() != old_rows)
-                    col_to = col_to->mutate()->cut(0, old_rows);
+                    col_to = (*std::move(col_to)).mutate()->cut(0, old_rows);
             }
         }
         catch (...)