clickhouse-native 0.9.0 → 0.10.0

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/client.h

@@ -10,6 +10,7 @@
 #include "columns/geo.h"
 #include "columns/ip4.h"
 #include "columns/ip6.h"
+#include "columns/json.h"
 #include "columns/lowcardinality.h"
 #include "columns/nothing.h"
 #include "columns/nullable.h"
@@ -19,6 +20,7 @@
 #include "columns/tuple.h"
 #include "columns/time.h"
 #include "columns/uuid.h"
+#include "columns/bool.h"
 
 #include <chrono>
 #include <cstdint>
@@ -247,6 +249,9 @@ public:
     /// Intends for execute arbitrary queries.
     void Execute(const Query& query);
 
+    /// Alias for Execute.
+    void Select(const Query& query);
+
     /// Intends for execute select queries.  Data will be returned with
     /// one or more call of \p cb.
     void Select(const std::string& query, SelectCallback cb);
@@ -267,8 +272,30 @@ public:
     void SelectWithExternalDataCancelable(const std::string& query, const ExternalTables& external_tables, SelectCancelableCallback cb);
     void SelectWithExternalDataCancelable(const std::string& query, const std::string& query_id, const ExternalTables& external_tables, SelectCancelableCallback cb);
 
-    /// Alias for Execute.
-    void Select(const Query& query);
+    /// EXPERIMENTAL. Intends for execute arbitrary queries while reading the data interactively with
+    /// NextBlock().
+    void BeginExecute(const Query& query);
+
+    /// EXPERIMENTAL. Alias for BeginExecute.
+    void BeginSelect(const Query& query);
+
+    /// EXPERIMENTAL. Interactive version of select, data will be returned on consequent calls
+    /// to NextBlock().
+    void BeginSelect(const char* query);
+    void BeginSelect(const std::string& query);
+    void BeginSelect(const std::string& query, const std::string& query_id);
+
+    /// Returns the next block in the dataset after using BeginSelect family of functions
+    /// functions.
+    std::optional<Block> NextBlock();
+
+    // EXPERIMENTAL. Cancels current execution of BeginSelect and drains all in-flight data.
+    // Consecutive calls to NextBlock() after Cancel() will throw an exception.
+    void Cancel();
+
+    // EXPERIMENTAL. Returns true if the client is still in data-receiving mode and more future
+    // calls to NextBlock().
+    bool IsSelecting() const;
 
     /// Intends for insert block of data into a table \p table_name.
     void Insert(const std::string& table_name, const Block& block);
@@ -284,6 +311,8 @@ public:
     /// End an \p INSERT session started by \p BeginInsert.
     void EndInsert();
 
+    bool IsInserting() const;
+
     /// Ping server for aliveness.
     void Ping();
 

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/array.cpp

@@ -167,6 +167,18 @@ ColumnRef ColumnArray::GetData() {
     return data_;
 }
 
