Antalya 26.1: bump to 26.1.4

ci/jobs/scripts/workflow_hooks/pr_body_check.py

@@ -60,6 +60,11 @@ def check_changelog_entry(category, pr_body: str) -> str:
     if not title or not body:
         print("WARNING: Failed to get PR title or body, read from environment")
         body = Info().pr_body
+        labels = Info().pr_labels
+
+    if "release" in labels or "release-lts" in labels:
+        print("NOTE: Release PR detected, skipping changelog entry check")
+        sys.exit(0)
 
     error, category = get_category(body)
     if error or not category:

ci/jobs/scripts/workflow_hooks/pr_labels_and_category.py

@@ -181,6 +181,9 @@ def check_labels(category, info):
 
 if __name__ == "__main__":
     info = Info()
+    if Labels.RELEASE in info.pr_labels or Labels.RELEASE_LTS in info.pr_labels:
+        print("NOTE: Release PR detected, skipping changelog category check")
+        sys.exit(0)
     error, category = get_category(info.pr_body)
     if not category or error:
         print(f"ERROR: {error}")

cmake/autogenerated_versions.txt

@@ -2,13 +2,13 @@
 
 # NOTE: VERSION_REVISION has nothing common with DBMS_TCP_PROTOCOL_VERSION,
 # only DBMS_TCP_PROTOCOL_VERSION should be incremented on protocol changes.
-SET(VERSION_REVISION 54508)
+SET(VERSION_REVISION 54509)
 SET(VERSION_MAJOR 26)
 SET(VERSION_MINOR 1)
-SET(VERSION_PATCH 3)
-SET(VERSION_GITHASH 53779390caa67a65a2368cdbb7533ed925608ba9)
-SET(VERSION_DESCRIBE v26.1.3.20001.altinityantalya)
-SET(VERSION_STRING 26.1.3.20001.altinityantalya)
+SET(VERSION_PATCH 4)
+SET(VERSION_GITHASH 5549f2acae95c6d627654f50e212a85d059a55f9)
+SET(VERSION_DESCRIBE v26.1.4.20001.altinityantalya)
+SET(VERSION_STRING 26.1.4.20001.altinityantalya)
 # end of autochange
 
 SET(VERSION_TWEAK 20001)

src/Access/IAccessStorage.cpp

@@ -547,7 +547,7 @@ std::optional<AuthResult> IAccessStorage::authenticateImpl(
     {
         if (auto user = tryRead<User>(*id))
         {
-            AuthResult auth_result { .user_id = *id };
+            AuthResult auth_result { .user_id = *id, .user_name = credentials.getUserName() };
             if (!isAddressAllowed(*user, address))
                 throwAddressNotAllowed(address);
 

src/Access/IAccessStorage.h

@@ -33,6 +33,9 @@ struct AuthResult
     /// Session settings received from authentication server (if any)
     SettingsChanges settings{};
     AuthenticationData authentication_data {};
+    /// Username determined by the access storage during authentication,
+    /// should be treated as the authenticated user name
+    String user_name;
 };
 
 /// Contains entities, i.e. instances of classes derived from IAccessEntity.

src/Access/LDAPAccessStorage.cpp

@@ -490,7 +490,7 @@ std::optional<AuthResult> LDAPAccessStorage::authenticateImpl(
     }
 
     if (id)
-        return AuthResult{ .user_id = *id, .authentication_data = AuthenticationData(AuthenticationType::LDAP) };
+        return AuthResult{ .user_id = *id, .authentication_data = AuthenticationData(AuthenticationType::LDAP), .user_name = credentials.getUserName() };
     return std::nullopt;
 }
 

src/Access/TokenAccessStorage.cpp

@@ -583,7 +583,7 @@ std::optional<AuthResult> TokenAccessStorage::authenticateImpl(
     }
 
     if (id)
-        return AuthResult{ .user_id = *id, .authentication_data = AuthenticationData(AuthenticationType::JWT) };
+        return AuthResult{ .user_id = *id, .authentication_data = AuthenticationData(AuthenticationType::JWT), .user_name = credentials.getUserName()  };
     return std::nullopt;
 }
 

src/Analyzer/Passes/FunctionToSubcolumnsPass.cpp

