Merge pull request ClickHouse#77415 from PedroTadim/buzzhouse-update

Next BuzzHouse update

Author: PedroTadim

programs/client/FuzzLoop.cpp

@@ -454,79 +454,7 @@ bool Client::buzzHouse()
         UNUSED(v);
 
         outf << "--Session seed: " << rg.getSeed() << std::endl;
-        DB::Strings defaultSettings
-            = {"engine_file_truncate_on_insert",
-               "allow_aggregate_partitions_independently",
-               "allow_archive_path_syntax",
-               "allow_asynchronous_read_from_io_pool_for_merge_tree",
-               "allow_changing_replica_until_first_data_packet",
-               "allow_create_index_without_type",
-               "allow_custom_error_code_in_throwif",
-               "allow_ddl",
-               "allow_deprecated_database_ordinary",
-               "allow_deprecated_error_prone_window_functions",
-               "allow_deprecated_snowflake_conversion_functions",
-               "allow_deprecated_syntax_for_merge_tree",
-               "allow_distributed_ddl",
-               "allow_drop_detached",
-               "allow_execute_multiif_columnar",
-               "allow_experimental_analyzer",
-               "allow_experimental_codecs",
-               "allow_experimental_database_materialized_mysql",
-               "allow_experimental_database_materialized_postgresql",
-               "allow_experimental_dynamic_type",
-               "allow_experimental_full_text_index",
-               "allow_experimental_funnel_functions",
-               "allow_experimental_hash_functions",
-               "allow_experimental_inverted_index",
-               "allow_experimental_join_right_table_sorting",
-               "allow_experimental_json_type",
-               "allow_experimental_kafka_offsets_storage_in_keeper",
-               "allow_experimental_live_view",
-               "allow_experimental_materialized_postgresql_table",
-               "allow_experimental_nlp_functions",
-               "allow_experimental_parallel_reading_from_replicas",
-               "allow_experimental_query_deduplication",
-               "allow_experimental_shared_set_join",
-               "allow_experimental_statistics",
-               "allow_experimental_time_series_table",
-               "allow_experimental_variant_type",
-               "allow_experimental_vector_similarity_index",
-               "allow_experimental_window_view",
-               "allow_get_client_http_header",
-               "allow_hyperscan",
-               "allow_introspection_functions",
-               "allow_materialized_view_with_bad_select",
-               "allow_named_collection_override_by_default",
-               "allow_non_metadata_alters",
-               "allow_nonconst_timezone_arguments",
-               "allow_nondeterministic_mutations",
-               "allow_nondeterministic_optimize_skip_unused_shards",
-               "allow_prefetched_read_pool_for_local_filesystem",
-               "allow_prefetched_read_pool_for_remote_filesystem",
-               "allow_push_predicate_when_subquery_contains_with",
-               "allow_reorder_prewhere_conditions",
-               "allow_settings_after_format_in_insert",
-               "allow_simdjson",
-               "allow_statistics_optimize",
-               "allow_suspicious_codecs",
-               "allow_suspicious_fixed_string_types",
-               "allow_suspicious_indices",
-               "allow_suspicious_low_cardinality_types",
-               "allow_suspicious_primary_key",
-               "allow_suspicious_ttl_expressions",
-               "allow_suspicious_variant_types",
-               "allow_suspicious_types_in_group_by",
-               "allow_suspicious_types_in_order_by",
-               "allow_unrestricted_reads_from_keeper",
-               "enable_analyzer",
-               "enable_deflate_qpl_codec",
-               "enable_zstd_qat_codec",
-               "type_json_skip_duplicated_paths",
-               "allow_experimental_database_iceberg",
-               "allow_experimental_bfloat16_type",
-               "allow_not_comparable_types_in_order_by",
-               "allow_not_comparable_types_in_comparison_functions"};
+        DB::Strings defaultSettings = {"engine_file_truncate_on_insert"};
         defaultSettings.emplace_back(rg.nextBool() ? "s3_truncate_on_insert" : "s3_create_new_file_on_insert");
 
         full_query.resize(0);
