FLASH-783 NULL behavior fix for in expr (#386)

windtalker · zanmato1984 · web-flow · commit 8892fd16c797 · 2020-01-10T17:12:50.000+08:00
* fix expr in error * Revert "fix expr in error" This reverts commit 799b89d. * add tidbIn * 1. address comments, 2. fix build error * address comments Co-authored-by: ruoxi <zanmato1984@gmail.com>
diff --git a/dbms/src/Flash/Coprocessor/DAGExpressionAnalyzer.cpp b/dbms/src/Flash/Coprocessor/DAGExpressionAnalyzer.cpp
@@ -9,6 +9,7 @@
 #include <Flash/Coprocessor/DAGCodec.h>
 #include <Flash/Coprocessor/DAGUtils.h>
 #include <Functions/FunctionFactory.h>
+#include <Functions/FunctionHelpers.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/Set.h>
 #include <Interpreters/convertFieldToType.h>
@@ -416,7 +417,7 @@ void DAGExpressionAnalyzer::makeExplicitSetForIndex(const tipb::Expr & expr, con
     }
     const String & func_name = getFunctionName(expr);
     // only support col_name in (value_list)
-    if (isInOrGlobalInOperator(func_name) && expr.children(0).tp() == tipb::ExprType::ColumnRef && !prepared_sets.count(&expr))
+    if (functionIsInOrGlobalInOperator(func_name) && expr.children(0).tp() == tipb::ExprType::ColumnRef && !prepared_sets.count(&expr))
     {
         NamesAndTypesList column_list;
         for (const auto & col : getCurrentInputColumns())
@@ -488,7 +489,7 @@ String DAGExpressionAnalyzer::getActionsForInOperator(const tipb::Expr & expr, E
     // key not in (const1, const2, non_const1, non_const2) => and(key not in (const1, const2), key not eq non_const1, key not eq non_const2)
     argument_names.clear();
     argument_names.push_back(expr_name);
-    bool is_not_in = func_name == "notIn" || func_name == "globalNotIn";
+    bool is_not_in = func_name == "notIn" || func_name == "globalNotIn" || func_name == "tidbNotIn";
     for (const tipb::Expr * non_constant_expr : set->remaining_exprs)
     {
         Names eq_arg_names;
@@ -532,7 +533,7 @@ String DAGExpressionAnalyzer::getActions(const tipb::Expr & expr, ExpressionActi
         }
         const String & func_name = getFunctionName(expr);
 
-        if (isInOrGlobalInOperator(func_name))
+        if (functionIsInOrGlobalInOperator(func_name))
         {
             return getActionsForInOperator(expr, actions);
         }
diff --git a/dbms/src/Flash/Coprocessor/DAGUtils.cpp b/dbms/src/Flash/Coprocessor/DAGUtils.cpp
@@ -2,6 +2,7 @@
 
 #include <Core/Types.h>
 #include <Flash/Coprocessor/DAGCodec.h>
+#include <Functions/FunctionHelpers.h>
 #include <Interpreters/Context.h>
 #include <Storages/Transaction/Datum.h>
 #include <Storages/Transaction/TiDB.h>
@@ -119,7 +120,7 @@ String exprToString(const tipb::Expr & expr, const std::vector<NameAndTypePair>
             throw Exception(tipb::ExprType_Name(expr.tp()) + " not supported", ErrorCodes::UNSUPPORTED_METHOD);
     }
     // build function expr
-    if (isInOrGlobalInOperator(func_name))
+    if (functionIsInOrGlobalInOperator(func_name))
     {
         // for in, we could not represent the function expr using func_name(param1, param2, ...)
         ss << exprToString(expr.children(0), input_col) << " " << func_name << " (";
@@ -263,8 +264,6 @@ String getColumnNameForColumnExpr(const tipb::Expr & expr, const std::vector<Nam
     return input_col[column_index].name;
 }
 
-bool isInOrGlobalInOperator(const String & name) { return name == "in" || name == "notIn" || name == "globalIn" || name == "globalNotIn"; }
-
 // for some historical or unknown reasons, TiDB might set a invalid
 // field type. This function checks if the expr has a valid field type
 // so far the known invalid field types are:
@@ -573,9 +572,9 @@ std::unordered_map<tipb::ScalarFuncSig, String> scalar_func_map({
     //{tipb::ScalarFuncSig::ValuesString, "cast"},
     //{tipb::ScalarFuncSig::ValuesTime, "cast"},
 
-    {tipb::ScalarFuncSig::InInt, "in"}, {tipb::ScalarFuncSig::InReal, "in"}, {tipb::ScalarFuncSig::InString, "in"},
-    {tipb::ScalarFuncSig::InDecimal, "in"}, {tipb::ScalarFuncSig::InTime, "in"}, {tipb::ScalarFuncSig::InDuration, "in"},
-    {tipb::ScalarFuncSig::InJson, "in"},
+    {tipb::ScalarFuncSig::InInt, "tidbIn"}, {tipb::ScalarFuncSig::InReal, "tidbIn"}, {tipb::ScalarFuncSig::InString, "tidbIn"},
+    {tipb::ScalarFuncSig::InDecimal, "tidbIn"}, {tipb::ScalarFuncSig::InTime, "tidbIn"}, {tipb::ScalarFuncSig::InDuration, "tidbIn"},
+    {tipb::ScalarFuncSig::InJson, "tidbIn"},
 
     {tipb::ScalarFuncSig::IfNullInt, "ifNull"}, {tipb::ScalarFuncSig::IfNullReal, "ifNull"}, {tipb::ScalarFuncSig::IfNullString, "ifNull"},
     {tipb::ScalarFuncSig::IfNullDecimal, "ifNull"}, {tipb::ScalarFuncSig::IfNullTime, "ifNull"},
diff --git a/dbms/src/Flash/Coprocessor/DAGUtils.h b/dbms/src/Flash/Coprocessor/DAGUtils.h
@@ -25,7 +25,6 @@ bool isColumnExpr(const tipb::Expr & expr);
 String getColumnNameForColumnExpr(const tipb::Expr & expr, const std::vector<NameAndTypePair> & input_col);
 const String & getTypeName(const tipb::Expr & expr);
 String exprToString(const tipb::Expr & expr, const std::vector<NameAndTypePair> & input_col);
-bool isInOrGlobalInOperator(const String & name);
 bool exprHasValidFieldType(const tipb::Expr & expr);
 void constructStringLiteralTiExpr(tipb::Expr & expr, const String & value);
 void constructInt64LiteralTiExpr(tipb::Expr & expr, Int64 value);
diff --git a/dbms/src/Functions/FunctionHelpers.cpp b/dbms/src/Functions/FunctionHelpers.cpp
@@ -96,4 +96,14 @@ Block createBlockWithNestedColumns(const Block & block, const ColumnNumbers & ar
     return createBlockWithNestedColumnsImpl(block, args_set);
 }
 
+bool functionIsInOperator(const String & name)
+{
+    return name == "in" || name == "notIn" || name == "tidbIn" || name == "tidbNotIn";
+}
+
+bool functionIsInOrGlobalInOperator(const String & name)
+{
+    return name == "in" || name == "notIn" || name == "globalIn" || name == "globalNotIn" || name == "tidbIn" || name == "tidbNotIn";
+}
+
 }
diff --git a/dbms/src/Functions/FunctionHelpers.h b/dbms/src/Functions/FunctionHelpers.h
@@ -99,5 +99,8 @@ Block createBlockWithNestedColumns(const Block & block, const ColumnNumbers & ar
 /// Similar function as above. Additionally transform the result type if needed.
 Block createBlockWithNestedColumns(const Block & block, const ColumnNumbers & args, size_t result);
 
+bool functionIsInOperator(const String & name);
+
+bool functionIsInOrGlobalInOperator(const String & name);
 
 }
diff --git a/dbms/src/Functions/FunctionsMiscellaneous.cpp b/dbms/src/Functions/FunctionsMiscellaneous.cpp
@@ -19,8 +19,10 @@
 #include <DataTypes/DataTypeArray.h>
 #include <DataTypes/DataTypeDate.h>
 #include <DataTypes/DataTypeDateTime.h>
+#include <DataTypes/DataTypeSet.h>
 #include <DataTypes/DataTypeString.h>
 #include <DataTypes/DataTypeTuple.h>
+#include <DataTypes/DataTypeNullable.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeEnum.h>
 #include <DataTypes/NumberTraits.h>
@@ -681,34 +683,44 @@ class FunctionMaterialize : public IFunction
     }
 };
 
-template <bool negative, bool global>
+template <bool negative, bool global, bool ignore_null>
 struct FunctionInName;
 template <>
-struct FunctionInName<false, false>
+struct FunctionInName<false, false, true>
 {
     static constexpr auto name = "in";
 };
 template <>
-struct FunctionInName<false, true>
+struct FunctionInName<false, false, false>
+{
+    static constexpr auto name = "tidbIn";
+};
+template <>
+struct FunctionInName<false, true, true>
 {
     static constexpr auto name = "globalIn";
 };
 template <>
-struct FunctionInName<true, false>
+struct FunctionInName<true, false, true>
 {
     static constexpr auto name = "notIn";
 };
 template <>
-struct FunctionInName<true, true>
+struct FunctionInName<true, false, false>
+{
+    static constexpr auto name = "tidbNotIn";
+};
+template <>
+struct FunctionInName<true, true, true>
 {
     static constexpr auto name = "globalNotIn";
 };
 
-template <bool negative, bool global>
+template <bool negative, bool global, bool ignore_null>
 class FunctionIn : public IFunction
 {
 public:
-    static constexpr auto name = FunctionInName<negative, global>::name;
+    static constexpr auto name = FunctionInName<negative, global, ignore_null>::name;
     static FunctionPtr create(const Context &)
     {
         return std::make_shared<FunctionIn>();
@@ -724,9 +736,27 @@ class FunctionIn : public IFunction
         return 2;
     }
 
-    DataTypePtr getReturnTypeImpl(const DataTypes & /*arguments*/) const override
+    DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
     {
-        return std::make_shared<DataTypeUInt8>();
+        if constexpr (ignore_null)
+            return std::make_shared<DataTypeUInt8>();
+
+        auto type = removeNullable(arguments[0].type);
+        if (typeid_cast<const DataTypeTuple *>(type.get()))
+            throw Exception("Illegal type (" + arguments[0].type->getName() + ") of 1 argument of function " + getName(),
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        if (!typeid_cast<const DataTypeSet *>(arguments[1].type.get()))
+            throw Exception("Illegal type (" + arguments[1].type->getName() + ") of 2 argument of function " + getName(),
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        bool return_nullable = arguments[0].type->isNullable();
+        ColumnPtr column_set_ptr = arguments[1].column;
+        auto * column_set = typeid_cast<const ColumnSet *>(&*column_set_ptr);
+        return_nullable |= column_set->getData()->containsNullValue();
+
+        if (return_nullable)
+            return makeNullable(std::make_shared<DataTypeUInt8>());
+        else
+            return std::make_shared<DataTypeUInt8>();
     }
 
     bool useDefaultImplementationForNulls() const override
@@ -736,6 +766,16 @@ class FunctionIn : public IFunction
 
     void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override
     {
+        const ColumnWithTypeAndName & left_arg = block.getByPosition(arguments[0]);
+        if constexpr (!ignore_null)
+        {
+            if (left_arg.type->onlyNull())
+            {
+                block.getByPosition(result).column =
+                        block.getByPosition(result).type->createColumnConst(block.rows(),Null());
+                return;
+            }
+        }
         /// Second argument must be ColumnSet.
         ColumnPtr column_set_ptr = block.getByPosition(arguments[1]).column;
         const ColumnSet * column_set = typeid_cast<const ColumnSet *>(&*column_set_ptr);
@@ -746,7 +786,6 @@ class FunctionIn : public IFunction
         Block block_of_key_columns;
 
         /// First argument may be tuple or single column.
-        const ColumnWithTypeAndName & left_arg = block.getByPosition(arguments[0]);
         const ColumnTuple * tuple = typeid_cast<const ColumnTuple *>(left_arg.column.get());
         const ColumnConst * const_tuple = checkAndGetColumnConst<ColumnTuple>(left_arg.column.get());
         const DataTypeTuple * type_tuple = typeid_cast<const DataTypeTuple *>(left_arg.type.get());
@@ -769,7 +808,55 @@ class FunctionIn : public IFunction
         else
             block_of_key_columns.insert(left_arg);
 
-        block.getByPosition(result).column = column_set->getData()->execute(block_of_key_columns, negative);
+        if constexpr (ignore_null)
+        {
+            block.getByPosition(result).column = column_set->getData()->execute(block_of_key_columns, negative);
+        }
+        else
+        {
+            bool set_contains_null = column_set->getData()->containsNullValue();
+            bool return_nullable = left_arg.type->isNullable() || set_contains_null;
+            if (return_nullable)
+            {
+                auto nested_res = column_set->getData()->execute(block_of_key_columns, negative);
+                if (left_arg.column->isColumnNullable())
+                {
+                    ColumnPtr result_null_map_column = dynamic_cast<const ColumnNullable &>(*left_arg.column).getNullMapColumnPtr();
+                    if (set_contains_null)
+                    {
+                        MutableColumnPtr mutable_result_null_map_column = (*std::move(result_null_map_column)).mutate();
+                        NullMap & result_null_map = dynamic_cast<ColumnUInt8 &>(*mutable_result_null_map_column).getData();
+                        auto uint8_column = checkAndGetColumn<ColumnUInt8>(nested_res.get());
+                        const auto & data = uint8_column->getData();
+                        for (size_t i = 0, size = result_null_map.size(); i < size; i++)
+                        {
+                            if (data[i] == negative)
+                                result_null_map[i] = 1;
+                        }
+                        result_null_map_column = std::move(mutable_result_null_map_column);
+                    }
+                    block.getByPosition(result).column = ColumnNullable::create(nested_res, result_null_map_column);
+                }
+                else
+                {
+                    auto col_null_map = ColumnUInt8::create();
+                    ColumnUInt8::Container & vec_null_map = col_null_map->getData();
+                    vec_null_map.assign(block.rows(), (UInt8) 0);
+                    auto uint8_column = checkAndGetColumn<ColumnUInt8>(nested_res.get());
+                    const auto & data = uint8_column->getData();
+                    for (size_t i = 0, size = vec_null_map.size(); i < size; i++)
+                    {
+                        if (data[i] == negative)
+                            vec_null_map[i] = 1;
+                    }
+                    block.getByPosition(result).column = ColumnNullable::create(nested_res, std::move(col_null_map));
+                }
+            }
+            else
+            {
+                block.getByPosition(result).column = column_set->getData()->execute(block_of_key_columns, negative);
+            }
+        }
     }
 };
 
@@ -1865,10 +1952,12 @@ void registerFunctionsMiscellaneous(FunctionFactory & factory)
     factory.registerFunction<FunctionBar>();
     factory.registerFunction<FunctionHasColumnInTable>();
 
-    factory.registerFunction<FunctionIn<false, false>>();
-    factory.registerFunction<FunctionIn<false, true>>();
-    factory.registerFunction<FunctionIn<true, false>>();
-    factory.registerFunction<FunctionIn<true, true>>();
+    factory.registerFunction<FunctionIn<false, false, true>>();
+    factory.registerFunction<FunctionIn<false, true, true>>();
+    factory.registerFunction<FunctionIn<true, false, true>>();
+    factory.registerFunction<FunctionIn<true, true, true>>();
+    factory.registerFunction<FunctionIn<true, false, false>>();
+    factory.registerFunction<FunctionIn<false, false, false>>();
 
     factory.registerFunction<FunctionIsFinite>();
     factory.registerFunction<FunctionIsInfinite>();
diff --git a/dbms/src/Interpreters/ExpressionAnalyzer.cpp b/dbms/src/Interpreters/ExpressionAnalyzer.cpp
@@ -52,6 +52,7 @@
 #include <Parsers/formatAST.h>
 
 #include <Functions/FunctionFactory.h>
+#include <Functions/FunctionHelpers.h>
 #include <Functions/IFunction.h>
 
 #include <ext/range.h>
@@ -132,16 +133,6 @@ const std::unordered_set<String> possibly_injective_function_names
 namespace
 {
 
-bool functionIsInOperator(const String & name)
-{
-    return name == "in" || name == "notIn";
-}
-
-bool functionIsInOrGlobalInOperator(const String & name)
-{
-    return name == "in" || name == "notIn" || name == "globalIn" || name == "globalNotIn";
-}
-
 void removeDuplicateColumns(NamesAndTypesList & columns)
 {
     std::set<String> names;
diff --git a/dbms/src/Interpreters/Set.cpp b/dbms/src/Interpreters/Set.cpp
@@ -222,6 +222,8 @@ void Set::createFromAST(const DataTypes & types, ASTPtr node, const Context & co
 
             if (!value.isNull())
                 columns[0]->insert(value);
+            else
+                setContainsNullValue(true);
         }
         else if (ASTFunction * func = typeid_cast<ASTFunction *>(elem.get()))
         {
@@ -277,6 +279,10 @@ std::vector<const tipb::Expr *> Set::createFromDAGExpr(const DataTypes & types,
     MutableColumns columns = header.cloneEmptyColumns();
     std::vector<const tipb::Expr *> remainingExprs;
 
+    // if left arg is null constant, just return without decode children expr
+    if (types[0]->onlyNull())
+        return remainingExprs;
+
     for (int i = 1; i < expr.children_size(); i++)
     {
         auto & child = expr.children(i);
@@ -292,6 +298,8 @@ std::vector<const tipb::Expr *> Set::createFromDAGExpr(const DataTypes & types,
 
         if (!value.isNull())
             columns[0]->insert(value);
+        else
+            setContainsNullValue(true);
     }
 
     Block block = header.cloneWithColumns(std::move(columns));
diff --git a/dbms/src/Interpreters/Set.h b/dbms/src/Interpreters/Set.h
@@ -78,6 +78,9 @@ class Set
 
     SetElements & getSetElements() { return *set_elements.get(); }
 
+    void setContainsNullValue(bool contains_null_value_) { contains_null_value = contains_null_value_; }
+    bool containsNullValue() const { return contains_null_value; }
+
 private:
     size_t keys_size;
     Sizes key_sizes;
@@ -109,6 +112,8 @@ class Set
     /// Limitations on the maximum size of the set
     SizeLimits limits;
 
+    bool contains_null_value = false;
+
     /// If in the left part columns contains the same types as the elements of the set.
     void executeOrdinary(
         const ColumnRawPtrs & key_columns,
diff --git a/tests/mutable-test/txn_dag/in.test b/tests/mutable-test/txn_dag/in.test

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`#include <Flash/Coprocessor/DAGCodec.h>`
`10`	`10`	`#include <Flash/Coprocessor/DAGUtils.h>`
`11`	`11`	`#include <Functions/FunctionFactory.h>`
	`12`	`+#include <Functions/FunctionHelpers.h>`
`12`	`13`	`#include <Interpreters/Context.h>`
`13`	`14`	`#include <Interpreters/Set.h>`
`14`	`15`	`#include <Interpreters/convertFieldToType.h>`
`@@ -416,7 +417,7 @@ void DAGExpressionAnalyzer::makeExplicitSetForIndex(const tipb::Expr & expr, con`
`416`	`417`	`}`
`417`	`418`	`const String & func_name = getFunctionName(expr);`
`418`	`419`	`// only support col_name in (value_list)`
`419`		`- if (isInOrGlobalInOperator(func_name) && expr.children(0).tp() == tipb::ExprType::ColumnRef && !prepared_sets.count(&expr))`
	`420`	`+ if (functionIsInOrGlobalInOperator(func_name) && expr.children(0).tp() == tipb::ExprType::ColumnRef && !prepared_sets.count(&expr))`
`420`	`421`	`{`
`421`	`422`	`NamesAndTypesList column_list;`
`422`	`423`	`for (const auto & col : getCurrentInputColumns())`
`@@ -488,7 +489,7 @@ String DAGExpressionAnalyzer::getActionsForInOperator(const tipb::Expr & expr, E`
`488`	`489`	`// key not in (const1, const2, non_const1, non_const2) => and(key not in (const1, const2), key not eq non_const1, key not eq non_const2)`
`489`	`490`	`argument_names.clear();`
`490`	`491`	`argument_names.push_back(expr_name);`
`491`		`- bool is_not_in = func_name == "notIn" \|\| func_name == "globalNotIn";`
	`492`	`+ bool is_not_in = func_name == "notIn" \|\| func_name == "globalNotIn" \|\| func_name == "tidbNotIn";`
`492`	`493`	`for (const tipb::Expr * non_constant_expr : set->remaining_exprs)`
`493`	`494`	`{`
`494`	`495`	`Names eq_arg_names;`
`@@ -532,7 +533,7 @@ String DAGExpressionAnalyzer::getActions(const tipb::Expr & expr, ExpressionActi`
`532`	`533`	`}`
`533`	`534`	`const String & func_name = getFunctionName(expr);`
`534`	`535`
`535`		`- if (isInOrGlobalInOperator(func_name))`
	`536`	`+ if (functionIsInOrGlobalInOperator(func_name))`
`536`	`537`	`{`
`537`	`538`	`return getActionsForInOperator(expr, actions);`
`538`	`539`	`}`
Original file line number	Diff line number	Diff line change
`@@ -96,4 +96,14 @@ Block createBlockWithNestedColumns(const Block & block, const ColumnNumbers & ar`
`96`	`96`	`return createBlockWithNestedColumnsImpl(block, args_set);`
`97`	`97`	`}`
`98`	`98`
	`99`	`+bool functionIsInOperator(const String & name)`
	`100`	`+{`
	`101`	`+ return name == "in" \|\| name == "notIn" \|\| name == "tidbIn" \|\| name == "tidbNotIn";`
	`102`	`+}`
	`103`	`+`
	`104`	`+bool functionIsInOrGlobalInOperator(const String & name)`
	`105`	`+{`
	`106`	`+ return name == "in" \|\| name == "notIn" \|\| name == "globalIn" \|\| name == "globalNotIn" \|\| name == "tidbIn" \|\| name == "tidbNotIn";`
	`107`	`+}`
	`108`	`+`
`99`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -99,5 +99,8 @@ Block createBlockWithNestedColumns(const Block & block, const ColumnNumbers & ar`
`99`	`99`	`/// Similar function as above. Additionally transform the result type if needed.`
`100`	`100`	`Block createBlockWithNestedColumns(const Block & block, const ColumnNumbers & args, size_t result);`
`101`	`101`
	`102`	`+bool functionIsInOperator(const String & name);`
	`103`	`+`
	`104`	`+bool functionIsInOrGlobalInOperator(const String & name);`
`102`	`105`
`103`	`106`	`}`
Original file line number	Diff line number	Diff line change
`@@ -222,6 +222,8 @@ void Set::createFromAST(const DataTypes & types, ASTPtr node, const Context & co`
`222`	`222`
`223`	`223`	`if (!value.isNull())`
`224`	`224`	`columns[0]->insert(value);`
	`225`	`+ else`
	`226`	`+ setContainsNullValue(true);`
`225`	`227`	`}`
`226`	`228`	`else if (ASTFunction * func = typeid_cast<ASTFunction *>(elem.get()))`
`227`	`229`	`{`
`@@ -277,6 +279,10 @@ std::vector<const tipb::Expr *> Set::createFromDAGExpr(const DataTypes & types,`
`277`	`279`	`MutableColumns columns = header.cloneEmptyColumns();`
`278`	`280`	`std::vector<const tipb::Expr *> remainingExprs;`
`279`	`281`
	`282`	`+ // if left arg is null constant, just return without decode children expr`
	`283`	`+ if (types[0]->onlyNull())`
	`284`	`+ return remainingExprs;`
	`285`	`+`
`280`	`286`	`for (int i = 1; i < expr.children_size(); i++)`
`281`	`287`	`{`
`282`	`288`	`auto & child = expr.children(i);`
`@@ -292,6 +298,8 @@ std::vector<const tipb::Expr *> Set::createFromDAGExpr(const DataTypes & types,`
`292`	`298`
`293`	`299`	`if (!value.isNull())`
`294`	`300`	`columns[0]->insert(value);`
	`301`	`+ else`
	`302`	`+ setContainsNullValue(true);`
`295`	`303`	`}`
`296`	`304`
`297`	`305`	`Block block = header.cloneWithColumns(std::move(columns));`