@@ -366,6 +366,18 @@ std::map<std::pair<TypeIndex, String>, NodeToSubcolumnTransformer> node_transfor
             NameAndTypePair column{ctx.column.name + ".null", std::make_shared<DataTypeUInt8>()};
             if (sourceHasColumn(ctx.column_source, column.name) || !canOptimizeToSubcolumn(ctx.column_source, column.name))
                 return;
+
+            /// For nested Nullable types (e.g. Nullable(Tuple(... Nullable(T) ...))),
+            /// the .null subcolumn in storage is Nullable(UInt8), not UInt8.
+            /// Using it with a hardcoded UInt8 type causes a type mismatch at runtime.
+            if (auto * table_node = ctx.column_source->as<TableNode>())
+            {
+                auto actual = table_node->getStorageSnapshot()->tryGetColumn(
+                    GetColumnsOptions(GetColumnsOptions::All).withRegularSubcolumns(), column.name);
+                if (actual && actual->type->isNullable())
+                    return;
+            }
+
             node = std::make_shared<ColumnNode>(column, ctx.column_source);
         },
     },
@@ -377,6 +389,16 @@ std::map<std::pair<TypeIndex, String>, NodeToSubcolumnTransformer> node_transfor
             NameAndTypePair column{ctx.column.name + ".null", std::make_shared<DataTypeUInt8>()};
             if (sourceHasColumn(ctx.column_source, column.name) || !canOptimizeToSubcolumn(ctx.column_source, column.name))
                 return;
+
+            /// Same guard as isNull above: nested Nullable .null subcolumn may itself be Nullable.
+            if (auto * table_node = ctx.column_source->as<TableNode>())
+            {
+                auto actual = table_node->getStorageSnapshot()->tryGetColumn(
+                    GetColumnsOptions(GetColumnsOptions::All).withRegularSubcolumns(), column.name);
+                if (actual && actual->type->isNullable())
+                    return;
+            }
+
             auto & function_arguments_nodes = function_node.getArguments().getNodes();
 
             function_arguments_nodes = {std::make_shared<ColumnNode>(column, ctx.column_source)};

src/Analyzer/Passes/InverseDictionaryLookupPass.cpp

@@ -15,6 +15,8 @@
 
 #include <Functions/FunctionsExternalDictionaries.h>
 
+#include <Access/ContextAccess.h>
+#include <Access/Common/AccessType.h>
 #include <Core/Settings.h>
 #include <Common/typeid_cast.h>
 
@@ -140,6 +142,12 @@ class InverseDictionaryLookupVisitor : public InDepthQueryTreeVisitorWithContext
         if (getSettings()[Setting::rewrite_in_to_join])
             return;
 
+        /// This rewrite turns `dictGet(...)` predicates into `IN (SELECT ... FROM dictionary(...))`.
+        /// The `dictionary()` table function requires `CREATE TEMPORARY TABLE`; if that grant is missing,
+        /// skip the optimization to avoid `ACCESS_DENIED`.
+        if (!getContext()->getAccess()->isGranted(AccessType::CREATE_TEMPORARY_TABLE))
+            return;
+
         auto * node_function = node->as<FunctionNode>();
 
         if (!node_function)

src/Columns/ColumnConst.h

@@ -122,11 +122,12 @@ class ColumnConst final : public COWHelper<IColumnHelper<ColumnConst>, ColumnCon
     }
 
 #if !defined(DEBUG_OR_SANITIZER_BUILD)
-    void insertRangeFrom(const IColumn &, size_t /*start*/, size_t length) override
+    void insertRangeFrom(const IColumn & src, size_t /*start*/, size_t length) override
 #else
-    void doInsertRangeFrom(const IColumn &, size_t /*start*/, size_t length) override
+    void doInsertRangeFrom(const IColumn & src, size_t /*start*/, size_t length) override
 #endif
     {
+        chassert(!typeid_cast<const ColumnConst *>(&src) || data->compareAt(0, 0, *typeid_cast<const ColumnConst &>(src).data, -1) == 0);
         s += length;
     }
 

src/Columns/ColumnDynamic.h

@@ -228,7 +228,7 @@ class ColumnDynamic final : public COWHelper<IColumnHelper<ColumnDynamic>, Colum
 
     ColumnPtr permute(const Permutation & perm, size_t limit) const override
     {
-        return create(variant_column_ptr->permute(perm, limit), variant_info, max_dynamic_types, global_max_dynamic_types);
+        return create(variant_column_ptr->permute(perm, limit), variant_info, max_dynamic_types, global_max_dynamic_types, statistics);
     }
 
     ColumnPtr index(const IColumn & indexes, size_t limit) const override