+std::shared_ptr<const Column> ColumnArray::GetData() const {
+    return data_;
+}
+
+std::shared_ptr<ColumnUInt64>& ColumnArray::GetOffsets() {
+    return offsets_;
+}
+
+std::shared_ptr<const ColumnUInt64> ColumnArray::GetOffsets() const {
+    return offsets_;
+}
+
 void ColumnArray::Reset() {
     data_.reset();
     offsets_.reset();

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/array.h

@@ -78,14 +78,26 @@ public:
 
     void OffsetsIncrease(size_t);
 
+    /// Gets the backing data array of the Array's. This does not include any Array Bounds.
+    ColumnRef GetData();
+    std::shared_ptr<const Column> GetData() const;
+
+    /// Gets all offsets denoting the list boundaries overlayed GetData.
+    /// The layout is [size_i, ...] where `i` is the row.
+    std::shared_ptr<ColumnUInt64>& GetOffsets();
+    std::shared_ptr<const ColumnUInt64> GetOffsets() const;
+
+    /// Gets the offset of the start of row `n` into `GetData()`.
+    size_t GetOffset(size_t n) const;
+
+    /// Gets the element count of row `n`.
+    size_t GetSize(size_t n) const;
+
 protected:
     template<typename T> friend class ColumnArrayT;
 
     ColumnArray(ColumnArray&& array);
 
-    size_t GetOffset(size_t n) const;
-    size_t GetSize(size_t n) const;
-    ColumnRef GetData();
     void AddOffset(size_t n);
     void Reset();
 
@@ -262,11 +274,9 @@ public:
     template <typename Container>
     inline void Append(Container&& container) {
         using container_type = decltype(container);
-        if constexpr (std::is_lvalue_reference_v<container_type> || 
-            std::is_const_v<std::remove_reference_t<container_type>>) {
+        if constexpr (std::is_lvalue_reference_v<container_type> || std::is_const_v<std::remove_reference_t<container_type>>) {
             Append(std::begin(container), std::end(container));
-        }
-        else {
+        } else {
             Append(std::make_move_iterator(std::begin(container)),
                 std::make_move_iterator(std::end(container)));
         }

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/bool.cpp

@@ -0,0 +1,79 @@
+#include "bool.h"
+
+#include "../types/types.h"
+
+namespace clickhouse {
+
+ColumnBool::ColumnBool()
+    : Column(Type::CreateSimple<bool>())
+    , data_()
+{
+}
+
+ColumnBool::ColumnBool(std::vector<uint8_t> data)
+    : Column(Type::CreateSimple<bool>())
+    , data_(std::move(data))
+{
+}
+
+void ColumnBool::Reserve(size_t new_cap) {
+    data_.Reserve(new_cap);
+}
+
+size_t ColumnBool::Capacity() const {
+    return data_.Capacity();
+}
+
+void ColumnBool::Append(bool value) {
+    data_.Append(static_cast<uint8_t>(value));
+}
+
+bool ColumnBool::At(size_t n) const {
+    return static_cast<bool>(data_.At(n));
+}
+
+void ColumnBool::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnBool>()) {
+        auto& src = col->data_.GetWritableData();
+        data_.GetWritableData().insert(data_.GetWritableData().end(), src.begin(), src.end());
+    } else if (auto col = column->As<ColumnUInt8>()) {
+        auto& src = col->GetWritableData();
+        data_.GetWritableData().insert(data_.GetWritableData().end(), src.begin(), src.end());
+    }
+}
+
+bool ColumnBool::LoadBody(InputStream* input, size_t rows) {
+    return data_.LoadBody(input, rows);
+}
+
+void ColumnBool::SaveBody(OutputStream* output) {
+    data_.SaveBody(output);
+}
+
+void ColumnBool::Clear() {
+    data_.Clear();
+}
+
+size_t ColumnBool::Size() const {
+    return data_.Size();
+}
+
+ColumnRef ColumnBool::Slice(size_t begin, size_t len) const {
+    auto sliced = std::static_pointer_cast<ColumnUInt8>(data_.Slice(begin, len));
+    return std::make_shared<ColumnBool>(std::move(sliced->GetWritableData()));
+}
+
+ColumnRef ColumnBool::CloneEmpty() const {
+    return std::make_shared<ColumnBool>();
+}
+
+void ColumnBool::Swap(Column& other) {
+    auto& col = dynamic_cast<ColumnBool&>(other);
+    data_.Swap(col.data_);
+}
+
+ItemView ColumnBool::GetItem(size_t index) const {
+    return ItemView{Type::Bool, data_.At(index)};
+}
+
+}  // namespace clickhouse

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/bool.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "column.h"
+#include "numeric.h"
+
+#include "../types/types.h"
+
+#include <vector>
+
+namespace clickhouse {
+
+class ColumnBool : public Column {
+public:
+    using ValueType = bool;
+
+    ColumnBool();
+    explicit ColumnBool(std::vector<uint8_t> data);
+
+    /// Increase the capacity of the column for large block insertion.
+    void Reserve(size_t new_cap) override;
+
+    /// Appends one element to the end of column.
+    void Append(bool value);
+
+    /// Returns element at given row number.
+    bool At(size_t n) const;
+
+    /// Returns element at given row number.
+    bool operator[](size_t n) const { return At(n); }
+
+    /// Returns the capacity of the column
+    size_t Capacity() const;
+
+public:
+    /// Appends content of given column to the end of current one.
+    /// Accepts ColumnBool or ColumnUInt8.
+    void Append(ColumnRef column) override;
+
+    /// Loads column data from input stream.
+    bool LoadBody(InputStream* input, size_t rows) override;
+
+    /// Saves column data to output stream.
+    void SaveBody(OutputStream* output) override;
+
+    /// Clear column data.
+    void Clear() override;
+
+    /// Returns count of rows in the column.
+    size_t Size() const override;
+
+    /// Makes slice of the current column.
+    ColumnRef Slice(size_t begin, size_t len) const override;
+    ColumnRef CloneEmpty() const override;
+    void Swap(Column& other) override;
+
+    ItemView GetItem(size_t index) const override;
+
+private:
+    ColumnUInt8 data_;
+};
+
+}  // namespace clickhouse

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/factory.cpp

@@ -7,11 +7,13 @@
 #include "geo.h"
 #include "ip4.h"
 #include "ip6.h"
+#include "json.h"
 #include "lowcardinality.h"
 #include "lowcardinalityadaptor.h"
 #include "map.h"
 #include "nothing.h"
 #include "nullable.h"
+#include "bool.h"
 #include "numeric.h"
 #include "string.h"
 #include "./time.h" // `./` avoids possible conflicts with standard C time.h
@@ -49,6 +51,8 @@ static ColumnRef CreateTerminalColumn(const TypeAst& ast) {
     case Type::Void:
         return std::make_shared<ColumnNothing>();
 
+    case Type::Bool:
+        return std::make_shared<ColumnBool>();
     case Type::UInt8:
         return std::make_shared<ColumnUInt8>();
     case Type::UInt16:
@@ -136,6 +140,8 @@ static ColumnRef CreateTerminalColumn(const TypeAst& ast) {
             return nullptr;
         }
         return std::make_shared<ColumnTime64>(GetASTChildElement(ast, 0).value);
+    case Type::JSON:
+        return std::make_shared<ColumnJSON>();
     default:
         return nullptr;
     }
@@ -162,16 +168,26 @@ static ColumnRef CreateColumnFromAst(const TypeAst& ast, CreateColumnByTypeSetti
 
         case TypeAst::Tuple: {
             std::vector<ColumnRef> columns;
+            std::vector<std::string> names;
 
             columns.reserve(ast.elements.size());
+            names.reserve(ast.elements.size());
+            bool any_named = false;
             for (const auto& elem : ast.elements) {
                 if (auto col = CreateColumnFromAst(elem, settings)) {
                     columns.push_back(col);
+                    names.push_back(elem.element_name);
+                    if (!elem.element_name.empty()) {
+                        any_named = true;
+                    }
                 } else {
                     return nullptr;
                 }
             }
 
+            if (any_named) {
+                return std::make_shared<ColumnTuple>(columns, std::move(names));
+            }
             return std::make_shared<ColumnTuple>(columns);
         }
 

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/itemview.cpp

@@ -44,6 +44,7 @@ void ItemView::ValidateData(Type::Code type, DataType data) {
         case Type::Code::Int8:
         case Type::Code::UInt8:
         case Type::Code::Enum8:
+        case Type::Code::Bool:
             return AssertSize({1});
 
         case Type::Code::Int16:
@@ -72,6 +73,7 @@ void ItemView::ValidateData(Type::Code type, DataType data) {
 
         case Type::Code::String:
         case Type::Code::FixedString:
+        case Type::Code::JSON:
             // value can be of any size
             return;
 

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/itemview.h

@@ -28,7 +28,9 @@ private:
     inline auto ConvertToStorageValue(const T& t) {
         if constexpr (std::is_same_v<std::string_view, T> || std::is_same_v<std::string, T>) {
             return std::string_view{t};
-        } else if constexpr (std::is_fundamental_v<T> || std::is_same_v<Int128, std::decay_t<T>> || std::is_same_v<UInt128, std::decay_t<T>>) {
+        } else if constexpr (std::is_fundamental_v<T>
+                          || std::is_same_v<Int128, std::decay_t<T>>
+                          || std::is_same_v<UInt128, std::decay_t<T>>) {
             return std::string_view{reinterpret_cast<const char*>(&t), sizeof(T)};
         } else {
             static_assert(!std::is_same_v<T, T>, "Unknown type, which can't be stored in ItemView");
@@ -65,7 +67,9 @@ public:
         using ValueType = std::remove_cv_t<std::decay_t<T>>;
         if constexpr (std::is_same_v<std::string_view, ValueType> || std::is_same_v<std::string, ValueType>) {
             return data;
-        } else if constexpr (std::is_fundamental_v<ValueType> || std::is_same_v<Int128, ValueType> || std::is_same_v<UInt128, ValueType>) {
+        } else if constexpr (std::is_fundamental_v<ValueType>
+                          || std::is_same_v<Int128, ValueType>
+                          || std::is_same_v<UInt128, ValueType>) {
             if (sizeof(ValueType) == data.size()) {
                 return *reinterpret_cast<const T*>(data.data());
             } else {

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/json.cpp

@@ -0,0 +1,102 @@
+#include "json.h"
+#include "../base/wire_format.h"
+
+namespace clickhouse {
+
+enum class JSONSerializationVersion : uint64_t {
+  // String is the only currently supported serialization of JSON.
+  // it should be enabled with output_format_native_write_json_as_string=1
+  String = 1,
+};
+
+ColumnJSON::ColumnJSON()
+    : Column(Type::CreateJSON())
+    , data_(std::make_shared<ColumnString>())
+{}
+
+ColumnJSON::ColumnJSON(std::vector<std::string> data)
+    : Column(Type::CreateJSON())
+    , data_(std::make_shared<ColumnString>(std::move(data)))
+{}
+
+void ColumnJSON::Append(std::string_view str) {
+    data_->Append(str);
+}
+
+void ColumnJSON::Append(const char* str) {
+    data_->Append(str);
+}
+void ColumnJSON::Append(std::string&& str) {
+    data_->Append(std::move(str));
+}
+
+std::string_view ColumnJSON::At(size_t n) const {
+    return data_->At(n);
+}
+
+void ColumnJSON::Append(ColumnRef column) {
+    if (auto col = column->As<ColumnJSON>()) {
+        data_->Append(col->data_);
+    }
+}
+
+void ColumnJSON::Reserve(size_t new_cap) {
+    data_->Reserve(new_cap);
+}
+
+bool ColumnJSON::LoadPrefix(InputStream* input, size_t) {
+    uint64_t v;
+    if (!WireFormat::ReadFixed(*input, &v)) {
+        return false;
+    }
+    if (v != static_cast<uint64_t>(JSONSerializationVersion::String)) {
+        // Hard stop: the library can only parse JSON when `output_format_native_write_json_as_string` is enabled.
+        // Further processing is meaningless after this error and the user must be notified immediately.
+        throw ProtocolError("Unsupported JSON serialization version. "
+                            "Make sure output_format_native_write_json_as_string=1 is set.");
+    }
+    return true;
+}
+
+bool ColumnJSON::LoadBody(InputStream* input, size_t rows) {
+    return data_->LoadBody(input, rows);
+}
+
+void ColumnJSON::SavePrefix(OutputStream* output) {
+    WireFormat::WriteFixed(*output, static_cast<uint64_t>(JSONSerializationVersion::String));
+}
+
+void ColumnJSON::SaveBody(OutputStream* output) {
+    data_->SaveBody(output);
+}
+
+void ColumnJSON::Clear() {
+    data_->Clear();
+}
+
+size_t ColumnJSON::Size() const {
+    return data_->Size();
+}
+
+ColumnRef ColumnJSON::Slice(size_t begin, size_t len) const {
+    auto ret = std::make_shared<ColumnJSON>();
+    auto sliced_data = data_->Slice(begin, len)->As<ColumnString>();
+    ret->data_->Swap(*sliced_data);
+    return ret;
+}
+
+ColumnRef ColumnJSON::CloneEmpty() const
+{
+    return std::make_shared<ColumnJSON>();
+}
+
+void ColumnJSON::Swap(Column& other) {
+    auto & col = dynamic_cast<ColumnJSON &>(other);
+    data_.swap(col.data_);
+}
+
+ItemView ColumnJSON::GetItem(size_t index) const {
+    return ItemView{Type::JSON, data_->GetItem(index)};
+}
+
+}

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/json.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include "column.h"
+#include "string.h"
+#include "nullable.h"
+
+namespace clickhouse {
+
+/**
+ * JSON Column: Represents JSON values as strings.
+ * Works only when ClickHouse outputs JSON as strings and requires the setting
+ * output_format_native_write_json_as_string to be set to 1 for selecting data.
+ * Inserting JSON data does not require setting this setting.
+ * 
+ * WARNING: THIS IS AN EXPERIMENTAL IMPLEMENTATION.
+ * The API may change in the future as we continue working on full support for JSON columns.
+ *
+ * ClickHouse does not accept empty strings as JSON; it requires an empty object ({}).
+ * For nullable columns, each row marked a NULL must contain {}.
+ * For convenience `clickhouse::ColumnNullableT<ColumnJSON>` automatically inserts {} for NULL rows.
+ */
+class ColumnJSON : public Column {
+public:
+
+    ColumnJSON();
+    explicit ColumnJSON(std::vector<std::string> data);
+
+    /// Appends one element to the column.
+    void Append(std::string_view str);
+
+    void Append(const char* str);
+    void Append(std::string&& str);
+
+    std::string_view At(size_t n) const;
+    inline std::string_view operator [] (size_t n) const { return At(n); }
+
+    /// Appends content of given column to the end of current one.
+    void Append(ColumnRef column) override;
+
+    /// Increase the capacity of the column for large block insertion.
+    void Reserve(size_t new_cap) override;
+
+    /// Loads column prefix from input stream.
+    bool LoadPrefix(InputStream* input, size_t rows) override;
+
+    /// Loads column data from input stream.
+    bool LoadBody(InputStream* input, size_t rows) override;
+
+    /// Saves column prefix to output stream. Column types with prefixes must implement it.
+    void SavePrefix(OutputStream* output) override;
+
+    /// Saves column data to output stream.
+    void SaveBody(OutputStream* output) override;
+
+    /// Clear column data .
+    void Clear() override;
+
+    /// Returns count of rows in the column.
+    size_t Size() const override;
+
+    /// Makes slice of the current column.
+    ColumnRef Slice(size_t begin, size_t len) const override;
+    ColumnRef CloneEmpty() const override;
+    void Swap(Column& other) override;
+
+    ItemView GetItem(size_t index) const override;
+
+private:
+    std::shared_ptr<ColumnString> data_;
+};
+
+template <>
+inline void ColumnNullableT<ColumnJSON>::Append(std::optional<std::string_view> value) {
+    ColumnNullable::Append(!value.has_value());
+    if (value.has_value()) {
+        typed_nested_data_->Append(*value);
+    } else {
+        typed_nested_data_->Append(std::string_view("{}"));
+    }
+}
+
+}

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/lowcardinality.cpp

@@ -396,7 +396,8 @@ void ColumnLowCardinality::SavePrefix(OutputStream* output) {
 }
 
 void ColumnLowCardinality::SaveBody(OutputStream* output) {
-    const uint64_t index_serialization_type = indexTypeFromIndexColumn(*index_column_) | IndexFlag::HasAdditionalKeysBit;
+    const uint64_t index_serialization_type =
+        static_cast<uint64_t>(indexTypeFromIndexColumn(*index_column_)) | IndexFlag::HasAdditionalKeysBit;
     WireFormat::WriteFixed(*output, index_serialization_type);
 
     const uint64_t number_of_keys = dictionary_column_->Size();

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/string.cpp

@@ -136,8 +136,13 @@ struct ColumnString::Block
     std::string_view AppendUnsafe(std::string_view str) {
         const auto pos = &data_[size];
 
-        memcpy(pos, str.data(), str.size());
-        size += str.size();
+        // memcpy's source pointer is declared nonnull regardless of the
+        // size argument, so an empty string_view backed by std::string()
+        // (where data() may be null) trips UBSan on every empty append.
+        if (str.size() > 0) {
+            memcpy(pos, str.data(), str.size());
+            size += str.size();
+        }
 
         return std::string_view(pos, str.size());
     }

data/ext/clickhouse_native/vendor/clickhouse-cpp/clickhouse/columns/tuple.cpp

@@ -1,8 +1,9 @@
 #include "tuple.h"
 
 namespace clickhouse {
+namespace {
 
-static std::vector<TypeRef> CollectTypes(const std::vector<ColumnRef>& columns) {
+std::vector<TypeRef> CollectTypes(const std::vector<ColumnRef>& columns) {
     std::vector<TypeRef> types;
     for (const auto& col : columns) {
         types.push_back(col->Type());
@@ -10,12 +11,45 @@ static std::vector<TypeRef> CollectTypes(const std::vector<ColumnRef>& columns)
     return types;
 }
 
+/// Tuple types can be appended if they have the same shape.
+bool CanAppendType(const TypeRef& destination_type, const TypeRef& source_type) {
+    if (destination_type->GetCode() != Type::Tuple || source_type->GetCode() != Type::Tuple) {
+        return destination_type->IsEqual(source_type);
+    }
+
+    const auto* destination_tuple = destination_type->As<TupleType>();
+    const auto* source_tuple      = source_type->As<TupleType>();
+
+    const auto destination_item_types = destination_tuple->GetTupleType();
+    const auto source_item_types      = source_tuple->GetTupleType();
+    if (destination_item_types.size() != source_item_types.size()) {
+        return false;
+    }
+
+    for (size_t i = 0; i < destination_item_types.size(); ++i) {
+        if (!CanAppendType(destination_item_types[i], source_item_types[i])) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+}
+
 ColumnTuple::ColumnTuple(const std::vector<ColumnRef>& columns)
     : Column(Type::CreateTuple(CollectTypes(columns)))
     , columns_(columns)
 {
 }
 
+ColumnTuple::ColumnTuple(const std::vector<ColumnRef>& columns,
+                         std::vector<std::string> names)
+    : Column(Type::CreateTuple(CollectTypes(columns), std::move(names)))
+    , columns_(columns)
+{
+}
+
 size_t ColumnTuple::TupleSize() const {
     return columns_.size();
 }
@@ -23,11 +57,11 @@ size_t ColumnTuple::TupleSize() const {
 void ColumnTuple::Reserve(size_t new_cap) {
     for (auto& column : columns_) {
         column->Reserve(new_cap);
-    }  
+    }
 }
 
 void ColumnTuple::Append(ColumnRef column) {
-    if (!this->Type()->IsEqual(column->Type())) {
+    if (!CanAppendType(this->Type(), column->Type())) {
         throw ValidationError(
             "can't append column of type " + column->Type()->GetName() + " "
             "to column type " + this->Type()->GetName());
@@ -37,6 +71,7 @@ void ColumnTuple::Append(ColumnRef column) {
         columns_[ci]->Append((*source_tuple_column)[ci]);
     }
 }
+
 size_t ColumnTuple::Size() const {
     return columns_.empty() ? 0 : columns_[0]->Size();
 }
@@ -48,7 +83,11 @@ ColumnRef ColumnTuple::Slice(size_t begin, size_t len) const {
         sliced_columns.push_back(column->Slice(begin, len));
     }
 
-    return std::make_shared<ColumnTuple>(sliced_columns);
+    const auto& names = this->Type()->As<TupleType>()->GetItemNames();
+    if (names.empty()) {
+        return std::make_shared<ColumnTuple>(sliced_columns);
+    }
+    return std::make_shared<ColumnTuple>(sliced_columns, names);
 }
 
 ColumnRef ColumnTuple::CloneEmpty() const {
@@ -59,7 +98,11 @@ ColumnRef ColumnTuple::CloneEmpty() const {
         result_columns.push_back(column->CloneEmpty());
     }
 
-    return std::make_shared<ColumnTuple>(result_columns);
+    const auto& names = this->Type()->As<TupleType>()->GetItemNames();
+    if (names.empty()) {
+        return std::make_shared<ColumnTuple>(result_columns);
+    }
+    return std::make_shared<ColumnTuple>(result_columns, names);
 }
 
 bool ColumnTuple::LoadPrefix(InputStream* input, size_t rows) {