Merge pull request #2285 from Altinity/mkmkme/antalya-25.7/hybrid-restart

Antalya 25.8 hybrid: resolve currentDatabase() in hybrid segment metadata

Author: zvonand

src/Storages/StorageDistributed.cpp

@@ -16,6 +16,8 @@
 
 #include <Disks/IVolume.h>
 
+#include <Functions/FunctionFactory.h>
+
 #include <Storages/Distributed/DistributedSettings.h>
 #include <Storages/Distributed/DistributedSink.h>
 #include <Storages/StorageFactory.h>
@@ -161,7 +163,8 @@ void replaceCurrentDatabaseFunction(ASTPtr & ast, const ContextPtr & context)
 
     if (auto * func = ast->as<ASTFunction>())
     {
-        if (func->name == "currentDatabase")
+        /// `currentDatabase` is reachable through its aliases, so get a canonical name
+        if (getFunctionCanonicalNameIfAny(func->name) == "currentDatabase")
         {
             ast = evaluateConstantExpressionForDatabaseName(ast, context);
             return;
@@ -2699,12 +2702,12 @@ void registerStorageHybrid(StorageFactory & factory)
                                     "Argument #{}: additional table function must be a valid table function, got: {}", i, func->name);
                 }
 
-                // Normalize arguments (evaluate `currentDatabase()`, expand named collections, etc.).
-                // TableFunctionFactory::get mutates the AST in-place inside TableFunctionRemote::parseArguments.
-                ASTPtr normalized_table_function_ast = table_function_ast->clone();
+                // Evaluate `currentDatabase()` on the original argument, since that one is serialized to metadata.
+                // The clone is for TableFunctionFactory::get, which mutates the AST in-place inside TableFunctionRemote::parseArguments.
+                replaceCurrentDatabaseFunction(engine_args[i], local_context);
+                ASTPtr normalized_table_function_ast = engine_args[i]->clone();
                 auto additional_table_function = TableFunctionFactory::instance().get(normalized_table_function_ast, local_context);
                 ColumnsDescription segment_columns = additional_table_function->getActualTableStructure(local_context, true);
-                replaceCurrentDatabaseFunction(normalized_table_function_ast, local_context);
 
                 validate_segment_schema(segment_columns, normalized_table_function_ast->formatForLogging());
 

tests/queries/0_stateless/04302_hybrid_current_database_reattach.reference

@@ -0,0 +1,4 @@
+4
+4
+4
+4

tests/queries/0_stateless/04302_hybrid_current_database_reattach.sql

@@ -0,0 +1,48 @@
+-- Reproduce the Hybrid currentDatabase() metadata bug without a server restart.
+-- Detaching the table and re-attaching it while a different database is current
+-- mimics the missing session-database context that startup ATTACH has. Before the
+-- fix the stored metadata keeps currentDatabase(), which then resolves to the wrong
+-- database and the segment fails to attach with UNKNOWN_TABLE.
+
+SET allow_experimental_hybrid_table = 1;
+
+CREATE TABLE {CLICKHOUSE_DATABASE:Identifier}.local_hot (ts DateTime, value UInt64) ENGINE = MergeTree ORDER BY ts;
+CREATE TABLE {CLICKHOUSE_DATABASE:Identifier}.local_cold (ts DateTime, value UInt64) ENGINE = MergeTree ORDER BY ts;
+INSERT INTO {CLICKHOUSE_DATABASE:Identifier}.local_hot VALUES ('2025-10-15', 1), ('2025-11-01', 2);
+INSERT INTO {CLICKHOUSE_DATABASE:Identifier}.local_cold VALUES ('2025-08-01', 3), ('2025-06-15', 4);
+
+-- Create with the test database as current so currentDatabase() resolves to it.
+USE {CLICKHOUSE_DATABASE:Identifier};
+CREATE TABLE {CLICKHOUSE_DATABASE:Identifier}.hybrid_t (ts DateTime, value UInt64)
+ENGINE = Hybrid(
+    remote('localhost:9000', {CLICKHOUSE_DATABASE:String}, 'local_hot'), ts > '2025-09-01',
+    remote('localhost:9000', currentDatabase(), 'local_cold'), ts <= '2025-09-01'
+);
+
+SELECT count() FROM {CLICKHOUSE_DATABASE:Identifier}.hybrid_t;
+
+-- Same table through the DATABASE() alias of currentDatabase(): the metadata rewrite
+-- has to canonicalize the function name instead of comparing it literally.
+CREATE TABLE {CLICKHOUSE_DATABASE:Identifier}.hybrid_alias_t (ts DateTime, value UInt64)
+ENGINE = Hybrid(
+    remote('localhost:9000', {CLICKHOUSE_DATABASE:String}, 'local_hot'), ts > '2025-09-01',
+    remote('localhost:9000', DATABASE(), 'local_cold'), ts <= '2025-09-01'
+);
+
+SELECT count() FROM {CLICKHOUSE_DATABASE:Identifier}.hybrid_alias_t;
+
+-- Detach, switch the current database, then re-attach. currentDatabase() in the
+-- stored metadata now resolves against the other database, whose local_cold does
+-- not exist. With the fix the metadata holds the resolved name, so this succeeds.
+DETACH TABLE {CLICKHOUSE_DATABASE:Identifier}.hybrid_t;
+DETACH TABLE {CLICKHOUSE_DATABASE:Identifier}.hybrid_alias_t;
+CREATE DATABASE IF NOT EXISTS {CLICKHOUSE_DATABASE_1:Identifier};
+USE {CLICKHOUSE_DATABASE_1:Identifier};
+ATTACH TABLE {CLICKHOUSE_DATABASE:Identifier}.hybrid_t;
+ATTACH TABLE {CLICKHOUSE_DATABASE:Identifier}.hybrid_alias_t;
+
+SELECT count() FROM {CLICKHOUSE_DATABASE:Identifier}.hybrid_t;
+SELECT count() FROM {CLICKHOUSE_DATABASE:Identifier}.hybrid_alias_t;
+
+USE {CLICKHOUSE_DATABASE:Identifier};
+DROP DATABASE {CLICKHOUSE_DATABASE_1:Identifier};