Merge pull request ClickHouse#80596 from ClickHouse/fix-const-tuple

Fix analyzer: constant tuple in distributed query should use CAST.

Author: yakov-olkhovskiy

src/Analyzer/ConstantNode.cpp

@@ -55,58 +55,10 @@ String ConstantNode::getValueStringRepresentation() const
     return applyVisitor(FieldVisitorToString(), getValue());
 }
 
-bool ConstantNode::requiresCastCall(Field::Types::Which type, const DataTypePtr & field_type, const DataTypePtr & data_type)
-{
-    bool need_to_add_cast_function = false;
-    WhichDataType constant_value_type(data_type);
-
-    switch (type)
-    {
-        case Field::Types::String:
-        {
-            need_to_add_cast_function = !constant_value_type.isString();
-            break;
-        }
-        case Field::Types::UInt64:
-        case Field::Types::Int64:
-        case Field::Types::Float64:
-        {
-            WhichDataType constant_value_field_type(field_type);
-            need_to_add_cast_function = constant_value_field_type.idx != constant_value_type.idx;
-            break;
-        }
-        case Field::Types::Int128:
-        case Field::Types::UInt128:
-        case Field::Types::Int256:
-        case Field::Types::UInt256:
-        case Field::Types::Decimal32:
-        case Field::Types::Decimal64:
-        case Field::Types::Decimal128:
-        case Field::Types::Decimal256:
-        case Field::Types::AggregateFunctionState:
-        case Field::Types::Array:
-        case Field::Types::Tuple:
-        case Field::Types::Map:
-        case Field::Types::UUID:
-        case Field::Types::Bool:
-        case Field::Types::Object:
-        case Field::Types::IPv4:
-        case Field::Types::IPv6:
-        case Field::Types::Null:
-        case Field::Types::CustomType:
-        {
-            need_to_add_cast_function = true;
-            break;
-        }
-    }
-
-    return need_to_add_cast_function;
-}
-
 bool ConstantNode::requiresCastCall(const DataTypePtr & field_type, const DataTypePtr & data_type)
 {
     WhichDataType which_field_type(field_type);
-    if (which_field_type.isNullable() || which_field_type.isArray())
+    if (which_field_type.isNullable() || which_field_type.isArray() || which_field_type.isTuple())
         return true;
 
     return field_type->getTypeId() != data_type->getTypeId();
@@ -203,21 +155,29 @@ ASTPtr ConstantNode::toASTImpl(const ConvertToASTOptions & options) const
         return std::make_shared<ASTLiteral>(getFieldFromColumnForASTLiteral(constant_value.getColumn(), 0, constant_value.getType()));
 
     const auto & constant_value_type = constant_value.getType();
-    auto constant_value_ast = std::make_shared<ASTLiteral>(getValue());
 
     // Add cast if constant was created as a result of constant folding.
     // Constant folding may lead to type transformation and literal on shard
     // may have a different type.
-    if (source_expression != nullptr || requiresCastCall(constant_value_ast->value.getType(), applyVisitor(FieldToDataType(), constant_value_ast->value), getResultType()))
+
+    auto requires_cast = [this]()
+    {
+        const auto & [_, type] = getValueNameAndType();
+        return requiresCastCall(type, getResultType());
+    };
+
+    if (source_expression != nullptr || requires_cast())
     {
         /// For some types we cannot just get a field from a column, because it can loose type information during serialization/deserialization of the literal.
         /// For example, DateTime64 will return Field with Decimal64 and we won't be able to parse it to DateTine64 back in some cases.
         /// Also for Dynamic and Object types we can loose types information, so we need to create a Field carefully.
-        constant_value_ast = std::make_shared<ASTLiteral>(getFieldFromColumnForASTLiteral(constant_value.getColumn(), 0, constant_value.getType()));
+        auto constant_value_ast = std::make_shared<ASTLiteral>(getFieldFromColumnForASTLiteral(constant_value.getColumn(), 0, constant_value.getType()));
         auto constant_type_name_ast = std::make_shared<ASTLiteral>(constant_value_type->getName());
         return makeASTFunction("_CAST", std::move(constant_value_ast), std::move(constant_type_name_ast));
     }
 
+    auto constant_value_ast = std::make_shared<ASTLiteral>(getValue());
+
     if (isBool(constant_value_type))
         constant_value_ast->custom_type = constant_value_type;
 

src/Analyzer/ConstantNode.h

@@ -91,7 +91,6 @@ class ConstantNode final : public IQueryTreeNode
     }
 
     /// Check if conversion to AST requires wrapping with _CAST function.
-    static bool requiresCastCall(Field::Types::Which type, const DataTypePtr & field_type, const DataTypePtr & data_type);
     static bool requiresCastCall(const DataTypePtr & field_type, const DataTypePtr & data_type);
 
     /// Check if constant is a result of _CAST function constant folding.

tests/queries/0_stateless/03519_analyzer_tuple_cast.reference

@@ -0,0 +1,9 @@
+2	(-9,0)
+2	(-8,1)
+2	{1:1}
+2	{1:2}
+(1,2)
+(3,4)
+(1,2)
+(1,2)
+1	('dete','ok')	('dete','ok')

tests/queries/0_stateless/03519_analyzer_tuple_cast.sql

@@ -0,0 +1,17 @@
+set enable_analyzer=1;
+
+DROP TABLE IF EXISTS test, src;
+
+SELECT count(), plus((-9, 0), (number,  number)) AS k FROM remote('127.0.0.{3,2}', numbers(2)) GROUP BY k ORDER BY k;
+SELECT count(), mapAdd(map(1::UInt128, 1), map(1::UInt128 ,number)) AS k FROM remote('127.0.0.{3,2}', numbers(2)) GROUP BY k ORDER BY k;
+
+CREATE TABLE test (s String) ORDER BY ();
+INSERT INTO test VALUES ('a'), ('b');
+SELECT transform(s, ['a', 'b'], [(1, 2), (3, 4)], (0, 0)) AS k FROM test ORDER BY k;
+SELECT s != '' ? (1,2) : (0,0) AS k FROM test ORDER BY k;
+
+CREATE TABLE src (id UInt32, type String, data String) ENGINE=MergeTree ORDER BY tuple();
+INSERT INTO src VALUES (1, 'ok', 'data');
+SELECT id, tuple(replaceAll(data, 'a', 'e') AS col_a, type) AS a, tuple(replaceAll(data, 'a', 'e') AS col_b, type) AS b FROM src;
+
+DROP TABLE IF EXISTS test, src;