Fuzzing-related fixes

programs/client/Client.cpp

@@ -1054,6 +1054,10 @@ private:
                     auto base_before_fuzz = fuzz_base->formatForErrorMessage();
 
                     ast_to_process = fuzz_base->clone();
+
+                    std::stringstream dump_of_cloned_ast;
+                    ast_to_process->dumpTree(dump_of_cloned_ast);
+
                     fuzzer.fuzzMain(ast_to_process);
 
                     auto base_after_fuzz = fuzz_base->formatForErrorMessage();
@@ -1066,6 +1070,8 @@ private:
                             base_after_fuzz.c_str());
                         fprintf(stderr, "dump before fuzz:\n%s\n",
                             dump_before_fuzz.str().c_str());
+                        fprintf(stderr, "dump of cloned ast:\n%s\n",
+                            dump_of_cloned_ast.str().c_str());
                         fprintf(stderr, "dump after fuzz:\n");
                         fuzz_base->dumpTree(std::cerr);
                         assert(false);

src/Functions/FunctionBinaryArithmetic.h

@@ -1096,8 +1096,10 @@ public:
             return;
         }
 
-        auto * left_generic = block.getByPosition(arguments[0]).type.get();
-        auto * right_generic = block.getByPosition(arguments[1]).type.get();
+        const auto & left_argument = block.getByPosition(arguments[0]);
+        const auto & right_argument = block.getByPosition(arguments[1]);
+        auto * left_generic = left_argument.type.get();
+        auto * right_generic = right_argument.type.get();
         bool valid = castBothTypes(left_generic, right_generic, [&](const auto & left, const auto & right)
         {
             using LeftDataType = std::decay_t<decltype(left)>;
@@ -1112,8 +1114,17 @@ public:
             else
                 return executeNumeric(block, arguments, result, left, right);
         });
+
         if (!valid)
-            throw Exception(getName() + "'s arguments do not match the expected data types", ErrorCodes::LOGICAL_ERROR);
+        {
+            // This is a logical error, because the types should have been checked
+            // by getReturnTypeImpl().
+            throw Exception(ErrorCodes::LOGICAL_ERROR,
+                "Arguments of '{}' have incorrect data types: '{}' of type '{}',"
+                " '{}' of type '{}'", getName(),
+                left_argument.name, left_argument.type->getName(),
+                right_argument.name, right_argument.type->getName());
+        }
     }
 
 #if USE_EMBEDDED_COMPILER

src/Parsers/ASTNameTypePair.cpp

@@ -12,7 +12,7 @@ ASTPtr ASTNameTypePair::clone() const
 
     if (type)
     {
-        res->type = type;
+        res->type = type->clone();
         res->children.push_back(res->type);
     }
 

src/Storages/StorageBuffer.cpp

@@ -50,6 +50,7 @@ namespace DB
 
 namespace ErrorCodes
 {
+    extern const int BAD_ARGUMENTS;
     extern const int NOT_IMPLEMENTED;
     extern const int LOGICAL_ERROR;
     extern const int INFINITE_LOOP;
@@ -842,9 +843,22 @@ void registerStorageBuffer(StorageFactory & factory)
                 " destination_database, destination_table, num_buckets, min_time, max_time, min_rows, max_rows, min_bytes, max_bytes.",
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
+        // Table and database name arguments accept expressions, evaluate them.
         engine_args[0] = evaluateConstantExpressionForDatabaseName(engine_args[0], args.local_context);
         engine_args[1] = evaluateConstantExpressionOrIdentifierAsLiteral(engine_args[1], args.local_context);
 
+        // After we evaluated all expressions, check that all arguments are
+        // literals.
+        for (size_t i = 0; i < 9; i++)
+        {
+            if (!typeid_cast<ASTLiteral *>(engine_args[i].get()))
+            {
+                throw Exception(ErrorCodes::BAD_ARGUMENTS,
+                    "Storae Buffer expects a literal as an argument #{}, got '{}'"
+                    " instead", i, engine_args[i]->formatForErrorMessage());
+            }
+        }
+
         String destination_database = engine_args[0]->as<ASTLiteral &>().value.safeGet<String>();
         String destination_table = engine_args[1]->as<ASTLiteral &>().value.safeGet<String>();