@@ -675,7 +603,7 @@ bool Client::buzzHouse()
 
                     sq4.Clear();
                     full_query.resize(0);
-                    qo.generateImportQuery(gen, t, sq2, sq4);
+                    qo.generateImportQuery(rg, gen, t, sq2, sq4);
                     BuzzHouse::SQLQueryToString(full_query, sq4);
                     outf << full_query << std::endl;
                     server_up &= processBuzzHouseQuery(full_query);

src/Client/BuzzHouse/AST/SQLProtoStr.cpp

@@ -118,7 +118,7 @@ CONV_FN(ExprColAlias, eca)
     }
 }
 
-void convertToSQLString(String & ret, const String & s)
+static void convertToSQLString(String & ret, const String & s)
 {
     for (size_t i = 0; i < s.length(); i++)
     {
@@ -704,7 +704,7 @@ CONV_FN(EnumDefValue, edf)
     ret += std::to_string(edf.number());
 }
 
-void BottomTypeNameToString(String & ret, const uint32_t quote, const bool lcard, const BottomTypeName & btn)
+static void BottomTypeNameToString(String & ret, const uint32_t quote, const bool lcard, const BottomTypeName & btn)
 {
     using BottomTypeNameType = BottomTypeName::BottomOneOfCase;
     switch (btn.bottom_one_of_case())
@@ -1790,7 +1790,7 @@ CONV_FN(GenerateSeriesFunc, gsf)
 
 CONV_FN(TableFunction, tf);
 
-void TableOrFunctionToString(String & ret, const bool tudf, const TableOrFunction & tof)
+static void TableOrFunctionToString(String & ret, const bool tudf, const TableOrFunction & tof)
 {
     using TableOrFunctionType = TableOrFunction::JtfOneofCase;
     switch (tof.jtf_oneof_case())
@@ -2001,6 +2001,45 @@ CONV_FN(MergeTreeIndexFunc, mfunc)
     ret += ")";
 }
 
+CONV_FN(GenerateRandomFunc, grfunc)
+{
+    ret += "generateRandom('";
+    ret += grfunc.structure();
+    ret += "'";
+    if (grfunc.has_random_seed())
+    {
+        ret += ", ";
+        ret += std::to_string(grfunc.random_seed());
+    }
+    if (grfunc.has_max_string_length())
+    {
+        ret += ", ";
+        ret += std::to_string(grfunc.max_string_length());
+    }
+    if (grfunc.has_max_array_length())
+    {
+        ret += ", ";
+        ret += std::to_string(grfunc.max_array_length());
+    }
+    ret += ")";
+}
+
+static void ValuesStatementToString(String & ret, const bool tudf, const ValuesStatement & values)
+{
+    ret += "VALUES ";
+    ret += tudf ? "(" : "";
+    ret += "(";
+    ExprListToString(ret, values.expr_list());
+    ret += ")";
+    for (int i = 0; i < values.extra_expr_lists_size(); i++)
+    {
+        ret += ", (";
+        ExprListToString(ret, values.extra_expr_lists(i));
+        ret += ")";
+    }
+    ret += tudf ? ")" : "";
+}
+
 CONV_FN(TableFunction, tf)
 {
     using TableFunctionType = TableFunction::JtfOneofCase;
@@ -2047,6 +2086,12 @@ CONV_FN(TableFunction, tf)
             TableOrFunctionToString(ret, true, tf.loop());
             ret += ")";
             break;
+        case TableFunctionType::kGrandom:
+            GenerateRandomFuncToString(ret, tf.grandom());
+            break;
+        case TableFunctionType::kValues:
+            ValuesStatementToString(ret, true, tf.values());
+            break;
         default:
             ret += "numbers(10)";
     }
@@ -3016,71 +3061,9 @@ CONV_FN(Drop, dt)
     }
 }
 
