Finally fixed

dbms/src/DataStreams/AddingDefaultBlockOutputStream.cpp

@@ -13,18 +13,25 @@ namespace DB
 
 void AddingDefaultBlockOutputStream::write(const Block & block)
 {
-    Block res = block;
+    Block res;
+    /// We take given columns from input block
+    /// and missed columns without default value (default and meterialized will be computed later)
+    for (const auto & column : output_block)
+        if (block.has(column.name))
+            res.insert(block.getByName(column.name));
+        else if (!column_defaults.count(column.name))
+            res.insert(column);
 
     /// Adds not specified default values.
-    size_t rows = res.rows();
+    size_t rows = block.rows();
 
     /// For missing columns of nested structure, you need to create not a column of empty arrays, but a column of arrays of correct lengths.
     /// First, remember the offset columns for all arrays in the block.
     std::map<String, ColumnPtr> offset_columns;
 
-    for (size_t i = 0, size = res.columns(); i < size; ++i)
+    for (size_t i = 0, size = block.columns(); i < size; ++i)
     {
-        const auto & elem = res.getByPosition(i);
+        const auto & elem = block.getByPosition(i);
 
         if (const ColumnArray * array = typeid_cast<const ColumnArray *>(&*elem.column))
         {
@@ -37,39 +44,33 @@ void AddingDefaultBlockOutputStream::write(const Block & block)
         }
     }
 
-    size_t i = 0;
-    for (auto col = required_columns.begin(); col != required_columns.end(); ++col, ++i)
+    /// In this loop we feel missed columns
+    for (auto & column : res)
     {
-        if (res.has(col->name) || column_defaults.count(col->name))
+        if (block.has(column.name))
             continue;
 
-        ColumnWithTypeAndName column_to_add;
-        column_to_add.name = col->name;
-        column_to_add.type = col->type;
-
-        String offsets_name = Nested::extractTableName(column_to_add.name);
+        String offsets_name = Nested::extractTableName(column.name);
         if (offset_columns.count(offsets_name))
         {
             ColumnPtr offsets_column = offset_columns[offsets_name];
-            DataTypePtr nested_type = typeid_cast<const DataTypeArray &>(*column_to_add.type).getNestedType();
+            DataTypePtr nested_type = typeid_cast<const DataTypeArray &>(*column.type).getNestedType();
             UInt64 nested_rows = rows ? get<UInt64>((*offsets_column)[rows - 1]) : 0;
 
             ColumnPtr nested_column = nested_type->createColumnConstWithDefaultValue(nested_rows)->convertToFullColumnIfConst();
-            column_to_add.column = ColumnArray::create(nested_column, offsets_column);
+            column.column = ColumnArray::create(nested_column, offsets_column);
         }
         else
         {
             /** It is necessary to turn a constant column into a full column, since in part of blocks (from other parts),
             *  it can be full (or the interpreter may decide that it is constant everywhere).
             */
-            column_to_add.column = column_to_add.type->createColumnConstWithDefaultValue(rows)->convertToFullColumnIfConst();
+            column.column = column.type->createColumnConstWithDefaultValue(rows)->convertToFullColumnIfConst();
         }
-
-        res.insert(i, std::move(column_to_add));
     }
 
-    /// Computes explicitly specified values (in column_defaults) by default.
-    evaluateMissingDefaults(res, required_columns, column_defaults, context);
+    /// Computes explicitly specified values (in column_defaults) by default and materialized columns.
+    evaluateMissingDefaults(res, output_block.getNamesAndTypesList(), column_defaults, context);
 
     output->write(res);
 }

dbms/src/DataStreams/AddingDefaultBlockOutputStream.h

@@ -10,8 +10,11 @@ namespace DB
 {
 
 
-/** Adds missing columns to the block with default values.
-  * These columns are materialized (not constants).
+/** This stream adds three types of columns into block
+  * 1. Columns, that are missed inside request, but present in table without defaults (missed columns)
+  * 2. Columns, that are missed inside request, but present in table with defaults (columns with default values)
+  * 3. Columns that materialized from other columns (materialized columns)
+  * All three types of columns are materialized (not constants).
   */
 class AddingDefaultBlockOutputStream : public IBlockOutputStream
 {
@@ -19,10 +22,10 @@ public:
     AddingDefaultBlockOutputStream(
         const BlockOutputStreamPtr & output_,
         const Block & header_,
-        NamesAndTypesList required_columns_,
+        const Block & output_block_,
         const ColumnDefaults & column_defaults_,
         const Context & context_)
-        : output(output_), header(header_), required_columns(required_columns_),
+        : output(output_), header(header_), output_block(output_block_),
           column_defaults(column_defaults_), context(context_)
     {
     }
@@ -37,8 +40,9 @@ public:
 
 private:
     BlockOutputStreamPtr output;
-    Block header;
-    NamesAndTypesList required_columns;
+    const Block header;
+    /// Blocks after this stream should have this structure
+    const Block output_block;
     const ColumnDefaults column_defaults;
     const Context & context;
 };

dbms/src/Interpreters/InterpreterInsertQuery.cpp

@@ -112,7 +112,7 @@ BlockIO InterpreterInsertQuery::execute()
     /// Actually we don't know structure of input blocks from query/table,
     /// because some clients break insertion protocol (columns != header)
     out = std::make_shared<AddingDefaultBlockOutputStream>(
-        out, getSampleBlock(query, table), table->getColumns().getAllPhysical(), table->getColumns().defaults, context);
+        out, getSampleBlock(query, table), table->getSampleBlock(), table->getColumns().defaults, context);
 
     auto out_wrapper = std::make_shared<CountingBlockOutputStream>(out);
     out_wrapper->setProcessListElement(context.getProcessListElement());