@@ -332,6 +332,12 @@ class ColumnDynamic final : public COWHelper<IColumnHelper<ColumnDynamic>, Colum
 
     void forEachSubcolumn(ColumnCallback callback) const override { callback(variant_column); }
 
+    /// Dynamic columns manage their own variant_info type metadata.
+    /// The default convertToFullIfNeeded recurses into subcolumns and strips LowCardinality
+    /// from variant columns, but cannot update variant_info, creating column/type mismatches.
+    /// Override to skip recursion — Dynamic is a self-contained typed container.
+    [[nodiscard]] IColumn::Ptr convertToFullIfNeeded() const override { return getPtr(); }
+
     void forEachMutableSubcolumnRecursively(RecursiveMutableColumnCallback callback) override
     {
         callback(*variant_column);

src/Columns/ColumnLowCardinality.cpp

@@ -287,6 +287,11 @@ char * ColumnLowCardinality::serializeValueIntoMemory(size_t n, char * memory, c
     return getDictionary().serializeValueIntoMemory(getIndexes().getUInt(n), memory, settings);
 }
 
+std::optional<size_t> ColumnLowCardinality::getSerializedValueSize(size_t n, const IColumn::SerializationSettings * settings) const
+{
+    return getDictionary().getSerializedValueSize(getIndexes().getUInt(n), settings);
+}
+
 void ColumnLowCardinality::collectSerializedValueSizes(PaddedPODArray<UInt64> & sizes, const UInt8 * is_null, const IColumn::SerializationSettings * settings) const
 {
     /// nullable is handled internally.

src/Columns/ColumnLowCardinality.h

@@ -105,6 +105,8 @@ class ColumnLowCardinality final : public COWHelper<IColumnHelper<ColumnLowCardi
     std::string_view serializeValueIntoArena(size_t n, Arena & arena, char const *& begin, const IColumn::SerializationSettings * settings) const override;
     char * serializeValueIntoMemory(size_t n, char * memory, const IColumn::SerializationSettings * settings) const override;
 
+    std::optional<size_t> getSerializedValueSize(size_t n, const IColumn::SerializationSettings * settings) const override;
+
     void collectSerializedValueSizes(PaddedPODArray<UInt64> & sizes, const UInt8 * is_null, const IColumn::SerializationSettings * settings) const override;
 
     void deserializeAndInsertFromArena(ReadBuffer & in, const IColumn::SerializationSettings * settings) override;

src/Columns/ColumnObject.cpp

@@ -1213,7 +1213,7 @@ ColumnPtr ColumnObject::permute(const Permutation & perm, size_t limit) const
         permuted_dynamic_paths[path] = column->permute(perm, limit);
 
     auto permuted_shared_data = shared_data->permute(perm, limit);
-    return ColumnObject::create(permuted_typed_paths, permuted_dynamic_paths, permuted_shared_data, max_dynamic_paths, global_max_dynamic_paths, max_dynamic_types);
+    return ColumnObject::create(permuted_typed_paths, permuted_dynamic_paths, permuted_shared_data, max_dynamic_paths, global_max_dynamic_paths, max_dynamic_types, statistics);
 }
 
 ColumnPtr ColumnObject::index(const IColumn & indexes, size_t limit) const

src/Columns/ColumnUnique.h

@@ -90,6 +90,7 @@ class ColumnUnique final : public COWHelper<IColumnUnique, ColumnUnique<ColumnTy
     bool getBool(size_t n) const override { return getNestedColumn()->getBool(n); }
     bool isNullAt(size_t n) const override { return is_nullable && n == getNullValueIndex(); }
     void collectSerializedValueSizes(PaddedPODArray<UInt64> & sizes, const UInt8 * is_null, const IColumn::SerializationSettings * settings) const override;
+    std::optional<size_t> getSerializedValueSize(size_t n, const IColumn::SerializationSettings * settings) const override;
     std::string_view serializeValueIntoArena(size_t n, Arena & arena, char const *& begin, const IColumn::SerializationSettings * settings) const override;
     char * serializeValueIntoMemory(size_t n, char * memory, const IColumn::SerializationSettings * settings) const override;
     void skipSerializedInArena(ReadBuffer & in) const override;
@@ -456,6 +457,22 @@ void ColumnUnique<ColumnType>::collectSerializedValueSizes(PaddedPODArray<UInt64
         column_holder->collectSerializedValueSizes(sizes, nullptr, settings);
 }
 
+template <typename ColumnType>
+std::optional<size_t> ColumnUnique<ColumnType>::getSerializedValueSize(
+    size_t n, const IColumn::SerializationSettings * settings) const
+{
+    if (is_nullable)
+    {
+        if (n == getNullValueIndex())
+            return 1;
+        auto nested_size = column_holder->getSerializedValueSize(n, settings);
+        if (!nested_size)
+            return std::nullopt;
+        return 1 + *nested_size;
+    }
+    return column_holder->getSerializedValueSize(n, settings);
+}
+
 template <typename ColumnType>
 std::string_view ColumnUnique<ColumnType>::serializeValueIntoArena(
     size_t n, Arena & arena, char const *& begin, const IColumn::SerializationSettings * settings) const

src/Columns/ColumnVariant.cpp

@@ -215,6 +215,8 @@ ColumnVariant::ColumnVariant(DB::MutableColumnPtr local_discriminators_, DB::Mut
             global_to_local_discriminators[local_to_global_discriminators[i]] = i;
         }
     }