-CONV_FN(ValuesStatement, values)
-{
-    if (values.has_setting_values())
-    {
-        ret += "SETTINGS ";
-        SettingValuesToString(ret, values.setting_values());
-        ret += " ";
-    }
-    ret += "VALUES (";
-    ExprListToString(ret, values.expr_list());
-    ret += ")";
-    for (int i = 0; i < values.extra_expr_lists_size(); i++)
-    {
-        ret += ", (";
-        ExprListToString(ret, values.extra_expr_lists(i));
-        ret += ")";
-    }
-}
-
-CONV_FN(InsertFromFile, insert_file)
-{
-    ret += "FROM INFILE '";
-    ret += insert_file.path();
-    ret += "'";
-    if (insert_file.has_fcomp())
-    {
-        ret += " COMPRESSION '";
-        ret += FileCompression_Name(insert_file.fcomp()).substr(4);
-        ret += "'";
-    }
-    if (insert_file.has_settings())
-    {
-        ret += " SETTINGS ";
-        SettingValuesToString(ret, insert_file.settings());
-    }
-    ret += " FORMAT ";
-    ret += InFormat_Name(insert_file.format()).substr(3);
-}
-
-CONV_FN(InsertSelect, insert_sel)
-{
-    if (insert_sel.has_setting_values())
-    {
-        ret += "SETTINGS ";
-        SettingValuesToString(ret, insert_sel.setting_values());
-        ret += " ";
-    }
-    SelectToString(ret, insert_sel.select());
-}
-
-CONV_FN(InsertStringQuery, insert_query)
-{
-    if (insert_query.has_setting_values())
-    {
-        ret += "SETTINGS ";
-        SettingValuesToString(ret, insert_query.setting_values());
-        ret += " ";
-    }
-    ret += "VALUES ";
-    ret += insert_query.query();
-}
-
 CONV_FN(Insert, insert)
 {
-    if (insert.has_ctes() && insert.has_est() && insert.has_insert_select())
+    if (insert.has_ctes() && insert.has_est() && insert.has_select())
     {
         CTEsToString(ret, insert.ctes());
     }
@@ -3108,21 +3091,45 @@ CONV_FN(Insert, insert)
         ret += ")";
     }
     ret += " ";
+    if (!insert.has_insert_file() && insert.has_setting_values())
+    {
+        ret += "SETTINGS ";
+        SettingValuesToString(ret, insert.setting_values());
+        ret += " ";
+    }
     if (insert.has_values())
     {
-        ValuesStatementToString(ret, insert.values());
+        ValuesStatementToString(ret, false, insert.values());
     }
-    else if (insert.has_insert_select())
+    else if (insert.has_select())
     {
-        InsertSelectToString(ret, insert.insert_select());
+        SelectToString(ret, insert.select());
     }
     else if (insert.has_insert_file())
     {
-        InsertFromFileToString(ret, insert.insert_file());
+        const InsertFromFile & insert_file = insert.insert_file();
+
+        ret += "FROM INFILE '";
+        ret += insert_file.path();
+        ret += "'";
+        if (insert_file.has_fcomp())
+        {
+            ret += " COMPRESSION '";
+            ret += FileCompression_Name(insert_file.fcomp()).substr(4);
+            ret += "'";
+        }
+        if (insert.has_setting_values())
+        {
+            ret += " SETTINGS ";
+            SettingValuesToString(ret, insert.setting_values());
+        }
+        ret += " FORMAT ";
+        ret += InFormat_Name(insert_file.format()).substr(3);
     }
     else if (insert.has_query())
     {
-        InsertStringQueryToString(ret, insert.query());
+        ret += "VALUES ";
+        ret += insert.query();
     }
     else
     {
@@ -3276,7 +3283,7 @@ CONV_FN(DeduplicateExpr, de)
     if (de.has_col_list())
     {
         ret += " BY ";
-        ExprColumnListToString(ret, de.col_list());
+        ColumnPathListToString(ret, 0, de.col_list());
     }
     else if (de.has_ded_star())
     {
@@ -3285,7 +3292,7 @@ CONV_FN(DeduplicateExpr, de)
     else if (de.has_ded_star_except())
     {
         ret += " BY * EXCEPT (";
-        ExprColumnListToString(ret, de.ded_star_except());
+        ColumnPathListToString(ret, 0, de.ded_star_except());
         ret += ")";
     }
 }