+
+    validateState();
 }
 
 namespace
@@ -1840,5 +1842,35 @@ void ColumnVariant::fixDynamicStructure()
         variant->fixDynamicStructure();
 }
 
+void ColumnVariant::validateState() const
+{
+    const auto & local_discriminators_data = getLocalDiscriminators();
+    const auto & offsets_data = getOffsets();
+    if (local_discriminators_data.size() != offsets_data.size())
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Size of discriminators and offsets should be equal, but {} and {} were given", local_discriminators_data.size(), offsets_data.size());
+
+    std::vector<size_t> actual_variant_sizes(variants.size());
+    for (size_t i = 0; i != variants.size(); ++i)
+        actual_variant_sizes[i] = variants[i]->size();
+
+    std::vector<size_t> expected_variant_sizes(variants.size(), 0);
+    for (size_t i = 0; i != local_discriminators_data.size(); ++i)
+    {
+        auto local_discr = local_discriminators_data[i];
+        if (local_discr != NULL_DISCRIMINATOR)
+        {
+            ++expected_variant_sizes[local_discr];
+            if (offsets_data[i] >= actual_variant_sizes[local_discr])
+                throw Exception(ErrorCodes::LOGICAL_ERROR, "Offset at position {} is {}, but variant {} ({}) has size {}", i, offsets_data[i], static_cast<UInt32>(local_discr), variants[local_discr]->getName(), variants[local_discr]->size());
+        }
+    }
+
+    for (size_t i = 0; i != variants.size(); ++i)
+    {
+        if (variants[i]->size() != expected_variant_sizes[i])
+            throw Exception(ErrorCodes::LOGICAL_ERROR, "Variant {} ({}) has size {}, but expected {}", i, variants[i]->getName(), variants[i]->size(), expected_variant_sizes[i]);
+    }
+}
+
 
 }

src/Columns/ColumnVariant.h

@@ -260,6 +260,12 @@ class ColumnVariant final : public COWHelper<IColumnHelper<ColumnVariant>, Colum
     void forEachMutableSubcolumnRecursively(RecursiveMutableColumnCallback callback) override;
     void forEachSubcolumn(ColumnCallback callback) const override;
     void forEachSubcolumnRecursively(RecursiveColumnCallback callback) const override;
+
+    /// Variant columns pair variant sub-columns with DataTypeVariant's sorted type list.
+    /// The default convertToFullIfNeeded recurses into sub-columns and strips LowCardinality
+    /// from variant columns, but cannot update the corresponding DataTypeVariant, creating
+    /// column/type position mismatches. Override to skip recursion.
+    [[nodiscard]] IColumn::Ptr convertToFullIfNeeded() const override { return getPtr(); }
     bool structureEquals(const IColumn & rhs) const override;
     ColumnPtr compress(bool force_compression) const override;
     double getRatioOfDefaultRows(double sample_ratio) const override;
@@ -348,6 +354,8 @@ class ColumnVariant final : public COWHelper<IColumnHelper<ColumnVariant>, Colum
     void takeDynamicStructureFromColumn(const ColumnPtr & source_column) override;
     void fixDynamicStructure() override;
 
+    void validateState() const;
+
 private:
     void insertFromImpl(const IColumn & src_, size_t n, const std::vector<ColumnVariant::Discriminator> * global_discriminators_mapping);
     void insertRangeFromImpl(const IColumn & src_, size_t start, size_t length, const std::vector<ColumnVariant::Discriminator> * global_discriminators_mapping, const Discriminator * skip_discriminator);

src/Columns/IColumn.h

@@ -130,7 +130,32 @@ class IColumn : public COW<IColumn>
 
     [[nodiscard]] virtual Ptr convertToFullIfNeeded() const
     {
-        return convertToFullColumnIfConst()->convertToFullColumnIfReplicated()->convertToFullColumnIfSparse()->convertToFullColumnIfLowCardinality();
+        Ptr converted = convertToFullColumnIfConst()
+            ->convertToFullColumnIfReplicated()
+            ->convertToFullColumnIfSparse()
+            ->convertToFullColumnIfLowCardinality();
+
+        Columns new_subcolumns;
+        bool any_changed = false;
+
+        converted->forEachSubcolumn([&](const WrappedPtr & subcolumn)
+        {
+            auto new_sub = subcolumn->convertToFullIfNeeded();
+            any_changed |= (new_sub.get() != subcolumn.get());
+            new_subcolumns.push_back(std::move(new_sub));
+        });
+
+        if (!any_changed)
+            return converted;
+
+        auto mutable_column = IColumn::mutate(std::move(converted));
+        size_t i = 0;
+        mutable_column->forEachMutableSubcolumn([&](WrappedPtr & subcolumn)
+        {
+            subcolumn = std::move(new_subcolumns[i++]);
+        });
+
+        return std::move(mutable_column);
     }
 
     /// Creates empty column with the same type.

src/Common/ZooKeeper/ZooKeeperImpl.cpp

@@ -809,6 +809,15 @@ void ZooKeeper::sendThread()
                         HistogramMetrics::KeeperClientQueueDuration,
                         std::chrono::duration_cast<std::chrono::milliseconds>(dequeue_ts - info.request->enqueue_ts).count());
 
+                    if (info.watch)
+                        info.request->has_watch = true;
+
+                    if (info.request->add_root_path)
+                        info.request->addRootPath(args.chroot);
+
+                    /// Insert into operations AFTER mutating the request (has_watch, addRootPath)
+                    /// to avoid a data race: receiveThread reads from operations concurrently,
+                    /// and the request object is shared via shared_ptr.
                     if (info.request->xid != close_xid)
                     {
                         CurrentMetrics::add(CurrentMetrics::ZooKeeperRequest);
@@ -817,17 +826,11 @@ void ZooKeeper::sendThread()
                         operations[info.request->xid] = info;
                     }
 
-                    if (info.watch)
-                        info.request->has_watch = true;
-
                     if (requests_queue.isFinished())
                     {
                         break;
                     }
 
-                    if (info.request->add_root_path)
-                        info.request->addRootPath(args.chroot);
-
                     info.request->probably_sent = true;
                     info.request->write(getWriteBuffer(), use_xid_64);
                     flushWriteBuffer();

src/Common/setThreadName.h

@@ -65,6 +65,7 @@ namespace DB
     M(HASHED_DICT_DTOR, "HashedDictDtor") \
     M(HASHED_DICT_LOAD, "HashedDictLoad") \
     M(HTTP_HANDLER, "HTTPHandler") \
+    M(ICEBERG_ITERATOR, "IcebergIter") \
     M(INTERSERVER_HANDLER, "IntersrvHandler") \
     M(IO_URING_MONITOR, "IoUringMonitr") \
     M(KEEPER_HANDLER, "KeeperHandler") \

src/Coordination/KeeperContext.cpp

@@ -204,7 +204,7 @@ bool diskValidator(const Poco::Util::AbstractConfiguration & config, const std::
     {
         "s3"sv,
         "s3_plain"sv,
-        "local"sv
+        "local"sv,
     };
 
     if (std::all_of(

src/Core/BaseSettings.h

@@ -605,6 +605,10 @@ void BaseSettings<TTraits>::readBinary(ReadBuffer & in)
         size_t index = accessor.find(name);
 
         std::ignore = BaseSettingsHelpers::readFlags(in);
+
+        if (index == static_cast<size_t>(-1))
+            BaseSettingsHelpers::throwSettingNotFound(name);
+
         accessor.readBinary(*this, index, in);
     }
 }