From 589177705dd4824902afc58d3ea3e7aaab9bbe47 Mon Sep 17 00:00:00 2001 From: Bradyn Walsh Date: Sat, 17 May 2025 17:04:49 +1000 Subject: [PATCH 001/100] Make NumericStats only have MinMax for ordered min-max values --- src/storage/statistics/numeric_stats.cpp | 3 ++- .../statistics/statistics_null_comparison.test | 12 ++++++------ test/sql/subquery/exists/test_issue_9308.test | 5 +++++ 3 files changed, 13 insertions(+), 7 deletions(-) diff --git a/src/storage/statistics/numeric_stats.cpp b/src/storage/statistics/numeric_stats.cpp index 3e30e4d9af3c..803c21f124d1 100644 --- a/src/storage/statistics/numeric_stats.cpp +++ b/src/storage/statistics/numeric_stats.cpp @@ -375,7 +375,8 @@ Value NumericValueUnionToValue(const LogicalType &type, const NumericValueUnion } bool NumericStats::HasMinMax(const BaseStatistics &stats) { - return NumericStats::HasMin(stats) && NumericStats::HasMax(stats); + return NumericStats::HasMin(stats) && NumericStats::HasMax(stats) && + NumericStats::Min(stats) <= NumericStats::Max(stats); } bool NumericStats::HasMin(const BaseStatistics &stats) { diff --git a/test/optimizer/statistics/statistics_null_comparison.test b/test/optimizer/statistics/statistics_null_comparison.test index a66c38afa7be..3c7e206abd48 100644 --- a/test/optimizer/statistics/statistics_null_comparison.test +++ b/test/optimizer/statistics/statistics_null_comparison.test @@ -45,12 +45,6 @@ EXPLAIN SELECT * FROM integers WHERE i>j ORDER BY i; ---- logical_opt :.*constant_or_null.* -# t2.c0>=t2.c0 means always true or null which is equals to is not null -query II -EXPLAIN SELECT * FROM t1 INNER JOIN t2 ON ((t2.c0)>=(t2.c0)); ----- -logical_opt :.*IS NOT NULL.* - # now verify that the results are correct query I SELECT i=j FROM integers ORDER BY i; @@ -91,6 +85,12 @@ SELECT * FROM t1 INNER JOIN t2 ON ((t2.c0)>=(t2.c0)); statement ok INSERT INTO t2 VALUES(1); +# t2.c0>=t2.c0 means always true or null which is equals to is not null +query II +EXPLAIN SELECT * FROM t1 INNER JOIN t2 ON ((t2.c0)>=(t2.c0)); +---- +logical_opt :.*IS NOT NULL.* + query II SELECT * FROM t1 INNER JOIN t2 ON ((t2.c0)>=(t2.c0)); ---- diff --git a/test/sql/subquery/exists/test_issue_9308.test b/test/sql/subquery/exists/test_issue_9308.test index 4c37187e18b4..78295306befe 100644 --- a/test/sql/subquery/exists/test_issue_9308.test +++ b/test/sql/subquery/exists/test_issue_9308.test @@ -23,3 +23,8 @@ query I select c1 from t1 where not exists (select 1 from t2 where t1.c1 <= t2.c1); ---- 1 + +query I +select c1 from t1 anti join t2 on (t1.c1 <= t2.c1) +---- +1 \ No newline at end of file From 6c9819743fb963ba55ed4565deb9b3f4d0a866d4 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Fri, 6 Jun 2025 17:42:12 +0200 Subject: [PATCH 002/100] have a fix, need to clean it up --- src/optimizer/statistics/operator/propagate_get.cpp | 7 +++++++ src/planner/table_filter_state.cpp | 3 ++- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index 2ff9be3ea56d..e385caf71f52 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -20,6 +20,13 @@ FilterPropagateResult StatisticsPropagator::PropagateTableFilter(ColumnBinding s // otherwise the filter can be pruned by the updated statistics auto copy_expr = filter_expr->Copy(); auto propagate_result = HandleFilter(filter_expr); + if (filter_expr->type == ExpressionType::BOUND_FUNCTION) { + auto &func = filter_expr->Cast(); + if (expr_filter.expr->type == ExpressionType::BOUND_FUNCTION) { + auto &dumb = expr_filter.expr->Cast(); + dumb.function = func.function; + } + } UpdateFilterStatistics(*copy_expr); return propagate_result; } diff --git a/src/planner/table_filter_state.cpp b/src/planner/table_filter_state.cpp index c542939dcda4..fe47e5a653a5 100644 --- a/src/planner/table_filter_state.cpp +++ b/src/planner/table_filter_state.cpp @@ -36,7 +36,8 @@ unique_ptr TableFilterState::Initialize(ClientContext &context } case TableFilterType::EXPRESSION_FILTER: { auto &expr_filter = filter.Cast(); - return make_uniq(context, *expr_filter.expr); + auto ret = make_uniq(context, *expr_filter.expr); + return ret; } case TableFilterType::CONSTANT_COMPARISON: case TableFilterType::IS_NULL: From 5fadaa1c164f51596d5d61c8b201eb9e12525794 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Tue, 10 Jun 2025 10:47:57 +0200 Subject: [PATCH 003/100] copy the filter function to the original filter after pushdown --- .github/regression/micro.csv | 3 ++- .../choose_correct_filter_function.benchmark | 21 +++++++++++++++++++ .../statistics/operator/propagate_get.cpp | 10 ++++----- 3 files changed, 28 insertions(+), 6 deletions(-) create mode 100644 benchmark/micro/filter/choose_correct_filter_function.benchmark diff --git a/.github/regression/micro.csv b/.github/regression/micro.csv index 51056b4d3e61..8ac86ed12d00 100644 --- a/.github/regression/micro.csv +++ b/.github/regression/micro.csv @@ -21,4 +21,5 @@ benchmark/micro/logger/disabled/logging_disabled_file_opener.benchmark benchmark/micro/logger/enabled/logging_enabled_client_context.benchmark benchmark/micro/logger/enabled/logging_enabled_global.benchmark benchmark/micro/logger/enabled/logging_enabled_file_opener.benchmark -benchmark/micro/logger/enabled/logging_enabled_global.benchmark \ No newline at end of file +benchmark/micro/logger/enabled/logging_enabled_global.benchmark +benchmark/micro/filter/choose_correct_filter_function.benchmark \ No newline at end of file diff --git a/benchmark/micro/filter/choose_correct_filter_function.benchmark b/benchmark/micro/filter/choose_correct_filter_function.benchmark new file mode 100644 index 000000000000..c07cfc5d1d75 --- /dev/null +++ b/benchmark/micro/filter/choose_correct_filter_function.benchmark @@ -0,0 +1,21 @@ +# name: benchmark/micro/filter/choose_correct_filter_function.benchmark +# description: Make sure we use like with the ASCII selector and not the generate character iterator +# group: [filter] + +group micro +subgroup filter + +load +create or replace table int_and_long_strings as + from range(100000) t(i) + select + md5(i::varchar) as medium_string +; +insert into int_and_long_strings from int_and_long_strings; +insert into int_and_long_strings from int_and_long_strings; + +run +from int_and_long_strings +where + medium_string ilike '%888%' +; diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index e385caf71f52..ced3643ae097 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -20,12 +20,12 @@ FilterPropagateResult StatisticsPropagator::PropagateTableFilter(ColumnBinding s // otherwise the filter can be pruned by the updated statistics auto copy_expr = filter_expr->Copy(); auto propagate_result = HandleFilter(filter_expr); + // Handle filter propagates the statistics, and also chooses what function to run. + // We need to copy the function from filter_expr (which is a copy) to the expr_filter (which is the original). if (filter_expr->type == ExpressionType::BOUND_FUNCTION) { - auto &func = filter_expr->Cast(); - if (expr_filter.expr->type == ExpressionType::BOUND_FUNCTION) { - auto &dumb = expr_filter.expr->Cast(); - dumb.function = func.function; - } + auto &func_filter = filter_expr->Cast(); + auto &original_func_filter = expr_filter.expr->Cast(); + original_func_filter.function = func_filter.function; } UpdateFilterStatistics(*copy_expr); return propagate_result; From d5242927048d00f4f8ae8379d8264cb0a7f22b29 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Tue, 10 Jun 2025 10:49:12 +0200 Subject: [PATCH 004/100] revert unnecessary change --- src/planner/table_filter_state.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/planner/table_filter_state.cpp b/src/planner/table_filter_state.cpp index fe47e5a653a5..c542939dcda4 100644 --- a/src/planner/table_filter_state.cpp +++ b/src/planner/table_filter_state.cpp @@ -36,8 +36,7 @@ unique_ptr TableFilterState::Initialize(ClientContext &context } case TableFilterType::EXPRESSION_FILTER: { auto &expr_filter = filter.Cast(); - auto ret = make_uniq(context, *expr_filter.expr); - return ret; + return make_uniq(context, *expr_filter.expr); } case TableFilterType::CONSTANT_COMPARISON: case TableFilterType::IS_NULL: From 46a04955beddbaef9e63fea834699bded60687b2 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Tue, 10 Jun 2025 11:23:04 +0200 Subject: [PATCH 005/100] include missing header --- src/optimizer/statistics/operator/propagate_get.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index ced3643ae097..5580291646a2 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -3,6 +3,7 @@ #include "duckdb/planner/expression/bound_columnref_expression.hpp" #include "duckdb/planner/filter/conjunction_filter.hpp" #include "duckdb/planner/filter/constant_filter.hpp" +#include "duckdb/planner/expression/bound_function_expression.hpp" #include "duckdb/planner/filter/expression_filter.hpp" #include "duckdb/planner/filter/null_filter.hpp" #include "duckdb/planner/operator/logical_get.hpp" From 55db2881729c85b65cde75353b7069803ef143b3 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Wed, 11 Jun 2025 09:38:33 +0200 Subject: [PATCH 006/100] dont need to call handle filter on copy of expression --- .../choose_correct_filter_function.benchmark | 2 +- benchmark/tpcds_plan_cost/init/load.sql | 0 benchmark/tpcds_plan_cost/init/schema.sql | 0 benchmark/tpcds_plan_cost/queries/04.sql | 120 ++++++++++++++++++ .../statistics/operator/propagate_get.cpp | 10 +- 5 files changed, 122 insertions(+), 10 deletions(-) create mode 100644 benchmark/tpcds_plan_cost/init/load.sql create mode 100644 benchmark/tpcds_plan_cost/init/schema.sql create mode 100644 benchmark/tpcds_plan_cost/queries/04.sql diff --git a/benchmark/micro/filter/choose_correct_filter_function.benchmark b/benchmark/micro/filter/choose_correct_filter_function.benchmark index c07cfc5d1d75..3efb06913bf3 100644 --- a/benchmark/micro/filter/choose_correct_filter_function.benchmark +++ b/benchmark/micro/filter/choose_correct_filter_function.benchmark @@ -7,7 +7,7 @@ subgroup filter load create or replace table int_and_long_strings as - from range(100000) t(i) + from range(100) t(i) select md5(i::varchar) as medium_string ; diff --git a/benchmark/tpcds_plan_cost/init/load.sql b/benchmark/tpcds_plan_cost/init/load.sql new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/benchmark/tpcds_plan_cost/init/schema.sql b/benchmark/tpcds_plan_cost/init/schema.sql new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/benchmark/tpcds_plan_cost/queries/04.sql b/benchmark/tpcds_plan_cost/queries/04.sql new file mode 100644 index 000000000000..fadb0a6c418c --- /dev/null +++ b/benchmark/tpcds_plan_cost/queries/04.sql @@ -0,0 +1,120 @@ +WITH year_total AS + (SELECT c_customer_id customer_id, + c_first_name customer_first_name, + c_last_name customer_last_name, + c_preferred_cust_flag customer_preferred_cust_flag, + c_birth_country customer_birth_country, + c_login customer_login, + c_email_address customer_email_address, + d_year dyear, + sum(((ss_ext_list_price-ss_ext_wholesale_cost-ss_ext_discount_amt)+ss_ext_sales_price)/2) year_total, + 's' sale_type + FROM customer, + store_sales, + date_dim + WHERE c_customer_sk = ss_customer_sk + AND ss_sold_date_sk = d_date_sk + GROUP BY c_customer_id, + c_first_name, + c_last_name, + c_preferred_cust_flag, + c_birth_country, + c_login, + c_email_address, + d_year + UNION ALL SELECT c_customer_id customer_id, + c_first_name customer_first_name, + c_last_name customer_last_name, + c_preferred_cust_flag customer_preferred_cust_flag, + c_birth_country customer_birth_country, + c_login customer_login, + c_email_address customer_email_address, + d_year dyear, + sum((((cs_ext_list_price-cs_ext_wholesale_cost-cs_ext_discount_amt)+cs_ext_sales_price)/2)) year_total, + 'c' sale_type + FROM customer, + catalog_sales, + date_dim + WHERE c_customer_sk = cs_bill_customer_sk + AND cs_sold_date_sk = d_date_sk + GROUP BY c_customer_id, + c_first_name, + c_last_name, + c_preferred_cust_flag, + c_birth_country, + c_login, + c_email_address, + d_year + UNION ALL SELECT c_customer_id customer_id, + c_first_name customer_first_name, + c_last_name customer_last_name, + c_preferred_cust_flag customer_preferred_cust_flag, + c_birth_country customer_birth_country, + c_login customer_login, + c_email_address customer_email_address, + d_year dyear, + sum((((ws_ext_list_price-ws_ext_wholesale_cost-ws_ext_discount_amt)+ws_ext_sales_price)/2)) year_total, + 'w' sale_type + FROM customer, + web_sales, + date_dim + WHERE c_customer_sk = ws_bill_customer_sk + AND ws_sold_date_sk = d_date_sk + GROUP BY c_customer_id, + c_first_name, + c_last_name, + c_preferred_cust_flag, + c_birth_country, + c_login, + c_email_address, + d_year) +SELECT t_s_secyear.customer_id, + t_s_secyear.customer_first_name, + t_s_secyear.customer_last_name, + t_s_secyear.customer_preferred_cust_flag +FROM year_total t_s_firstyear, + year_total t_s_secyear, + year_total t_c_firstyear, + year_total t_c_secyear, + year_total t_w_firstyear, + year_total t_w_secyear +WHERE t_s_secyear.customer_id = t_s_firstyear.customer_id + AND t_s_firstyear.customer_id = t_c_secyear.customer_id + AND t_s_firstyear.customer_id = t_c_firstyear.customer_id + AND t_s_firstyear.customer_id = t_w_firstyear.customer_id + AND t_s_firstyear.customer_id = t_w_secyear.customer_id + AND t_s_firstyear.sale_type = 's' + AND t_c_firstyear.sale_type = 'c' + AND t_w_firstyear.sale_type = 'w' + AND t_s_secyear.sale_type = 's' + AND t_c_secyear.sale_type = 'c' + AND t_w_secyear.sale_type = 'w' + AND t_s_firstyear.dyear = 2001 + AND t_s_secyear.dyear = 2001+1 + AND t_c_firstyear.dyear = 2001 + AND t_c_secyear.dyear = 2001+1 + AND t_w_firstyear.dyear = 2001 + AND t_w_secyear.dyear = 2001+1 + AND t_s_firstyear.year_total > 0 + AND t_c_firstyear.year_total > 0 + AND t_w_firstyear.year_total > 0 + AND CASE + WHEN t_c_firstyear.year_total > 0 THEN t_c_secyear.year_total / t_c_firstyear.year_total + ELSE NULL + END > CASE + WHEN t_s_firstyear.year_total > 0 THEN t_s_secyear.year_total / t_s_firstyear.year_total + ELSE NULL + END + AND CASE + WHEN t_c_firstyear.year_total > 0 THEN t_c_secyear.year_total / t_c_firstyear.year_total + ELSE NULL + END > CASE + WHEN t_w_firstyear.year_total > 0 THEN t_w_secyear.year_total / t_w_firstyear.year_total + ELSE NULL + END +ORDER BY t_s_secyear.customer_id NULLS FIRST, + t_s_secyear.customer_first_name NULLS FIRST, + t_s_secyear.customer_last_name NULLS FIRST, + t_s_secyear.customer_preferred_cust_flag NULLS FIRST +LIMIT 100; + diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index 5580291646a2..fdc90791fbe4 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -19,16 +19,8 @@ FilterPropagateResult StatisticsPropagator::PropagateTableFilter(ColumnBinding s auto filter_expr = expr_filter.ToExpression(*column_ref); // handle the filter before updating the statistics // otherwise the filter can be pruned by the updated statistics - auto copy_expr = filter_expr->Copy(); auto propagate_result = HandleFilter(filter_expr); - // Handle filter propagates the statistics, and also chooses what function to run. - // We need to copy the function from filter_expr (which is a copy) to the expr_filter (which is the original). - if (filter_expr->type == ExpressionType::BOUND_FUNCTION) { - auto &func_filter = filter_expr->Cast(); - auto &original_func_filter = expr_filter.expr->Cast(); - original_func_filter.function = func_filter.function; - } - UpdateFilterStatistics(*copy_expr); + UpdateFilterStatistics(*filter_expr); return propagate_result; } return filter.CheckStatistics(stats); From 9b2e164d4b0af1c52d645e51a24803f02ab7557b Mon Sep 17 00:00:00 2001 From: Tmonster Date: Wed, 11 Jun 2025 11:06:08 +0200 Subject: [PATCH 007/100] use the physical storage index from bound ref, since they are all the same for table refs --- .../statistics/operator/propagate_get.cpp | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index fdc90791fbe4..f14a91e368c7 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -9,18 +9,50 @@ #include "duckdb/planner/operator/logical_get.hpp" #include "duckdb/planner/table_filter.hpp" +#include + namespace duckdb { +static void ReplaceExpressionRecursive(unique_ptr &expr, const Expression &column) { + if (expr->type == ExpressionType::BOUND_COLUMN_REF) { + expr = column.Copy(); + return; + } + ExpressionIterator::EnumerateChildren( + *expr, [&](unique_ptr &child) { ReplaceExpressionRecursive(child, column); }); +} + +static void GetColumnIndex(unique_ptr &expr, idx_t &index) { + if (expr->type == ExpressionType::BOUND_REF) { + auto &bound_ref = expr->Cast(); + index = bound_ref.index; + return; + } + ExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr &child) { GetColumnIndex(child, index); }); +} + FilterPropagateResult StatisticsPropagator::PropagateTableFilter(ColumnBinding stats_binding, BaseStatistics &stats, TableFilter &filter) { if (filter.filter_type == TableFilterType::EXPRESSION_FILTER) { auto &expr_filter = filter.Cast(); + + // get physical storage index of the filter + // since it is a table filter, every storage index is the same + idx_t physical_index = DConstants::INVALID_INDEX; + GetColumnIndex(expr_filter.expr, physical_index); + D_ASSERT(physical_index != DConstants::INVALID_INDEX); + auto column_ref = make_uniq(stats.GetType(), stats_binding); auto filter_expr = expr_filter.ToExpression(*column_ref); // handle the filter before updating the statistics // otherwise the filter can be pruned by the updated statistics auto propagate_result = HandleFilter(filter_expr); + auto colref = make_uniq(stats.GetType(), physical_index); UpdateFilterStatistics(*filter_expr); + + // replace BoundColumnRefs with BoundRefs + ReplaceExpressionRecursive(filter_expr, *colref); + expr_filter.expr = std::move(filter_expr); return propagate_result; } return filter.CheckStatistics(stats); From 8e5d7d8dc21c606a4bfbce0d25513f5f5c6fc518 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Wed, 11 Jun 2025 11:15:16 +0200 Subject: [PATCH 008/100] move some functions around --- .../duckdb/planner/filter/expression_filter.hpp | 2 ++ src/optimizer/statistics/operator/propagate_get.cpp | 11 +---------- src/planner/filter/expression_filter.cpp | 7 ++++--- 3 files changed, 7 insertions(+), 13 deletions(-) diff --git a/src/include/duckdb/planner/filter/expression_filter.hpp b/src/include/duckdb/planner/filter/expression_filter.hpp index 2d947376bb86..62284b045f6c 100644 --- a/src/include/duckdb/planner/filter/expression_filter.hpp +++ b/src/include/duckdb/planner/filter/expression_filter.hpp @@ -35,6 +35,8 @@ class ExpressionFilter : public TableFilter { unique_ptr ToExpression(const Expression &column) const override; void Serialize(Serializer &serializer) const override; static unique_ptr Deserialize(Deserializer &deserializer); + static void ReplaceExpressionRecursive(unique_ptr &expr, const Expression &column, + ExpressionType replace_type = ExpressionType::BOUND_REF); }; } // namespace duckdb diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index f14a91e368c7..2fc11ae3ea4f 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -13,15 +13,6 @@ namespace duckdb { -static void ReplaceExpressionRecursive(unique_ptr &expr, const Expression &column) { - if (expr->type == ExpressionType::BOUND_COLUMN_REF) { - expr = column.Copy(); - return; - } - ExpressionIterator::EnumerateChildren( - *expr, [&](unique_ptr &child) { ReplaceExpressionRecursive(child, column); }); -} - static void GetColumnIndex(unique_ptr &expr, idx_t &index) { if (expr->type == ExpressionType::BOUND_REF) { auto &bound_ref = expr->Cast(); @@ -51,7 +42,7 @@ FilterPropagateResult StatisticsPropagator::PropagateTableFilter(ColumnBinding s UpdateFilterStatistics(*filter_expr); // replace BoundColumnRefs with BoundRefs - ReplaceExpressionRecursive(filter_expr, *colref); + ExpressionFilter::ReplaceExpressionRecursive(filter_expr, *colref, ExpressionType::BOUND_COLUMN_REF); expr_filter.expr = std::move(filter_expr); return propagate_result; } diff --git a/src/planner/filter/expression_filter.cpp b/src/planner/filter/expression_filter.cpp index e2ff7d44281f..8e9b3299f36b 100644 --- a/src/planner/filter/expression_filter.cpp +++ b/src/planner/filter/expression_filter.cpp @@ -36,13 +36,14 @@ string ExpressionFilter::ToString(const string &column_name) const { return ToExpression(*name_expr)->ToString(); } -static void ReplaceExpressionRecursive(unique_ptr &expr, const Expression &column) { - if (expr->type == ExpressionType::BOUND_REF) { +void ExpressionFilter::ReplaceExpressionRecursive(unique_ptr &expr, const Expression &column, + ExpressionType replace_type) { + if (expr->type == replace_type) { expr = column.Copy(); return; } ExpressionIterator::EnumerateChildren( - *expr, [&](unique_ptr &child) { ReplaceExpressionRecursive(child, column); }); + *expr, [&](unique_ptr &child) { ReplaceExpressionRecursive(child, column, replace_type); }); } unique_ptr ExpressionFilter::ToExpression(const Expression &column) const { From c43444ffb0507ff3ba2e0ae74b0f40daba505e07 Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Thu, 12 Jun 2025 14:02:27 +0200 Subject: [PATCH 009/100] Avoid going to in-depth while computing join order Cutoff to 25 is arbitrary, in duckdb-wasm with stack of 64KB it would have gone up to 80+ (depending on implementation details / compiler optimization level), but high enough that should not really influence actual plans. There might be better solution, and cutoff might even be made customizable, so that different situation might warrant different behaviours (and better testing). This has been tested bailing out at level 3, just to check system could handle bailing out. Test is added that concatenates `select 1 as num` with 500 times `union all select 1 as num`. Both with and without this PR the test can be passed, but adding a limit on depth significantly increases the reachable depth. Experimenting with higher numbers (together with `SET max_expression_depth = x` to actually have the statement be parseable), will show a path to further improve in this area. --- .../join_order/join_order_optimizer.hpp | 1 + .../join_order/join_order_optimizer.cpp | 10 +++++- test/CMakeLists.txt | 1 + test/optimizer/CMakeLists.txt | 5 +++ test/optimizer/union_alls.cpp | 31 +++++++++++++++++++ 5 files changed, 47 insertions(+), 1 deletion(-) create mode 100644 test/optimizer/CMakeLists.txt create mode 100644 test/optimizer/union_alls.cpp diff --git a/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp b/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp index 921e03a21423..527ccf94d5ad 100644 --- a/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp +++ b/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp @@ -60,6 +60,7 @@ class JoinOrderOptimizer { unordered_map materialized_cte_stats; //! Stats of Delim Scans of the Delim Join that is currently being optimized optional_ptr delim_scan_stats; + idx_t depth; }; } // namespace duckdb diff --git a/src/optimizer/join_order/join_order_optimizer.cpp b/src/optimizer/join_order/join_order_optimizer.cpp index e49798ac4bff..3fa70204ec94 100644 --- a/src/optimizer/join_order/join_order_optimizer.cpp +++ b/src/optimizer/join_order/join_order_optimizer.cpp @@ -10,19 +10,27 @@ namespace duckdb { -JoinOrderOptimizer::JoinOrderOptimizer(ClientContext &context) : context(context), query_graph_manager(context) { +JoinOrderOptimizer::JoinOrderOptimizer(ClientContext &context) + : context(context), query_graph_manager(context), depth(1) { } JoinOrderOptimizer JoinOrderOptimizer::CreateChildOptimizer() { JoinOrderOptimizer child_optimizer(context); child_optimizer.materialized_cte_stats = materialized_cte_stats; child_optimizer.delim_scan_stats = delim_scan_stats; + child_optimizer.depth = depth + 1; return child_optimizer; } unique_ptr JoinOrderOptimizer::Optimize(unique_ptr plan, optional_ptr stats) { + if (depth > 25) { + // Very deep plans will eventually consume quite some stack space + // Returning the current plan is always a valid choice + return std::move(plan); + } + // make sure query graph manager has not extracted a relation graph already LogicalOperator *op = plan.get(); diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index ca4178669145..64ab4bdf406b 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -17,6 +17,7 @@ if(${ENABLE_UNITTEST_CPP_TESTS}) add_subdirectory(memoryleak) add_subdirectory(parallel_csv) add_subdirectory(secrets) + add_subdirectory(optimizer) add_subdirectory(serialize) add_subdirectory(sql) add_subdirectory(ossfuzz) diff --git a/test/optimizer/CMakeLists.txt b/test/optimizer/CMakeLists.txt new file mode 100644 index 000000000000..160294cb5fab --- /dev/null +++ b/test/optimizer/CMakeLists.txt @@ -0,0 +1,5 @@ +add_library_unity(test_optimizer OBJECT union_alls.cpp) + +set(ALL_OBJECT_FILES + ${ALL_OBJECT_FILES} $ + PARENT_SCOPE) diff --git a/test/optimizer/union_alls.cpp b/test/optimizer/union_alls.cpp new file mode 100644 index 000000000000..f90467a103a2 --- /dev/null +++ b/test/optimizer/union_alls.cpp @@ -0,0 +1,31 @@ +#include "catch.hpp" +#include "test_helpers.hpp" +#include "duckdb.hpp" +#include "duckdb/main/database.hpp" +#include "duckdb/main/secret/secret_manager.hpp" +#include "duckdb/main/secret/secret_storage.hpp" +#include "duckdb/main/secret/secret.hpp" +#include "duckdb/main/extension_util.hpp" + +using namespace duckdb; +using namespace std; + +TEST_CASE("A lot of unions", "[optimizer][.]") { + DuckDB db(nullptr); + Connection con(db); + + duckdb::stringstream q; + q << "select 1 as num"; + + int max = 0; + int curr = 1; + while (max < 500) { + max = (max *1.1) + 1; + while (curr < max) { + q << " union all select 1 as num"; + curr++; + } + REQUIRE_NO_FAIL(con.Query(q.str())); + } +} + From c607a2df36464356f12e5573efcc36680273616b Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Thu, 12 Jun 2025 15:02:03 +0200 Subject: [PATCH 010/100] Handle review from @Tmonster and fix format --- .../duckdb/optimizer/join_order/join_order_optimizer.hpp | 1 + src/optimizer/join_order/join_order_optimizer.cpp | 2 +- test/optimizer/union_alls.cpp | 4 ++-- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp b/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp index 527ccf94d5ad..15358bbb7ff0 100644 --- a/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp +++ b/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp @@ -61,6 +61,7 @@ class JoinOrderOptimizer { //! Stats of Delim Scans of the Delim Join that is currently being optimized optional_ptr delim_scan_stats; idx_t depth; + static constexpr idx_t THRESHOLD_AVOID_IN_DEPTH_VISIT = 25; }; } // namespace duckdb diff --git a/src/optimizer/join_order/join_order_optimizer.cpp b/src/optimizer/join_order/join_order_optimizer.cpp index 3fa70204ec94..7464ed44ddd5 100644 --- a/src/optimizer/join_order/join_order_optimizer.cpp +++ b/src/optimizer/join_order/join_order_optimizer.cpp @@ -25,7 +25,7 @@ JoinOrderOptimizer JoinOrderOptimizer::CreateChildOptimizer() { unique_ptr JoinOrderOptimizer::Optimize(unique_ptr plan, optional_ptr stats) { - if (depth > 25) { + if (depth > THRESHOLD_AVOID_IN_DEPTH_VISIT) { // Very deep plans will eventually consume quite some stack space // Returning the current plan is always a valid choice return std::move(plan); diff --git a/test/optimizer/union_alls.cpp b/test/optimizer/union_alls.cpp index f90467a103a2..d2087598c5ed 100644 --- a/test/optimizer/union_alls.cpp +++ b/test/optimizer/union_alls.cpp @@ -11,6 +11,7 @@ using namespace duckdb; using namespace std; TEST_CASE("A lot of unions", "[optimizer][.]") { + DuckDB db(nullptr); Connection con(db); @@ -20,7 +21,7 @@ TEST_CASE("A lot of unions", "[optimizer][.]") { int max = 0; int curr = 1; while (max < 500) { - max = (max *1.1) + 1; + max = (max * 1.1) + 1; while (curr < max) { q << " union all select 1 as num"; curr++; @@ -28,4 +29,3 @@ TEST_CASE("A lot of unions", "[optimizer][.]") { REQUIRE_NO_FAIL(con.Query(q.str())); } } - From 1dbb3c0b0eb6dc6c44fd7f5393d2a30a1544a36d Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Fri, 13 Jun 2025 08:20:10 +0200 Subject: [PATCH 011/100] Move THRESHOLD_AVOID_IN_DEPTH_VISIT to 100 --- .../duckdb/optimizer/join_order/join_order_optimizer.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp b/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp index 15358bbb7ff0..a783f17a6222 100644 --- a/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp +++ b/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp @@ -61,7 +61,7 @@ class JoinOrderOptimizer { //! Stats of Delim Scans of the Delim Join that is currently being optimized optional_ptr delim_scan_stats; idx_t depth; - static constexpr idx_t THRESHOLD_AVOID_IN_DEPTH_VISIT = 25; + static constexpr idx_t THRESHOLD_AVOID_IN_DEPTH_VISIT = 100; }; } // namespace duckdb From 13594a1b103bcd703d1bd25b3120542710ec3a60 Mon Sep 17 00:00:00 2001 From: Laurens Kuiper Date: Fri, 13 Jun 2025 09:26:46 +0200 Subject: [PATCH 012/100] sort purged nodes and bulk re-add instead of one-by-one --- src/storage/buffer/buffer_pool.cpp | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/src/storage/buffer/buffer_pool.cpp b/src/storage/buffer/buffer_pool.cpp index d62788abfaef..051811da5a0c 100644 --- a/src/storage/buffer/buffer_pool.cpp +++ b/src/storage/buffer/buffer_pool.cpp @@ -211,7 +211,7 @@ void EvictionQueue::PurgeIteration(const idx_t purge_size) { } // bulk purge - idx_t actually_dequeued = q.try_dequeue_bulk(purge_nodes.begin(), purge_size); + const idx_t actually_dequeued = q.try_dequeue_bulk(purge_nodes.begin(), purge_size); // retrieve all alive nodes that have been wrongly dequeued idx_t alive_nodes = 0; @@ -219,11 +219,17 @@ void EvictionQueue::PurgeIteration(const idx_t purge_size) { auto &node = purge_nodes[i]; auto handle = node.TryGetBlockHandle(); if (handle) { - q.enqueue(std::move(node)); - alive_nodes++; + purge_nodes[alive_nodes++] = std::move(node); } } + // order them by sequence number to try somewhat retain LRU behavior, then bulk re-add + std::sort(purge_nodes.begin(), purge_nodes.begin() + NumericCast(alive_nodes), + [](const BufferEvictionNode &lhs, const BufferEvictionNode &rhs) { + return lhs.handle_sequence_number < rhs.handle_sequence_number; + }); + q.enqueue_bulk(purge_nodes.begin(), alive_nodes); + total_dead_nodes -= actually_dequeued - alive_nodes; } From 517a06d465d0b61cde372edfdf83bb0b7530dac4 Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Fri, 13 Jun 2025 09:41:02 +0200 Subject: [PATCH 013/100] Avoid std::move, fix amalgamation --- src/optimizer/join_order/join_order_optimizer.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/optimizer/join_order/join_order_optimizer.cpp b/src/optimizer/join_order/join_order_optimizer.cpp index 7464ed44ddd5..d4f9eb163b9e 100644 --- a/src/optimizer/join_order/join_order_optimizer.cpp +++ b/src/optimizer/join_order/join_order_optimizer.cpp @@ -28,7 +28,7 @@ unique_ptr JoinOrderOptimizer::Optimize(unique_ptr THRESHOLD_AVOID_IN_DEPTH_VISIT) { // Very deep plans will eventually consume quite some stack space // Returning the current plan is always a valid choice - return std::move(plan); + return plan; } // make sure query graph manager has not extracted a relation graph already From f02ca026ff4886255005c4fc6f10dde200d42f8f Mon Sep 17 00:00:00 2001 From: Tmonster Date: Fri, 13 Jun 2025 12:13:53 +0200 Subject: [PATCH 014/100] fix headers --- src/optimizer/statistics/operator/propagate_get.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index 2fc11ae3ea4f..9aedb26335c5 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -1,15 +1,17 @@ #include "duckdb/common/helper.hpp" #include "duckdb/optimizer/statistics_propagator.hpp" #include "duckdb/planner/expression/bound_columnref_expression.hpp" +#include "duckdb/planner/expression_iterator.hpp" #include "duckdb/planner/filter/conjunction_filter.hpp" #include "duckdb/planner/filter/constant_filter.hpp" #include "duckdb/planner/expression/bound_function_expression.hpp" +#include "duckdb/planner/expression/bound_reference_expression.hpp" #include "duckdb/planner/filter/expression_filter.hpp" #include "duckdb/planner/filter/null_filter.hpp" #include "duckdb/planner/operator/logical_get.hpp" #include "duckdb/planner/table_filter.hpp" -#include + namespace duckdb { From 5da78bc7bd86e371b36e76a33aa64d992f22c34d Mon Sep 17 00:00:00 2001 From: Tmonster Date: Fri, 13 Jun 2025 13:01:52 +0200 Subject: [PATCH 015/100] format fix --- src/optimizer/statistics/operator/propagate_get.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index 9aedb26335c5..432a311d4ac3 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -11,8 +11,6 @@ #include "duckdb/planner/operator/logical_get.hpp" #include "duckdb/planner/table_filter.hpp" - - namespace duckdb { static void GetColumnIndex(unique_ptr &expr, idx_t &index) { From 9590c3d2835986931536fe5d01ba880182abf09f Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Fri, 13 Jun 2025 13:04:37 +0200 Subject: [PATCH 016/100] Use max_expression_depth to determine the maximum depth --- .../duckdb/optimizer/join_order/join_order_optimizer.hpp | 1 - src/optimizer/join_order/join_order_optimizer.cpp | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp b/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp index a783f17a6222..527ccf94d5ad 100644 --- a/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp +++ b/src/include/duckdb/optimizer/join_order/join_order_optimizer.hpp @@ -61,7 +61,6 @@ class JoinOrderOptimizer { //! Stats of Delim Scans of the Delim Join that is currently being optimized optional_ptr delim_scan_stats; idx_t depth; - static constexpr idx_t THRESHOLD_AVOID_IN_DEPTH_VISIT = 100; }; } // namespace duckdb diff --git a/src/optimizer/join_order/join_order_optimizer.cpp b/src/optimizer/join_order/join_order_optimizer.cpp index d4f9eb163b9e..5bf3f6a98a77 100644 --- a/src/optimizer/join_order/join_order_optimizer.cpp +++ b/src/optimizer/join_order/join_order_optimizer.cpp @@ -25,7 +25,7 @@ JoinOrderOptimizer JoinOrderOptimizer::CreateChildOptimizer() { unique_ptr JoinOrderOptimizer::Optimize(unique_ptr plan, optional_ptr stats) { - if (depth > THRESHOLD_AVOID_IN_DEPTH_VISIT) { + if (depth > query_graph_manager.context.config.max_expression_depth) { // Very deep plans will eventually consume quite some stack space // Returning the current plan is always a valid choice return plan; From 35b96f8a0d947ee0259742071a3530662391272b Mon Sep 17 00:00:00 2001 From: Laurens Kuiper Date: Fri, 13 Jun 2025 15:59:43 +0200 Subject: [PATCH 017/100] should sort on timestamp, leave that for v1.4.0 --- src/storage/buffer/buffer_pool.cpp | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/storage/buffer/buffer_pool.cpp b/src/storage/buffer/buffer_pool.cpp index 051811da5a0c..f2e35ef1a85d 100644 --- a/src/storage/buffer/buffer_pool.cpp +++ b/src/storage/buffer/buffer_pool.cpp @@ -223,11 +223,7 @@ void EvictionQueue::PurgeIteration(const idx_t purge_size) { } } - // order them by sequence number to try somewhat retain LRU behavior, then bulk re-add - std::sort(purge_nodes.begin(), purge_nodes.begin() + NumericCast(alive_nodes), - [](const BufferEvictionNode &lhs, const BufferEvictionNode &rhs) { - return lhs.handle_sequence_number < rhs.handle_sequence_number; - }); + // bulk re-add (TODO order them by timestamp to better retain the LRU behavior) q.enqueue_bulk(purge_nodes.begin(), alive_nodes); total_dead_nodes -= actually_dequeued - alive_nodes; From 181cf55b0c0b476d8c7091639c3c8ed0e08ce211 Mon Sep 17 00:00:00 2001 From: Zuleykha Pavlichenkova Date: Wed, 18 Jun 2025 10:44:37 +0200 Subject: [PATCH 018/100] adding DONT_LINK parameter to the test extension configuration should fix CI failure when it cannot remove inet.duckdb_extension.info --- scripts/run_extension_medata_tests.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/scripts/run_extension_medata_tests.sh b/scripts/run_extension_medata_tests.sh index 26f0f24d728e..a41b0aeec986 100755 --- a/scripts/run_extension_medata_tests.sh +++ b/scripts/run_extension_medata_tests.sh @@ -54,6 +54,7 @@ else duckdb_extension_load(tpch DONT_LINK EXTENSION_VERSION v0.0.1) duckdb_extension_load(tpcds DONT_LINK EXTENSION_VERSION v0.0.1) duckdb_extension_load(inet + DONT_LINK GIT_URL https://github.com/duckdb/duckdb_inet GIT_TAG eca867b2517af06eabc89ccd6234266e9a7d6d71 INCLUDE_DIR src/include @@ -83,6 +84,7 @@ EOL duckdb_extension_load(json DONT_LINK EXTENSION_VERSION v0.0.1) duckdb_extension_load(tpch DONT_LINK EXTENSION_VERSION v0.0.2) duckdb_extension_load(inet + DONT_LINK GIT_URL https://github.com/duckdb/duckdb_inet GIT_TAG eca867b2517af06eabc89ccd6234266e9a7d6d71 INCLUDE_DIR src/include From 41c3af69ca7a538a9472efceab683ad22e78e883 Mon Sep 17 00:00:00 2001 From: Laurens Kuiper Date: Wed, 18 Jun 2025 14:06:34 +0200 Subject: [PATCH 019/100] grab lock before finalizing filters --- src/planner/table_filter.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/planner/table_filter.cpp b/src/planner/table_filter.cpp index ee6a20ac004a..841d4ad0dbbb 100644 --- a/src/planner/table_filter.cpp +++ b/src/planner/table_filter.cpp @@ -58,6 +58,7 @@ bool DynamicTableFilterSet::HasFilters() const { unique_ptr DynamicTableFilterSet::GetFinalTableFilters(const PhysicalTableScan &scan, optional_ptr existing_filters) const { + lock_guard l(lock); D_ASSERT(HasFilters()); auto result = make_uniq(); if (existing_filters) { From 148396fcf3762a0fa6c8a33e6a03613c5c8c356c Mon Sep 17 00:00:00 2001 From: Christiaan Herrewijn Date: Wed, 18 Jun 2025 16:43:27 +0200 Subject: [PATCH 020/100] bump julia to v1.3.1 --- tools/juliapkg/Project.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/juliapkg/Project.toml b/tools/juliapkg/Project.toml index b68f564181a0..e876d9c4d0a5 100644 --- a/tools/juliapkg/Project.toml +++ b/tools/juliapkg/Project.toml @@ -1,7 +1,7 @@ name = "DuckDB" uuid = "d2f5444f-75bc-4fdf-ac35-56f514c445e1" authors = ["Mark Raasveldt "] -version = "1.2.2" +version = "1.3.1" [deps] DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965" @@ -14,7 +14,7 @@ WeakRefStrings = "ea10d353-3f73-51f8-a26c-33c1cb351aa5" [compat] DBInterface = "2.5" -DuckDB_jll = "1.2.2" +DuckDB_jll = "1.3.1" FixedPointDecimals = "0.4, 0.5, 0.6" Tables = "1.7" WeakRefStrings = "1.4" From aef9792b0d232c738575b072715247619ad902c7 Mon Sep 17 00:00:00 2001 From: Laurens Kuiper Date: Thu, 19 Jun 2025 11:58:20 +0200 Subject: [PATCH 021/100] don't grab lock twice --- src/planner/table_filter.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/planner/table_filter.cpp b/src/planner/table_filter.cpp index 841d4ad0dbbb..df6ca7eee439 100644 --- a/src/planner/table_filter.cpp +++ b/src/planner/table_filter.cpp @@ -59,7 +59,7 @@ unique_ptr DynamicTableFilterSet::GetFinalTableFilters(const PhysicalTableScan &scan, optional_ptr existing_filters) const { lock_guard l(lock); - D_ASSERT(HasFilters()); + D_ASSERT(!filters.empty()); auto result = make_uniq(); if (existing_filters) { for (auto &entry : existing_filters->filters) { From 68df410581f746e05abd26393d54c708c5fb5906 Mon Sep 17 00:00:00 2001 From: Richard Wesley <13156216+hawkfish@users.noreply.github.com> Date: Thu, 19 Jun 2025 15:42:50 +0200 Subject: [PATCH 022/100] Issue #5144: AsOf Join Threshold * Use an inequality for the cardinality test to defend against zero LHS cardinalities fixes: duckdblabs/duckdb-internal#5144 --- src/execution/physical_plan/plan_asof_join.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/execution/physical_plan/plan_asof_join.cpp b/src/execution/physical_plan/plan_asof_join.cpp index 14cb7d4e870d..f435c4b2d551 100644 --- a/src/execution/physical_plan/plan_asof_join.cpp +++ b/src/execution/physical_plan/plan_asof_join.cpp @@ -271,7 +271,7 @@ PhysicalOperator &PhysicalPlanGenerator::PlanAsOfJoin(LogicalComparisonJoin &op) auto &config = ClientConfig::GetConfig(context); if (!config.force_asof_iejoin) { - if (op.children[0]->has_estimated_cardinality && lhs_cardinality <= config.asof_loop_join_threshold) { + if (op.children[0]->has_estimated_cardinality && lhs_cardinality < config.asof_loop_join_threshold) { auto result = PlanAsOfLoopJoin(op, left, right); if (result) { return *result; From 91df10b69f445fa7815d5cb02bf1470e927cddae Mon Sep 17 00:00:00 2001 From: Tmonster Date: Fri, 20 Jun 2025 10:16:55 +0200 Subject: [PATCH 023/100] remove random benchmark files --- benchmark/tpcds_plan_cost/init/load.sql | 0 benchmark/tpcds_plan_cost/init/schema.sql | 0 benchmark/tpcds_plan_cost/queries/04.sql | 120 ---------------------- 3 files changed, 120 deletions(-) delete mode 100644 benchmark/tpcds_plan_cost/init/load.sql delete mode 100644 benchmark/tpcds_plan_cost/init/schema.sql delete mode 100644 benchmark/tpcds_plan_cost/queries/04.sql diff --git a/benchmark/tpcds_plan_cost/init/load.sql b/benchmark/tpcds_plan_cost/init/load.sql deleted file mode 100644 index e69de29bb2d1..000000000000 diff --git a/benchmark/tpcds_plan_cost/init/schema.sql b/benchmark/tpcds_plan_cost/init/schema.sql deleted file mode 100644 index e69de29bb2d1..000000000000 diff --git a/benchmark/tpcds_plan_cost/queries/04.sql b/benchmark/tpcds_plan_cost/queries/04.sql deleted file mode 100644 index fadb0a6c418c..000000000000 --- a/benchmark/tpcds_plan_cost/queries/04.sql +++ /dev/null @@ -1,120 +0,0 @@ -WITH year_total AS - (SELECT c_customer_id customer_id, - c_first_name customer_first_name, - c_last_name customer_last_name, - c_preferred_cust_flag customer_preferred_cust_flag, - c_birth_country customer_birth_country, - c_login customer_login, - c_email_address customer_email_address, - d_year dyear, - sum(((ss_ext_list_price-ss_ext_wholesale_cost-ss_ext_discount_amt)+ss_ext_sales_price)/2) year_total, - 's' sale_type - FROM customer, - store_sales, - date_dim - WHERE c_customer_sk = ss_customer_sk - AND ss_sold_date_sk = d_date_sk - GROUP BY c_customer_id, - c_first_name, - c_last_name, - c_preferred_cust_flag, - c_birth_country, - c_login, - c_email_address, - d_year - UNION ALL SELECT c_customer_id customer_id, - c_first_name customer_first_name, - c_last_name customer_last_name, - c_preferred_cust_flag customer_preferred_cust_flag, - c_birth_country customer_birth_country, - c_login customer_login, - c_email_address customer_email_address, - d_year dyear, - sum((((cs_ext_list_price-cs_ext_wholesale_cost-cs_ext_discount_amt)+cs_ext_sales_price)/2)) year_total, - 'c' sale_type - FROM customer, - catalog_sales, - date_dim - WHERE c_customer_sk = cs_bill_customer_sk - AND cs_sold_date_sk = d_date_sk - GROUP BY c_customer_id, - c_first_name, - c_last_name, - c_preferred_cust_flag, - c_birth_country, - c_login, - c_email_address, - d_year - UNION ALL SELECT c_customer_id customer_id, - c_first_name customer_first_name, - c_last_name customer_last_name, - c_preferred_cust_flag customer_preferred_cust_flag, - c_birth_country customer_birth_country, - c_login customer_login, - c_email_address customer_email_address, - d_year dyear, - sum((((ws_ext_list_price-ws_ext_wholesale_cost-ws_ext_discount_amt)+ws_ext_sales_price)/2)) year_total, - 'w' sale_type - FROM customer, - web_sales, - date_dim - WHERE c_customer_sk = ws_bill_customer_sk - AND ws_sold_date_sk = d_date_sk - GROUP BY c_customer_id, - c_first_name, - c_last_name, - c_preferred_cust_flag, - c_birth_country, - c_login, - c_email_address, - d_year) -SELECT t_s_secyear.customer_id, - t_s_secyear.customer_first_name, - t_s_secyear.customer_last_name, - t_s_secyear.customer_preferred_cust_flag -FROM year_total t_s_firstyear, - year_total t_s_secyear, - year_total t_c_firstyear, - year_total t_c_secyear, - year_total t_w_firstyear, - year_total t_w_secyear -WHERE t_s_secyear.customer_id = t_s_firstyear.customer_id - AND t_s_firstyear.customer_id = t_c_secyear.customer_id - AND t_s_firstyear.customer_id = t_c_firstyear.customer_id - AND t_s_firstyear.customer_id = t_w_firstyear.customer_id - AND t_s_firstyear.customer_id = t_w_secyear.customer_id - AND t_s_firstyear.sale_type = 's' - AND t_c_firstyear.sale_type = 'c' - AND t_w_firstyear.sale_type = 'w' - AND t_s_secyear.sale_type = 's' - AND t_c_secyear.sale_type = 'c' - AND t_w_secyear.sale_type = 'w' - AND t_s_firstyear.dyear = 2001 - AND t_s_secyear.dyear = 2001+1 - AND t_c_firstyear.dyear = 2001 - AND t_c_secyear.dyear = 2001+1 - AND t_w_firstyear.dyear = 2001 - AND t_w_secyear.dyear = 2001+1 - AND t_s_firstyear.year_total > 0 - AND t_c_firstyear.year_total > 0 - AND t_w_firstyear.year_total > 0 - AND CASE - WHEN t_c_firstyear.year_total > 0 THEN t_c_secyear.year_total / t_c_firstyear.year_total - ELSE NULL - END > CASE - WHEN t_s_firstyear.year_total > 0 THEN t_s_secyear.year_total / t_s_firstyear.year_total - ELSE NULL - END - AND CASE - WHEN t_c_firstyear.year_total > 0 THEN t_c_secyear.year_total / t_c_firstyear.year_total - ELSE NULL - END > CASE - WHEN t_w_firstyear.year_total > 0 THEN t_w_secyear.year_total / t_w_firstyear.year_total - ELSE NULL - END -ORDER BY t_s_secyear.customer_id NULLS FIRST, - t_s_secyear.customer_first_name NULLS FIRST, - t_s_secyear.customer_last_name NULLS FIRST, - t_s_secyear.customer_preferred_cust_flag NULLS FIRST -LIMIT 100; - From bb9a013fca28edf5ea3c295156a48f935fef24c4 Mon Sep 17 00:00:00 2001 From: Mytherin Date: Fri, 20 Jun 2025 10:29:18 +0200 Subject: [PATCH 024/100] Use SharedLockTable in DataTable::Fetch --- src/storage/data_table.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/storage/data_table.cpp b/src/storage/data_table.cpp index 8ec2831dfbdf..ec65f9fb762a 100644 --- a/src/storage/data_table.cpp +++ b/src/storage/data_table.cpp @@ -415,7 +415,7 @@ TableStorageInfo DataTable::GetStorageInfo() { //===--------------------------------------------------------------------===// void DataTable::Fetch(DuckTransaction &transaction, DataChunk &result, const vector &column_ids, const Vector &row_identifiers, idx_t fetch_count, ColumnFetchState &state) { - auto lock = info->checkpoint_lock.GetSharedLock(); + auto lock = transaction.SharedLockTable(*info); row_groups->Fetch(transaction, result, column_ids, row_identifiers, fetch_count, state); } From 58968f371f04df6402586cd645aa9dc4ab360473 Mon Sep 17 00:00:00 2001 From: pdet Date: Fri, 20 Jun 2025 13:20:47 +0200 Subject: [PATCH 025/100] We can't cast to hugeint if the data is uhugeint --- src/optimizer/filter_combiner.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/optimizer/filter_combiner.cpp b/src/optimizer/filter_combiner.cpp index 9742d23687ca..96c40c1f7fb9 100644 --- a/src/optimizer/filter_combiner.cpp +++ b/src/optimizer/filter_combiner.cpp @@ -242,7 +242,7 @@ bool FilterCombiner::IsDenseRange(vector &in_list) { if (in_list.empty()) { return true; } - if (!in_list[0].type().IsIntegral()) { + if (!in_list[0].type().IsIntegral() || in_list[0].type() == LogicalType::UHUGEINT) { return false; } // sort the input list From a92491b7d7c465878e778779e42e64badd821f92 Mon Sep 17 00:00:00 2001 From: Alex Kasko Date: Fri, 20 Jun 2025 13:21:50 +0100 Subject: [PATCH 026/100] Disable constexpr std::mutex on Windows On Windows the `constexpr` constructor of `std::mutex`, that was supposed to be there since C++11, was not implemented until VS2022. Its implementation has required to use Slim Reader/Writer (SRW) Locks ([ref](https://learn.microsoft.com/en-us/windows/win32/sync/slim-reader-writer--srw--locks)) that are only supported since Window 7, but VS2019 was still supporting Windows Vista as a target ([more details from SO](https://stackoverflow.com/a/74255773)). The implementation of `constexpr std::mutex` in MSVC has required the ABI breakage in C++ STL that was eventually added in VS2022 17.10 ([commit](https://github.com/microsoft/STL/commit/4aad4b84d69e033d47215ff7d35bdee3e3b66b62)). This commit has introduced the macro `_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR` that can be defined to stay ABI compatible with older versions of C++ stdlib. Thus the binaries built with VS2022 17.10 or later and without this macro cannot be run with older versions of C++ stdlib `msvcp140.dll` even if they do not use `constexpr std::mutex` - any mutex usage will crash with something like this ([more examples and comments from MSFT](https://web.archive.org/web/20250618223106/https://developercommunity.visualstudio.com/t/Access-violation-in-_Thrd_yield-after-up/10664660)): ``` Faulting application name: duckdb.exe, version: 1.3.1.0, time stamp: 0x684fdb82 Faulting module name: MSVCP140.dll, version: 14.36.32532.0, time stamp: 0x04a30cf0 Exception code: 0xc0000005 ``` This PR adds the `_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR` macro definition to Windows builds assuming that we are not going to use `constexpr` constructor of `std::mutex` and we want to be able to run with `msvcp140.dll` while being compiled with newer toolchains. Note, that running binaries, that were built against `msvcp140.dll` version `14.40+`, in environment with earlier versions `msvcp140.dll` is not officially supported by MSFT ([ref](https://learn.microsoft.com/en-us/cpp/porting/binary-compat-2015-2017?view=msvc-170)). But we don't really have a choice here (unless we want to keep DuckDB itself on VS2019). Extensions (which build should include the engine CMake file being update by this PR) are going to be loaded though JDBC into JVM processes. As of mid 2025, OpenJDK builds from some of major vendors (e.g. Amazon Corretto), including the latest stable JDK 24 (released in March 2025) are still using VS2019 (likely the topic of this issue is one of the reasons for that). And all these JDKs include a vendored copy of `msvcp140.dll` version `14.29`. Due to the way, how Windows shared lib loader works, this vendored C++ stdlib will be loaded by the JVM instead of any system one. And then later when the JVM will load DuckDB extensions shared libs through JDBC - these extensions will also use this pre-loaded version of C++ stdlib, as we do not do static linking for it. In general, LTS JDK versions have 10+ years of production support (for example, JDK 6 released in late 2006 is still supported by some vendors). And even if later updates of LTS JDKs (11, 17, 21, 24 etc) will move to a newer version of MSVC toolchain - the old JDK binaries are going to be still in use for a long time. Thus this change is proposed as a permanent change - not a temporary workaround. Testing: additional test run of `unittest.exe` is added that uses `msvcp140.dll` from VS2019 instead of the system-provided one. Fixes: #17971 --- .github/workflows/Windows.yml | 9 +++++++++ CMakeLists.txt | 5 ++++- 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/.github/workflows/Windows.yml b/.github/workflows/Windows.yml index 2ac5ceb84be3..32e2633d3d56 100644 --- a/.github/workflows/Windows.yml +++ b/.github/workflows/Windows.yml @@ -98,6 +98,15 @@ jobs: run: | test/Release/unittest.exe + - name: Test with VS2019 C++ stdlib + shell: bash + if: ${{ inputs.skip_tests != 'true' }} + run: | + choco install wget -y --no-progress + wget -P test/Release https://blobs.duckdb.org/ci/msvcp140.dll + test/Release/unittest.exe + rm test/Release/msvcp140.dll + - name: Tools Test shell: bash if: ${{ inputs.skip_tests != 'true' }} diff --git a/CMakeLists.txt b/CMakeLists.txt index 1705fcb77a45..a51fbdcdc9fa 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -642,8 +642,11 @@ if(NOT MSVC) message(WARNING "Please use a recent compiler for debug builds") endif() else() + # we don't use "constexpr static std::mutex", so we can use the + # _DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR definition that is required + # to keep the compatibility with C++ stdlib version 14.29 from MSVC 2019 set(CMAKE_CXX_WINDOWS_FLAGS - "/wd4244 /wd4267 /wd4200 /wd26451 /wd26495 /D_CRT_SECURE_NO_WARNINGS /utf-8") + "/wd4244 /wd4267 /wd4200 /wd26451 /wd26495 /D_CRT_SECURE_NO_WARNINGS /D_DISABLE_CONSTEXPR_MUTEX_CONSTRUCTOR /utf-8") if(TREAT_WARNINGS_AS_ERRORS) set(CMAKE_CXX_WINDOWS_FLAGS "${CMAKE_CXX_WINDOWS_FLAGS} /WX") endif() From 6da6b745b069ff08cb2f4100784a1a25f9c60e5c Mon Sep 17 00:00:00 2001 From: Alex Kasko Date: Fri, 20 Jun 2025 18:32:14 +0100 Subject: [PATCH 027/100] On Windows CI use zip from msys2 instead of choco The command `choco install zip -y --force` has started failing on GH actions Windows runners. It is not clear how long this failure will persist. It is proposed to use zip utility from msys2 instead of choco at least temporary to allow Windows jobs to run to completion. --- .github/workflows/Windows.yml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/Windows.yml b/.github/workflows/Windows.yml index 2ac5ceb84be3..c193d2cc4bab 100644 --- a/.github/workflows/Windows.yml +++ b/.github/workflows/Windows.yml @@ -130,9 +130,9 @@ jobs: AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_DUCKDB_STAGING_KEY }} run: | python scripts/amalgamation.py - choco install zip -y --force - zip -j duckdb_cli-windows-amd64.zip Release/duckdb.exe - zip -j libduckdb-windows-amd64.zip src/Release/duckdb.dll src/Release/duckdb.lib src/amalgamation/duckdb.hpp src/include/duckdb.h + /c/msys64/usr/bin/bash.exe -lc "pacman -Sy --noconfirm zip" + /c/msys64/usr/bin/zip.exe -j duckdb_cli-windows-amd64.zip Release/duckdb.exe + /c/msys64/usr/bin/zip.exe -j libduckdb-windows-amd64.zip src/Release/duckdb.dll src/Release/duckdb.lib src/amalgamation/duckdb.hpp src/include/duckdb.h ./scripts/upload-assets-to-staging.sh github_release libduckdb-windows-amd64.zip duckdb_cli-windows-amd64.zip - uses: actions/upload-artifact@v4 @@ -239,9 +239,9 @@ jobs: AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_DUCKDB_STAGING_KEY }} run: | python scripts/amalgamation.py - choco install zip -y --force - zip -j duckdb_cli-windows-arm64.zip Release/duckdb.exe - zip -j libduckdb-windows-arm64.zip src/Release/duckdb.dll src/Release/duckdb.lib src/amalgamation/duckdb.hpp src/include/duckdb.h + /c/msys64/usr/bin/bash.exe -lc "pacman -Sy --noconfirm zip" + /c/msys64/usr/bin/zip.exe -j duckdb_cli-windows-arm64.zip Release/duckdb.exe + /c/msys64/usr/bin/zip.exe -j libduckdb-windows-arm64.zip src/Release/duckdb.dll src/Release/duckdb.lib src/amalgamation/duckdb.hpp src/include/duckdb.h ./scripts/upload-assets-to-staging.sh github_release libduckdb-windows-arm64.zip duckdb_cli-windows-arm64.zip - uses: actions/upload-artifact@v4 From bf2aa87a8b3fa87e8c7ce4d9ec59eae4c32715be Mon Sep 17 00:00:00 2001 From: Rusty Conover Date: Sat, 21 Jun 2025 22:39:20 -0400 Subject: [PATCH 028/100] fix: check validity mask before copying data into ArrowBool8 --- src/common/arrow/arrow_type_extension.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/common/arrow/arrow_type_extension.cpp b/src/common/arrow/arrow_type_extension.cpp index dee514cad4ce..38fc867d699c 100644 --- a/src/common/arrow/arrow_type_extension.cpp +++ b/src/common/arrow/arrow_type_extension.cpp @@ -358,7 +358,9 @@ struct ArrowBool8 { auto source_ptr = reinterpret_cast(format.data); auto result_ptr = reinterpret_cast(FlatVector::GetData(result)); for (idx_t i = 0; i < count; i++) { - result_ptr[i] = static_cast(source_ptr[i]); + if (format.validity.RowIsValid(i)) { + result_ptr[i] = static_cast(source_ptr[i]); + } } } }; From 50f72f5aa52efaa518e3e3bdc1ad525336afdc77 Mon Sep 17 00:00:00 2001 From: taniabogatsch <44262898+taniabogatsch@users.noreply.github.com> Date: Mon, 23 Jun 2025 13:16:35 +0200 Subject: [PATCH 029/100] use getcolumnnames to avoid matching the alias to lambda parameters --- .../expression/bind_columnref_expression.cpp | 5 +- .../expression_binder/alter_binder.cpp | 5 +- .../expression_binder/having_binder.cpp | 4 +- .../table_function_binder.cpp | 8 +-- .../list/test_lambda_with_struct_aliases.test | 57 +++++++++++++++++++ 5 files changed, 67 insertions(+), 12 deletions(-) create mode 100644 test/sql/function/list/test_lambda_with_struct_aliases.test diff --git a/src/planner/binder/expression/bind_columnref_expression.cpp b/src/planner/binder/expression/bind_columnref_expression.cpp index 5731bf3a17f9..026226221573 100644 --- a/src/planner/binder/expression/bind_columnref_expression.cpp +++ b/src/planner/binder/expression/bind_columnref_expression.cpp @@ -445,10 +445,9 @@ unique_ptr ExpressionBinder::QualifyColumnNameWithManyDots(Col } unique_ptr ExpressionBinder::QualifyColumnName(ColumnRefExpression &col_ref, ErrorData &error) { - - // try binding as a lambda parameter if (!col_ref.IsQualified()) { - auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetName()); + // Try binding as a lambda parameter. + auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetColumnName()); if (lambda_ref) { return lambda_ref; } diff --git a/src/planner/expression_binder/alter_binder.cpp b/src/planner/expression_binder/alter_binder.cpp index 797e37111640..128ba6541033 100644 --- a/src/planner/expression_binder/alter_binder.cpp +++ b/src/planner/expression_binder/alter_binder.cpp @@ -38,10 +38,9 @@ string AlterBinder::UnsupportedAggregateMessage() { } BindResult AlterBinder::BindColumnReference(ColumnRefExpression &col_ref, idx_t depth) { - - // try binding as a lambda parameter if (!col_ref.IsQualified()) { - auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetName()); + // Try binding as a lambda parameter. + auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetColumnName()); if (lambda_ref) { return BindLambdaReference(lambda_ref->Cast(), depth); } diff --git a/src/planner/expression_binder/having_binder.cpp b/src/planner/expression_binder/having_binder.cpp index 6f0c96a06517..902add5e28cc 100644 --- a/src/planner/expression_binder/having_binder.cpp +++ b/src/planner/expression_binder/having_binder.cpp @@ -44,9 +44,9 @@ BindResult HavingBinder::BindColumnRef(unique_ptr &expr_ptr, i auto col_ref = expr_ptr->Cast(); const auto &column_name = col_ref.GetColumnName(); - // Try binding as a lambda parameter if (!col_ref.IsQualified()) { - auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetName()); + // Try binding as a lambda parameter. + auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetColumnName()); if (lambda_ref) { return BindLambdaReference(lambda_ref->Cast(), depth); } diff --git a/src/planner/expression_binder/table_function_binder.cpp b/src/planner/expression_binder/table_function_binder.cpp index 71ccdefe4dd2..3c3c1491c485 100644 --- a/src/planner/expression_binder/table_function_binder.cpp +++ b/src/planner/expression_binder/table_function_binder.cpp @@ -18,18 +18,18 @@ BindResult TableFunctionBinder::BindLambdaReference(LambdaRefExpression &expr, i BindResult TableFunctionBinder::BindColumnReference(unique_ptr &expr_ptr, idx_t depth, bool root_expression) { - // try binding as a lambda parameter auto &col_ref = expr_ptr->Cast(); if (!col_ref.IsQualified()) { - auto column_name = col_ref.GetName(); - auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, column_name); + // Try binding as a lambda parameter. + auto lambda_ref = LambdaRefExpression::FindMatchingBinding(lambda_bindings, col_ref.GetColumnName()); if (lambda_ref) { return BindLambdaReference(lambda_ref->Cast(), depth); } - if (binder.macro_binding && binder.macro_binding->HasMatchingBinding(column_name)) { + if (binder.macro_binding && binder.macro_binding->HasMatchingBinding(col_ref.GetName())) { throw ParameterNotResolvedException(); } } + auto query_location = col_ref.GetQueryLocation(); auto column_names = col_ref.column_names; auto result_name = StringUtil::Join(column_names, "."); diff --git a/test/sql/function/list/test_lambda_with_struct_aliases.test b/test/sql/function/list/test_lambda_with_struct_aliases.test new file mode 100644 index 000000000000..17c7f815ecd1 --- /dev/null +++ b/test/sql/function/list/test_lambda_with_struct_aliases.test @@ -0,0 +1,57 @@ +# name: test/sql/function/list/lambdas/test_lambda_with_struct_aliases.test +# description: Test binding lambda functions containing a STRUCT with an alias. +# group: [lambdas] + +statement ok +PRAGMA enable_verification; + +# Test TableFunctionBinder::BindColumnReference. + +query I +SELECT COALESCE(*COLUMNS(lambda c: {'title': c}.title IN ('a', 'c'))) +FROM (SELECT NULL, 2, 3) t(a, b, c); +---- +3 + +# Test HavingBinder::BindColumnRef. + +statement ok +CREATE TABLE addresses (i INT, b INT); + +statement ok +INSERT INTO addresses VALUES (1, 10), (2, 20), (1, 52), (3, 7); + +query II +SELECT i, sum(b) FROM addresses +GROUP BY i +HAVING sum(b) >= list_sum(list_transform([20], lambda x: {'title': x}.title + 30)) +---- +1 62 + +# Test ExpressionBinder::QualifyColumnName. + +query I +SELECT list_transform([10], lambda x: sum(1) + {'title': x}.title) +---- +[11] + +# Test AlterBinder::BindColumnReference. + +statement ok +CREATE TABLE test (a VARCHAR[]); + +statement ok +INSERT INTO test VALUES (NULL), ([]), (['asdf']), (['qwer', 'CXZASDF']); + +statement ok +ALTER TABLE test +ALTER COLUMN a TYPE STRUCT(title VARCHAR)[] +USING (list_transform(a, lambda x: {'title': x})); + +query I +SELECT a FROM test ORDER BY ALL; +---- +[] +[{'title': asdf}] +[{'title': qwer}, {'title': CXZASDF}] +NULL From b8877798ed1a54f1092763914399f3ce7c417247 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Mon, 23 Jun 2025 13:33:44 +0200 Subject: [PATCH 030/100] constant or null can be replaced when argument is a bound column reg --- .../scalar/generic/constant_or_null.cpp | 5 +++- .../test_constant_or_null_pushdown.test | 25 +++++++++++++++++++ 2 files changed, 29 insertions(+), 1 deletion(-) create mode 100644 test/optimizer/pushdown/test_constant_or_null_pushdown.test diff --git a/src/function/scalar/generic/constant_or_null.cpp b/src/function/scalar/generic/constant_or_null.cpp index cc7c7901dea6..a73dba9138f0 100644 --- a/src/function/scalar/generic/constant_or_null.cpp +++ b/src/function/scalar/generic/constant_or_null.cpp @@ -80,7 +80,10 @@ bool ConstantOrNull::IsConstantOrNull(BoundFunctionExpression &expr, const Value D_ASSERT(expr.bind_info); auto &bind_data = expr.bind_info->Cast(); D_ASSERT(bind_data.value.type() == val.type()); - return bind_data.value == val; + if (expr.children.size() == 2 && expr.children.at(1)->type == ExpressionType::BOUND_COLUMN_REF) { + return bind_data.value == val; + } + return false; } unique_ptr ConstantOrNullBind(ClientContext &context, ScalarFunction &bound_function, diff --git a/test/optimizer/pushdown/test_constant_or_null_pushdown.test b/test/optimizer/pushdown/test_constant_or_null_pushdown.test new file mode 100644 index 000000000000..09e1a7e65a72 --- /dev/null +++ b/test/optimizer/pushdown/test_constant_or_null_pushdown.test @@ -0,0 +1,25 @@ +# name: test/optimizer/pushdown/test_constant_or_null_pushdown.test +# description: Test Table OR Filter Push Down +# group: [pushdown] + +statement ok +create table t1 (ts_stop TIMESTAMPTZ); + +statement ok +insert into t1 values (NULL), (NULL); + +query II +explain select count(*) from t1 where constant_or_null(true, COALESCE(ts_stop, '9999-09-09 07:09:09+00'::TIMESTAMPTZ), '2025-06-23 10:32:02.216+00'::TIMESTAMPTZ); +---- +physical_plan :.*constant_or_null.* + +statement ok +create table t2 as select range%2 a, range b from range(100); + +statement ok +insert into t2 values (NULL, NULL), (NULL, NULL), (NULL, NULL); + +query II +explain select * from t2 where constant_or_null(true, a); +---- +physical_plan :.*a IS NOT NULL.* \ No newline at end of file From b5b5d555af187db06e41143a90b7b9f4fb494977 Mon Sep 17 00:00:00 2001 From: taniabogatsch <44262898+taniabogatsch@users.noreply.github.com> Date: Mon, 23 Jun 2025 15:21:45 +0200 Subject: [PATCH 031/100] format fix --- test/sql/function/list/test_lambda_with_struct_aliases.test | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/sql/function/list/test_lambda_with_struct_aliases.test b/test/sql/function/list/test_lambda_with_struct_aliases.test index 17c7f815ecd1..c7ed227ee250 100644 --- a/test/sql/function/list/test_lambda_with_struct_aliases.test +++ b/test/sql/function/list/test_lambda_with_struct_aliases.test @@ -1,6 +1,6 @@ -# name: test/sql/function/list/lambdas/test_lambda_with_struct_aliases.test +# name: test/sql/function/list/test_lambda_with_struct_aliases.test # description: Test binding lambda functions containing a STRUCT with an alias. -# group: [lambdas] +# group: [list] statement ok PRAGMA enable_verification; From d5a3a00a7e8fb8abd9a09e1d3bc5fd1850db29f8 Mon Sep 17 00:00:00 2001 From: Laurens Kuiper Date: Mon, 23 Jun 2025 16:37:04 +0200 Subject: [PATCH 032/100] make test more lenient --- test/sql/copy/per_thread_output.test | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/sql/copy/per_thread_output.test b/test/sql/copy/per_thread_output.test index 0efcf832842d..4698d0bfbeaf 100644 --- a/test/sql/copy/per_thread_output.test +++ b/test/sql/copy/per_thread_output.test @@ -40,7 +40,7 @@ SELECT COUNT(*) FROM read_csv('__TEST_DIR__/per_thread_output_csv/*.csv', column 20000 query I -SELECT COUNT(*) > 2 f FROM GLOB('__TEST_DIR__/per_thread_output_csv/data_*.csv') ORDER BY f +SELECT COUNT(*) >= 2 f FROM GLOB('__TEST_DIR__/per_thread_output_csv/data_*.csv') ORDER BY f ---- true From 8eeda406696520557cbd5cfeaaf866e53100cdee Mon Sep 17 00:00:00 2001 From: taniabogatsch <44262898+taniabogatsch@users.noreply.github.com> Date: Mon, 23 Jun 2025 17:09:10 +0200 Subject: [PATCH 033/100] ensure we print internal exception stack traces on failed rollback --- src/common/error_data.cpp | 7 +++++++ src/include/duckdb/storage/table/segment_tree.hpp | 2 +- src/transaction/duck_transaction_manager.cpp | 9 ++++++--- 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/src/common/error_data.cpp b/src/common/error_data.cpp index c1e564217f64..bbb1fe12de85 100644 --- a/src/common/error_data.cpp +++ b/src/common/error_data.cpp @@ -65,6 +65,13 @@ string ErrorData::ConstructFinalMessage() const { error += "\nThis error signals an assertion failure within DuckDB. This usually occurs due to " "unexpected conditions or errors in the program's logic.\nFor more information, see " "https://duckdb.org/docs/stable/dev/internal_errors"; + + // Ensure that we print the stack trace for internal exceptions. + auto entry = extra_info.find("stack_trace_pointers"); + if (entry != extra_info.end()) { + auto stack_trace = StackTrace::ResolveStacktraceSymbols(entry->second); + error += "\n\n" + stack_trace; + } } return error; } diff --git a/src/include/duckdb/storage/table/segment_tree.hpp b/src/include/duckdb/storage/table/segment_tree.hpp index 1a461ac37f22..647ba06ea2c2 100644 --- a/src/include/duckdb/storage/table/segment_tree.hpp +++ b/src/include/duckdb/storage/table/segment_tree.hpp @@ -198,7 +198,7 @@ class SegmentTree { error += StringUtil::Format("Node %lld: Start %lld, Count %lld", i, nodes[i].row_start, nodes[i].node->count.load()); } - throw InternalException("Could not find node in column segment tree!\n%s%s", error, Exception::GetStackTrace()); + throw InternalException("Could not find node in column segment tree!\n%s", error); } bool TryGetSegmentIndex(SegmentLock &l, idx_t row_number, idx_t &result) { diff --git a/src/transaction/duck_transaction_manager.cpp b/src/transaction/duck_transaction_manager.cpp index a114bdc2df1a..dc4997b50624 100644 --- a/src/transaction/duck_transaction_manager.cpp +++ b/src/transaction/duck_transaction_manager.cpp @@ -269,14 +269,17 @@ ErrorData DuckTransactionManager::CommitTransaction(ClientContext &context, Tran if (!error.HasError()) { error = transaction.Commit(db, commit_id, std::move(commit_state)); } + if (error.HasError()) { - // commit unsuccessful: rollback the transaction instead + // COMMIT not successful: ROLLBACK. checkpoint_decision = CheckpointDecision(error.Message()); transaction.commit_id = 0; + auto rollback_error = transaction.Rollback(); if (rollback_error.HasError()) { - throw FatalException("Failed to rollback transaction. Cannot continue operation.\nError: %s", - rollback_error.Message()); + throw FatalException( + "Failed to rollback transaction. Cannot continue operation.\nOriginal Error: %s\nRollback Error: %s", + error.Message(), rollback_error.Message()); } } else { // check if catalog changes were made From f06a081c469b7a4ade5f1b628e790190be5927bb Mon Sep 17 00:00:00 2001 From: taniabogatsch <44262898+taniabogatsch@users.noreply.github.com> Date: Mon, 23 Jun 2025 17:58:19 +0200 Subject: [PATCH 034/100] more fixes around getdatabases --- src/catalog/catalog.cpp | 2 +- src/main/database_manager.cpp | 9 +++++++-- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 196940ca7449..bb895d4d7921 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -662,7 +662,7 @@ CatalogException Catalog::CreateMissingEntryException(CatalogEntryRetriever &ret break; } auto &catalog = database.get().GetCatalog(); - auto current_schemas = catalog.GetAllSchemas(context); + auto current_schemas = catalog.GetSchemas(context); for (auto ¤t_schema : current_schemas) { if (unseen_schemas.size() >= max_schema_count) { break; diff --git a/src/main/database_manager.cpp b/src/main/database_manager.cpp index 604fe06d066f..88e2c6dc6e83 100644 --- a/src/main/database_manager.cpp +++ b/src/main/database_manager.cpp @@ -256,8 +256,13 @@ vector> DatabaseManager::GetDatabases(ClientContext return true; }); - result.push_back(*system); - result.push_back(*context.client_data->temporary_objects); + if (!max_db_count.IsValid() || max_db_count.GetIndex() >= 1) { + result.push_back(*system); + } + if (!max_db_count.IsValid() || max_db_count.GetIndex() >= 2) { + result.push_back(*context.client_data->temporary_objects); + } + return result; } From d9a7e50cf8dd3dbb8b791c5fcddfc1e19f1cf63c Mon Sep 17 00:00:00 2001 From: Laurens Kuiper Date: Tue, 24 Jun 2025 08:44:54 +0200 Subject: [PATCH 035/100] implement bulk enqueue for no threads --- src/include/duckdb/parallel/concurrentqueue.hpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/include/duckdb/parallel/concurrentqueue.hpp b/src/include/duckdb/parallel/concurrentqueue.hpp index 7c277ac49983..ddbb5870a416 100644 --- a/src/include/duckdb/parallel/concurrentqueue.hpp +++ b/src/include/duckdb/parallel/concurrentqueue.hpp @@ -84,6 +84,14 @@ class ConcurrentQueue { } return max; } + + template + bool enqueue_bulk(It itemFirst, size_t count) { + for (size_t i = 0; i < count; i++) { + q.push(std::move(*itemFirst++)); + } + return true; + } }; } // namespace duckdb_moodycamel From 151ec8d50a1190f49045a949273d3cf9d8686802 Mon Sep 17 00:00:00 2001 From: Laurens Kuiper Date: Tue, 24 Jun 2025 10:05:00 +0200 Subject: [PATCH 036/100] format --- src/include/duckdb/parallel/concurrentqueue.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/include/duckdb/parallel/concurrentqueue.hpp b/src/include/duckdb/parallel/concurrentqueue.hpp index ddbb5870a416..4ab2a8165709 100644 --- a/src/include/duckdb/parallel/concurrentqueue.hpp +++ b/src/include/duckdb/parallel/concurrentqueue.hpp @@ -85,7 +85,7 @@ class ConcurrentQueue { return max; } - template + template bool enqueue_bulk(It itemFirst, size_t count) { for (size_t i = 0; i < count; i++) { q.push(std::move(*itemFirst++)); From 54a879b40780686b63c613562bedae3a58191c4f Mon Sep 17 00:00:00 2001 From: Mathias Lafeldt Date: Mon, 23 Jun 2025 14:38:43 +0200 Subject: [PATCH 037/100] Bring back libduckdb-src.zip as release artifact --- .github/workflows/LinuxRelease.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/LinuxRelease.yml b/.github/workflows/LinuxRelease.yml index 2ab8e98be63c..dccbbf195716 100644 --- a/.github/workflows/LinuxRelease.yml +++ b/.github/workflows/LinuxRelease.yml @@ -106,10 +106,12 @@ jobs: AWS_ACCESS_KEY_ID: ${{ secrets.S3_DUCKDB_STAGING_ID }} AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_DUCKDB_STAGING_KEY }} run: | + python3 scripts/amalgamation.py zip -j duckdb_cli-linux-${{ matrix.config.arch }}.zip build/release/duckdb gzip -9 -k -n -c build/release/duckdb > duckdb_cli-linux-${{ matrix.config.arch }}.gz zip -j libduckdb-linux-${{ matrix.config.arch }}.zip build/release/src/libduckdb*.* src/amalgamation/duckdb.hpp src/include/duckdb.h - ./scripts/upload-assets-to-staging.sh github_release libduckdb-linux-${{ matrix.config.arch }}.zip duckdb_cli-linux-${{ matrix.config.arch }}.zip duckdb_cli-linux-${{ matrix.config.arch }}.gz + zip -j libduckdb-src.zip src/amalgamation/duckdb.hpp src/amalgamation/duckdb.cpp src/include/duckdb.h src/include/duckdb_extension.h + ./scripts/upload-assets-to-staging.sh github_release libduckdb-src.zip libduckdb-linux-${{ matrix.config.arch }}.zip duckdb_cli-linux-${{ matrix.config.arch }}.zip duckdb_cli-linux-${{ matrix.config.arch }}.gz - uses: actions/upload-artifact@v4 with: From 679fd298546bd43c722c60b161761cfc75a98d65 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Tue, 24 Jun 2025 12:48:19 +0200 Subject: [PATCH 038/100] is_constant_or_null is only replaced if all args are constant or a bound ref --- .../scalar/generic/constant_or_null.cpp | 5 +-- .../statistics/operator/propagate_get.cpp | 42 ++++++++++++++++++- 2 files changed, 42 insertions(+), 5 deletions(-) diff --git a/src/function/scalar/generic/constant_or_null.cpp b/src/function/scalar/generic/constant_or_null.cpp index a73dba9138f0..cc7c7901dea6 100644 --- a/src/function/scalar/generic/constant_or_null.cpp +++ b/src/function/scalar/generic/constant_or_null.cpp @@ -80,10 +80,7 @@ bool ConstantOrNull::IsConstantOrNull(BoundFunctionExpression &expr, const Value D_ASSERT(expr.bind_info); auto &bind_data = expr.bind_info->Cast(); D_ASSERT(bind_data.value.type() == val.type()); - if (expr.children.size() == 2 && expr.children.at(1)->type == ExpressionType::BOUND_COLUMN_REF) { - return bind_data.value == val; - } - return false; + return bind_data.value == val; } unique_ptr ConstantOrNullBind(ClientContext &context, ScalarFunction &bound_function, diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index 2ff9be3ea56d..52835f2ab151 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -46,6 +46,41 @@ void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &input, TableFi } } +static bool IsConstantOrNullFilter(TableFilter &table_filter) { + if (table_filter.filter_type != TableFilterType::EXPRESSION_FILTER) { + return false; + } + auto &expr_filter = table_filter.Cast(); + if (expr_filter.expr->type != ExpressionType::BOUND_FUNCTION) { + return false; + } + auto &func = expr_filter.expr->Cast(); + return ConstantOrNull::IsConstantOrNull(func, Value::BOOLEAN(true)); +} + +static bool CanReplaceConstantOrNull(TableFilter &table_filter) { + if (!IsConstantOrNullFilter(table_filter)) { + throw InternalException("CanReplaceConstantOrNull() called on unexepected Table Filter"); + } + D_ASSERT(table_filter->filter_type == TableFilterType::EXPRESSION_FILTER); + auto &expr_filter = table_filter.Cast(); + auto &func = expr_filter.expr->Cast(); + if (ConstantOrNull::IsConstantOrNull(func, Value::BOOLEAN(true))) { + for (auto child = ++func.children.begin(); child != func.children.end(); child++) { + switch (child->get()->type) { + case ExpressionType::BOUND_REF: + case ExpressionType::VALUE_CONSTANT: + continue; + default: + // expression type could be a function like Coalesce + return false; + } + } + } + // all children of constant or null are bound refs to the table filter column + return true; +} + unique_ptr StatisticsPropagator::PropagateStatistics(LogicalGet &get, unique_ptr &node_ptr) { if (get.function.cardinality) { @@ -99,10 +134,15 @@ unique_ptr StatisticsPropagator::PropagateStatistics(LogicalGet // erase this condition get.table_filters.filters.erase(table_filter_column); break; - case FilterPropagateResult::FILTER_TRUE_OR_NULL: + case FilterPropagateResult::FILTER_TRUE_OR_NULL: { + if (IsConstantOrNullFilter(*get.table_filters.filters[table_filter_column]) && + !CanReplaceConstantOrNull(*get.table_filters.filters[table_filter_column])) { + break; + } // filter is true or null; we can replace this with a not null filter get.table_filters.filters[table_filter_column] = make_uniq(); break; + } case FilterPropagateResult::FILTER_FALSE_OR_NULL: case FilterPropagateResult::FILTER_ALWAYS_FALSE: // filter is always false; this entire filter should be replaced by an empty result block From c055865d7d2be478fc38674736f1a53eb304ad28 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Tue, 24 Jun 2025 12:56:25 +0200 Subject: [PATCH 039/100] fix D_ASSERT syntax --- src/optimizer/statistics/operator/propagate_get.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index 52835f2ab151..0916b96603f8 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -62,7 +62,7 @@ static bool CanReplaceConstantOrNull(TableFilter &table_filter) { if (!IsConstantOrNullFilter(table_filter)) { throw InternalException("CanReplaceConstantOrNull() called on unexepected Table Filter"); } - D_ASSERT(table_filter->filter_type == TableFilterType::EXPRESSION_FILTER); + D_ASSERT(table_filter.filter_type == TableFilterType::EXPRESSION_FILTER); auto &expr_filter = table_filter.Cast(); auto &func = expr_filter.expr->Cast(); if (ConstantOrNull::IsConstantOrNull(func, Value::BOOLEAN(true))) { From ab6c24b01e761e2722ee8ec393b0fd9bb9bd98b1 Mon Sep 17 00:00:00 2001 From: Mathias Lafeldt Date: Tue, 24 Jun 2025 13:19:17 +0200 Subject: [PATCH 040/100] Move libduckdb-src.zip upload to separate CI job --- .github/workflows/LinuxRelease.yml | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/.github/workflows/LinuxRelease.yml b/.github/workflows/LinuxRelease.yml index dccbbf195716..e27694d8cb4c 100644 --- a/.github/workflows/LinuxRelease.yml +++ b/.github/workflows/LinuxRelease.yml @@ -110,8 +110,7 @@ jobs: zip -j duckdb_cli-linux-${{ matrix.config.arch }}.zip build/release/duckdb gzip -9 -k -n -c build/release/duckdb > duckdb_cli-linux-${{ matrix.config.arch }}.gz zip -j libduckdb-linux-${{ matrix.config.arch }}.zip build/release/src/libduckdb*.* src/amalgamation/duckdb.hpp src/include/duckdb.h - zip -j libduckdb-src.zip src/amalgamation/duckdb.hpp src/amalgamation/duckdb.cpp src/include/duckdb.h src/include/duckdb_extension.h - ./scripts/upload-assets-to-staging.sh github_release libduckdb-src.zip libduckdb-linux-${{ matrix.config.arch }}.zip duckdb_cli-linux-${{ matrix.config.arch }}.zip duckdb_cli-linux-${{ matrix.config.arch }}.gz + ./scripts/upload-assets-to-staging.sh github_release libduckdb-linux-${{ matrix.config.arch }}.zip duckdb_cli-linux-${{ matrix.config.arch }}.zip duckdb_cli-linux-${{ matrix.config.arch }}.gz - uses: actions/upload-artifact@v4 with: @@ -140,6 +139,27 @@ jobs: build/release/benchmark/benchmark_runner benchmark/micro/update/update_with_join.benchmark build/release/duckdb -c "COPY (SELECT 42) TO '/dev/stdout' (FORMAT PARQUET)" | cat + upload-libduckdb-src: + name: Upload libduckdb-src.zip + needs: linux-release-cli + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + with: + fetch-depth: 0 + ref: ${{ inputs.git_ref }} + + - name: Deploy + shell: bash + env: + AWS_ACCESS_KEY_ID: ${{ secrets.S3_DUCKDB_STAGING_ID }} + AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_DUCKDB_STAGING_KEY }} + run: | + python3 scripts/amalgamation.py + zip -j libduckdb-src.zip src/amalgamation/duckdb.hpp src/amalgamation/duckdb.cpp src/include/duckdb.h src/include/duckdb_extension.h + ./scripts/upload-assets-to-staging.sh github_release libduckdb-src.zip + linux-extensions-64: # Builds extensions for linux_amd64 name: Linux Extensions (x64) From f72d15d546bd7561152575502bd7e5ac02ceffe5 Mon Sep 17 00:00:00 2001 From: Richard Wesley <13156216+hawkfish@users.noreply.github.com> Date: Tue, 24 Jun 2025 14:42:42 +0200 Subject: [PATCH 041/100] Issue #18035: Zero Fill TIMESTAMP_NS MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Make sure that zero µss are filled in for non-zero ns fixes: duckdb#18035 --- src/common/operator/string_cast.cpp | 3 +++ test/sql/types/timestamp/test_timestamp_types.test | 6 ++++++ 2 files changed, 9 insertions(+) diff --git a/src/common/operator/string_cast.cpp b/src/common/operator/string_cast.cpp index e152c71bf9b5..911a966af9b4 100644 --- a/src/common/operator/string_cast.cpp +++ b/src/common/operator/string_cast.cpp @@ -161,6 +161,9 @@ duckdb::string_t StringFromTimestamp(timestamp_t input, Vector &vector) { idx_t nano_length = 0; if (picos) { // If there are ps, we need all the µs + if (!time[3]) { + TimeToStringCast::FormatMicros(time[3], micro_buffer); + } time_length = 15; nano_length = 6; nano_length -= NumericCast(TimeToStringCast::FormatMicros(picos, nano_buffer)); diff --git a/test/sql/types/timestamp/test_timestamp_types.test b/test/sql/types/timestamp/test_timestamp_types.test index d39a789018da..d9fea8ca48fc 100644 --- a/test/sql/types/timestamp/test_timestamp_types.test +++ b/test/sql/types/timestamp/test_timestamp_types.test @@ -85,6 +85,12 @@ select '1969-01-01T23:59:59.9999999'::timestamp_ns; ---- 1969-01-01 23:59:59.9999999 +# Zero µs witn non-zero ns +query I +SELECT '1970-01-01 00:00:00.000000123'::TIMESTAMP_NS; +---- +1970-01-01 00:00:00.000000123 + # TIME conversions are now supported query I select sec::TIME from timestamp; From 3e46cb311d55d71d1eaae9f74555b4ee5f620c54 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Tue, 24 Jun 2025 15:45:23 +0200 Subject: [PATCH 042/100] include bound function expression header --- src/optimizer/statistics/operator/propagate_get.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index 0916b96603f8..19ea87861960 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -7,6 +7,7 @@ #include "duckdb/planner/filter/null_filter.hpp" #include "duckdb/planner/operator/logical_get.hpp" #include "duckdb/planner/table_filter.hpp" +#include "duckdb/planner/expression/bound_function_expression.hpp" namespace duckdb { From a111dda13e668c2c42c8726f65b4a49463d7ba54 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Tue, 24 Jun 2025 18:13:31 +0200 Subject: [PATCH 043/100] add missing includes --- .../statistics/operator/propagate_get.cpp | 256 +++++++++--------- 1 file changed, 129 insertions(+), 127 deletions(-) diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index 19ea87861960..ba687be620bd 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -8,154 +8,156 @@ #include "duckdb/planner/operator/logical_get.hpp" #include "duckdb/planner/table_filter.hpp" #include "duckdb/planner/expression/bound_function_expression.hpp" +#include "duckdb/function/scalar/generic_functions.hpp" +" -namespace duckdb { + namespace duckdb { -FilterPropagateResult StatisticsPropagator::PropagateTableFilter(ColumnBinding stats_binding, BaseStatistics &stats, - TableFilter &filter) { - if (filter.filter_type == TableFilterType::EXPRESSION_FILTER) { - auto &expr_filter = filter.Cast(); - auto column_ref = make_uniq(stats.GetType(), stats_binding); - auto filter_expr = expr_filter.ToExpression(*column_ref); - // handle the filter before updating the statistics - // otherwise the filter can be pruned by the updated statistics - auto copy_expr = filter_expr->Copy(); - auto propagate_result = HandleFilter(filter_expr); - UpdateFilterStatistics(*copy_expr); - return propagate_result; + FilterPropagateResult StatisticsPropagator::PropagateTableFilter(ColumnBinding stats_binding, + BaseStatistics & stats, TableFilter & filter) { + if (filter.filter_type == TableFilterType::EXPRESSION_FILTER) { + auto &expr_filter = filter.Cast(); + auto column_ref = make_uniq(stats.GetType(), stats_binding); + auto filter_expr = expr_filter.ToExpression(*column_ref); + // handle the filter before updating the statistics + // otherwise the filter can be pruned by the updated statistics + auto copy_expr = filter_expr->Copy(); + auto propagate_result = HandleFilter(filter_expr); + UpdateFilterStatistics(*copy_expr); + return propagate_result; + } + return filter.CheckStatistics(stats); } - return filter.CheckStatistics(stats); -} -void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &input, TableFilter &filter) { - // FIXME: update stats... - switch (filter.filter_type) { - case TableFilterType::CONJUNCTION_AND: { - auto &conjunction_and = filter.Cast(); - for (auto &child_filter : conjunction_and.child_filters) { - UpdateFilterStatistics(input, *child_filter); + void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics & input, TableFilter & filter) { + // FIXME: update stats... + switch (filter.filter_type) { + case TableFilterType::CONJUNCTION_AND: { + auto &conjunction_and = filter.Cast(); + for (auto &child_filter : conjunction_and.child_filters) { + UpdateFilterStatistics(input, *child_filter); + } + break; + } + case TableFilterType::CONSTANT_COMPARISON: { + auto &constant_filter = filter.Cast(); + UpdateFilterStatistics(input, constant_filter.comparison_type, constant_filter.constant); + break; + } + default: + break; } - break; - } - case TableFilterType::CONSTANT_COMPARISON: { - auto &constant_filter = filter.Cast(); - UpdateFilterStatistics(input, constant_filter.comparison_type, constant_filter.constant); - break; - } - default: - break; } -} -static bool IsConstantOrNullFilter(TableFilter &table_filter) { - if (table_filter.filter_type != TableFilterType::EXPRESSION_FILTER) { - return false; - } - auto &expr_filter = table_filter.Cast(); - if (expr_filter.expr->type != ExpressionType::BOUND_FUNCTION) { - return false; + static bool IsConstantOrNullFilter(TableFilter & table_filter) { + if (table_filter.filter_type != TableFilterType::EXPRESSION_FILTER) { + return false; + } + auto &expr_filter = table_filter.Cast(); + if (expr_filter.expr->type != ExpressionType::BOUND_FUNCTION) { + return false; + } + auto &func = expr_filter.expr->Cast(); + return ConstantOrNull::IsConstantOrNull(func, Value::BOOLEAN(true)); } - auto &func = expr_filter.expr->Cast(); - return ConstantOrNull::IsConstantOrNull(func, Value::BOOLEAN(true)); -} -static bool CanReplaceConstantOrNull(TableFilter &table_filter) { - if (!IsConstantOrNullFilter(table_filter)) { - throw InternalException("CanReplaceConstantOrNull() called on unexepected Table Filter"); - } - D_ASSERT(table_filter.filter_type == TableFilterType::EXPRESSION_FILTER); - auto &expr_filter = table_filter.Cast(); - auto &func = expr_filter.expr->Cast(); - if (ConstantOrNull::IsConstantOrNull(func, Value::BOOLEAN(true))) { - for (auto child = ++func.children.begin(); child != func.children.end(); child++) { - switch (child->get()->type) { - case ExpressionType::BOUND_REF: - case ExpressionType::VALUE_CONSTANT: - continue; - default: - // expression type could be a function like Coalesce - return false; + static bool CanReplaceConstantOrNull(TableFilter & table_filter) { + if (!IsConstantOrNullFilter(table_filter)) { + throw InternalException("CanReplaceConstantOrNull() called on unexepected Table Filter"); + } + D_ASSERT(table_filter.filter_type == TableFilterType::EXPRESSION_FILTER); + auto &expr_filter = table_filter.Cast(); + auto &func = expr_filter.expr->Cast(); + if (ConstantOrNull::IsConstantOrNull(func, Value::BOOLEAN(true))) { + for (auto child = ++func.children.begin(); child != func.children.end(); child++) { + switch (child->get()->type) { + case ExpressionType::BOUND_REF: + case ExpressionType::VALUE_CONSTANT: + continue; + default: + // expression type could be a function like Coalesce + return false; + } } } + // all children of constant or null are bound refs to the table filter column + return true; } - // all children of constant or null are bound refs to the table filter column - return true; -} -unique_ptr StatisticsPropagator::PropagateStatistics(LogicalGet &get, - unique_ptr &node_ptr) { - if (get.function.cardinality) { - node_stats = get.function.cardinality(context, get.bind_data.get()); - } - if (!get.function.statistics) { - // no column statistics to get - return std::move(node_stats); - } - auto &column_ids = get.GetColumnIds(); - for (idx_t i = 0; i < column_ids.size(); i++) { - auto stats = get.function.statistics(context, get.bind_data.get(), column_ids[i].GetPrimaryIndex()); - if (stats) { - ColumnBinding binding(get.table_index, i); - statistics_map.insert(make_pair(binding, std::move(stats))); + unique_ptr StatisticsPropagator::PropagateStatistics(LogicalGet & get, + unique_ptr & node_ptr) { + if (get.function.cardinality) { + node_stats = get.function.cardinality(context, get.bind_data.get()); } - } - // push table filters into the statistics - vector column_indexes; - column_indexes.reserve(get.table_filters.filters.size()); - for (auto &kv : get.table_filters.filters) { - column_indexes.push_back(kv.first); - } - - for (auto &table_filter_column : column_indexes) { - idx_t column_index; - for (column_index = 0; column_index < column_ids.size(); column_index++) { - if (column_ids[column_index].GetPrimaryIndex() == table_filter_column) { - break; + if (!get.function.statistics) { + // no column statistics to get + return std::move(node_stats); + } + auto &column_ids = get.GetColumnIds(); + for (idx_t i = 0; i < column_ids.size(); i++) { + auto stats = get.function.statistics(context, get.bind_data.get(), column_ids[i].GetPrimaryIndex()); + if (stats) { + ColumnBinding binding(get.table_index, i); + statistics_map.insert(make_pair(binding, std::move(stats))); } } - D_ASSERT(column_index < column_ids.size()); - D_ASSERT(column_ids[column_index].GetPrimaryIndex() == table_filter_column); - - // find the stats - ColumnBinding stats_binding(get.table_index, column_index); - auto entry = statistics_map.find(stats_binding); - if (entry == statistics_map.end()) { - // no stats for this entry - continue; + // push table filters into the statistics + vector column_indexes; + column_indexes.reserve(get.table_filters.filters.size()); + for (auto &kv : get.table_filters.filters) { + column_indexes.push_back(kv.first); } - auto &stats = *entry->second; - // fetch the table filter - D_ASSERT(get.table_filters.filters.count(table_filter_column) > 0); - auto &filter = get.table_filters.filters[table_filter_column]; - auto propagate_result = PropagateTableFilter(stats_binding, stats, *filter); - switch (propagate_result) { - case FilterPropagateResult::FILTER_ALWAYS_TRUE: - // filter is always true; it is useless to execute it - // erase this condition - get.table_filters.filters.erase(table_filter_column); - break; - case FilterPropagateResult::FILTER_TRUE_OR_NULL: { - if (IsConstantOrNullFilter(*get.table_filters.filters[table_filter_column]) && - !CanReplaceConstantOrNull(*get.table_filters.filters[table_filter_column])) { + for (auto &table_filter_column : column_indexes) { + idx_t column_index; + for (column_index = 0; column_index < column_ids.size(); column_index++) { + if (column_ids[column_index].GetPrimaryIndex() == table_filter_column) { + break; + } + } + D_ASSERT(column_index < column_ids.size()); + D_ASSERT(column_ids[column_index].GetPrimaryIndex() == table_filter_column); + + // find the stats + ColumnBinding stats_binding(get.table_index, column_index); + auto entry = statistics_map.find(stats_binding); + if (entry == statistics_map.end()) { + // no stats for this entry + continue; + } + auto &stats = *entry->second; + + // fetch the table filter + D_ASSERT(get.table_filters.filters.count(table_filter_column) > 0); + auto &filter = get.table_filters.filters[table_filter_column]; + auto propagate_result = PropagateTableFilter(stats_binding, stats, *filter); + switch (propagate_result) { + case FilterPropagateResult::FILTER_ALWAYS_TRUE: + // filter is always true; it is useless to execute it + // erase this condition + get.table_filters.filters.erase(table_filter_column); + break; + case FilterPropagateResult::FILTER_TRUE_OR_NULL: { + if (IsConstantOrNullFilter(*get.table_filters.filters[table_filter_column]) && + !CanReplaceConstantOrNull(*get.table_filters.filters[table_filter_column])) { + break; + } + // filter is true or null; we can replace this with a not null filter + get.table_filters.filters[table_filter_column] = make_uniq(); + break; + } + case FilterPropagateResult::FILTER_FALSE_OR_NULL: + case FilterPropagateResult::FILTER_ALWAYS_FALSE: + // filter is always false; this entire filter should be replaced by an empty result block + ReplaceWithEmptyResult(node_ptr); + return make_uniq(0U, 0U); + default: + // general case: filter can be true or false, update this columns' statistics + UpdateFilterStatistics(stats, *filter); break; } - // filter is true or null; we can replace this with a not null filter - get.table_filters.filters[table_filter_column] = make_uniq(); - break; - } - case FilterPropagateResult::FILTER_FALSE_OR_NULL: - case FilterPropagateResult::FILTER_ALWAYS_FALSE: - // filter is always false; this entire filter should be replaced by an empty result block - ReplaceWithEmptyResult(node_ptr); - return make_uniq(0U, 0U); - default: - // general case: filter can be true or false, update this columns' statistics - UpdateFilterStatistics(stats, *filter); - break; } + return std::move(node_stats); } - return std::move(node_stats); -} } // namespace duckdb From 600b569f71b239f64edf26e4711a53baa09c733f Mon Sep 17 00:00:00 2001 From: damon Date: Tue, 24 Jun 2025 14:44:24 +0800 Subject: [PATCH 044/100] Fix handling dynamic table filters in RemoveUnusedColumns --- src/optimizer/remove_unused_columns.cpp | 6 +++++- test/optimizer/unused_columns/issue_18028.test | 18 ++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-) create mode 100644 test/optimizer/unused_columns/issue_18028.test diff --git a/src/optimizer/remove_unused_columns.cpp b/src/optimizer/remove_unused_columns.cpp index a601dce550b1..1034ed2b9c2a 100644 --- a/src/optimizer/remove_unused_columns.cpp +++ b/src/optimizer/remove_unused_columns.cpp @@ -256,7 +256,11 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) { ColumnBinding filter_binding(get.table_index, index.GetIndex()); auto column_ref = make_uniq(std::move(column_type), filter_binding); auto filter_expr = filter.second->ToExpression(*column_ref); - VisitExpression(&filter_expr); + if (filter_expr->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) { + AddBinding(*column_ref); + } else { + VisitExpression(&filter_expr); + } filter_expressions.push_back(std::move(filter_expr)); } diff --git a/test/optimizer/unused_columns/issue_18028.test b/test/optimizer/unused_columns/issue_18028.test new file mode 100644 index 000000000000..38832b8842b8 --- /dev/null +++ b/test/optimizer/unused_columns/issue_18028.test @@ -0,0 +1,18 @@ +# name: test/optimizer/unused_columns/issue_18028.test +# description: Test remove unused columns with dynamic filters +# group: [unused_columns] + +statement ok +PRAGMA enable_verification + +statement ok +INSTALL tpch + +statement ok +LOAD tpch; + +statement ok +CALL dbgen(sf=0.1); + +statement ok +SELECT * FROM (SELECT * FROM lineitem LIMIT 500) ORDER BY l_orderkey DESC LIMIT 10; From c32fdc3f4461bb91342d792f7916ab2f36d3ef1f Mon Sep 17 00:00:00 2001 From: damon Date: Tue, 24 Jun 2025 16:57:34 +0800 Subject: [PATCH 045/100] Keep column_ref alive --- src/optimizer/remove_unused_columns.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/optimizer/remove_unused_columns.cpp b/src/optimizer/remove_unused_columns.cpp index 1034ed2b9c2a..90ea86d16685 100644 --- a/src/optimizer/remove_unused_columns.cpp +++ b/src/optimizer/remove_unused_columns.cpp @@ -1,5 +1,7 @@ #include "duckdb/optimizer/remove_unused_columns.hpp" +#include "duckdb/common/unique_ptr.hpp" +#include "duckdb/common/vector.hpp" #include "duckdb/function/aggregate/distributive_functions.hpp" #include "duckdb/function/function_binder.hpp" #include "duckdb/parser/parsed_data/vacuum_info.hpp" @@ -237,6 +239,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) { ClearUnusedExpressions(proj_sel, get.table_index, false); vector> filter_expressions; + vector> column_refs; // for every table filter, push a column binding into the column references map to prevent the column from // being projected out for (auto &filter : get.table_filters.filters) { @@ -258,6 +261,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) { auto filter_expr = filter.second->ToExpression(*column_ref); if (filter_expr->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) { AddBinding(*column_ref); + column_refs.push_back(std::move(column_ref)); } else { VisitExpression(&filter_expr); } From 381744e2279982406a63e32c2c9d797310dbda49 Mon Sep 17 00:00:00 2001 From: damon Date: Wed, 25 Jun 2025 09:27:36 +0800 Subject: [PATCH 046/100] Fix review --- src/optimizer/remove_unused_columns.cpp | 9 +++------ test/optimizer/unused_columns/issue_18028.test | 18 ------------------ test/sql/tpch/tpch_topn.test_slow | 4 ++++ 3 files changed, 7 insertions(+), 24 deletions(-) delete mode 100644 test/optimizer/unused_columns/issue_18028.test diff --git a/src/optimizer/remove_unused_columns.cpp b/src/optimizer/remove_unused_columns.cpp index 90ea86d16685..b318b1f3ea52 100644 --- a/src/optimizer/remove_unused_columns.cpp +++ b/src/optimizer/remove_unused_columns.cpp @@ -239,7 +239,6 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) { ClearUnusedExpressions(proj_sel, get.table_index, false); vector> filter_expressions; - vector> column_refs; // for every table filter, push a column binding into the column references map to prevent the column from // being projected out for (auto &filter : get.table_filters.filters) { @@ -259,12 +258,10 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) { ColumnBinding filter_binding(get.table_index, index.GetIndex()); auto column_ref = make_uniq(std::move(column_type), filter_binding); auto filter_expr = filter.second->ToExpression(*column_ref); - if (filter_expr->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) { - AddBinding(*column_ref); - column_refs.push_back(std::move(column_ref)); - } else { - VisitExpression(&filter_expr); + if (filter_expr->IsScalar()) { + filter_expr = std::move(column_ref); } + VisitExpression(&filter_expr); filter_expressions.push_back(std::move(filter_expr)); } diff --git a/test/optimizer/unused_columns/issue_18028.test b/test/optimizer/unused_columns/issue_18028.test deleted file mode 100644 index 38832b8842b8..000000000000 --- a/test/optimizer/unused_columns/issue_18028.test +++ /dev/null @@ -1,18 +0,0 @@ -# name: test/optimizer/unused_columns/issue_18028.test -# description: Test remove unused columns with dynamic filters -# group: [unused_columns] - -statement ok -PRAGMA enable_verification - -statement ok -INSTALL tpch - -statement ok -LOAD tpch; - -statement ok -CALL dbgen(sf=0.1); - -statement ok -SELECT * FROM (SELECT * FROM lineitem LIMIT 500) ORDER BY l_orderkey DESC LIMIT 10; diff --git a/test/sql/tpch/tpch_topn.test_slow b/test/sql/tpch/tpch_topn.test_slow index f9e5e4d44812..464a27bc103e 100644 --- a/test/sql/tpch/tpch_topn.test_slow +++ b/test/sql/tpch/tpch_topn.test_slow @@ -45,3 +45,7 @@ SELECT l_orderkey,l_partkey,l_suppkey,l_linenumber,l_quantity,l_extendedprice,l_ 5999975 37131 2138 3 18 19226.34 0.04 0.01 A F 1993-11-17 1993-08-28 1993-12-08 DELIVER IN PERSON FOB 5999975 6452 1453 2 7 9509.15 0.04 0.00 A F 1993-11-02 1993-09-23 1993-11-19 DELIVER IN PERSON SHIP 5999975 7272 2273 1 32 37736.64 0.07 0.01 R F 1993-10-07 1993-09-30 1993-10-21 COLLECT COD REG AIR + +# test issue 18028 +statement ok +SELECT * FROM (SELECT * FROM lineitem LIMIT 500) ORDER BY l_orderkey DESC LIMIT 10; From 86fd394193b8a5422377f6971ca3f99590be44f8 Mon Sep 17 00:00:00 2001 From: damon Date: Wed, 25 Jun 2025 11:16:15 +0800 Subject: [PATCH 047/100] Revert headers import --- src/optimizer/remove_unused_columns.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/optimizer/remove_unused_columns.cpp b/src/optimizer/remove_unused_columns.cpp index b318b1f3ea52..9f7aa4a09437 100644 --- a/src/optimizer/remove_unused_columns.cpp +++ b/src/optimizer/remove_unused_columns.cpp @@ -1,7 +1,5 @@ #include "duckdb/optimizer/remove_unused_columns.hpp" -#include "duckdb/common/unique_ptr.hpp" -#include "duckdb/common/vector.hpp" #include "duckdb/function/aggregate/distributive_functions.hpp" #include "duckdb/function/function_binder.hpp" #include "duckdb/parser/parsed_data/vacuum_info.hpp" From 92dcccf2a4325ebe930f7dc5865fc50c18778a82 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Wed, 25 Jun 2025 13:05:44 +0200 Subject: [PATCH 048/100] fix duplicate includes --- src/optimizer/statistics/operator/propagate_get.cpp | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index d874ae0e0e0e..b27af44ab07e 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -10,7 +10,6 @@ #include "duckdb/planner/filter/null_filter.hpp" #include "duckdb/planner/operator/logical_get.hpp" #include "duckdb/planner/table_filter.hpp" -#include "duckdb/planner/expression/bound_function_expression.hpp" #include "duckdb/function/scalar/generic_functions.hpp" namespace duckdb { @@ -25,7 +24,7 @@ static void GetColumnIndex(unique_ptr &expr, idx_t &index) { } FilterPropagateResult StatisticsPropagator::PropagateTableFilter(ColumnBinding stats_binding, BaseStatistics &stats, - TableFilter &filter) { + TableFilter &filter) { if (filter.filter_type == TableFilterType::EXPRESSION_FILTER) { auto &expr_filter = filter.Cast(); @@ -71,7 +70,7 @@ void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &input, TableFi } } -static bool IsConstantOrNullFilter(TableFilter & table_filter) { +static bool IsConstantOrNullFilter(TableFilter &table_filter) { if (table_filter.filter_type != TableFilterType::EXPRESSION_FILTER) { return false; } @@ -83,7 +82,7 @@ static bool IsConstantOrNullFilter(TableFilter & table_filter) { return ConstantOrNull::IsConstantOrNull(func, Value::BOOLEAN(true)); } -static bool CanReplaceConstantOrNull(TableFilter & table_filter) { +static bool CanReplaceConstantOrNull(TableFilter &table_filter) { if (!IsConstantOrNullFilter(table_filter)) { throw InternalException("CanReplaceConstantOrNull() called on unexepected Table Filter"); } @@ -106,8 +105,8 @@ static bool CanReplaceConstantOrNull(TableFilter & table_filter) { return true; } -unique_ptr StatisticsPropagator::PropagateStatistics(LogicalGet & get, - unique_ptr & node_ptr) { +unique_ptr StatisticsPropagator::PropagateStatistics(LogicalGet &get, + unique_ptr &node_ptr) { if (get.function.cardinality) { node_stats = get.function.cardinality(context, get.bind_data.get()); } From 13c7800aabedf9b8b105b89d77fe812cc416b589 Mon Sep 17 00:00:00 2001 From: Max Gabrielsson Date: Wed, 25 Jun 2025 14:09:20 +0200 Subject: [PATCH 049/100] bump spatial --- .github/config/out_of_tree_extensions.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index 300e56b27aee..bdf5ae42c71d 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -123,7 +123,7 @@ if (NOT MINGW AND ${BUILD_COMPLETE_EXTENSION_SET}) duckdb_extension_load(spatial DONT_LINK LOAD_TESTS GIT_URL https://github.com/duckdb/duckdb-spatial - GIT_TAG 95ed129e22bf9b14f64c8d0bd8fd55f9ca0a9e61 + GIT_TAG 7ab1710c125f25208c7382560c7cb313a967eb2c INCLUDE_DIR spatial/include TEST_DIR test/sql ) From 05b11759b5a188ac22ca4c1304dfcd55ba2f4369 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Wed, 25 Jun 2025 14:18:23 +0200 Subject: [PATCH 050/100] Add one more header --- src/optimizer/statistics/operator/propagate_get.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/optimizer/statistics/operator/propagate_get.cpp b/src/optimizer/statistics/operator/propagate_get.cpp index b27af44ab07e..b01f7d704be0 100644 --- a/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/optimizer/statistics/operator/propagate_get.cpp @@ -10,6 +10,7 @@ #include "duckdb/planner/filter/null_filter.hpp" #include "duckdb/planner/operator/logical_get.hpp" #include "duckdb/planner/table_filter.hpp" +#include "duckdb/function/scalar/generic_common.hpp" #include "duckdb/function/scalar/generic_functions.hpp" namespace duckdb { From ae10471a4a3bfe47940c5c99402651236ad6b855 Mon Sep 17 00:00:00 2001 From: taniabogatsch <44262898+taniabogatsch@users.noreply.github.com> Date: Wed, 25 Jun 2025 16:35:59 +0200 Subject: [PATCH 051/100] fix index scan to correctly extract in filter values of nested conjunctions ands --- src/function/table/table_scan.cpp | 116 +++++++++++++++++------------- 1 file changed, 67 insertions(+), 49 deletions(-) diff --git a/src/function/table/table_scan.cpp b/src/function/table/table_scan.cpp index 23c3134f52e1..24a9887f626c 100644 --- a/src/function/table/table_scan.cpp +++ b/src/function/table/table_scan.cpp @@ -26,6 +26,8 @@ #include "duckdb/planner/filter/conjunction_filter.hpp" #include "duckdb/common/types/value_map.hpp" +#include + namespace duckdb { struct TableScanLocalState : public LocalTableFunctionState { @@ -384,9 +386,9 @@ unique_ptr DuckIndexScanInitGlobal(ClientContext &cont return std::move(g_state); } -void ExtractExpressionsFromValues(value_set_t &unique_values, BoundColumnRefExpression &bound_ref, +void ExtractExpressionsFromValues(vector &values, BoundColumnRefExpression &bound_ref, vector> &expressions) { - for (const auto &value : unique_values) { + for (const auto &value : values) { auto bound_constant = make_uniq(value); auto filter_expr = make_uniq(ExpressionType::COMPARE_EQUAL, bound_ref.Copy(), std::move(bound_constant)); @@ -394,26 +396,30 @@ void ExtractExpressionsFromValues(value_set_t &unique_values, BoundColumnRefExpr } } -void ExtractIn(InFilter &filter, BoundColumnRefExpression &bound_ref, vector> &expressions) { +void ExtractIn(InFilter &filter, vector &values) { // Eliminate any duplicates. value_set_t unique_values; for (const auto &value : filter.values) { if (unique_values.find(value) == unique_values.end()) { unique_values.insert(value); + values.push_back(value); } } - ExtractExpressionsFromValues(unique_values, bound_ref, expressions); + D_ASSERT(!values.empty()); } -void ExtractConjunctionAnd(ConjunctionAndFilter &filter, BoundColumnRefExpression &bound_ref, - vector> &expressions) { +bool ExtractConjunctionAnd(ConjunctionAndFilter &filter, vector> &value_vectors) { + // Every CONJUNCTION_AND must have at least one IN_FILTER, + // OR it must have an IN_FILTER in a lower level. + // The IN_FILTER is the "source of truth", as any values not in the IN_FILTER evaluate to false. if (filter.child_filters.empty()) { - return; + return false; } // Extract the CONSTANT_COMPARISON and IN_FILTER children. vector> comparisons; vector> in_filters; + idx_t sort_start = value_vectors.size(); for (idx_t i = 0; i < filter.child_filters.size(); i++) { auto &child_filter = *filter.child_filters[i]; @@ -421,58 +427,63 @@ void ExtractConjunctionAnd(ConjunctionAndFilter &filter, BoundColumnRefExpressio case TableFilterType::CONSTANT_COMPARISON: { auto &comparison = child_filter.Cast(); comparisons.push_back(comparison); - break; + continue; } case TableFilterType::CONJUNCTION_AND: { auto &conjunction = child_filter.Cast(); - ExtractConjunctionAnd(conjunction, bound_ref, expressions); - break; + if (!ExtractConjunctionAnd(conjunction, value_vectors)) { + // CONJUNCTION_AND has unsupported filters, or no qualifying values. + return false; + } + continue; } case TableFilterType::OPTIONAL_FILTER: { auto &optional_filter = child_filter.Cast(); if (!optional_filter.child_filter) { - return; + return false; } if (optional_filter.child_filter->filter_type != TableFilterType::IN_FILTER) { // No support for other optional filter types yet. - return; + return false; } auto &in_filter = optional_filter.child_filter->Cast(); - in_filters.push_back(in_filter); - break; + value_vectors.emplace_back(); + ExtractIn(in_filter, value_vectors.back()); + continue; } default: - // Not yet supported: filter types than CONSTANT_COMPARISON/IN_FILTER/CONJUNCTION_AND in CONJUNCTION_AND. - expressions.clear(); - return; + // Filter types other than CONSTANT_COMPARISON/IN_FILTER/CONJUNCTION_AND are not yet supported. + return false; } } - // No support for other CONJUNCTION_AND cases yet. - if (in_filters.empty()) { - return; + // No support for other CONJUNCTION_AND cases. + if (value_vectors.empty()) { + return false; } - // Get the combined unique values of the IN filters. - value_set_t unique_values; - for (idx_t filter_idx = 0; filter_idx < in_filters.size(); filter_idx++) { - auto &in_filter = in_filters[filter_idx].get(); - for (idx_t value_idx = 0; value_idx < in_filter.values.size(); value_idx++) { - auto &value = in_filter.values[value_idx]; - if (unique_values.find(value) != unique_values.end()) { - continue; - } - unique_values.insert(value); - } + // Get the UNION of all IN_FILTER values. + for (idx_t i = sort_start; i < value_vectors.size(); i++) { + std::sort(value_vectors[i].begin(), value_vectors[i].end()); + } + while (value_vectors.size() > 1) { + value_vectors.emplace_back(); + auto &first = value_vectors[0]; + auto &second = value_vectors[1]; + std::set_union(first.cbegin(), first.cend(), second.cbegin(), second.cend(), + std::back_inserter(value_vectors.back())); + value_vectors.erase(value_vectors.begin()); + value_vectors.erase(value_vectors.begin()); } // Extract all qualifying values. - for (auto value_it = unique_values.begin(); value_it != unique_values.end();) { + auto &final_vec = value_vectors.back(); + for (auto value_it = final_vec.begin(); value_it != final_vec.end();) { bool qualifies = true; for (idx_t comp_idx = 0; comp_idx < comparisons.size(); comp_idx++) { if (!comparisons[comp_idx].get().Compare(*value_it)) { qualifies = false; - value_it = unique_values.erase(value_it); + value_it = final_vec.erase(value_it); break; } } @@ -480,32 +491,34 @@ void ExtractConjunctionAnd(ConjunctionAndFilter &filter, BoundColumnRefExpressio value_it++; } } - - ExtractExpressionsFromValues(unique_values, bound_ref, expressions); + if (final_vec.empty()) { + value_vectors.erase(value_vectors.cbegin()); + return false; + } + return true; } -void ExtractFilter(TableFilter &filter, BoundColumnRefExpression &bound_ref, - vector> &expressions) { +bool ExtractFilter(TableFilter &filter, vector> &value_vectors) { switch (filter.filter_type) { case TableFilterType::OPTIONAL_FILTER: { auto &optional_filter = filter.Cast(); if (!optional_filter.child_filter) { - return; + return false; } - return ExtractFilter(*optional_filter.child_filter, bound_ref, expressions); + return ExtractFilter(*optional_filter.child_filter, value_vectors); } case TableFilterType::IN_FILTER: { auto &in_filter = filter.Cast(); - ExtractIn(in_filter, bound_ref, expressions); - return; + value_vectors.emplace_back(); + ExtractIn(in_filter, value_vectors.back()); + return true; } case TableFilterType::CONJUNCTION_AND: { auto &conjunction_and = filter.Cast(); - ExtractConjunctionAnd(conjunction_and, bound_ref, expressions); - return; + return ExtractConjunctionAnd(conjunction_and, value_vectors); } default: - return; + return false; } } @@ -515,13 +528,18 @@ vector> ExtractFilterExpressions(const ColumnDefinition & auto bound_ref = make_uniq(col.Name(), col.Type(), binding); vector> expressions; - ExtractFilter(*filter, *bound_ref, expressions); + vector> value_vectors; - // Attempt matching the top-level filter to the index expression. - if (expressions.empty()) { - auto filter_expr = filter->ToExpression(*bound_ref); - expressions.push_back(std::move(filter_expr)); + if (ExtractFilter(*filter, value_vectors)) { + D_ASSERT(value_vectors.size() == 1); + D_ASSERT(!value_vectors.begin()->empty()); + ExtractExpressionsFromValues(*value_vectors.begin(), *bound_ref, expressions); + return expressions; } + + // Attempt matching the top-level filter to the index expression. + auto filter_expr = filter->ToExpression(*bound_ref); + expressions.push_back(std::move(filter_expr)); return expressions; } From 587e11e84c0013603696234e78666416c523d9b9 Mon Sep 17 00:00:00 2001 From: Richard Wesley <13156216+hawkfish@users.noreply.github.com> Date: Wed, 25 Jun 2025 17:09:10 +0200 Subject: [PATCH 052/100] Issue #18047: TIMESTAMP_TZ Upcast Costs * Add missing costs for DATE => TIMESTAMP_TZ cast and friends. fixes: duckdb#18047 fixes: duckdblabs/duckdb-internal#5187 --- extension/icu/icu-timezone.cpp | 16 ++++++++++------ .../function/timestamp/test_icu_datediff.test | 6 ++++++ 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/extension/icu/icu-timezone.cpp b/extension/icu/icu-timezone.cpp index be1a8d986a40..b17853c958cb 100644 --- a/extension/icu/icu-timezone.cpp +++ b/extension/icu/icu-timezone.cpp @@ -185,16 +185,20 @@ struct ICUFromNaiveTimestamp : public ICUDateFunc { } } + static void AddCast(CastFunctionSet &casts, const LogicalType &source, const LogicalType &target) { + const auto implicit_cost = CastRules::ImplicitCast(source, target); + casts.RegisterCastFunction(source, target, BindCastFromNaive, implicit_cost); + } + static void AddCasts(DatabaseInstance &db) { auto &config = DBConfig::GetConfig(db); auto &casts = config.GetCastFunctions(); - const auto implicit_cost = CastRules::ImplicitCast(LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ); - casts.RegisterCastFunction(LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ, BindCastFromNaive, implicit_cost); - casts.RegisterCastFunction(LogicalType::TIMESTAMP_MS, LogicalType::TIMESTAMP_TZ, BindCastFromNaive); - casts.RegisterCastFunction(LogicalType::TIMESTAMP_NS, LogicalType::TIMESTAMP_TZ, BindCastFromNaive); - casts.RegisterCastFunction(LogicalType::TIMESTAMP_S, LogicalType::TIMESTAMP_TZ, BindCastFromNaive); - casts.RegisterCastFunction(LogicalType::DATE, LogicalType::TIMESTAMP_TZ, BindCastFromNaive); + AddCast(casts, LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ); + AddCast(casts, LogicalType::TIMESTAMP_MS, LogicalType::TIMESTAMP_TZ); + AddCast(casts, LogicalType::TIMESTAMP_NS, LogicalType::TIMESTAMP_TZ); + AddCast(casts, LogicalType::TIMESTAMP_S, LogicalType::TIMESTAMP_TZ); + AddCast(casts, LogicalType::DATE, LogicalType::TIMESTAMP_TZ); } }; diff --git a/test/sql/function/timestamp/test_icu_datediff.test b/test/sql/function/timestamp/test_icu_datediff.test index 08ed1704b9ad..56201cd3f949 100644 --- a/test/sql/function/timestamp/test_icu_datediff.test +++ b/test/sql/function/timestamp/test_icu_datediff.test @@ -137,3 +137,9 @@ FROM issue9673; ---- 2022-10-30 02:17:00+02 2022-10-30 02:00:21+01 43 2021-10-31 02:39:00+02 2021-10-31 02:38:20+01 59 + +# Promotion cast from DATE +query I +select date_diff('day', '2022-01-04 19:00:00'::timestamptz, '2024-03-01'::date) as c1; +---- +787 From 499dcaad1c1b69d6b1de7df6ffa8f7dd056953dd Mon Sep 17 00:00:00 2001 From: Laurens Kuiper Date: Thu, 26 Jun 2025 11:04:09 +0200 Subject: [PATCH 053/100] fix issue with empty rhs --- src/execution/operator/join/physical_iejoin.cpp | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/execution/operator/join/physical_iejoin.cpp b/src/execution/operator/join/physical_iejoin.cpp index 71c0e285cad8..384f7358a7b9 100644 --- a/src/execution/operator/join/physical_iejoin.cpp +++ b/src/execution/operator/join/physical_iejoin.cpp @@ -166,6 +166,10 @@ SinkResultType PhysicalIEJoin::Sink(ExecutionContext &context, DataChunk &chunk, auto &gstate = input.global_state.Cast(); auto &lstate = input.local_state.Cast(); + if (gstate.child == 0 && gstate.tables[1]->global_sort_state.sorted_blocks.empty() && EmptyResultIfRHSIsEmpty()) { + return SinkResultType::FINISHED; + } + gstate.Sink(chunk, lstate); if (filter_pushdown && !gstate.skip_filter_pushdown) { @@ -207,15 +211,19 @@ SinkFinalizeType PhysicalIEJoin::Finalize(Pipeline &pipeline, Event &event, Clie // for FULL/LEFT/RIGHT OUTER JOIN, initialize found_match to false for every tuple table.IntializeMatches(); } + + SinkFinalizeType res; if (gstate.child == 1 && global_sort_state.sorted_blocks.empty() && EmptyResultIfRHSIsEmpty()) { // Empty input! - return SinkFinalizeType::NO_OUTPUT_POSSIBLE; + res = SinkFinalizeType::NO_OUTPUT_POSSIBLE; + } else { + res = SinkFinalizeType::READY; } // Move to the next input child gstate.Finalize(pipeline, event); - return SinkFinalizeType::READY; + return res; } //===--------------------------------------------------------------------===// From 6104341645067a82f21ce1f0bebdcae9631b30e2 Mon Sep 17 00:00:00 2001 From: Laurens Kuiper Date: Thu, 26 Jun 2025 17:26:40 +0200 Subject: [PATCH 054/100] add test --- test/sql/join/iejoin/test_iejoin.test | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/test/sql/join/iejoin/test_iejoin.test b/test/sql/join/iejoin/test_iejoin.test index 7ce2c0f788e4..fae1fb322210 100644 --- a/test/sql/join/iejoin/test_iejoin.test +++ b/test/sql/join/iejoin/test_iejoin.test @@ -182,3 +182,20 @@ WITH data_table AS ( 37 1607087520 1607878080 9 38 1607878080 1608668640 9 39 1608668640 1609459200 9 + +# internal issue 5197 +statement ok +create table test_big as select range i, range + 100_000 j, 'hello' k from range (20_000) + +statement ok +create table test_small as select range i, range + 100_000 j, 'hello' k from range (0,20_000,10) + +statement ok +select * +from test_small t1 +join test_small t2 +on (t1.i = t2.j) +join test_small t3 +on (true) +join test_big t4 +on (t3.i < t4.i and t3.j > t4.j) From 44d5bb2db5584acf2b5c3217989cc6125de31937 Mon Sep 17 00:00:00 2001 From: Evert Date: Fri, 27 Jun 2025 15:31:40 +0200 Subject: [PATCH 055/100] Run Python workflow against both Python 3.9 and 3.13 on PR to ensure minimum version compatibility See https://github.com/duckdblabs/duckdb-internal/issues/5192 --- .github/workflows/Python.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.github/workflows/Python.yml b/.github/workflows/Python.yml index 976a22710474..c957e828c50e 100644 --- a/.github/workflows/Python.yml +++ b/.github/workflows/Python.yml @@ -142,8 +142,6 @@ jobs: - ${{ startsWith(github.ref, 'refs/tags/v') || github.ref == 'refs/heads/main' || inputs.run_all == 'true' }} exclude: # Speed things up a bit for non-releases - - isRelease: false - python_build: 'cp39-*' - isRelease: false python_build: 'cp310-*' - isRelease: false From a3a7ccfa5b63abf826da305c6f8e69a366cb9b81 Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Fri, 27 Jun 2025 14:49:39 +0200 Subject: [PATCH 056/100] Move very long workflow from debug to reldebug Currently, on each PR iteration: 2* (15 minutes building + 1h45' testing) Moving from debug to reldebug: 2* (18 minutes building + 2' testing) Moving from 2 parallel jobs to a single one: 18 minutes building + 4' testing Considering building step might also be cached, this is 10x to 20x improvement (in this particular step, that was the more time consuming at the moment). --- .github/workflows/Main.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/Main.yml b/.github/workflows/Main.yml index 8ca7294e9690..fce2fff76a3a 100644 --- a/.github/workflows/Main.yml +++ b/.github/workflows/Main.yml @@ -35,7 +35,7 @@ env: jobs: linux-debug: - name: Linux Debug (${{ matrix.tag }}) + name: Linux RelDebug (${{ matrix.tag }}) if: ${{ !startsWith(github.ref, 'refs/tags/v') }} runs-on: ubuntu-22.04 strategy: @@ -73,11 +73,11 @@ jobs: - name: Build shell: bash - run: make debug + run: make reldebug - name: Output version info shell: bash - run: ./build/debug/duckdb -c "PRAGMA version;" + run: ./build/reldebug/duckdb -c "PRAGMA version;" - name: Set DUCKDB_INSTALL_LIB for ADBC tests shell: bash @@ -89,7 +89,7 @@ jobs: - name: Test shell: bash run: | - python3 scripts/run_tests_one_by_one.py build/debug/test/unittest --tests-per-invocation 100 ${{ matrix.start_offset }} ${{ matrix.end_offset }} + python3 scripts/run_tests_one_by_one.py build/reldebug/test/unittest --tests-per-invocation 100 ${{ matrix.start_offset }} ${{ matrix.end_offset }} linux-release: name: Linux Release (full suite) From 31344937f38c3b2a345f233568a639cf8d19ec11 Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Fri, 27 Jun 2025 16:13:00 +0200 Subject: [PATCH 057/100] Main.yml: Actually move to single job instead of parallels --- .github/workflows/Main.yml | 22 +++++++--------------- 1 file changed, 7 insertions(+), 15 deletions(-) diff --git a/.github/workflows/Main.yml b/.github/workflows/Main.yml index fce2fff76a3a..d0ace7774fbe 100644 --- a/.github/workflows/Main.yml +++ b/.github/workflows/Main.yml @@ -35,25 +35,17 @@ env: jobs: linux-debug: - name: Linux RelDebug (${{ matrix.tag }}) - if: ${{ !startsWith(github.ref, 'refs/tags/v') }} + name: Linux DEBUG + sanitizers + # This tests release build while enabling slow verifiers (masked by #ifdef DEBUG) and sanitizers runs-on: ubuntu-22.04 - strategy: - fail-fast: false - matrix: - include: - - tag: 1 - start_offset: "" - end_offset: "--end-offset 2000" - - tag: 2 - start_offset: "--start-offset 2000" - end_offset: "" env: CC: gcc-10 CXX: g++-10 TREAT_WARNINGS_AS_ERRORS: 1 GEN: ninja CRASH_ON_ASSERT: 1 + CMAKE_CXX_FLAGS: '-DDEBUG' + FORCE_ASSERT: 1 steps: - uses: actions/checkout@v4 @@ -73,11 +65,11 @@ jobs: - name: Build shell: bash - run: make reldebug + run: make release - name: Output version info shell: bash - run: ./build/reldebug/duckdb -c "PRAGMA version;" + run: ./build/release/duckdb -c "PRAGMA version;" - name: Set DUCKDB_INSTALL_LIB for ADBC tests shell: bash @@ -89,7 +81,7 @@ jobs: - name: Test shell: bash run: | - python3 scripts/run_tests_one_by_one.py build/reldebug/test/unittest --tests-per-invocation 100 ${{ matrix.start_offset }} ${{ matrix.end_offset }} + python3 scripts/run_tests_one_by_one.py build/release/test/unittest --tests-per-invocation 100 linux-release: name: Linux Release (full suite) From cbcfa3aafa5e2ddbe6b3f4fc0780d1f6d5dcf133 Mon Sep 17 00:00:00 2001 From: Jelte Fennema-Nio Date: Mon, 30 Jun 2025 09:22:04 +0200 Subject: [PATCH 058/100] Add Stack Trace marker to stack trace Since https://github.com/duckdb/duckdb/pull/18023 stack traces are now being added in ConstructFinalMessage. However they were not using the "Stack trace:" prefix that is used for all other stack traces. This makes it hard extract/remove these specific stack traces from the resulting error message. This adds that same prefix. --- src/common/error_data.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/common/error_data.cpp b/src/common/error_data.cpp index bbb1fe12de85..de6685ce9041 100644 --- a/src/common/error_data.cpp +++ b/src/common/error_data.cpp @@ -70,7 +70,7 @@ string ErrorData::ConstructFinalMessage() const { auto entry = extra_info.find("stack_trace_pointers"); if (entry != extra_info.end()) { auto stack_trace = StackTrace::ResolveStacktraceSymbols(entry->second); - error += "\n\n" + stack_trace; + error += "\n\nStack Trace:\n" + stack_trace; } } return error; From a8c72af4a4303cbd0a7e5f97db40559797fa8fa8 Mon Sep 17 00:00:00 2001 From: Mytherin Date: Mon, 30 Jun 2025 14:08:36 +0200 Subject: [PATCH 059/100] Add write_bloom_filter flag to allow disabling of bloom filters --- extension/parquet/include/parquet_writer.hpp | 9 +++++++-- .../include/writer/templated_column_writer.hpp | 14 +++++++++----- extension/parquet/parquet_extension.cpp | 7 +++++-- extension/parquet/parquet_writer.cpp | 6 ++++-- test/sql/copy/parquet/bloom_filters.test | 9 +++++++++ 5 files changed, 34 insertions(+), 11 deletions(-) diff --git a/extension/parquet/include/parquet_writer.hpp b/extension/parquet/include/parquet_writer.hpp index 66aecf8c183d..b5292aad15a1 100644 --- a/extension/parquet/include/parquet_writer.hpp +++ b/extension/parquet/include/parquet_writer.hpp @@ -82,8 +82,9 @@ class ParquetWriter { vector names, duckdb_parquet::CompressionCodec::type codec, ChildFieldIDs field_ids, const vector> &kv_metadata, shared_ptr encryption_config, idx_t dictionary_size_limit, - idx_t string_dictionary_page_size_limit, double bloom_filter_false_positive_ratio, - int64_t compression_level, bool debug_use_openssl, ParquetVersion parquet_version); + idx_t string_dictionary_page_size_limit, bool enable_bloom_filters, + double bloom_filter_false_positive_ratio, int64_t compression_level, bool debug_use_openssl, + ParquetVersion parquet_version); ~ParquetWriter(); public: @@ -122,6 +123,9 @@ class ParquetWriter { idx_t StringDictionaryPageSizeLimit() const { return string_dictionary_page_size_limit; } + double EnableBloomFilters() const { + return enable_bloom_filters; + } double BloomFilterFalsePositiveRatio() const { return bloom_filter_false_positive_ratio; } @@ -164,6 +168,7 @@ class ParquetWriter { shared_ptr encryption_config; idx_t dictionary_size_limit; idx_t string_dictionary_page_size_limit; + bool enable_bloom_filters; double bloom_filter_false_positive_ratio; int64_t compression_level; bool debug_use_openssl; diff --git a/extension/parquet/include/writer/templated_column_writer.hpp b/extension/parquet/include/writer/templated_column_writer.hpp index ff2bc270e86e..392c2d815e96 100644 --- a/extension/parquet/include/writer/templated_column_writer.hpp +++ b/extension/parquet/include/writer/templated_column_writer.hpp @@ -284,15 +284,19 @@ class StandardColumnWriter : public PrimitiveColumnWriter { auto &state = state_p.Cast>(); D_ASSERT(state.encoding == duckdb_parquet::Encoding::RLE_DICTIONARY); - state.bloom_filter = - make_uniq(state.dictionary.GetSize(), writer.BloomFilterFalsePositiveRatio()); + if (writer.EnableBloomFilters()) { + state.bloom_filter = + make_uniq(state.dictionary.GetSize(), writer.BloomFilterFalsePositiveRatio()); + } state.dictionary.IterateValues([&](const SRC &src_value, const TGT &tgt_value) { // update the statistics OP::template HandleStats(stats, tgt_value); - // update the bloom filter - auto hash = OP::template XXHash64(tgt_value); - state.bloom_filter->FilterInsert(hash); + if (state.bloom_filter) { + // update the bloom filter + auto hash = OP::template XXHash64(tgt_value); + state.bloom_filter->FilterInsert(hash); + } }); // flush the dictionary page and add it to the to-be-written pages diff --git a/extension/parquet/parquet_extension.cpp b/extension/parquet/parquet_extension.cpp index 66c7c9a403de..234b58768b30 100644 --- a/extension/parquet/parquet_extension.cpp +++ b/extension/parquet/parquet_extension.cpp @@ -227,6 +227,7 @@ struct ParquetWriteBindData : public TableFunctionData { //! This is huge but we grow it starting from 1 MB idx_t string_dictionary_page_size_limit = PrimitiveColumnWriter::MAX_UNCOMPRESSED_DICT_PAGE_SIZE; + bool enable_bloom_filters = true; //! What false positive rate are we willing to accept for bloom filters double bloom_filter_false_positive_ratio = 0.01; @@ -373,6 +374,8 @@ unique_ptr ParquetWriteBind(ClientContext &context, CopyFunctionBi PrimitiveColumnWriter::MAX_UNCOMPRESSED_DICT_PAGE_SIZE); } bind_data->string_dictionary_page_size_limit = val; + } else if (loption == "write_bloom_filter") { + bind_data->enable_bloom_filters = BooleanValue::Get(option.second[0].DefaultCastAs(LogicalType::BOOLEAN)); } else if (loption == "bloom_filter_false_positive_ratio") { auto val = option.second[0].GetValue(); if (val <= 0) { @@ -436,8 +439,8 @@ unique_ptr ParquetWriteInitializeGlobal(ClientContext &conte context, fs, file_path, parquet_bind.sql_types, parquet_bind.column_names, parquet_bind.codec, parquet_bind.field_ids.Copy(), parquet_bind.kv_metadata, parquet_bind.encryption_config, parquet_bind.dictionary_size_limit, parquet_bind.string_dictionary_page_size_limit, - parquet_bind.bloom_filter_false_positive_ratio, parquet_bind.compression_level, parquet_bind.debug_use_openssl, - parquet_bind.parquet_version); + parquet_bind.enable_bloom_filters, parquet_bind.bloom_filter_false_positive_ratio, + parquet_bind.compression_level, parquet_bind.debug_use_openssl, parquet_bind.parquet_version); return std::move(global_state); } diff --git a/extension/parquet/parquet_writer.cpp b/extension/parquet/parquet_writer.cpp index e1ac44b9d616..d07f92eb1dc4 100644 --- a/extension/parquet/parquet_writer.cpp +++ b/extension/parquet/parquet_writer.cpp @@ -345,12 +345,14 @@ ParquetWriter::ParquetWriter(ClientContext &context, FileSystem &fs, string file vector names_p, CompressionCodec::type codec, ChildFieldIDs field_ids_p, const vector> &kv_metadata, shared_ptr encryption_config_p, idx_t dictionary_size_limit_p, - idx_t string_dictionary_page_size_limit_p, double bloom_filter_false_positive_ratio_p, - int64_t compression_level_p, bool debug_use_openssl_p, ParquetVersion parquet_version) + idx_t string_dictionary_page_size_limit_p, bool enable_bloom_filters_p, + double bloom_filter_false_positive_ratio_p, int64_t compression_level_p, + bool debug_use_openssl_p, ParquetVersion parquet_version) : context(context), file_name(std::move(file_name_p)), sql_types(std::move(types_p)), column_names(std::move(names_p)), codec(codec), field_ids(std::move(field_ids_p)), encryption_config(std::move(encryption_config_p)), dictionary_size_limit(dictionary_size_limit_p), string_dictionary_page_size_limit(string_dictionary_page_size_limit_p), + enable_bloom_filters(enable_bloom_filters_p), bloom_filter_false_positive_ratio(bloom_filter_false_positive_ratio_p), compression_level(compression_level_p), debug_use_openssl(debug_use_openssl_p), parquet_version(parquet_version), total_written(0), num_row_groups(0) { diff --git a/test/sql/copy/parquet/bloom_filters.test b/test/sql/copy/parquet/bloom_filters.test index c00ecce89e21..1c40e009963d 100644 --- a/test/sql/copy/parquet/bloom_filters.test +++ b/test/sql/copy/parquet/bloom_filters.test @@ -129,6 +129,15 @@ select row_group_id, bloom_filter_offset IS NOT NULL, bloom_filter_length IS NOT ---- 0 false false +# no bloom filter - disabled explicitly +statement ok +copy (select (r1.range*10)::BIGINT r, +from range(100) r1, range(100) order by r) to '__TEST_DIR__/disable_bloom_filter.parquet' (format parquet, ROW_GROUP_SIZE 10000, write_bloom_filter false); + +query III +select row_group_id, bloom_filter_offset IS NOT NULL, bloom_filter_length IS NOT NULL from parquet_metadata('__TEST_DIR__/disable_bloom_filter.parquet') order by row_group_id; +---- +0 false false # still no bloom filter, limit off-by-one statement ok From 42eb1f2d6559561b0eb86888b2d94e1b21f18739 Mon Sep 17 00:00:00 2001 From: Alex Kasko Date: Mon, 30 Jun 2025 22:58:35 +0100 Subject: [PATCH 060/100] Fix copy constructor in SetVariableStatement This change fixes the copy constructor of the `SetVariableStatement` by adding there a call to the superclass copy constructor. Previously this constructor was using non-copy constructor of the superclass and thus was failing to copy `named_param_map` field (and some other fields). When the `postgres_scanner` extension is loaded the result of the `Prepare()` call for queries like `SET VARIABLE v = ?` was gettng an empty `named_param_map` field and the execution of this statement was failing with: > Binder Error: Parameter/argument count mismatch for prepared statement. Expected 0, got 1 Testing: new test is added that uses `CanRequestRebind()` API to check the code path on which `SQLStatement`'s copy constructor is invoked. Fixes: duckdb/duckdb-java#294 --- src/parser/statement/set_statement.cpp | 2 +- test/api/test_prepared_api.cpp | 28 ++++++++++++++++++++++++++ 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/src/parser/statement/set_statement.cpp b/src/parser/statement/set_statement.cpp index c0cd75a52845..6c4138643cb7 100644 --- a/src/parser/statement/set_statement.cpp +++ b/src/parser/statement/set_statement.cpp @@ -14,7 +14,7 @@ SetVariableStatement::SetVariableStatement(string name_p, unique_ptrCopy(), other.scope) { + : SetStatement(other), value(other.value->Copy()) { } unique_ptr SetVariableStatement::Copy() const { diff --git a/test/api/test_prepared_api.cpp b/test/api/test_prepared_api.cpp index b09ad9b6822c..10e14d1326d4 100644 --- a/test/api/test_prepared_api.cpp +++ b/test/api/test_prepared_api.cpp @@ -512,3 +512,31 @@ TEST_CASE("Test prepared statements that require rebind", "[api]") { REQUIRE_NO_FAIL(con2.Query("CREATE OR REPLACE TABLE t1 (c1 varchar)")); REQUIRE_NO_FAIL(prepared->Execute()); } + +class TestExtensionState : public ClientContextState { +public: + bool CanRequestRebind() override { + return true; + } +}; + +TEST_CASE("Test prepared statements with extension that can request a rebind", "[api]") { + DuckDB db(nullptr); + Connection con(db); + REQUIRE_NO_FAIL(con.Query("CREATE OR REPLACE TABLE t1 (c1 INTEGER)")); + + // https://github.com/duckdb/duckdb/pull/11096 + con.context->registered_state->Insert("test_extension", make_shared_ptr()); + + // SelectStatement + REQUIRE_NO_FAIL(con.Prepare("SELECT ?")->Execute(42)); + + // InsertStatement + REQUIRE_NO_FAIL(con.Prepare("INSERT INTO t1 VALUES(?)")->Execute(42)); + + // UpdateStatement + REQUIRE_NO_FAIL(con.Prepare("UPDATE t1 SET c1 = ?")->Execute(43)); + + // SetVariableStatement + REQUIRE_NO_FAIL(con.Prepare("SET VARIABLE test_var = ?")->Execute(42)); +} From e87b7d8d79f208519dcbbf90eeadfc5f28670dc6 Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Tue, 1 Jul 2025 09:35:54 +0200 Subject: [PATCH 061/100] OSX.yml: Move from using debug builds to release + DDEBUG + FORCE_ASSERT --- .github/workflows/OSX.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/OSX.yml b/.github/workflows/OSX.yml index c4360d5d92a7..2b853b2747d3 100644 --- a/.github/workflows/OSX.yml +++ b/.github/workflows/OSX.yml @@ -49,6 +49,8 @@ jobs: env: TREAT_WARNINGS_AS_ERRORS: 1 + CMAKE_CXX_FLAGS: '-DDEBUG' + FORCE_ASSERT: 1 steps: - uses: actions/checkout@v4 @@ -72,7 +74,7 @@ jobs: - name: Build shell: bash - run: GEN=ninja make debug + run: GEN=ninja make release - name: Set DUCKDB_INSTALL_LIB for ADBC tests shell: bash @@ -84,7 +86,7 @@ jobs: - name: Test if: ${{ inputs.skip_tests != 'true' }} shell: bash - run: make unittestci + run: make unittest_release - name: Amalgamation if: ${{ inputs.skip_tests != 'true' }} From a4dce39caeefd6f8b567c9c26784632e2709ceea Mon Sep 17 00:00:00 2001 From: Laurens Kuiper Date: Tue, 1 Jul 2025 10:11:05 +0200 Subject: [PATCH 062/100] add missing hugeint to switch --- extension/parquet/column_reader.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/extension/parquet/column_reader.cpp b/extension/parquet/column_reader.cpp index e74912c80ae6..6b65684074a0 100644 --- a/extension/parquet/column_reader.cpp +++ b/extension/parquet/column_reader.cpp @@ -763,6 +763,8 @@ unique_ptr CreateDecimalReader(ParquetReader &reader, const Parque return make_uniq>>(reader, schema); case PhysicalType::INT64: return make_uniq>>(reader, schema); + case PhysicalType::INT128: + return make_uniq>>(reader, schema); default: throw NotImplementedException("Unimplemented internal type for CreateDecimalReader"); } From 73571b0a8e764f608000f6517ac4f45653b86b87 Mon Sep 17 00:00:00 2001 From: Laurens Kuiper Date: Tue, 1 Jul 2025 11:08:52 +0200 Subject: [PATCH 063/100] refactor extracting filter expressions for index scan --- src/function/table/table_scan.cpp | 171 ++++++++++-------------------- 1 file changed, 56 insertions(+), 115 deletions(-) diff --git a/src/function/table/table_scan.cpp b/src/function/table/table_scan.cpp index 24a9887f626c..1cfd8de966c8 100644 --- a/src/function/table/table_scan.cpp +++ b/src/function/table/table_scan.cpp @@ -386,104 +386,60 @@ unique_ptr DuckIndexScanInitGlobal(ClientContext &cont return std::move(g_state); } -void ExtractExpressionsFromValues(vector &values, BoundColumnRefExpression &bound_ref, - vector> &expressions) { - for (const auto &value : values) { - auto bound_constant = make_uniq(value); - auto filter_expr = make_uniq(ExpressionType::COMPARE_EQUAL, bound_ref.Copy(), - std::move(bound_constant)); - expressions.push_back(std::move(filter_expr)); +bool ExtractComparisonsAndInFilters(TableFilter &filter, vector> &comparisons, + vector> &in_filters) { + switch (filter.filter_type) { + case TableFilterType::CONSTANT_COMPARISON: { + auto &comparison = filter.Cast(); + comparisons.push_back(comparison); + return true; } -} - -void ExtractIn(InFilter &filter, vector &values) { - // Eliminate any duplicates. - value_set_t unique_values; - for (const auto &value : filter.values) { - if (unique_values.find(value) == unique_values.end()) { - unique_values.insert(value); - values.push_back(value); + case TableFilterType::OPTIONAL_FILTER: { + auto &optional_filter = filter.Cast(); + if (!optional_filter.child_filter) { + return true; // No child filters, always OK } + return ExtractComparisonsAndInFilters(*optional_filter.child_filter, comparisons, in_filters); } - D_ASSERT(!values.empty()); -} - -bool ExtractConjunctionAnd(ConjunctionAndFilter &filter, vector> &value_vectors) { - // Every CONJUNCTION_AND must have at least one IN_FILTER, - // OR it must have an IN_FILTER in a lower level. - // The IN_FILTER is the "source of truth", as any values not in the IN_FILTER evaluate to false. - if (filter.child_filters.empty()) { - return false; + case TableFilterType::IN_FILTER: { + in_filters.push_back(filter.Cast()); + return true; } - - // Extract the CONSTANT_COMPARISON and IN_FILTER children. - vector> comparisons; - vector> in_filters; - idx_t sort_start = value_vectors.size(); - - for (idx_t i = 0; i < filter.child_filters.size(); i++) { - auto &child_filter = *filter.child_filters[i]; - switch (child_filter.filter_type) { - case TableFilterType::CONSTANT_COMPARISON: { - auto &comparison = child_filter.Cast(); - comparisons.push_back(comparison); - continue; - } - case TableFilterType::CONJUNCTION_AND: { - auto &conjunction = child_filter.Cast(); - if (!ExtractConjunctionAnd(conjunction, value_vectors)) { - // CONJUNCTION_AND has unsupported filters, or no qualifying values. - return false; - } - continue; - } - case TableFilterType::OPTIONAL_FILTER: { - auto &optional_filter = child_filter.Cast(); - if (!optional_filter.child_filter) { - return false; - } - if (optional_filter.child_filter->filter_type != TableFilterType::IN_FILTER) { - // No support for other optional filter types yet. + case TableFilterType::CONJUNCTION_AND: { + auto &conjunction_and = filter.Cast(); + for (idx_t i = 0; i < conjunction_and.child_filters.size(); i++) { + if (!ExtractComparisonsAndInFilters(*conjunction_and.child_filters[i], comparisons, in_filters)) { return false; } - auto &in_filter = optional_filter.child_filter->Cast(); - value_vectors.emplace_back(); - ExtractIn(in_filter, value_vectors.back()); - continue; - } - default: - // Filter types other than CONSTANT_COMPARISON/IN_FILTER/CONJUNCTION_AND are not yet supported. - return false; } + return true; } - - // No support for other CONJUNCTION_AND cases. - if (value_vectors.empty()) { + default: return false; } +} - // Get the UNION of all IN_FILTER values. - for (idx_t i = sort_start; i < value_vectors.size(); i++) { - std::sort(value_vectors[i].begin(), value_vectors[i].end()); - } - while (value_vectors.size() > 1) { - value_vectors.emplace_back(); - auto &first = value_vectors[0]; - auto &second = value_vectors[1]; - std::set_union(first.cbegin(), first.cend(), second.cbegin(), second.cend(), - std::back_inserter(value_vectors.back())); - value_vectors.erase(value_vectors.begin()); - value_vectors.erase(value_vectors.begin()); +value_set_t GetUniqueValues(vector> &comparisons, vector> &in_filters) { + // Get the combined unique values of the IN filters. + value_set_t unique_values; + for (idx_t filter_idx = 0; filter_idx < in_filters.size(); filter_idx++) { + auto &in_filter = in_filters[filter_idx].get(); + for (idx_t value_idx = 0; value_idx < in_filter.values.size(); value_idx++) { + auto &value = in_filter.values[value_idx]; + if (unique_values.find(value) != unique_values.end()) { + continue; + } + unique_values.insert(value); + } } // Extract all qualifying values. - auto &final_vec = value_vectors.back(); - for (auto value_it = final_vec.begin(); value_it != final_vec.end();) { + for (auto value_it = unique_values.begin(); value_it != unique_values.end();) { bool qualifies = true; for (idx_t comp_idx = 0; comp_idx < comparisons.size(); comp_idx++) { if (!comparisons[comp_idx].get().Compare(*value_it)) { qualifies = false; - value_it = final_vec.erase(value_it); + value_it = unique_values.erase(value_it); break; } } @@ -491,34 +447,17 @@ bool ExtractConjunctionAnd(ConjunctionAndFilter &filter, vector> & value_it++; } } - if (final_vec.empty()) { - value_vectors.erase(value_vectors.cbegin()); - return false; - } - return true; + + return unique_values; } -bool ExtractFilter(TableFilter &filter, vector> &value_vectors) { - switch (filter.filter_type) { - case TableFilterType::OPTIONAL_FILTER: { - auto &optional_filter = filter.Cast(); - if (!optional_filter.child_filter) { - return false; - } - return ExtractFilter(*optional_filter.child_filter, value_vectors); - } - case TableFilterType::IN_FILTER: { - auto &in_filter = filter.Cast(); - value_vectors.emplace_back(); - ExtractIn(in_filter, value_vectors.back()); - return true; - } - case TableFilterType::CONJUNCTION_AND: { - auto &conjunction_and = filter.Cast(); - return ExtractConjunctionAnd(conjunction_and, value_vectors); - } - default: - return false; +void ExtractExpressionsFromValues(const value_set_t &unique_values, BoundColumnRefExpression &bound_ref, + vector> &expressions) { + for (const auto &value : unique_values) { + auto bound_constant = make_uniq(value); + auto filter_expr = make_uniq(ExpressionType::COMPARE_EQUAL, bound_ref.Copy(), + std::move(bound_constant)); + expressions.push_back(std::move(filter_expr)); } } @@ -527,19 +466,21 @@ vector> ExtractFilterExpressions(const ColumnDefinition & ColumnBinding binding(0, storage_idx); auto bound_ref = make_uniq(col.Name(), col.Type(), binding); + // Extract all comparisons and IN filters from nested filters vector> expressions; - vector> value_vectors; - - if (ExtractFilter(*filter, value_vectors)) { - D_ASSERT(value_vectors.size() == 1); - D_ASSERT(!value_vectors.begin()->empty()); - ExtractExpressionsFromValues(*value_vectors.begin(), *bound_ref, expressions); - return expressions; + vector> comparisons; + vector> in_filters; + if (ExtractComparisonsAndInFilters(*filter, comparisons, in_filters)) { + // Deduplicate/deal with conflicting filters, then convert to expressions + ExtractExpressionsFromValues(GetUniqueValues(comparisons, in_filters), *bound_ref, expressions); } // Attempt matching the top-level filter to the index expression. - auto filter_expr = filter->ToExpression(*bound_ref); - expressions.push_back(std::move(filter_expr)); + if (expressions.empty()) { + auto filter_expr = filter->ToExpression(*bound_ref); + expressions.push_back(std::move(filter_expr)); + } + return expressions; } From b298ba894ea7ddcccf1d00c114ed649b7ff1a0c2 Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Tue, 1 Jul 2025 15:37:57 +0200 Subject: [PATCH 064/100] shared_ptr& must be reached from FileOpener Without this PR, there are situations where `httpfs` extension defaults to own HTTPFSUtil, instead of using the global registered one. I think while this currently work, it's somewhat of a code smell, and basically prevent other extensions (or clients, such as duckdb-wasm) to have a clean path to override the default http_util to be used. This is possibly also a problem connected to introduction of curl in the `httpfs` extension, since it's not possible for `httpfs` to offer two interfaces, and register one or the other depending on settings. This commit forces FileOpener to have a way to return a reference to the original shared_ptr (possibly caching on costructor / other ways). Then the main improvement is the chagnge (currently via a patch) that allows in duckdb-httpfs. This is an improved / slimmer version of https://github.com/duckdb/duckdb/pull/18103, thanks to feedback from @Mytherin. --- .github/config/out_of_tree_extensions.cmake | 1 + .../patches/extensions/httpfs/httpfs.patch | 20 +++++++++++++++++++ src/include/duckdb/common/file_opener.hpp | 1 + .../main/client_context_file_opener.hpp | 1 + .../duckdb/main/database_file_opener.hpp | 3 +++ src/main/client_context_file_opener.cpp | 4 ++++ 6 files changed, 30 insertions(+) create mode 100644 .github/patches/extensions/httpfs/httpfs.patch diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index bdf5ae42c71d..ab8b18b3896c 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -21,6 +21,7 @@ duckdb_extension_load(httpfs GIT_URL https://github.com/duckdb/duckdb-httpfs GIT_TAG 39779f89b16d0a35f04d3cfaf868e6366a2102f0 INCLUDE_DIR extension/httpfs/include + APPLY_PATCHES ) ################# AVRO diff --git a/.github/patches/extensions/httpfs/httpfs.patch b/.github/patches/extensions/httpfs/httpfs.patch new file mode 100644 index 000000000000..ae3fe4ad41dd --- /dev/null +++ b/.github/patches/extensions/httpfs/httpfs.patch @@ -0,0 +1,20 @@ +diff --git a/extension/httpfs/httpfs.cpp b/extension/httpfs/httpfs.cpp +index 4881e9d..56c8b8e 100644 +--- a/extension/httpfs/httpfs.cpp ++++ b/extension/httpfs/httpfs.cpp +@@ -23,13 +23,9 @@ namespace duckdb { + + shared_ptr HTTPFSUtil::GetHTTPUtil(optional_ptr opener) { + if (opener) { +- auto db = opener->TryGetDatabase(); +- if (db) { +- auto &config = DBConfig::GetConfig(*db); +- return config.http_util; +- } ++ return opener->GetHTTPUtil(); + } +- return make_shared_ptr(); ++ throw InternalException("FileOpener not provided, can't get HTTPUtil"); + } + + unique_ptr HTTPFSUtil::InitializeParameters(optional_ptr opener, diff --git a/src/include/duckdb/common/file_opener.hpp b/src/include/duckdb/common/file_opener.hpp index ff7aa9103853..349dfbd92f77 100644 --- a/src/include/duckdb/common/file_opener.hpp +++ b/src/include/duckdb/common/file_opener.hpp @@ -35,6 +35,7 @@ class FileOpener { virtual SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) = 0; virtual optional_ptr TryGetClientContext() = 0; virtual optional_ptr TryGetDatabase() = 0; + virtual shared_ptr &GetHTTPUtil() = 0; DUCKDB_API virtual Logger &GetLogger() const = 0; DUCKDB_API static unique_ptr TryGetCatalogTransaction(optional_ptr opener); diff --git a/src/include/duckdb/main/client_context_file_opener.hpp b/src/include/duckdb/main/client_context_file_opener.hpp index 189d7dfd8c64..373c4c4058f5 100644 --- a/src/include/duckdb/main/client_context_file_opener.hpp +++ b/src/include/duckdb/main/client_context_file_opener.hpp @@ -29,6 +29,7 @@ class ClientContextFileOpener : public FileOpener { return &context; } optional_ptr TryGetDatabase() override; + shared_ptr &GetHTTPUtil() override; private: ClientContext &context; diff --git a/src/include/duckdb/main/database_file_opener.hpp b/src/include/duckdb/main/database_file_opener.hpp index ae61f9272754..950f1f11e06b 100644 --- a/src/include/duckdb/main/database_file_opener.hpp +++ b/src/include/duckdb/main/database_file_opener.hpp @@ -36,6 +36,9 @@ class DatabaseFileOpener : public FileOpener { optional_ptr TryGetDatabase() override { return &db; } + shared_ptr &GetHTTPUtil() override { + return TryGetDatabase()->config.http_util; + } private: DatabaseInstance &db; diff --git a/src/main/client_context_file_opener.cpp b/src/main/client_context_file_opener.cpp index f7a85dc7cab5..24ed2aa663a3 100644 --- a/src/main/client_context_file_opener.cpp +++ b/src/main/client_context_file_opener.cpp @@ -24,6 +24,10 @@ optional_ptr ClientContextFileOpener::TryGetDatabase() { return context.db.get(); } +shared_ptr &ClientContextFileOpener::GetHTTPUtil() { + return TryGetDatabase()->config.http_util; +} + unique_ptr FileOpener::TryGetCatalogTransaction(optional_ptr opener) { if (!opener) { return nullptr; From 534f567bdc21d89157fc7b7347bc754dd88677bb Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Tue, 1 Jul 2025 23:12:39 +0200 Subject: [PATCH 065/100] Cleanup on correct branch (1.3-ossivalis) instead of v1.2-histrionicus --- .github/workflows/Python.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/Python.yml b/.github/workflows/Python.yml index c957e828c50e..2ce0825635d5 100644 --- a/.github/workflows/Python.yml +++ b/.github/workflows/Python.yml @@ -376,7 +376,7 @@ jobs: ./scripts/upload-assets-to-staging.sh twine_upload tools/pythonpkg/wheelhouse/*.whl linux-release-cleanup: - if: github.ref == 'refs/heads/v1.2-histrionicus' || github.ref == 'refs/heads/main' + if: github.ref == 'refs/heads/v1.3-ossivalis' || github.ref == 'refs/heads/main' name: PyPi Release Cleanup needs: twine-upload runs-on: ubuntu-22.04 From b541bec4fffde2c012a8b206f5155c96269694bc Mon Sep 17 00:00:00 2001 From: Zuleykha Pavlichenkova Date: Tue, 1 Jul 2025 23:54:55 +0200 Subject: [PATCH 066/100] Add v1.3.2 to version_map.json and generate storage_info --- src/storage/storage_info.cpp | 2 ++ src/storage/version_map.json | 4 +++- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/src/storage/storage_info.cpp b/src/storage/storage_info.cpp index a59474e2b73c..bfa36e92b73a 100644 --- a/src/storage/storage_info.cpp +++ b/src/storage/storage_info.cpp @@ -81,6 +81,7 @@ static const StorageVersionInfo storage_version_info[] = { {"v1.2.2", 65}, {"v1.3.0", 66}, {"v1.3.1", 66}, + {"v1.3.2", 66}, {nullptr, 0} }; // END OF STORAGE VERSION INFO @@ -104,6 +105,7 @@ static const SerializationVersionInfo serialization_version_info[] = { {"v1.2.2", 4}, {"v1.3.0", 5}, {"v1.3.1", 5}, + {"v1.3.2", 5}, {"latest", 5}, {nullptr, 0} }; diff --git a/src/storage/version_map.json b/src/storage/version_map.json index 090fd5660266..622ef959f716 100644 --- a/src/storage/version_map.json +++ b/src/storage/version_map.json @@ -53,7 +53,8 @@ "v1.2.1": 65, "v1.2.2": 65, "v1.3.0": 66, - "v1.3.1": 66 + "v1.3.1": 66, + "v1.3.2": 66 }, "default": 64 }, @@ -73,6 +74,7 @@ "v1.2.2": 4, "v1.3.0": 5, "v1.3.1": 5, + "v1.3.2": 5, "latest": 5 }, "default": 1 From e718d40db0d71ce32f6eada4840bf4043d86b25e Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Wed, 2 Jul 2025 11:17:50 +0200 Subject: [PATCH 067/100] Absorb patch from https://github.com/duckdb/duckdb/pull/18107 --- .github/config/out_of_tree_extensions.cmake | 3 +-- .../patches/extensions/httpfs/httpfs.patch | 20 ------------------- 2 files changed, 1 insertion(+), 22 deletions(-) delete mode 100644 .github/patches/extensions/httpfs/httpfs.patch diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index ab8b18b3896c..99e8dec2fad1 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -19,9 +19,8 @@ duckdb_extension_load(httpfs LOAD_TESTS GIT_URL https://github.com/duckdb/duckdb-httpfs - GIT_TAG 39779f89b16d0a35f04d3cfaf868e6366a2102f0 + GIT_TAG 64f3bfa2743c0d10b05e0e2e137520a5e2e182b3 INCLUDE_DIR extension/httpfs/include - APPLY_PATCHES ) ################# AVRO diff --git a/.github/patches/extensions/httpfs/httpfs.patch b/.github/patches/extensions/httpfs/httpfs.patch deleted file mode 100644 index ae3fe4ad41dd..000000000000 --- a/.github/patches/extensions/httpfs/httpfs.patch +++ /dev/null @@ -1,20 +0,0 @@ -diff --git a/extension/httpfs/httpfs.cpp b/extension/httpfs/httpfs.cpp -index 4881e9d..56c8b8e 100644 ---- a/extension/httpfs/httpfs.cpp -+++ b/extension/httpfs/httpfs.cpp -@@ -23,13 +23,9 @@ namespace duckdb { - - shared_ptr HTTPFSUtil::GetHTTPUtil(optional_ptr opener) { - if (opener) { -- auto db = opener->TryGetDatabase(); -- if (db) { -- auto &config = DBConfig::GetConfig(*db); -- return config.http_util; -- } -+ return opener->GetHTTPUtil(); - } -- return make_shared_ptr(); -+ throw InternalException("FileOpener not provided, can't get HTTPUtil"); - } - - unique_ptr HTTPFSUtil::InitializeParameters(optional_ptr opener, From b8443819f57776d3c8466bca1b55f58817f5b9ef Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Wed, 2 Jul 2025 14:04:14 +0200 Subject: [PATCH 068/100] Actually correctly skip building unnecessary extensions --- .github/actions/build_extensions/action.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/actions/build_extensions/action.yml b/.github/actions/build_extensions/action.yml index cfe039b85158..5715e642b686 100644 --- a/.github/actions/build_extensions/action.yml +++ b/.github/actions/build_extensions/action.yml @@ -114,7 +114,7 @@ runs: run: | echo "VCPKG_TOOLCHAIN_PATH=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake" >> $GITHUB_ENV echo "VCPKG_TARGET_TRIPLET=${{ inputs.vcpkg_target_triplet }}" >> $GITHUB_ENV - echo "BUILD_COMPLETE_EXTENSION_SET=${{ inputs.build_complete_extensions_set }}" >> docker_env.txt + echo "BUILD_COMPLETE_EXTENSION_SET=${{ inputs.build_complete_extensions_set }}" >> $GITHUB_ENV - name: workaround for https://github.com/duckdb/duckdb/issues/8360 if: inputs.vcpkg_target_triplet == 'x64-windows-static-md' From ccba5de6dedfcf74d406fbccd64a6a6ee73a7ea2 Mon Sep 17 00:00:00 2001 From: Laurens Kuiper Date: Thu, 3 Jul 2025 10:45:51 +0200 Subject: [PATCH 069/100] fix issue #18124 --- src/function/function_list.cpp | 2 +- .../compressed_materialization/compress_string.cpp | 12 ++++++------ .../scalar/compressed_materialization/functions.json | 2 +- .../scalar/compressed_materialization_utils.cpp | 2 +- .../scalar/compressed_materialization_functions.hpp | 4 ++-- src/optimizer/compressed_materialization.cpp | 8 ++++---- 6 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/function/function_list.cpp b/src/function/function_list.cpp index 60b1b098ccec..2c77fcadb888 100644 --- a/src/function/function_list.cpp +++ b/src/function/function_list.cpp @@ -53,8 +53,8 @@ static const StaticFunctionDefinition function[] = { DUCKDB_SCALAR_FUNCTION_SET(InternalCompressIntegralUintegerFun), DUCKDB_SCALAR_FUNCTION_SET(InternalCompressIntegralUsmallintFun), DUCKDB_SCALAR_FUNCTION_SET(InternalCompressIntegralUtinyintFun), - DUCKDB_SCALAR_FUNCTION(InternalCompressStringHugeintFun), DUCKDB_SCALAR_FUNCTION(InternalCompressStringUbigintFun), + DUCKDB_SCALAR_FUNCTION(InternalCompressStringUhugeintFun), DUCKDB_SCALAR_FUNCTION(InternalCompressStringUintegerFun), DUCKDB_SCALAR_FUNCTION(InternalCompressStringUsmallintFun), DUCKDB_SCALAR_FUNCTION(InternalCompressStringUtinyintFun), diff --git a/src/function/scalar/compressed_materialization/compress_string.cpp b/src/function/scalar/compressed_materialization/compress_string.cpp index 14576b12a997..38a8b7200c74 100644 --- a/src/function/scalar/compressed_materialization/compress_string.cpp +++ b/src/function/scalar/compressed_materialization/compress_string.cpp @@ -93,8 +93,8 @@ static scalar_function_t GetStringCompressFunctionSwitch(const LogicalType &resu return GetStringCompressFunction(result_type); case LogicalTypeId::UBIGINT: return GetStringCompressFunction(result_type); - case LogicalTypeId::HUGEINT: - return GetStringCompressFunction(result_type); + case LogicalTypeId::UHUGEINT: + return GetStringCompressFunction(result_type); default: throw InternalException("Unexpected type in GetStringCompressFunctionSwitch"); } @@ -189,8 +189,8 @@ static scalar_function_t GetStringDecompressFunctionSwitch(const LogicalType &in return GetStringDecompressFunction(input_type); case LogicalTypeId::UBIGINT: return GetStringDecompressFunction(input_type); - case LogicalTypeId::HUGEINT: - return GetStringDecompressFunction(input_type); + case LogicalTypeId::UHUGEINT: + return GetStringDecompressFunction(input_type); default: throw InternalException("Unexpected type in GetStringDecompressFunctionSwitch"); } @@ -262,8 +262,8 @@ ScalarFunction InternalCompressStringUbigintFun::GetFunction() { return CMStringCompressFun::GetFunction(LogicalType(LogicalTypeId::UBIGINT)); } -ScalarFunction InternalCompressStringHugeintFun::GetFunction() { - return CMStringCompressFun::GetFunction(LogicalType(LogicalTypeId::HUGEINT)); +ScalarFunction InternalCompressStringUhugeintFun::GetFunction() { + return CMStringCompressFun::GetFunction(LogicalType(LogicalTypeId::UHUGEINT)); } ScalarFunctionSet InternalDecompressStringFun::GetFunctions() { diff --git a/src/function/scalar/compressed_materialization/functions.json b/src/function/scalar/compressed_materialization/functions.json index 7d0980917c1d..c84527c36160 100644 --- a/src/function/scalar/compressed_materialization/functions.json +++ b/src/function/scalar/compressed_materialization/functions.json @@ -56,7 +56,7 @@ "type": "scalar_function" }, { - "name": "__internal_compress_string_hugeint", + "name": "__internal_compress_string_uhugeint", "parameters": "", "description": "", "example": "", diff --git a/src/function/scalar/compressed_materialization_utils.cpp b/src/function/scalar/compressed_materialization_utils.cpp index 2d09a7e7fc02..3076027c767f 100644 --- a/src/function/scalar/compressed_materialization_utils.cpp +++ b/src/function/scalar/compressed_materialization_utils.cpp @@ -8,7 +8,7 @@ const vector CMUtils::IntegralTypes() { const vector CMUtils::StringTypes() { return {LogicalType::UTINYINT, LogicalType::USMALLINT, LogicalType::UINTEGER, LogicalType::UBIGINT, - LogicalType::HUGEINT}; + LogicalType::UHUGEINT}; } // LCOV_EXCL_START diff --git a/src/include/duckdb/function/scalar/compressed_materialization_functions.hpp b/src/include/duckdb/function/scalar/compressed_materialization_functions.hpp index 918888594cd4..ac042a90689c 100644 --- a/src/include/duckdb/function/scalar/compressed_materialization_functions.hpp +++ b/src/include/duckdb/function/scalar/compressed_materialization_functions.hpp @@ -95,8 +95,8 @@ struct InternalCompressStringUbigintFun { static ScalarFunction GetFunction(); }; -struct InternalCompressStringHugeintFun { - static constexpr const char *Name = "__internal_compress_string_hugeint"; +struct InternalCompressStringUhugeintFun { + static constexpr const char *Name = "__internal_compress_string_uhugeint"; static constexpr const char *Parameters = ""; static constexpr const char *Description = ""; static constexpr const char *Example = ""; diff --git a/src/optimizer/compressed_materialization.cpp b/src/optimizer/compressed_materialization.cpp index 0245110b5ed4..316c701a0cc2 100644 --- a/src/optimizer/compressed_materialization.cpp +++ b/src/optimizer/compressed_materialization.cpp @@ -330,7 +330,7 @@ static Value GetIntegralRangeValue(ClientContext &context, const LogicalType &ty auto min = NumericStats::Min(stats); auto max = NumericStats::Max(stats); if (max < min) { - return Value::HUGEINT(NumericLimits::Maximum()); + return Value::UHUGEINT(NumericLimits::Maximum()); } vector> arguments; @@ -342,8 +342,8 @@ static Value GetIntegralRangeValue(ClientContext &context, const LogicalType &ty if (ExpressionExecutor::TryEvaluateScalar(context, sub, result)) { return result; } else { - // Couldn't evaluate: Return max hugeint as range so GetIntegralCompress will return nullptr - return Value::HUGEINT(NumericLimits::Maximum()); + // Couldn't evaluate: Return max uhugeint as range so GetIntegralCompress will return nullptr + return Value::UHUGEINT(NumericLimits::Maximum()); } } @@ -354,7 +354,7 @@ unique_ptr CompressedMaterialization::GetIntegralCompress(un return nullptr; } - // Get range and cast to UBIGINT (might fail for HUGEINT, in which case we just return) + // Get range and cast to UBIGINT (might fail for UHUGEINT, in which case we just return) Value range_value = GetIntegralRangeValue(context, type, stats); if (!range_value.DefaultTryCastAs(LogicalType::UBIGINT)) { return nullptr; From d9964bd8275dfff04e809fe580605390e5c4af29 Mon Sep 17 00:00:00 2001 From: taniabogatsch <44262898+taniabogatsch@users.noreply.github.com> Date: Thu, 3 Jul 2025 12:38:27 +0200 Subject: [PATCH 070/100] throw internal exception on corrupted roaring bitmap offsets --- src/storage/compression/roaring/scan.cpp | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/src/storage/compression/roaring/scan.cpp b/src/storage/compression/roaring/scan.cpp index cefc4df72242..24c9a43c941b 100644 --- a/src/storage/compression/roaring/scan.cpp +++ b/src/storage/compression/roaring/scan.cpp @@ -203,11 +203,20 @@ void BitsetContainerScanState::Verify() const { RoaringScanState::RoaringScanState(ColumnSegment &segment) : segment(segment) { auto &buffer_manager = BufferManager::GetBufferManager(segment.db); handle = buffer_manager.Pin(segment.block); - auto base_ptr = handle.Ptr() + segment.GetBlockOffset(); + auto segment_size = segment.SegmentSize(); + auto segment_block_offset = segment.GetBlockOffset(); + if (segment_block_offset >= segment_size) { + throw InternalException("invalid segment_block_offset in RoaringScanState constructor"); + } + + auto base_ptr = handle.Ptr() + segment_block_offset; data_ptr = base_ptr + sizeof(idx_t); // Deserialize the container metadata for this segment auto metadata_offset = Load(base_ptr); + if (metadata_offset >= segment_size) { + throw InternalException("invalid metadata offset in RoaringScanState constructor"); + } auto metadata_ptr = data_ptr + metadata_offset; auto segment_count = segment.count.load(); From 00bc79ce9270f4ce3b1a1e3f401a019022c9e220 Mon Sep 17 00:00:00 2001 From: pdet Date: Thu, 3 Jul 2025 13:57:49 +0200 Subject: [PATCH 071/100] Fix for arrow.json production extension type --- src/common/arrow/arrow_type_extension.cpp | 2 +- test/arrow/arrow_test_helper.cpp | 12 ++++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/src/common/arrow/arrow_type_extension.cpp b/src/common/arrow/arrow_type_extension.cpp index 38fc867d699c..9e50e7c25420 100644 --- a/src/common/arrow/arrow_type_extension.cpp +++ b/src/common/arrow/arrow_type_extension.cpp @@ -382,7 +382,7 @@ void ArrowTypeExtensionSet::Initialize(const DBConfig &config) { // Types that are 1:n config.RegisterArrowExtension({"arrow.json", &ArrowJson::PopulateSchema, &ArrowJson::GetType, - make_shared_ptr(LogicalType::VARCHAR)}); + make_shared_ptr(LogicalType::JSON())}); config.RegisterArrowExtension({"DuckDB", "bit", &ArrowBit::PopulateSchema, &ArrowBit::GetType, make_shared_ptr(LogicalType::BIT), nullptr, nullptr}); diff --git a/test/arrow/arrow_test_helper.cpp b/test/arrow/arrow_test_helper.cpp index 427f675a6e65..6f97472303a6 100644 --- a/test/arrow/arrow_test_helper.cpp +++ b/test/arrow/arrow_test_helper.cpp @@ -162,6 +162,18 @@ bool ArrowTestHelper::CompareResults(Connection &con, unique_ptr ar auto duck_collection = duck->TakeCollection(); auto duck_rel = make_shared_ptr(con.context, std::move(duck_collection), duck->names, "duck"); + if (materialized_arrow.types != duck->types) { + printf("-------------------------------------\n"); + printf("Arrow round-trip type comparison failed\n"); + printf("-------------------------------------\n"); + printf("Query: %s\n", query.c_str()); + printf("-----------------DuckDB-------------------\n"); + Printer::Print(duck_rel->ToString(0)); + printf("-----------------Arrow--------------------\n"); + Printer::Print(arrow_rel->ToString(0)); + printf("-------------------------------------\n"); + return false; + } // We perform a SELECT * FROM "duck_rel" EXCEPT ALL SELECT * FROM "arrow_rel" // this will tell us if there are tuples missing from 'arrow_rel' that are present in 'duck_rel' auto except_rel = make_shared_ptr(duck_rel, arrow_rel, SetOperationType::EXCEPT, /*setop_all=*/true); From ba5abdf9e6e4662cdb581685fdb38565786fdea7 Mon Sep 17 00:00:00 2001 From: pdet Date: Thu, 3 Jul 2025 14:16:07 +0200 Subject: [PATCH 072/100] Allow .tsv as an accepted db file --- src/main/database_path_and_type.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/database_path_and_type.cpp b/src/main/database_path_and_type.cpp index 80cc5a03cb7a..3cae9b54f674 100644 --- a/src/main/database_path_and_type.cpp +++ b/src/main/database_path_and_type.cpp @@ -26,7 +26,7 @@ void DBPathAndType::CheckMagicBytes(FileSystem &fs, string &path, string &db_typ case DataFileType::PARQUET_FILE: case DataFileType::UNKNOWN_FILE: { // FIXME: we should get this from the registered replacement scans instead of hardcoding it here - vector supported_suffixes {"parquet", "csv", "json", "jsonl", "ndjson"}; + vector supported_suffixes {"parquet", "csv", "tsv", "json", "jsonl", "ndjson"}; if (ReplacementScan::CanReplace(path, supported_suffixes)) { db_type = "__open_file__"; break; From f017e443d43b580a9e029dcc9fb69f3d9e8203df Mon Sep 17 00:00:00 2001 From: pdet Date: Thu, 3 Jul 2025 14:55:58 +0200 Subject: [PATCH 073/100] Fixing CSV Fuzzer issues --- data/csv/afl/5194/crashes/case_0.csv | 25 ++++++++++++++++++ data/csv/afl/5194/crashes/case_1.csv | Bin 0 -> 210 bytes data/csv/afl/5194/crashes/case_2.csv | Bin 0 -> 42 bytes data/csv/afl/5194/crashes/case_3.csv | Bin 0 -> 114 bytes data/csv/afl/5194/crashes/case_4.csv | Bin 0 -> 151 bytes data/csv/afl/5194/crashes/case_5.csv | 12 +++++++++ data/csv/afl/5194/crashes/case_6.csv | 9 +++++++ .../csv_scanner/scanner/scanner_boundary.cpp | 5 ++++ .../scanner/string_value_scanner.cpp | 4 +-- test/sql/copy/csv/afl/test_fuzz_5194.test | 17 ++++++++++++ 10 files changed, 70 insertions(+), 2 deletions(-) create mode 100644 data/csv/afl/5194/crashes/case_0.csv create mode 100644 data/csv/afl/5194/crashes/case_1.csv create mode 100644 data/csv/afl/5194/crashes/case_2.csv create mode 100644 data/csv/afl/5194/crashes/case_3.csv create mode 100644 data/csv/afl/5194/crashes/case_4.csv create mode 100644 data/csv/afl/5194/crashes/case_5.csv create mode 100644 data/csv/afl/5194/crashes/case_6.csv create mode 100644 test/sql/copy/csv/afl/test_fuzz_5194.test diff --git a/data/csv/afl/5194/crashes/case_0.csv b/data/csv/afl/5194/crashes/case_0.csv new file mode 100644 index 000000000000..db4d32426414 --- /dev/null +++ b/data/csv/afl/5194/crashes/case_0.csv @@ -0,0 +1,25 @@ +a,b,c +1,1,1 +1,1,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,\n,1 +1,1000;"aa "" +;a "" +10"\n,1 +1,\n,1 +1,1,1 +1,1,1 \ No newline at end of file diff --git a/data/csv/afl/5194/crashes/case_1.csv b/data/csv/afl/5194/crashes/case_1.csv new file mode 100644 index 0000000000000000000000000000000000000000..8cf777137b44613d18644e870fb705209a6e5811 GIT binary patch literal 210 zcmb1OR##FlNKGlqw@xau&daej)H65Y%1vZ65M?x!K$X-n3X%hvKS8fw8zU`W(S(n$uI41`=@0&EG? HF48FgqlqrT literal 0 HcmV?d00001 diff --git a/data/csv/afl/5194/crashes/case_2.csv b/data/csv/afl/5194/crashes/case_2.csv new file mode 100644 index 0000000000000000000000000000000000000000..1909c4c89f2dc33b28dd9d5fb5cea7748dd587c7 GIT binary patch literal 42 vcmcCE;xbj2U{+URU~pgn0vQ(RYW3v&ocKg_D+LoSbwf)_YeNGA18XG!h>8a_ literal 0 HcmV?d00001 diff --git a/data/csv/afl/5194/crashes/case_3.csv b/data/csv/afl/5194/crashes/case_3.csv new file mode 100644 index 0000000000000000000000000000000000000000..5e598f1e34c6f9fec91d0a674b026677bd6eb9a3 GIT binary patch literal 114 zcmd;JR<~A{V_-Do@MnMlMng^@M*t?q$Z*U+iA&)b2mqBdfEiE%$Tze$;!@%=1S$FR UOi@wse}iHi2p}tivTuNB02XO5CIA2c literal 0 HcmV?d00001 diff --git a/data/csv/afl/5194/crashes/case_4.csv b/data/csv/afl/5194/crashes/case_4.csv new file mode 100644 index 0000000000000000000000000000000000000000..9120bad66ad4aeb3a4300da6982dad76835ee9c4 GIT binary patch literal 151 zcmb1OR##FlNKGlqw@xau&daej)H65Y%1va{GiP96VGyX6V}Jk-W_6dul2mmo1qrwo zWr!9T15rjpR(TF2rPk_vjCw#(br;7FSLIrE9(C0u1y$V?9R*cJkZK8LYpAtgGZ=YU S4GN98m{^p!OdU(p6^sFofgDc& literal 0 HcmV?d00001 diff --git a/data/csv/afl/5194/crashes/case_5.csv b/data/csv/afl/5194/crashes/case_5.csv new file mode 100644 index 000000000000..f021697a8581 --- /dev/null +++ b/data/csv/afl/5194/crashes/case_5.csv @@ -0,0 +1,12 @@ +9;1000<"a "" +;a "" +10"0òòòòòòòòòòòÕòòòòòò€òòòòòòòòò +199VVVVVVVVVVVVVVV^VVVVV;1oo': P'0" +199;1000;"a "" +;a "" +10" +199;1000;"a "" +;a +;"" +1ooooooooooooooooooa "" +1o03,4 199;1000;"a "" diff --git a/data/csv/afl/5194/crashes/case_6.csv b/data/csv/afl/5194/crashes/case_6.csv new file mode 100644 index 000000000000..9585546a3748 --- /dev/null +++ b/data/csv/afl/5194/crashes/case_6.csv @@ -0,0 +1,9 @@ +"a "" +;a "" +10"0òòòòòòòòòòòÕòòòòòò€òòòòòòòòò +199VVVVVVVVVVVVVVVVVVVVV;1oo': P'0" +199>1000;"x "" +;a "" +10" +199;1000;"aVVVVVVVVVVVVVVVVoooooooooooooooa "" +1o03,4 199;1000;"a "" diff --git a/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp b/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp index bdb324d61057..9daf977550b8 100644 --- a/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp +++ b/src/execution/operator/csv_scanner/scanner/scanner_boundary.cpp @@ -41,6 +41,11 @@ idx_t CSVIterator::BytesPerThread(const CSVReaderOptions &reader_options) { // If we are setting up the buffer size directly, we must make sure each thread will read the full buffer. return max_row_size; } + if (bytes_per_thread == 0) { + // Bytes per thread can never be zero, but it might happen if max_row_size = 0 + // Not sure why a human being would do that... + return 1; + } return bytes_per_thread; } diff --git a/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp b/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp index 086b6145b07c..6a6ad454b072 100644 --- a/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp +++ b/src/execution/operator/csv_scanner/scanner/string_value_scanner.cpp @@ -1373,7 +1373,7 @@ void StringValueScanner::ProcessOverBufferValue() { result.escaped = true; } if (states.IsComment()) { - result.comment = true; + result.SetComment(result, j); } if (states.IsInvalid()) { result.InvalidState(result); @@ -1435,7 +1435,7 @@ void StringValueScanner::ProcessOverBufferValue() { result.SetQuoted(result, j); } if (states.IsComment()) { - result.comment = true; + result.SetComment(result, j); } if (states.IsEscaped() && result.state_machine.dialect_options.state_machine_options.escape != '\0') { result.escaped = true; diff --git a/test/sql/copy/csv/afl/test_fuzz_5194.test b/test/sql/copy/csv/afl/test_fuzz_5194.test new file mode 100644 index 000000000000..dd0d3085c205 --- /dev/null +++ b/test/sql/copy/csv/afl/test_fuzz_5194.test @@ -0,0 +1,17 @@ +# name: test/sql/copy/csv/afl/test_fuzz_5194.test +# description: fuzzer generated csv files - should not raise internal exception (by failed assertion). +# group: [csv] + +require json + +statement ok +PRAGMA enable_verification + +statement maybe +FROM read_csv('data/csv/afl/5194/crashes/case_0.csv', auto_detect=false, buffer_size=8, columns={'a': 'integer','b': 'integer','c': 'integer'}, header=true, maximum_line_size=0); +---- + +statement maybe +FROM read_csv('data/csv/afl/5194/crashes/case_4.csv', buffer_size=30, delim=';', union_by_name=false, header=false, null_padding=true); +---- + From 899948b58884b8c8d00e274f2d390c87f37c1905 Mon Sep 17 00:00:00 2001 From: pdet Date: Thu, 3 Jul 2025 14:56:27 +0200 Subject: [PATCH 074/100] Remove repeated tests --- data/csv/afl/5194/crashes/case_1.csv | Bin 210 -> 0 bytes data/csv/afl/5194/crashes/case_2.csv | Bin 42 -> 0 bytes data/csv/afl/5194/crashes/case_3.csv | Bin 114 -> 0 bytes data/csv/afl/5194/crashes/case_5.csv | 12 ------------ data/csv/afl/5194/crashes/case_6.csv | 9 --------- 5 files changed, 21 deletions(-) delete mode 100644 data/csv/afl/5194/crashes/case_1.csv delete mode 100644 data/csv/afl/5194/crashes/case_2.csv delete mode 100644 data/csv/afl/5194/crashes/case_3.csv delete mode 100644 data/csv/afl/5194/crashes/case_5.csv delete mode 100644 data/csv/afl/5194/crashes/case_6.csv diff --git a/data/csv/afl/5194/crashes/case_1.csv b/data/csv/afl/5194/crashes/case_1.csv deleted file mode 100644 index 8cf777137b44613d18644e870fb705209a6e5811..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 210 zcmb1OR##FlNKGlqw@xau&daej)H65Y%1vZ65M?x!K$X-n3X%hvKS8fw8zU`W(S(n$uI41`=@0&EG? HF48FgqlqrT diff --git a/data/csv/afl/5194/crashes/case_2.csv b/data/csv/afl/5194/crashes/case_2.csv deleted file mode 100644 index 1909c4c89f2dc33b28dd9d5fb5cea7748dd587c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 42 vcmcCE;xbj2U{+URU~pgn0vQ(RYW3v&ocKg_D+LoSbwf)_YeNGA18XG!h>8a_ diff --git a/data/csv/afl/5194/crashes/case_3.csv b/data/csv/afl/5194/crashes/case_3.csv deleted file mode 100644 index 5e598f1e34c6f9fec91d0a674b026677bd6eb9a3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 114 zcmd;JR<~A{V_-Do@MnMlMng^@M*t?q$Z*U+iA&)b2mqBdfEiE%$Tze$;!@%=1S$FR UOi@wse}iHi2p}tivTuNB02XO5CIA2c diff --git a/data/csv/afl/5194/crashes/case_5.csv b/data/csv/afl/5194/crashes/case_5.csv deleted file mode 100644 index f021697a8581..000000000000 --- a/data/csv/afl/5194/crashes/case_5.csv +++ /dev/null @@ -1,12 +0,0 @@ -9;1000<"a "" -;a "" -10"0òòòòòòòòòòòÕòòòòòò€òòòòòòòòò -199VVVVVVVVVVVVVVV^VVVVV;1oo': P'0" -199;1000;"a "" -;a "" -10" -199;1000;"a "" -;a -;"" -1ooooooooooooooooooa "" -1o03,4 199;1000;"a "" diff --git a/data/csv/afl/5194/crashes/case_6.csv b/data/csv/afl/5194/crashes/case_6.csv deleted file mode 100644 index 9585546a3748..000000000000 --- a/data/csv/afl/5194/crashes/case_6.csv +++ /dev/null @@ -1,9 +0,0 @@ -"a "" -;a "" -10"0òòòòòòòòòòòÕòòòòòò€òòòòòòòòò -199VVVVVVVVVVVVVVVVVVVVV;1oo': P'0" -199>1000;"x "" -;a "" -10" -199;1000;"aVVVVVVVVVVVVVVVVoooooooooooooooa "" -1o03,4 199;1000;"a "" From f3ac1b90fc79925a93e912e436b77fbee6501732 Mon Sep 17 00:00:00 2001 From: pdet Date: Thu, 3 Jul 2025 15:46:00 +0200 Subject: [PATCH 075/100] Tests fixaroo --- test/arrow/arrow_roundtrip.cpp | 54 +++++++++++++++++--------------- test/arrow/arrow_test_helper.cpp | 28 +++++++++++------ 2 files changed, 46 insertions(+), 36 deletions(-) diff --git a/test/arrow/arrow_roundtrip.cpp b/test/arrow/arrow_roundtrip.cpp index 39559da4d48e..dfa48275390a 100644 --- a/test/arrow/arrow_roundtrip.cpp +++ b/test/arrow/arrow_roundtrip.cpp @@ -48,47 +48,49 @@ TEST_CASE("Test Export Large", "[arrow]") { TestArrowRoundtrip("SELECT 'bla'::BLOB FROM range(10000)"); - TestArrowRoundtrip("SELECT '3d038406-6275-4aae-bec1-1235ccdeaade'::UUID FROM range(10000) tbl(i)"); + TestArrowRoundtrip("SELECT '3d038406-6275-4aae-bec1-1235ccdeaade'::UUID FROM range(10000) tbl(i)", false, true); // Test with Large Buffer Size TestArrowRoundtrip("SELECT 'bla' FROM range(10000)", true); TestArrowRoundtrip("SELECT 'bla'::BLOB FROM range(10000)", true); - TestArrowRoundtrip("SELECT '3d038406-6275-4aae-bec1-1235ccdeaade'::UUID FROM range(10000) tbl(i)", true); + TestArrowRoundtrip("SELECT '3d038406-6275-4aae-bec1-1235ccdeaade'::UUID FROM range(10000) tbl(i)", true, true); } TEST_CASE("Test arrow roundtrip", "[arrow]") { - TestArrowRoundtrip("SELECT * FROM range(10000) tbl(i) UNION ALL SELECT NULL"); - TestArrowRoundtrip("SELECT m from (select MAP(list_value(1), list_value(2)) from range(5) tbl(i)) tbl(m)"); - TestArrowRoundtrip("SELECT * FROM range(10) tbl(i)"); - TestArrowRoundtrip("SELECT case when i%2=0 then null else i end i FROM range(10) tbl(i)"); - TestArrowRoundtrip("SELECT case when i%2=0 then true else false end b FROM range(10) tbl(i)"); - TestArrowRoundtrip("SELECT case when i%2=0 then i%4=0 else null end b FROM range(10) tbl(i)"); - TestArrowRoundtrip("SELECT 'thisisalongstring'||i::varchar str FROM range(10) tbl(i)"); - TestArrowRoundtrip( - "SELECT case when i%2=0 then null else 'thisisalongstring'||i::varchar end str FROM range(10) tbl(i)"); - TestArrowRoundtrip("SELECT {'i': i, 'b': 10-i} str FROM range(10) tbl(i)"); - TestArrowRoundtrip("SELECT case when i%2=0 then {'i': case when i%4=0 then null else i end, 'b': 10-i} else null " - "end str FROM range(10) tbl(i)"); - TestArrowRoundtrip("SELECT [i, i+1, i+2] FROM range(10) tbl(i)"); - TestArrowRoundtrip( - "SELECT MAP(LIST_VALUE({'i':1,'j':2},{'i':3,'j':4}),LIST_VALUE({'i':1,'j':2},{'i':3,'j':4})) as a"); - TestArrowRoundtrip( - "SELECT MAP(LIST_VALUE({'i':i,'j':i+2},{'i':3,'j':NULL}),LIST_VALUE({'i':i+10,'j':2},{'i':i+4,'j':4})) as a " - "FROM range(10) tbl(i)"); - TestArrowRoundtrip("SELECT MAP(['hello', 'world'||i::VARCHAR],[i + 1, NULL]) as a FROM range(10) tbl(i)"); - TestArrowRoundtrip("SELECT (1.5 + i)::DECIMAL(4,2) dec4, (1.5 + i)::DECIMAL(9,3) dec9, (1.5 + i)::DECIMAL(18,3) " - "dec18, (1.5 + i)::DECIMAL(38,3) dec38 FROM range(10) tbl(i)"); - TestArrowRoundtrip( - "SELECT case when i%2=0 then null else INTERVAL (i) seconds end AS interval FROM range(10) tbl(i)"); + // TestArrowRoundtrip("SELECT * FROM range(10000) tbl(i) UNION ALL SELECT NULL"); + // TestArrowRoundtrip("SELECT m from (select MAP(list_value(1), list_value(2)) from range(5) tbl(i)) tbl(m)"); + // TestArrowRoundtrip("SELECT * FROM range(10) tbl(i)"); + // TestArrowRoundtrip("SELECT case when i%2=0 then null else i end i FROM range(10) tbl(i)"); + // TestArrowRoundtrip("SELECT case when i%2=0 then true else false end b FROM range(10) tbl(i)"); + // TestArrowRoundtrip("SELECT case when i%2=0 then i%4=0 else null end b FROM range(10) tbl(i)"); + // TestArrowRoundtrip("SELECT 'thisisalongstring'||i::varchar str FROM range(10) tbl(i)"); + // TestArrowRoundtrip( + // "SELECT case when i%2=0 then null else 'thisisalongstring'||i::varchar end str FROM range(10) tbl(i)"); + // TestArrowRoundtrip("SELECT {'i': i, 'b': 10-i} str FROM range(10) tbl(i)"); + // TestArrowRoundtrip("SELECT case when i%2=0 then {'i': case when i%4=0 then null else i end, 'b': 10-i} else null + // " + // "end str FROM range(10) tbl(i)"); + // TestArrowRoundtrip("SELECT [i, i+1, i+2] FROM range(10) tbl(i)"); + // TestArrowRoundtrip( + // "SELECT MAP(LIST_VALUE({'i':1,'j':2},{'i':3,'j':4}),LIST_VALUE({'i':1,'j':2},{'i':3,'j':4})) as a"); + // TestArrowRoundtrip( + // "SELECT MAP(LIST_VALUE({'i':i,'j':i+2},{'i':3,'j':NULL}),LIST_VALUE({'i':i+10,'j':2},{'i':i+4,'j':4})) as a " + // "FROM range(10) tbl(i)"); + // TestArrowRoundtrip("SELECT MAP(['hello', 'world'||i::VARCHAR],[i + 1, NULL]) as a FROM range(10) tbl(i)"); + // TestArrowRoundtrip("SELECT (1.5 + i)::DECIMAL(4,2) dec4, (1.5 + i)::DECIMAL(9,3) dec9, (1.5 + i)::DECIMAL(18,3) " + // "dec18, (1.5 + i)::DECIMAL(38,3) dec38 FROM range(10) tbl(i)"); + // TestArrowRoundtrip( + // "SELECT case when i%2=0 then null else INTERVAL (i) seconds end AS interval FROM range(10) tbl(i)"); #if STANDARD_VECTOR_SIZE < 64 // FIXME: there seems to be a bug in the enum arrow reader in this test when run with vsize=2 return; #endif TestArrowRoundtrip("SELECT * EXCLUDE(bit,time_tz, varint) REPLACE " "(interval (1) seconds AS interval, hugeint::DOUBLE as hugeint, uhugeint::DOUBLE as uhugeint) " - "FROM test_all_types()"); + "FROM test_all_types()", + false, true); } TEST_CASE("Test Arrow Extension Types", "[arrow][.]") { diff --git a/test/arrow/arrow_test_helper.cpp b/test/arrow/arrow_test_helper.cpp index 6f97472303a6..c8cb1bbcd4fc 100644 --- a/test/arrow/arrow_test_helper.cpp +++ b/test/arrow/arrow_test_helper.cpp @@ -163,16 +163,24 @@ bool ArrowTestHelper::CompareResults(Connection &con, unique_ptr ar auto duck_rel = make_shared_ptr(con.context, std::move(duck_collection), duck->names, "duck"); if (materialized_arrow.types != duck->types) { - printf("-------------------------------------\n"); - printf("Arrow round-trip type comparison failed\n"); - printf("-------------------------------------\n"); - printf("Query: %s\n", query.c_str()); - printf("-----------------DuckDB-------------------\n"); - Printer::Print(duck_rel->ToString(0)); - printf("-----------------Arrow--------------------\n"); - Printer::Print(arrow_rel->ToString(0)); - printf("-------------------------------------\n"); - return false; + bool mismatch_error = false; + std::ostringstream error_msg; + error_msg << "-------------------------------------\n"; + error_msg << "Arrow round-trip type comparison failed\n"; + error_msg << "-------------------------------------\n"; + error_msg << "Query: " << query.c_str() << "\n"; + for (idx_t i = 0; i < materialized_arrow.types.size(); i++) { + if (materialized_arrow.types[i] != duck->types[i] && duck->types[i].id() != LogicalTypeId::ENUM) { + mismatch_error = true; + error_msg << "Column " << i << "mismatch. DuckDB: '" << duck->types[i].ToString() << "'. Arrow '" + << materialized_arrow.types[i].ToString() << "'\n"; + } + } + error_msg << "-------------------------------------\n"; + if (mismatch_error) { + printf("%s", error_msg.str().c_str()); + return false; + } } // We perform a SELECT * FROM "duck_rel" EXCEPT ALL SELECT * FROM "arrow_rel" // this will tell us if there are tuples missing from 'arrow_rel' that are present in 'duck_rel' From e379cfb6ff8638e370c9910665a065314d79d593 Mon Sep 17 00:00:00 2001 From: pdet Date: Thu, 3 Jul 2025 15:51:07 +0200 Subject: [PATCH 076/100] format --- test/sql/copy/csv/afl/test_fuzz_5194.test | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/sql/copy/csv/afl/test_fuzz_5194.test b/test/sql/copy/csv/afl/test_fuzz_5194.test index dd0d3085c205..91f588d19a85 100644 --- a/test/sql/copy/csv/afl/test_fuzz_5194.test +++ b/test/sql/copy/csv/afl/test_fuzz_5194.test @@ -1,6 +1,6 @@ # name: test/sql/copy/csv/afl/test_fuzz_5194.test # description: fuzzer generated csv files - should not raise internal exception (by failed assertion). -# group: [csv] +# group: [afl] require json From ca2b2c816cd92c6cc0a9b07466a45799692b99c5 Mon Sep 17 00:00:00 2001 From: Tishj Date: Thu, 3 Jul 2025 17:01:32 +0200 Subject: [PATCH 077/100] bump iceberg --- .github/config/out_of_tree_extensions.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index 99e8dec2fad1..90a2e01ca433 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -93,7 +93,7 @@ if (NOT MINGW AND NOT ${WASM_ENABLED}) # ${LOAD_ICEBERG_TESTS} TODO: re-enable once autoloading test is fixed ${LOAD_ICEBERG_TESTS} GIT_URL https://github.com/duckdb/duckdb-iceberg - GIT_TAG 76fd8b092f9986f994ece37bb396dc89adf7b2cc + GIT_TAG 2746c589c12d0a8f6b77986ca12a1fc14ef463a4 ) endif() From 6fa2a8a388bb8b6c93ff6b7bac32ffd81a0c0943 Mon Sep 17 00:00:00 2001 From: Tishj Date: Thu, 3 Jul 2025 17:06:19 +0200 Subject: [PATCH 078/100] bump avro --- .github/config/out_of_tree_extensions.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index 90a2e01ca433..9a7188da0782 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -28,7 +28,7 @@ if (NOT MINGW) duckdb_extension_load(avro LOAD_TESTS DONT_LINK GIT_URL https://github.com/duckdb/duckdb-avro - GIT_TAG 1b53c8af9973b0267406ca5a24d7e0b52f22cec3 + GIT_TAG 73e97c0f28888f804ed1361313a1dae623f1a4d2 ) endif() From 50c933fbe27d50cfa2365e12bb3304ff0a4801b8 Mon Sep 17 00:00:00 2001 From: pdet Date: Fri, 4 Jul 2025 10:36:57 +0200 Subject: [PATCH 079/100] Uncomment accidental commented tests --- test/arrow/arrow_roundtrip.cpp | 47 +++++++++++++++++----------------- 1 file changed, 23 insertions(+), 24 deletions(-) diff --git a/test/arrow/arrow_roundtrip.cpp b/test/arrow/arrow_roundtrip.cpp index dfa48275390a..9cfcacfc5152 100644 --- a/test/arrow/arrow_roundtrip.cpp +++ b/test/arrow/arrow_roundtrip.cpp @@ -59,30 +59,29 @@ TEST_CASE("Test Export Large", "[arrow]") { } TEST_CASE("Test arrow roundtrip", "[arrow]") { - // TestArrowRoundtrip("SELECT * FROM range(10000) tbl(i) UNION ALL SELECT NULL"); - // TestArrowRoundtrip("SELECT m from (select MAP(list_value(1), list_value(2)) from range(5) tbl(i)) tbl(m)"); - // TestArrowRoundtrip("SELECT * FROM range(10) tbl(i)"); - // TestArrowRoundtrip("SELECT case when i%2=0 then null else i end i FROM range(10) tbl(i)"); - // TestArrowRoundtrip("SELECT case when i%2=0 then true else false end b FROM range(10) tbl(i)"); - // TestArrowRoundtrip("SELECT case when i%2=0 then i%4=0 else null end b FROM range(10) tbl(i)"); - // TestArrowRoundtrip("SELECT 'thisisalongstring'||i::varchar str FROM range(10) tbl(i)"); - // TestArrowRoundtrip( - // "SELECT case when i%2=0 then null else 'thisisalongstring'||i::varchar end str FROM range(10) tbl(i)"); - // TestArrowRoundtrip("SELECT {'i': i, 'b': 10-i} str FROM range(10) tbl(i)"); - // TestArrowRoundtrip("SELECT case when i%2=0 then {'i': case when i%4=0 then null else i end, 'b': 10-i} else null - // " - // "end str FROM range(10) tbl(i)"); - // TestArrowRoundtrip("SELECT [i, i+1, i+2] FROM range(10) tbl(i)"); - // TestArrowRoundtrip( - // "SELECT MAP(LIST_VALUE({'i':1,'j':2},{'i':3,'j':4}),LIST_VALUE({'i':1,'j':2},{'i':3,'j':4})) as a"); - // TestArrowRoundtrip( - // "SELECT MAP(LIST_VALUE({'i':i,'j':i+2},{'i':3,'j':NULL}),LIST_VALUE({'i':i+10,'j':2},{'i':i+4,'j':4})) as a " - // "FROM range(10) tbl(i)"); - // TestArrowRoundtrip("SELECT MAP(['hello', 'world'||i::VARCHAR],[i + 1, NULL]) as a FROM range(10) tbl(i)"); - // TestArrowRoundtrip("SELECT (1.5 + i)::DECIMAL(4,2) dec4, (1.5 + i)::DECIMAL(9,3) dec9, (1.5 + i)::DECIMAL(18,3) " - // "dec18, (1.5 + i)::DECIMAL(38,3) dec38 FROM range(10) tbl(i)"); - // TestArrowRoundtrip( - // "SELECT case when i%2=0 then null else INTERVAL (i) seconds end AS interval FROM range(10) tbl(i)"); + TestArrowRoundtrip("SELECT * FROM range(10000) tbl(i) UNION ALL SELECT NULL"); + TestArrowRoundtrip("SELECT m from (select MAP(list_value(1), list_value(2)) from range(5) tbl(i)) tbl(m)"); + TestArrowRoundtrip("SELECT * FROM range(10) tbl(i)"); + TestArrowRoundtrip("SELECT case when i%2=0 then null else i end i FROM range(10) tbl(i)"); + TestArrowRoundtrip("SELECT case when i%2=0 then true else false end b FROM range(10) tbl(i)"); + TestArrowRoundtrip("SELECT case when i%2=0 then i%4=0 else null end b FROM range(10) tbl(i)"); + TestArrowRoundtrip("SELECT 'thisisalongstring'||i::varchar str FROM range(10) tbl(i)"); + TestArrowRoundtrip( + "SELECT case when i%2=0 then null else 'thisisalongstring'||i::varchar end str FROM range(10) tbl(i)"); + TestArrowRoundtrip("SELECT {'i': i, 'b': 10-i} str FROM range(10) tbl(i)"); + TestArrowRoundtrip("SELECT case when i%2=0 then {'i': case when i%4=0 then null else i end, 'b': 10-i} else null " + "end str FROM range(10) tbl(i)"); + TestArrowRoundtrip("SELECT [i, i+1, i+2] FROM range(10) tbl(i)"); + TestArrowRoundtrip( + "SELECT MAP(LIST_VALUE({'i':1,'j':2},{'i':3,'j':4}),LIST_VALUE({'i':1,'j':2},{'i':3,'j':4})) as a"); + TestArrowRoundtrip( + "SELECT MAP(LIST_VALUE({'i':i,'j':i+2},{'i':3,'j':NULL}),LIST_VALUE({'i':i+10,'j':2},{'i':i+4,'j':4})) as a " + "FROM range(10) tbl(i)"); + TestArrowRoundtrip("SELECT MAP(['hello', 'world'||i::VARCHAR],[i + 1, NULL]) as a FROM range(10) tbl(i)"); + TestArrowRoundtrip("SELECT (1.5 + i)::DECIMAL(4,2) dec4, (1.5 + i)::DECIMAL(9,3) dec9, (1.5 + i)::DECIMAL(18,3) " + "dec18, (1.5 + i)::DECIMAL(38,3) dec38 FROM range(10) tbl(i)"); + TestArrowRoundtrip( + "SELECT case when i%2=0 then null else INTERVAL (i) seconds end AS interval FROM range(10) tbl(i)"); #if STANDARD_VECTOR_SIZE < 64 // FIXME: there seems to be a bug in the enum arrow reader in this test when run with vsize=2 return; From 06cd84b3e805925ddad40d93435fc162f11c51a0 Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Fri, 4 Jul 2025 10:42:17 +0200 Subject: [PATCH 080/100] Remove irrelevant comment --- .github/config/out_of_tree_extensions.cmake | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index 9a7188da0782..604c283459b1 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -90,7 +90,6 @@ endif() if (NOT MINGW AND NOT ${WASM_ENABLED}) duckdb_extension_load(iceberg -# ${LOAD_ICEBERG_TESTS} TODO: re-enable once autoloading test is fixed ${LOAD_ICEBERG_TESTS} GIT_URL https://github.com/duckdb/duckdb-iceberg GIT_TAG 2746c589c12d0a8f6b77986ca12a1fc14ef463a4 From 06d499cf1c7568fd496f55c34586a419084e2e52 Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Fri, 4 Jul 2025 10:43:00 +0200 Subject: [PATCH 081/100] Bump registry baseline --- scripts/merge_vcpkg_deps.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/merge_vcpkg_deps.py b/scripts/merge_vcpkg_deps.py index 404f2ef105d5..478d70148200 100644 --- a/scripts/merge_vcpkg_deps.py +++ b/scripts/merge_vcpkg_deps.py @@ -68,7 +68,7 @@ def prefix_overlay_port(overlay_port): else: data['vcpkg-configuration'] = {} -REGISTRY_BASELINE = '9989b8b4707261ce77425ae5364b7de7139a2030' +REGISTRY_BASELINE = '02558971ebafdbaa697a0704a3ed7ba365cd5495' # NOTE: use 'scripts/list_vcpkg_registry_packages.py --baseline ' to generate the list of packages data['vcpkg-configuration']['registries'] = [ { From 107c5d0885b3af791f70f47e26ba19811595bfaa Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Fri, 4 Jul 2025 13:04:39 +0200 Subject: [PATCH 082/100] Bump further avro & iceberg Include https://github.com/duckdb/duckdb-avro/pull/44 and https://github.com/duckdb/duckdb-iceberg/pull/349 --- .github/config/out_of_tree_extensions.cmake | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index 604c283459b1..ad0a34fb8ab2 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -23,12 +23,12 @@ duckdb_extension_load(httpfs INCLUDE_DIR extension/httpfs/include ) -################# AVRO +################## AVRO if (NOT MINGW) duckdb_extension_load(avro LOAD_TESTS DONT_LINK GIT_URL https://github.com/duckdb/duckdb-avro - GIT_TAG 73e97c0f28888f804ed1361313a1dae623f1a4d2 + GIT_TAG 180e41e8ad13b8712d207785a6bca0aa39341040 ) endif() @@ -92,7 +92,7 @@ if (NOT MINGW AND NOT ${WASM_ENABLED}) duckdb_extension_load(iceberg ${LOAD_ICEBERG_TESTS} GIT_URL https://github.com/duckdb/duckdb-iceberg - GIT_TAG 2746c589c12d0a8f6b77986ca12a1fc14ef463a4 + GIT_TAG 06d499cf1c7568fd496f55c34586a419084e2e52 ) endif() From 52a0cce5979941f65f331e466c4a9ccfc72ea6c0 Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Fri, 4 Jul 2025 13:05:37 +0200 Subject: [PATCH 083/100] Add iceberg_to_ducklake to extension_entries.hpp --- src/include/duckdb/main/extension_entries.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/include/duckdb/main/extension_entries.hpp b/src/include/duckdb/main/extension_entries.hpp index 8aec6ca7b62d..52dc106e324e 100644 --- a/src/include/duckdb/main/extension_entries.hpp +++ b/src/include/duckdb/main/extension_entries.hpp @@ -221,6 +221,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { {"iceberg_metadata", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, {"iceberg_scan", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, {"iceberg_snapshots", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, + {"iceberg_to_ducklake", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, {"icu_calendar_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY}, {"icu_collate_af", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, {"icu_collate_am", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, From 108e0919138b736ed5c4fd11b72a0c33c144462c Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Fri, 4 Jul 2025 13:11:52 +0200 Subject: [PATCH 084/100] Iceberg to 74f0b1d8f38 --- .github/config/out_of_tree_extensions.cmake | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index ad0a34fb8ab2..2e6247ceca4f 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -19,7 +19,7 @@ duckdb_extension_load(httpfs LOAD_TESTS GIT_URL https://github.com/duckdb/duckdb-httpfs - GIT_TAG 64f3bfa2743c0d10b05e0e2e137520a5e2e182b3 + GIT_TAG da2821906eb42f7255d969be3e073bc1b45a71a8 INCLUDE_DIR extension/httpfs/include ) @@ -92,7 +92,7 @@ if (NOT MINGW AND NOT ${WASM_ENABLED}) duckdb_extension_load(iceberg ${LOAD_ICEBERG_TESTS} GIT_URL https://github.com/duckdb/duckdb-iceberg - GIT_TAG 06d499cf1c7568fd496f55c34586a419084e2e52 + GIT_TAG 74f0b1d8f385ae82265b62d59c05fcd76ac2564b ) endif() From a9865a441c8711773a6f77c152163ebbd0b8a7b3 Mon Sep 17 00:00:00 2001 From: Sam Ansmink Date: Fri, 4 Jul 2025 13:23:46 +0200 Subject: [PATCH 085/100] partially restore deprecated http logging settings --- src/common/settings.json | 10 ++-- src/include/duckdb/main/settings.hpp | 4 +- src/main/settings/autogenerated_settings.cpp | 34 ------------- src/main/settings/custom_settings.cpp | 49 +++++++++++++++++++ test/sql/pragma/test_enable_http_logging.test | 8 ++- 5 files changed, 60 insertions(+), 45 deletions(-) diff --git a/src/common/settings.json b/src/common/settings.json index ac5c06d082ac..904eda38373e 100644 --- a/src/common/settings.json +++ b/src/common/settings.json @@ -364,10 +364,11 @@ }, { "name": "enable_http_logging", - "description": "Enables HTTP logging", + "description": "(deprecated) Enables HTTP logging", "type": "BOOLEAN", "scope": "local", - "struct": "EnableHTTPLoggingSetting" + "struct": "EnableHTTPLoggingSetting", + "custom_implementation": true }, { "name": "enable_http_metadata_cache", @@ -500,10 +501,11 @@ }, { "name": "http_logging_output", - "description": "The file to which HTTP logging output should be saved, or empty to print to the terminal", + "description": "(deprecated) The file to which HTTP logging output should be saved, or empty to print to the terminal", "type": "VARCHAR", "scope": "local", - "struct": "HTTPLoggingOutputSetting" + "struct": "HTTPLoggingOutputSetting", + "custom_implementation": true }, { "name": "http_proxy", diff --git a/src/include/duckdb/main/settings.hpp b/src/include/duckdb/main/settings.hpp index a49a155e9e9a..5eb91b63fbe1 100644 --- a/src/include/duckdb/main/settings.hpp +++ b/src/include/duckdb/main/settings.hpp @@ -560,7 +560,7 @@ struct EnableFSSTVectorsSetting { struct EnableHTTPLoggingSetting { using RETURN_TYPE = bool; static constexpr const char *Name = "enable_http_logging"; - static constexpr const char *Description = "Enables HTTP logging"; + static constexpr const char *Description = "(deprecated) Enables HTTP logging"; static constexpr const char *InputType = "BOOLEAN"; static void SetLocal(ClientContext &context, const Value ¶meter); static void ResetLocal(ClientContext &context); @@ -750,7 +750,7 @@ struct HTTPLoggingOutputSetting { using RETURN_TYPE = string; static constexpr const char *Name = "http_logging_output"; static constexpr const char *Description = - "The file to which HTTP logging output should be saved, or empty to print to the terminal"; + "(deprecated) The file to which HTTP logging output should be saved, or empty to print to the terminal"; static constexpr const char *InputType = "VARCHAR"; static void SetLocal(ClientContext &context, const Value ¶meter); static void ResetLocal(ClientContext &context); diff --git a/src/main/settings/autogenerated_settings.cpp b/src/main/settings/autogenerated_settings.cpp index 06efddb76644..859a0fccde4f 100644 --- a/src/main/settings/autogenerated_settings.cpp +++ b/src/main/settings/autogenerated_settings.cpp @@ -505,23 +505,6 @@ Value EnableFSSTVectorsSetting::GetSetting(const ClientContext &context) { return Value::BOOLEAN(config.options.enable_fsst_vectors); } -//===----------------------------------------------------------------------===// -// Enable H T T P Logging -//===----------------------------------------------------------------------===// -void EnableHTTPLoggingSetting::SetLocal(ClientContext &context, const Value &input) { - auto &config = ClientConfig::GetConfig(context); - config.enable_http_logging = input.GetValue(); -} - -void EnableHTTPLoggingSetting::ResetLocal(ClientContext &context) { - ClientConfig::GetConfig(context).enable_http_logging = ClientConfig().enable_http_logging; -} - -Value EnableHTTPLoggingSetting::GetSetting(const ClientContext &context) { - auto &config = ClientConfig::GetConfig(context); - return Value::BOOLEAN(config.enable_http_logging); -} - //===----------------------------------------------------------------------===// // Enable H T T P Metadata Cache //===----------------------------------------------------------------------===// @@ -678,23 +661,6 @@ Value HomeDirectorySetting::GetSetting(const ClientContext &context) { return Value(config.home_directory); } -//===----------------------------------------------------------------------===// -// H T T P Logging Output -//===----------------------------------------------------------------------===// -void HTTPLoggingOutputSetting::SetLocal(ClientContext &context, const Value &input) { - auto &config = ClientConfig::GetConfig(context); - config.http_logging_output = input.GetValue(); -} - -void HTTPLoggingOutputSetting::ResetLocal(ClientContext &context) { - ClientConfig::GetConfig(context).http_logging_output = ClientConfig().http_logging_output; -} - -Value HTTPLoggingOutputSetting::GetSetting(const ClientContext &context) { - auto &config = ClientConfig::GetConfig(context); - return Value(config.http_logging_output); -} - //===----------------------------------------------------------------------===// // H T T P Proxy //===----------------------------------------------------------------------===// diff --git a/src/main/settings/custom_settings.cpp b/src/main/settings/custom_settings.cpp index ba1805331f77..03e7c6839d21 100644 --- a/src/main/settings/custom_settings.cpp +++ b/src/main/settings/custom_settings.cpp @@ -1088,6 +1088,55 @@ void HomeDirectorySetting::SetLocal(ClientContext &context, const Value &input) config.home_directory = input.IsNull() ? string() : input.ToString(); } +//===----------------------------------------------------------------------===// +// Enable H T T P Logging +//===----------------------------------------------------------------------===// +void EnableHTTPLoggingSetting::SetLocal(ClientContext &context, const Value &input) { + auto &config = ClientConfig::GetConfig(context); + config.enable_http_logging = input.GetValue(); + + // NOTE: this is a deprecated setting: we mimick the old behaviour by setting the log storage output to STDOUT and + // enabling logging for http only. Note that this behaviour is slightly wonky in that it sets all sorts of logging + // config + auto &log_manager = LogManager::Get(context); + if (config.enable_http_logging) { + log_manager.SetEnableLogging(true); + log_manager.SetLogLevel(HTTPLogType::LEVEL); + unordered_set enabled_log_types = {HTTPLogType::NAME}; + log_manager.SetEnabledLogTypes(enabled_log_types); + log_manager.SetLogStorage(*context.db, LogConfig::STDOUT_STORAGE_NAME); + } else { + log_manager.SetEnableLogging(false); + } +} + +void EnableHTTPLoggingSetting::ResetLocal(ClientContext &context) { + ClientConfig::GetConfig(context).enable_http_logging = ClientConfig().enable_http_logging; +} + +Value EnableHTTPLoggingSetting::GetSetting(const ClientContext &context) { + auto &config = ClientConfig::GetConfig(context); + return Value::BOOLEAN(config.enable_http_logging); +} + +//===----------------------------------------------------------------------===// +// H T T P Logging Output +//===----------------------------------------------------------------------===// +void HTTPLoggingOutputSetting::SetLocal(ClientContext &context, const Value &input) { + throw NotImplementedException("This setting is deprecated and can no longer be used. Check out the DuckDB docs on " + "logging for more information"); +} + +void HTTPLoggingOutputSetting::ResetLocal(ClientContext &context) { + throw NotImplementedException("This setting is deprecated and can no longer be used. Check out the DuckDB docs on " + "logging for more information"); +} + +Value HTTPLoggingOutputSetting::GetSetting(const ClientContext &context) { + auto &config = ClientConfig::GetConfig(context); + return Value(config.http_logging_output); +} + //===----------------------------------------------------------------------===// // Index Scan Percentage //===----------------------------------------------------------------------===// diff --git a/test/sql/pragma/test_enable_http_logging.test b/test/sql/pragma/test_enable_http_logging.test index 982d44110a67..00892dd3e38c 100644 --- a/test/sql/pragma/test_enable_http_logging.test +++ b/test/sql/pragma/test_enable_http_logging.test @@ -10,9 +10,7 @@ statement ok SET enable_http_logging=true # select the location of where to save the http logging output (instead of printing to stdout) -statement ok +statement error SET http_logging_output='__TEST_DIR__/httplog.txt' - -# but we can clear it again -statement ok -SET http_logging_output='' +---- +Not implemented Error: This setting is deprecated and can no longer be used. Check out the DuckDB docs on logging for more information From f99ebd0a2947911606f9ee46bc9e52b9f3a65576 Mon Sep 17 00:00:00 2001 From: taniabogatsch <44262898+taniabogatsch@users.noreply.github.com> Date: Fri, 4 Jul 2025 14:48:07 +0200 Subject: [PATCH 086/100] internal exceptions --- src/storage/compression/fsst.cpp | 30 ++++++++++++------- src/storage/compression/roaring/compress.cpp | 24 +++++++++------ src/storage/table/column_checkpoint_state.cpp | 4 ++- 3 files changed, 38 insertions(+), 20 deletions(-) diff --git a/src/storage/compression/fsst.cpp b/src/storage/compression/fsst.cpp index a008c612fc6a..800079a80728 100644 --- a/src/storage/compression/fsst.cpp +++ b/src/storage/compression/fsst.cpp @@ -64,7 +64,7 @@ struct FSSTStorage { static char *FetchStringPointer(StringDictionaryContainer dict, data_ptr_t baseptr, int32_t dict_offset); static bp_delta_offsets_t CalculateBpDeltaOffsets(int64_t last_known_row, idx_t start, idx_t scan_count); static bool ParseFSSTSegmentHeader(data_ptr_t base_ptr, duckdb_fsst_decoder_t *decoder_out, - bitpacking_width_t *width_out); + bitpacking_width_t *width_out, const idx_t block_size); static bp_delta_offsets_t StartScan(FSSTScanState &scan_state, data_ptr_t base_data, idx_t start, idx_t vector_count); static void EndScan(FSSTScanState &scan_state, bp_delta_offsets_t &offsets, idx_t start, idx_t scan_count); @@ -335,14 +335,15 @@ class FSSTCompressionState : public CompressionState { idx_t Finalize() { auto &buffer_manager = BufferManager::GetBufferManager(current_segment->db); auto handle = buffer_manager.Pin(current_segment->block); - D_ASSERT(current_dictionary.end == info.GetBlockSize()); + if (current_dictionary.end != info.GetBlockSize()) { + throw InternalException("dictionary end does not match the block size in FSSTCompressionState::Finalize"); + } // calculate sizes auto compressed_index_buffer_size = BitpackingPrimitives::GetRequiredSize(current_segment->count, current_width); auto total_size = sizeof(fsst_compression_header_t) + compressed_index_buffer_size + current_dictionary.size + fsst_serialized_symbol_table_size; - if (total_size != last_fitting_size) { throw InternalException("FSST string compression failed due to incorrect size calculation"); } @@ -365,8 +366,12 @@ class FSSTCompressionState : public CompressionState { memset(base_ptr + symbol_table_offset, 0, fsst_serialized_symbol_table_size); } - Store(NumericCast(symbol_table_offset), - data_ptr_cast(&header_ptr->fsst_symbol_table_offset)); + auto cast_symbol_table_offset = NumericCast(symbol_table_offset); + if (cast_symbol_table_offset > info.GetBlockSize()) { + throw InternalException("invalid fsst_symbol_table_offset in FSSTCompressionState::Finalize"); + } + + Store(cast_symbol_table_offset, data_ptr_cast(&header_ptr->fsst_symbol_table_offset)); Store((uint32_t)current_width, data_ptr_cast(&header_ptr->bitpacking_width)); if (total_size >= info.GetCompactionFlushLimit()) { @@ -563,15 +568,16 @@ struct FSSTScanState : public StringScanState { }; unique_ptr FSSTStorage::StringInitScan(ColumnSegment &segment) { - auto string_block_limit = StringUncompressed::GetStringBlockLimit(segment.GetBlockManager().GetBlockSize()); + auto block_size = segment.GetBlockManager().GetBlockSize(); + auto string_block_limit = StringUncompressed::GetStringBlockLimit(block_size); auto state = make_uniq(string_block_limit); auto &buffer_manager = BufferManager::GetBufferManager(segment.db); state->handle = buffer_manager.Pin(segment.block); auto base_ptr = state->handle.Ptr() + segment.GetBlockOffset(); state->duckdb_fsst_decoder = make_buffer(); - auto retval = ParseFSSTSegmentHeader( - base_ptr, reinterpret_cast(state->duckdb_fsst_decoder.get()), &state->current_width); + auto decoder = reinterpret_cast(state->duckdb_fsst_decoder.get()); + auto retval = ParseFSSTSegmentHeader(base_ptr, decoder, &state->current_width, block_size); if (!retval) { state->duckdb_fsst_decoder = nullptr; } @@ -736,7 +742,8 @@ void FSSTStorage::StringFetchRow(ColumnSegment &segment, ColumnFetchState &state duckdb_fsst_decoder_t decoder; bitpacking_width_t width; - auto have_symbol_table = ParseFSSTSegmentHeader(base_ptr, &decoder, &width); + auto block_size = segment.GetBlockManager().GetBlockSize(); + auto have_symbol_table = ParseFSSTSegmentHeader(base_ptr, &decoder, &width, block_size); auto result_data = FlatVector::GetData(result); if (!have_symbol_table) { @@ -814,9 +821,12 @@ char *FSSTStorage::FetchStringPointer(StringDictionaryContainer dict, data_ptr_t // Returns false if no symbol table was found. This means all strings are either empty or null bool FSSTStorage::ParseFSSTSegmentHeader(data_ptr_t base_ptr, duckdb_fsst_decoder_t *decoder_out, - bitpacking_width_t *width_out) { + bitpacking_width_t *width_out, const idx_t block_size) { auto header_ptr = reinterpret_cast(base_ptr); auto fsst_symbol_table_offset = Load(data_ptr_cast(&header_ptr->fsst_symbol_table_offset)); + if (fsst_symbol_table_offset > block_size) { + throw InternalException("invalid fsst_symbol_table_offset in FSSTStorage::ParseFSSTSegmentHeader"); + } *width_out = (bitpacking_width_t)(Load(data_ptr_cast(&header_ptr->bitpacking_width))); return duckdb_fsst_import(decoder_out, base_ptr + fsst_symbol_table_offset); } diff --git a/src/storage/compression/roaring/compress.cpp b/src/storage/compression/roaring/compress.cpp index 172cc331ad34..fc2ba3625ae1 100644 --- a/src/storage/compression/roaring/compress.cpp +++ b/src/storage/compression/roaring/compress.cpp @@ -308,24 +308,30 @@ void RoaringCompressState::FlushSegment() { base_ptr += sizeof(idx_t); // Size of the 'd' part - idx_t data_size = NumericCast(data_ptr - base_ptr); - data_size = AlignValue(data_size); + auto unaligned_data_size = NumericCast(data_ptr - base_ptr); + auto data_size = AlignValue(unaligned_data_size); + data_ptr += data_size - unaligned_data_size; // Size of the 'm' part - idx_t metadata_size = metadata_collection.GetMetadataSizeForSegment(); - + auto metadata_size = metadata_collection.GetMetadataSizeForSegment(); if (current_segment->count.load() == 0) { D_ASSERT(metadata_size == 0); return; } - idx_t serialized_metadata_size = metadata_collection.Serialize(data_ptr); + auto serialized_metadata_size = metadata_collection.Serialize(data_ptr); + if (metadata_size != serialized_metadata_size) { + throw InternalException("mismatch in metadata size during RoaringCompressState::FlushSegment"); + } + metadata_collection.FlushSegment(); - (void)serialized_metadata_size; - D_ASSERT(metadata_size == serialized_metadata_size); - idx_t metadata_start = static_cast(data_ptr - base_ptr); + auto metadata_start = static_cast(data_ptr - base_ptr); + if (metadata_start > info.GetBlockSize()) { + throw InternalException("metadata start outside of block size during RoaringCompressState::FlushSegment"); + } + Store(metadata_start, handle.Ptr()); - idx_t total_segment_size = sizeof(idx_t) + data_size + metadata_size; + auto total_segment_size = sizeof(idx_t) + data_size + metadata_size; state.FlushSegment(std::move(current_segment), std::move(handle), total_segment_size); } diff --git a/src/storage/table/column_checkpoint_state.cpp b/src/storage/table/column_checkpoint_state.cpp index 57ce46dce3e4..9ceac7ab6d11 100644 --- a/src/storage/table/column_checkpoint_state.cpp +++ b/src/storage/table/column_checkpoint_state.cpp @@ -117,7 +117,9 @@ void ColumnCheckpointState::FlushSegment(unique_ptr segment, Buff void ColumnCheckpointState::FlushSegmentInternal(unique_ptr segment, idx_t segment_size) { auto block_size = partial_block_manager.GetBlockManager().GetBlockSize(); - D_ASSERT(segment_size <= block_size); + if (segment_size > block_size) { + throw InternalException("segment size exceeds block size in ColumnCheckpointState::FlushSegmentInternal"); + } auto tuple_count = segment->count.load(); if (tuple_count == 0) { // LCOV_EXCL_START From e510378b4ad995792ce5fc22985f5ecfe6ac4c82 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Fri, 4 Jul 2025 15:42:08 +0200 Subject: [PATCH 087/100] bump iceberg --- .github/config/out_of_tree_extensions.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index 99e8dec2fad1..430e7eceaa4c 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -93,7 +93,7 @@ if (NOT MINGW AND NOT ${WASM_ENABLED}) # ${LOAD_ICEBERG_TESTS} TODO: re-enable once autoloading test is fixed ${LOAD_ICEBERG_TESTS} GIT_URL https://github.com/duckdb/duckdb-iceberg - GIT_TAG 76fd8b092f9986f994ece37bb396dc89adf7b2cc + GIT_TAG e4ba34cde870ef4108525dee4ef81070a6214d4a ) endif() From 6b0be2cb7b539ccf256581c510a48608d882500e Mon Sep 17 00:00:00 2001 From: Tmonster Date: Fri, 4 Jul 2025 15:45:06 +0200 Subject: [PATCH 088/100] update sqlsmith and aws as well --- .github/config/out_of_tree_extensions.cmake | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index 430e7eceaa4c..1d364b0ce19d 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -38,7 +38,7 @@ if (NOT MINGW AND NOT ${WASM_ENABLED}) ### TODO: re-enable LOAD_TESTS LOAD_TESTS GIT_URL https://github.com/duckdb/duckdb-aws - GIT_TAG ce6a0965f4f67e82a7dc82ea0378b8b839a2a9aa + GIT_TAG b73faadeaa4d2c880deb949771baf570f42fe8cc ) endif() @@ -146,7 +146,7 @@ duckdb_extension_load(sqlite_scanner duckdb_extension_load(sqlsmith DONT_LINK LOAD_TESTS GIT_URL https://github.com/duckdb/duckdb-sqlsmith - GIT_TAG 06e8da8a95710c996fcd62f385962ccd36a363f6 + GIT_TAG 3b1ad2bd7234c1143b4a819517873f4b465168d2 ) ################# VSS From 09659b155f85e9c03ddd0ab99b1ccce9e8a47f0f Mon Sep 17 00:00:00 2001 From: Tmonster Date: Fri, 4 Jul 2025 15:50:27 +0200 Subject: [PATCH 089/100] revert iceberg bump --- .github/config/out_of_tree_extensions.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index 1d364b0ce19d..258c910f8d98 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -93,7 +93,7 @@ if (NOT MINGW AND NOT ${WASM_ENABLED}) # ${LOAD_ICEBERG_TESTS} TODO: re-enable once autoloading test is fixed ${LOAD_ICEBERG_TESTS} GIT_URL https://github.com/duckdb/duckdb-iceberg - GIT_TAG e4ba34cde870ef4108525dee4ef81070a6214d4a + GIT_TAG 76fd8b092f9986f994ece37bb396dc89adf7b2cc ) endif() From ecb0e444b07b138bbfd2829dde56de16a25776f4 Mon Sep 17 00:00:00 2001 From: taniabogatsch <44262898+taniabogatsch@users.noreply.github.com> Date: Fri, 4 Jul 2025 15:51:09 +0200 Subject: [PATCH 090/100] include fixes --- src/include/duckdb/common/operator/string_cast.hpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/include/duckdb/common/operator/string_cast.hpp b/src/include/duckdb/common/operator/string_cast.hpp index fac7a262a973..5e5612a17d8d 100644 --- a/src/include/duckdb/common/operator/string_cast.hpp +++ b/src/include/duckdb/common/operator/string_cast.hpp @@ -9,9 +9,11 @@ #pragma once #include "duckdb/common/common.hpp" -#include "duckdb/common/types.hpp" #include "duckdb/common/exception.hpp" +#include "duckdb/common/types.hpp" +#include "duckdb/common/types/date.hpp" #include "duckdb/common/types/string_type.hpp" +#include "duckdb/common/types/timestamp.hpp" namespace duckdb { From 0564560fd52730489a1fc13bec5abffc556f06d9 Mon Sep 17 00:00:00 2001 From: Tmonster Date: Fri, 4 Jul 2025 16:08:49 +0200 Subject: [PATCH 091/100] fix whitespace --- .github/config/out_of_tree_extensions.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index 258c910f8d98..3bbbb201833f 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -93,7 +93,7 @@ if (NOT MINGW AND NOT ${WASM_ENABLED}) # ${LOAD_ICEBERG_TESTS} TODO: re-enable once autoloading test is fixed ${LOAD_ICEBERG_TESTS} GIT_URL https://github.com/duckdb/duckdb-iceberg - GIT_TAG 76fd8b092f9986f994ece37bb396dc89adf7b2cc + GIT_TAG 76fd8b092f9986f994ece37bb396dc89adf7b2cc ) endif() From 8dce900a34f5585d7b88230d6d3ade375b9678d2 Mon Sep 17 00:00:00 2001 From: Sam Ansmink Date: Fri, 4 Jul 2025 16:39:26 +0200 Subject: [PATCH 092/100] exclude setting from test --- test/api/test_reset.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/api/test_reset.cpp b/test/api/test_reset.cpp index c2ec5894aca2..60e16cfe7731 100644 --- a/test/api/test_reset.cpp +++ b/test/api/test_reset.cpp @@ -115,7 +115,6 @@ OptionValueSet GetValueForOption(const string &name, const LogicalType &type) { {"http_proxy", {"localhost:80"}}, {"http_proxy_username", {"john"}}, {"http_proxy_password", {"doe"}}, - {"http_logging_output", {"my_cool_outputfile"}}, {"allocator_flush_threshold", {"4.0 GiB"}}, {"allocator_bulk_deallocation_flush_threshold", {"4.0 GiB"}}, {"arrow_output_version", {"1.5"}}, @@ -172,6 +171,7 @@ bool OptionIsExcludedFromTest(const string &name) { "default_block_size", "index_scan_percentage", "scheduler_process_partial", + "http_logging_output", "index_scan_max_count"}; return excluded_options.count(name) == 1; } From d985421f3b6b86bfbee821e76c69c6e9494f5ad4 Mon Sep 17 00:00:00 2001 From: Christiaan Herrewijn Date: Fri, 4 Jul 2025 16:48:37 +0200 Subject: [PATCH 093/100] bump ducklake for v1.3.2. --- .github/config/out_of_tree_extensions.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index 2e6247ceca4f..e55478d350a2 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -69,7 +69,7 @@ endif() duckdb_extension_load(ducklake DONT_LINK GIT_URL https://github.com/duckdb/ducklake - GIT_TAG 2d890446b33fe648c2d2135fe2e2f3b78419b6b7 + GIT_TAG 9cc2d903c51d360ff3fc6afb10cf38f8eac2e25b ) ################# EXCEL From 9f56dbca557f1d670b36dadc81836b2c478418ab Mon Sep 17 00:00:00 2001 From: Richard Wesley <13156216+hawkfish@users.noreply.github.com> Date: Sat, 5 Jul 2025 17:08:04 +0200 Subject: [PATCH 094/100] Internal #5245: AsOf NLJ Comparisons * Filter out comparisons that NLJ does not support. fixes: duckdblabs/duckdb-internal#5245 --- src/execution/physical_plan/plan_asof_join.cpp | 7 ++++++- test/sql/join/asof/test_asof_join.test | 9 +++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/src/execution/physical_plan/plan_asof_join.cpp b/src/execution/physical_plan/plan_asof_join.cpp index f435c4b2d551..c8c4077a6bba 100644 --- a/src/execution/physical_plan/plan_asof_join.cpp +++ b/src/execution/physical_plan/plan_asof_join.cpp @@ -95,8 +95,13 @@ PhysicalPlanGenerator::PlanAsOfLoopJoin(LogicalComparisonJoin &op, PhysicalOpera asof_idx = i; arg_min_max = "arg_min"; break; - default: + case ExpressionType::COMPARE_EQUAL: + case ExpressionType::COMPARE_NOTEQUAL: + case ExpressionType::COMPARE_DISTINCT_FROM: break; + default: + // Unsupported NLJ comparison + return nullptr; } } diff --git a/test/sql/join/asof/test_asof_join.test b/test/sql/join/asof/test_asof_join.test index 4f1dd370ce13..fbcaaeec12b2 100644 --- a/test/sql/join/asof/test_asof_join.test +++ b/test/sql/join/asof/test_asof_join.test @@ -43,6 +43,15 @@ FROM trades t ASOF JOIN prices p ---- 2020-01-01 00:00:03 1 42 +# NLJ does not support IS NOT DISTINCT FROM +query II +EXPLAIN +SELECT t.*, p.price +FROM trades t ASOF JOIN prices p + ON t.symbol IS NOT DISTINCT FROM p.symbol AND t.when >= p.when; +---- +physical_plan :.*NESTED_LOOP_JOIN.* + # Ignore non-join conditions query II SELECT p.ts, e.value From 7d473fcfac94aae97858c31078a1b4b2f8fe7976 Mon Sep 17 00:00:00 2001 From: Max Gabrielsson Date: Sun, 6 Jul 2025 01:16:24 +0200 Subject: [PATCH 095/100] bump spatial --- .github/config/out_of_tree_extensions.cmake | 2 +- src/include/duckdb/main/extension_entries.hpp | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index 2e6247ceca4f..b45922d7480f 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -122,7 +122,7 @@ if (NOT MINGW AND ${BUILD_COMPLETE_EXTENSION_SET}) duckdb_extension_load(spatial DONT_LINK LOAD_TESTS GIT_URL https://github.com/duckdb/duckdb-spatial - GIT_TAG 7ab1710c125f25208c7382560c7cb313a967eb2c + GIT_TAG b8e6ca20e033b88a2749627bf0267f1a2ad9a868 INCLUDE_DIR spatial/include TEST_DIR test/sql ) diff --git a/src/include/duckdb/main/extension_entries.hpp b/src/include/duckdb/main/extension_entries.hpp index 52dc106e324e..65451326866d 100644 --- a/src/include/duckdb/main/extension_entries.hpp +++ b/src/include/duckdb/main/extension_entries.hpp @@ -42,7 +42,6 @@ struct ExtensionFunctionOverloadEntry { static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { {"!__postfix", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"&&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"**", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"->>", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, {"<->", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, @@ -625,6 +624,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { {"st_linestring2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, {"st_linesubstring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, {"st_m", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makebox2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, {"st_makeenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, {"st_makeline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, {"st_makepolygon", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, @@ -772,6 +772,8 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { }; // END_OF_EXTENSION_FUNCTIONS static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] = { + {"&&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['ANY[]','ANY[]']>BOOLEAN"}, + {"&&", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY, "[BOX_2D,GEOMETRY]>BOOLEAN"}, {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>INTERVAL"}, {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP,TIMESTAMP]>INTERVAL"}, {"age", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>INTERVAL"}, From e27ccc25a8d9fa9ce26f0c0e8b88a0a91d32fda1 Mon Sep 17 00:00:00 2001 From: Max Gabrielsson Date: Sun, 6 Jul 2025 01:30:37 +0200 Subject: [PATCH 096/100] add box2d type --- src/include/duckdb/main/extension_entries.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/include/duckdb/main/extension_entries.hpp b/src/include/duckdb/main/extension_entries.hpp index 65451326866d..38ddadaa287a 100644 --- a/src/include/duckdb/main/extension_entries.hpp +++ b/src/include/duckdb/main/extension_entries.hpp @@ -1060,7 +1060,7 @@ static constexpr ExtensionEntry EXTENSION_COPY_FUNCTIONS[] = { // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb static constexpr ExtensionEntry EXTENSION_TYPES[] = { - {"json", "json"}, {"inet", "inet"}, {"geometry", "spatial"}}; // END_OF_EXTENSION_TYPES + {"json", "json"}, {"inet", "inet"}, {"geometry", "spatial"}, {"box_2d", "spatial"}}; // END_OF_EXTENSION_TYPES // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb From d1a4f376f13a8e51e9225e89d95c202e111e1274 Mon Sep 17 00:00:00 2001 From: Max Gabrielsson Date: Sun, 6 Jul 2025 02:05:37 +0200 Subject: [PATCH 097/100] bump again, remove && operator --- .github/config/out_of_tree_extensions.cmake | 2 +- src/include/duckdb/main/extension_entries.hpp | 5 ++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index b45922d7480f..306fbaf534bb 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -122,7 +122,7 @@ if (NOT MINGW AND ${BUILD_COMPLETE_EXTENSION_SET}) duckdb_extension_load(spatial DONT_LINK LOAD_TESTS GIT_URL https://github.com/duckdb/duckdb-spatial - GIT_TAG b8e6ca20e033b88a2749627bf0267f1a2ad9a868 + GIT_TAG d1ffa8c21fe1f90064956a119491e6d6d993192a INCLUDE_DIR spatial/include TEST_DIR test/sql ) diff --git a/src/include/duckdb/main/extension_entries.hpp b/src/include/duckdb/main/extension_entries.hpp index 38ddadaa287a..835ca0cf48c5 100644 --- a/src/include/duckdb/main/extension_entries.hpp +++ b/src/include/duckdb/main/extension_entries.hpp @@ -42,6 +42,7 @@ struct ExtensionFunctionOverloadEntry { static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { {"!__postfix", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"&&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"**", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"->>", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, {"<->", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, @@ -772,8 +773,6 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { }; // END_OF_EXTENSION_FUNCTIONS static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] = { - {"&&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['ANY[]','ANY[]']>BOOLEAN"}, - {"&&", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY, "[BOX_2D,GEOMETRY]>BOOLEAN"}, {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>INTERVAL"}, {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP,TIMESTAMP]>INTERVAL"}, {"age", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>INTERVAL"}, @@ -1060,7 +1059,7 @@ static constexpr ExtensionEntry EXTENSION_COPY_FUNCTIONS[] = { // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb static constexpr ExtensionEntry EXTENSION_TYPES[] = { - {"json", "json"}, {"inet", "inet"}, {"geometry", "spatial"}, {"box_2d", "spatial"}}; // END_OF_EXTENSION_TYPES + {"json", "json"}, {"inet", "inet"}, {"geometry", "spatial"}}; // END_OF_EXTENSION_TYPES // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb From 2f84fd8303f8ac114aef8fd34381909aa9efcca4 Mon Sep 17 00:00:00 2001 From: Carlo Piovesan Date: Mon, 7 Jul 2025 00:46:14 +0200 Subject: [PATCH 098/100] Bump for wasm fixes (excel and httpfs) and test fixes (iceberg) --- .github/config/out_of_tree_extensions.cmake | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/config/out_of_tree_extensions.cmake b/.github/config/out_of_tree_extensions.cmake index 2e6247ceca4f..08947340130f 100644 --- a/.github/config/out_of_tree_extensions.cmake +++ b/.github/config/out_of_tree_extensions.cmake @@ -19,7 +19,7 @@ duckdb_extension_load(httpfs LOAD_TESTS GIT_URL https://github.com/duckdb/duckdb-httpfs - GIT_TAG da2821906eb42f7255d969be3e073bc1b45a71a8 + GIT_TAG af7bcaf40c775016838fef4823666bd18b89b36b INCLUDE_DIR extension/httpfs/include ) @@ -76,7 +76,7 @@ duckdb_extension_load(ducklake duckdb_extension_load(excel LOAD_TESTS GIT_URL https://github.com/duckdb/duckdb-excel - GIT_TAG 7e97933214d0c7de2315668ec68589ae85651afb + GIT_TAG cf00672f2d16685d9aefcca48c6a04d8c37d7015 INCLUDE_DIR src/excel/include ) @@ -92,7 +92,7 @@ if (NOT MINGW AND NOT ${WASM_ENABLED}) duckdb_extension_load(iceberg ${LOAD_ICEBERG_TESTS} GIT_URL https://github.com/duckdb/duckdb-iceberg - GIT_TAG 74f0b1d8f385ae82265b62d59c05fcd76ac2564b + GIT_TAG 003a93fbb005a7fa2469400967a77db509595271 ) endif() From 70806812fe674cc1ee2af049b1874eb7fff88329 Mon Sep 17 00:00:00 2001 From: Christiaan Herrewijn Date: Mon, 7 Jul 2025 10:43:18 +0200 Subject: [PATCH 099/100] re-generate extension_entries.hpp --- src/include/duckdb/main/extension_entries.hpp | 2154 +++++++++-------- 1 file changed, 1090 insertions(+), 1064 deletions(-) diff --git a/src/include/duckdb/main/extension_entries.hpp b/src/include/duckdb/main/extension_entries.hpp index 52dc106e324e..3332b39a6cc1 100644 --- a/src/include/duckdb/main/extension_entries.hpp +++ b/src/include/duckdb/main/extension_entries.hpp @@ -14,1051 +14,1065 @@ // NOTE: this file is generated by scripts/generate_extensions_function.py. // Example usage to refresh one extension (replace "icu" with the desired extension): // GENERATE_EXTENSION_ENTRIES=1 make debug -// python3 scripts/generate_extensions_function.py --extensions icu --shell build/debug/duckdb --extension_repository -// build/debug/repository +// python3 scripts/generate_extensions_function.py --extensions icu --shell build/debug/duckdb --extension_repository build/debug/repository // Check out the check-load-install-extensions job in .github/workflows/LinuxRelease.yml for more details namespace duckdb { struct ExtensionEntry { - char name[48]; - char extension[48]; + char name[48]; + char extension[48]; }; struct ExtensionFunctionEntry { - char name[48]; - char extension[48]; - CatalogType type; + char name[48]; + char extension[48]; + CatalogType type; }; struct ExtensionFunctionOverloadEntry { - char name[48]; - char extension[48]; - CatalogType type; - char signature[96]; + char name[48]; + char extension[48]; + CatalogType type; + char signature[96]; }; static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { - {"!__postfix", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"&&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"**", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"->>", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"<->", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"<<", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"<<=", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"<=>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"<@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {">>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {">>=", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"@>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"^", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"^@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"abs", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"acos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"acosh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"add_numbers_together", "demo_capi", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"add_parquet_key", "parquet", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"alias", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"approx_count_distinct", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"approx_quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"approx_top_k", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"arg_max", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"arg_max_null", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"arg_min", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"arg_min_null", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"argmax", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"argmin", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"array_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"array_aggr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_cosine_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_cosine_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_cross_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_distinct", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_has_all", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_has_any", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_negative_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_negative_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_reverse_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_slice", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_transform", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_unique", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ascii", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"asin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"asinh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"atan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"atan2", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"atanh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"avg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"bar", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"bin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"bit_and", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"bit_count", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"bit_or", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"bit_position", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"bit_xor", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"bitstring", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"bitstring_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"bool_and", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"bool_or", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"broadcast", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"can_cast_implicitly", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"cardinality", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"cast_to_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"cbrt", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ceil", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ceiling", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"check_peg_parser", "autocomplete", CatalogType::TABLE_FUNCTION_ENTRY}, - {"chr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"corr", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"cos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"cosh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"cot", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"count_if", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"countif", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"covar_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"covar_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"create_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"current_database", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_date", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_localtime", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_localtimestamp", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_query", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_schema", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_schemas", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_setting", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"damerau_levenshtein", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"dbgen", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, - {"decode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"degrees", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"delta_scan", "delta", CatalogType::TABLE_FUNCTION_ENTRY}, - {"drop_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"dsdgen", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, - {"duckdb_proj_compiled_version", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"duckdb_proj_version", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ducklake_add_data_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_cleanup_old_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_expire_snapshots", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_list_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_merge_adjacent_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_options", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_set_option", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_snapshots", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_table_changes", "ducklake", CatalogType::TABLE_MACRO_ENTRY}, - {"ducklake_table_deletions", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_table_info", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_table_insertions", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"editdist3", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"element_at", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"encode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"entropy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"enum_code", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"enum_first", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"enum_last", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"enum_range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"enum_range_boundary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"epoch_ms", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"epoch_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"epoch_us", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"equi_width_bins", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"even", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"excel_text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"exp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"factorial", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"family", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"favg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"flatten", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"floor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"format", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"format_bytes", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"formatreadabledecimalsize", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"formatreadablesize", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"from_base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"from_binary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"from_hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"from_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"from_json_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"fsum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"fuzz_all_functions", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, - {"fuzzyduck", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, - {"gamma", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"gcd", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"gen_random_uuid", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"get_bit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"get_current_time", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"get_current_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"greatest", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"greatest_common_divisor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"group_concat", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"hamming", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"hash", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"histogram", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"histogram_exact", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"hnsw_compact_index", "vss", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"hnsw_index_scan", "vss", CatalogType::TABLE_FUNCTION_ENTRY}, - {"host", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"html_escape", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"html_unescape", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"iceberg_metadata", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, - {"iceberg_scan", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, - {"iceberg_snapshots", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, - {"iceberg_to_ducklake", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, - {"icu_calendar_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY}, - {"icu_collate_af", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_am", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ar", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ar_sa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_as", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_az", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_be", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_bg", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_bn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_bo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_br", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_bs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ca", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ceb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_chr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_cs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_cy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_da", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_de", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_de_at", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_dsb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_dz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ee", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_el", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_en", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_en_us", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_eo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_es", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_et", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fa_af", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fil", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fr_ca", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ga", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_gl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_gu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ha", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_haw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_he", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_he_il", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_hi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_hr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_hsb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_hu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_hy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_id", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_id_id", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ig", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_is", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_it", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ja", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ka", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_kk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_kl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_km", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_kn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ko", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_kok", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ku", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ky", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_lb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_lkt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ln", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_lo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_lt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_lv", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_mk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ml", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_mn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_mr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ms", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_mt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_my", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_nb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_nb_no", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ne", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_nl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_nn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_noaccent", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_om", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_or", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_pa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_pa_in", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_pl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ps", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_pt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ro", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ru", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_se", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_si", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_smn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sq", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sr_ba", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sr_me", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sr_rs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sv", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ta", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_te", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_th", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_tk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_to", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_tr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ug", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_uk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ur", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_uz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_vi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_wae", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_wo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_xh", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_yi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_yo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_yue", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_yue_cn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zh", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zh_cn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zh_hk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zh_mo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zh_sg", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zh_tw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_sort_key", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"in_search_path", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"instr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"is_histogram_other_bin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"isfinite", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"isinf", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"isnan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"jaccard", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"jaro_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"jaro_winkler_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json", "json", CatalogType::MACRO_ENTRY}, - {"json_array", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_array_length", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_contains", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_deserialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_each", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"json_execute_serialized_sql", "json", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"json_execute_serialized_sql", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"json_exists", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_extract", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_extract_path", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_extract_path_text", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_extract_string", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_group_array", "json", CatalogType::MACRO_ENTRY}, - {"json_group_object", "json", CatalogType::MACRO_ENTRY}, - {"json_group_structure", "json", CatalogType::MACRO_ENTRY}, - {"json_keys", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_merge_patch", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_object", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_pretty", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_quote", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_serialize_plan", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_serialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_structure", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_transform", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_transform_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_tree", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"json_type", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_valid", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_value", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"kahan_sum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"kurtosis", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"kurtosis_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"lcm", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"least", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"least_common_multiple", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"left", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"left_grapheme", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"levenshtein", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"lgamma", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"list_aggr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_cosine_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_cosine_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_distinct", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_has_all", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_has_any", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_negative_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_negative_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_pack", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_reverse_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_slice", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_transform", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_unique", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"listagg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"ln", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"load_aws_credentials", "aws", CatalogType::TABLE_FUNCTION_ENTRY}, - {"log", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"log10", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"log2", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"lpad", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ltrim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"mad", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"make_date", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"make_time", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"make_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"make_timestamp_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"make_timestamptz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_concat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_entries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_extract", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_extract_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_from_entries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_keys", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_values", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"max_by", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"mean", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"median", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"min_by", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"mismatches", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"mode", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"mysql_clear_cache", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"mysql_execute", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"mysql_query", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"nanosecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"netmask", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"network", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"nextafter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"normalized_interval", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"now", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ord", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"parquet_bloom_probe", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"parquet_file_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"parquet_kv_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"parquet_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"parquet_scan", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"parquet_schema", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"parse_dirname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"parse_dirpath", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"parse_filename", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"parse_path", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"pg_clear_cache", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"pg_timezone_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY}, - {"pi", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"position", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"postgres_attach", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"postgres_execute", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"postgres_query", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"postgres_scan", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"postgres_scan_pushdown", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"pow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"power", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"pragma_hnsw_index_info", "vss", CatalogType::TABLE_FUNCTION_ENTRY}, - {"pragma_rtree_index_info", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"printf", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"product", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"quantile_cont", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"quantile_disc", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"radians", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"random", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"read_avro", "avro", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_json", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_json_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_json_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_json_objects_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_ndjson", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_ndjson_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_ndjson_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_parquet", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_xlsx", "excel", CatalogType::TABLE_FUNCTION_ENTRY}, - {"reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"reduce_sql_statement", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, - {"register_geoarrow_extensions", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"regr_avgx", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_avgy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_count", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_intercept", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_r2", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_slope", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_sxx", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_sxy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_syy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"repeat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"replace", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"reservoir_quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"reverse", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"right", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"right_grapheme", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"round", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"row_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"rpad", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"rtree_index_dump", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"rtree_index_scan", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"rtrim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"sem", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"set_bit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"setseed", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"shapefile_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"sign", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"signbit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"sin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"sinh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"skewness", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"sql_auto_complete", "autocomplete", CatalogType::TABLE_FUNCTION_ENTRY}, - {"sqlite_attach", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"sqlite_query", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"sqlite_scan", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"sqlsmith", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, - {"sqrt", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_affine", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_area", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_area_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_asgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_ashexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_assvg", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_astext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_aswkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_azimuth", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_boundary", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_buffer", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_buildarea", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_centroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_collect", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_collectionextract", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_concavehull", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_contains", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_containsproperly", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_convexhull", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_coverageinvalidedges", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_coverageinvalidedges_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_coveragesimplify", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_coveragesimplify_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_coverageunion", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_coverageunion_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_coveredby", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_covers", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_crosses", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_difference", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_dimension", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_disjoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_distance", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_distance_geos", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_distance_sphere", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_distance_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_drivers", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"st_dump", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_dwithin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_dwithin_geos", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_dwithin_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_endpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_envelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_envelope_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_equals", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_extent_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_extent_approx", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_exteriorring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_flipcoordinates", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_force2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_force3dm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_force3dz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_force4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_generatepoints", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"st_geometrytype", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_geomfromgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_geomfromhexewkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_geomfromhexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_geomfromtext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_geomfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_hasm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_hasz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_hilbert", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_intersection", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_intersection_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_intersects", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_intersects_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_isclosed", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_isempty", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_isring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_issimple", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_isvalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_length", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_length_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_lineinterpolatepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_lineinterpolatepoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_linemerge", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_linestring2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_linesubstring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_m", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_makeenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_makeline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_makepolygon", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_makevalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_maximuminscribedcircle", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_memunion_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_minimumrotatedrectangle", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_mmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_mmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_multi", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_ngeometries", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_ninteriorrings", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_node", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_normalize", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_npoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_numgeometries", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_numinteriorrings", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_numpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_overlaps", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_perimeter", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_perimeter_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_point", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_point2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_point2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_point3d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_point4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_pointn", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_pointonsurface", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_points", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_polygon2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_polygonize", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_quadkey", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_read", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"st_read_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"st_readosm", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"st_readshp", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"st_reduceprecision", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_removerepeatedpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_reverse", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_rotate", "spatial", CatalogType::MACRO_ENTRY}, - {"st_rotatex", "spatial", CatalogType::MACRO_ENTRY}, - {"st_rotatey", "spatial", CatalogType::MACRO_ENTRY}, - {"st_rotatez", "spatial", CatalogType::MACRO_ENTRY}, - {"st_scale", "spatial", CatalogType::MACRO_ENTRY}, - {"st_shortestline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_simplify", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_simplifypreservetopology", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_startpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_tileenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_touches", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_transform", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_translate", "spatial", CatalogType::MACRO_ENTRY}, - {"st_transscale", "spatial", CatalogType::MACRO_ENTRY}, - {"st_union", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_union_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_voronoidiagram", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_within", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_withinproperly", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_x", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_xmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_xmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_y", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_ymax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_ymin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_z", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_zmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_zmflag", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_zmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"start_ui", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, - {"start_ui_server", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, - {"starts_with", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"stats", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"stddev", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"stddev_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"stddev_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"stem", "fts", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"stop_ui_server", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, - {"string_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"strpos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"struct_insert", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"sum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"sum_no_overflow", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"sumkahan", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"tan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"tanh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"timetz_byte_comparable", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_base", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_binary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_centuries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_days", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_decades", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_hours", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_microseconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_millennia", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_milliseconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_minutes", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_months", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_quarters", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_seconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_weeks", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_years", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"today", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"tpcds", "tpcds", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"tpcds_answers", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, - {"tpcds_queries", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, - {"tpch", "tpch", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"tpch_answers", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, - {"tpch_queries", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, - {"transaction_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"translate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"trim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"txid_current", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"typeof", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ui_is_started", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, - {"unbin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"unhex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"unicode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"union_extract", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"union_tag", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"union_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"unpivot_list", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"url_decode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"url_encode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"uuid", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"uuid_extract_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"uuid_extract_version", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"uuidv4", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"uuidv7", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"var_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"var_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"variance", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"vector_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"version", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"vss_join", "vss", CatalogType::TABLE_MACRO_ENTRY}, - {"vss_match", "vss", CatalogType::TABLE_MACRO_ENTRY}, - {"xor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"|", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"~", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"!__postfix", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"&&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"**", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"->>", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"<->", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"<<", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"<<=", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"<=>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"<@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {">>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {">>=", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"@>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"^", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"^@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"abs", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"acos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"acosh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"add_numbers_together", "demo_capi", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"add_parquet_key", "parquet", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"alias", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"approx_count_distinct", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"approx_quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"approx_top_k", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"arg_max", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"arg_max_null", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"arg_min", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"arg_min_null", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"argmax", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"argmin", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"array_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"array_aggr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_cosine_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_cosine_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_cross_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_distinct", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_has_all", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_has_any", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_negative_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_negative_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_reverse_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_slice", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_transform", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_unique", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ascii", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"asin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"asinh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"atan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"atan2", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"atanh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"avg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"bar", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"bin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"bit_and", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"bit_count", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"bit_or", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"bit_position", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"bit_xor", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"bitstring", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"bitstring_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"bool_and", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"bool_or", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"broadcast", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"can_cast_implicitly", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"cardinality", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"cast_to_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"cbrt", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ceil", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ceiling", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"check_peg_parser", "autocomplete", CatalogType::TABLE_FUNCTION_ENTRY}, + {"chr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"corr", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"cos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"cosh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"cot", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"count_if", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"countif", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"covar_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"covar_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"create_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"current_database", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_date", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_localtime", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_localtimestamp", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_query", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_schema", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_schemas", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_setting", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"damerau_levenshtein", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"dbgen", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, + {"decode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"degrees", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"delta_scan", "delta", CatalogType::TABLE_FUNCTION_ENTRY}, + {"drop_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"dsdgen", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, + {"duckdb_proj_compiled_version", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"duckdb_proj_version", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ducklake_add_data_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_cleanup_old_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_expire_snapshots", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_list_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_merge_adjacent_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_options", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_set_option", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_snapshots", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_table_changes", "ducklake", CatalogType::TABLE_MACRO_ENTRY}, + {"ducklake_table_deletions", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_table_info", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_table_insertions", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"editdist3", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"element_at", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"encode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"entropy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"enum_code", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"enum_first", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"enum_last", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"enum_range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"enum_range_boundary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"epoch_ms", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"epoch_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"epoch_us", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"equi_width_bins", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"even", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"excel_text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"exp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"factorial", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"family", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"favg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"flatten", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"floor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"format", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"format_bytes", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"formatreadabledecimalsize", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"formatreadablesize", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_binary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_json_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"fsum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"fuzz_all_functions", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, + {"fuzzyduck", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, + {"gamma", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"gcd", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"gen_random_uuid", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"get_bit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"get_current_time", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"get_current_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"greatest", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"greatest_common_divisor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"group_concat", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"hamming", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"hash", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"histogram", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"histogram_exact", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"hnsw_compact_index", "vss", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"hnsw_index_scan", "vss", CatalogType::TABLE_FUNCTION_ENTRY}, + {"host", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"html_escape", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"html_unescape", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"iceberg_metadata", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, + {"iceberg_scan", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, + {"iceberg_snapshots", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, + {"iceberg_to_ducklake", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, + {"icu_calendar_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY}, + {"icu_collate_af", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_am", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ar", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ar_sa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_as", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_az", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_be", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_bg", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_bn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_bo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_br", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_bs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ca", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ceb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_chr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_cs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_cy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_da", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_de", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_de_at", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_dsb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_dz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ee", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_el", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_en", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_en_us", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_eo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_es", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_et", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fa_af", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fil", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fr_ca", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ga", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_gl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_gu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ha", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_haw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_he", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_he_il", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_hi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_hr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_hsb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_hu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_hy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_id", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_id_id", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ig", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_is", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_it", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ja", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ka", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_kk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_kl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_km", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_kn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ko", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_kok", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ku", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ky", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_lb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_lkt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ln", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_lo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_lt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_lv", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_mk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ml", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_mn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_mr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ms", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_mt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_my", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_nb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_nb_no", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ne", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_nl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_nn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_noaccent", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_om", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_or", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_pa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_pa_in", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_pl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ps", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_pt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ro", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ru", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_se", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_si", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_smn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sq", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sr_ba", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sr_me", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sr_rs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sv", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ta", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_te", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_th", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_tk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_to", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_tr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ug", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_uk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ur", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_uz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_vi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_wae", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_wo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_xh", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_yi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_yo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_yue", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_yue_cn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zh", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zh_cn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zh_hk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zh_mo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zh_sg", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zh_tw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_sort_key", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"in_search_path", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"instr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"is_histogram_other_bin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"isfinite", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"isinf", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"isnan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"jaccard", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"jaro_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"jaro_winkler_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json", "json", CatalogType::MACRO_ENTRY}, + {"json_array", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_array_length", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_contains", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_deserialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_each", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"json_execute_serialized_sql", "json", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"json_execute_serialized_sql", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"json_exists", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_extract", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_extract_path", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_extract_path_text", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_extract_string", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_group_array", "json", CatalogType::MACRO_ENTRY}, + {"json_group_object", "json", CatalogType::MACRO_ENTRY}, + {"json_group_structure", "json", CatalogType::MACRO_ENTRY}, + {"json_keys", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_merge_patch", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_object", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_pretty", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_quote", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_serialize_plan", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_serialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_structure", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_transform", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_transform_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_tree", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"json_type", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_valid", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_value", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"kahan_sum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"kurtosis", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"kurtosis_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"lcm", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"least", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"least_common_multiple", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"left", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"left_grapheme", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"levenshtein", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"lgamma", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"list_aggr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_cosine_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_cosine_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_distinct", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_has_all", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_has_any", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_negative_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_negative_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_pack", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_reverse_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_slice", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_transform", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_unique", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"listagg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"ln", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"load_aws_credentials", "aws", CatalogType::TABLE_FUNCTION_ENTRY}, + {"log", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"log10", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"log2", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"lpad", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ltrim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"mad", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"make_date", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"make_time", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"make_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"make_timestamp_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"make_timestamptz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_concat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_entries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_extract", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_extract_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_from_entries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_keys", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_values", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"max_by", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"mean", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"median", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"min_by", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"mismatches", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"mode", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"mysql_clear_cache", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"mysql_execute", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"mysql_query", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"nanosecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"netmask", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"network", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"nextafter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"normalized_interval", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"now", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ord", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"parquet_bloom_probe", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_file_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_kv_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_scan", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_schema", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parse_dirname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"parse_dirpath", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"parse_filename", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"parse_path", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"pg_clear_cache", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"pg_timezone_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY}, + {"pi", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"position", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"postgres_attach", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"postgres_execute", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"postgres_query", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"postgres_scan", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"postgres_scan_pushdown", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"pow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"power", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"pragma_hnsw_index_info", "vss", CatalogType::TABLE_FUNCTION_ENTRY}, + {"pragma_rtree_index_info", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"printf", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"product", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"quantile_cont", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"quantile_disc", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"radians", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"random", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"read_avro", "avro", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_json", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_json_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_json_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_json_objects_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_ndjson", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_ndjson_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_ndjson_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_parquet", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_xlsx", "excel", CatalogType::TABLE_FUNCTION_ENTRY}, + {"reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"reduce_sql_statement", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, + {"register_geoarrow_extensions", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"regr_avgx", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_avgy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_count", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_intercept", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_r2", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_slope", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_sxx", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_sxy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_syy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"repeat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"replace", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"reservoir_quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"reverse", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"right", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"right_grapheme", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"round", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"row_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"rpad", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"rtree_index_dump", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"rtree_index_scan", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"rtrim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"sem", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"set_bit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"setseed", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"shapefile_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sign", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"signbit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"sin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"sinh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"skewness", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"sql_auto_complete", "autocomplete", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqlite_attach", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqlite_query", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqlite_scan", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqlsmith", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqrt", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_affine", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_area", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_area_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_asgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ashexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_assvg", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_astext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_aswkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_azimuth", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_boundary", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_buffer", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_buildarea", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_centroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_collect", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_collectionextract", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_concavehull", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_contains", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_containsproperly", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_convexhull", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_coverageinvalidedges", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_coverageinvalidedges_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_coveragesimplify", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_coveragesimplify_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_coverageunion", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_coverageunion_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_coveredby", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_covers", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_crosses", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_difference", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_dimension", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_disjoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_distance", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_distance_geos", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_distance_sphere", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_distance_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_drivers", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_dump", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_dwithin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_dwithin_geos", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_dwithin_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_endpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_envelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_envelope_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_equals", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_extent_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_extent_approx", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_exteriorring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_flipcoordinates", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_force2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_force3dm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_force3dz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_force4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_generatepoints", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_geometrytype", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromhexewkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromhexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromtext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_hasm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_hasz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_hilbert", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_intersection", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_intersection_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_intersects", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_intersects_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_isclosed", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_isempty", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_isring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_issimple", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_isvalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_length", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_length_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_lineinterpolatepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_lineinterpolatepoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_linemerge", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_linestring2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_linesubstring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_m", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makeenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makeline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makepolygon", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makevalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_maximuminscribedcircle", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_memunion_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_minimumrotatedrectangle", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_mmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_mmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_multi", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ngeometries", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ninteriorrings", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_node", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_normalize", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_npoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_numgeometries", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_numinteriorrings", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_numpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_overlaps", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_perimeter", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_perimeter_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point3d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_pointn", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_pointonsurface", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_points", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_polygon2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_polygonize", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_quadkey", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_read", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_read_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_readosm", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_readshp", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_reduceprecision", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_removerepeatedpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_reverse", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_rotate", "spatial", CatalogType::MACRO_ENTRY}, + {"st_rotatex", "spatial", CatalogType::MACRO_ENTRY}, + {"st_rotatey", "spatial", CatalogType::MACRO_ENTRY}, + {"st_rotatez", "spatial", CatalogType::MACRO_ENTRY}, + {"st_scale", "spatial", CatalogType::MACRO_ENTRY}, + {"st_shortestline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_simplify", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_simplifypreservetopology", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_startpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_tileenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_touches", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_transform", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_translate", "spatial", CatalogType::MACRO_ENTRY}, + {"st_transscale", "spatial", CatalogType::MACRO_ENTRY}, + {"st_union", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_union_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_voronoidiagram", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_within", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_withinproperly", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_x", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_xmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_xmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_y", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ymax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ymin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_z", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_zmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_zmflag", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_zmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"start_ui", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, + {"start_ui_server", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, + {"starts_with", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"stats", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"stddev", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"stddev_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"stddev_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"stem", "fts", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"stop_ui_server", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, + {"string_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"strpos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"struct_insert", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"sum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"sum_no_overflow", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"sumkahan", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"tan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"tanh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"timetz_byte_comparable", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_base", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_binary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_centuries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_days", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_decades", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_hours", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_microseconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_millennia", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_milliseconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_minutes", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_months", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_quarters", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_seconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_weeks", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_years", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"today", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"tpcds", "tpcds", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"tpcds_answers", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, + {"tpcds_queries", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, + {"tpch", "tpch", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"tpch_answers", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, + {"tpch_queries", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, + {"transaction_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"translate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"trim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"txid_current", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"typeof", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ui_is_started", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, + {"unbin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"unhex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"unicode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"union_extract", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"union_tag", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"union_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"unpivot_list", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"url_decode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"url_encode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"uuid", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"uuid_extract_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"uuid_extract_version", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"uuidv4", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"uuidv7", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"var_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"var_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"variance", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"vector_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"version", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"vss_join", "vss", CatalogType::TABLE_MACRO_ENTRY}, + {"vss_match", "vss", CatalogType::TABLE_MACRO_ENTRY}, + {"xor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"|", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"~", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, }; // END_OF_EXTENSION_FUNCTIONS static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] = { - {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>INTERVAL"}, - {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP,TIMESTAMP]>INTERVAL"}, - {"age", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>INTERVAL"}, - {"age", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ,TIMESTAMPTZ]>INTERVAL"}, - {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"century", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, - {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, - {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, - {"date_diff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',DATE]>STRUCT()"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',INTERVAL]>STRUCT()"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME]>STRUCT()"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMP]>STRUCT()"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMETZ]>STRUCT()"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>BIGINT"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>BIGINT"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME]>BIGINT"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>BIGINT"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>BIGINT"}, - {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMPTZ]>STRUCT()"}, - {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>BIGINT"}, - {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, - {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, - {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, - {"date_sub", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, - {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>TIMESTAMP"}, - {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>INTERVAL"}, - {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>TIMESTAMP"}, - {"date_trunc", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>TIMESTAMPTZ"}, - {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, - {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, - {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, - {"datediff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',DATE]>STRUCT()"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',INTERVAL]>STRUCT()"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME]>STRUCT()"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMP]>STRUCT()"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMETZ]>STRUCT()"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>BIGINT"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>BIGINT"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME]>BIGINT"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>BIGINT"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>BIGINT"}, - {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMPTZ]>STRUCT()"}, - {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>BIGINT"}, - {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, - {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, - {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, - {"datesub", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, - {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>TIMESTAMP"}, - {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>INTERVAL"}, - {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>TIMESTAMP"}, - {"datetrunc", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>TIMESTAMPTZ"}, - {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"day", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"dayname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>VARCHAR"}, - {"dayname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>VARCHAR"}, - {"dayname", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>VARCHAR"}, - {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"dayofmonth", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"dayofweek", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"dayofyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"decade", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>DOUBLE"}, - {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>DOUBLE"}, - {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>DOUBLE"}, - {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DOUBLE"}, - {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>DOUBLE"}, - {"epoch", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DOUBLE"}, - {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"era", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT]>BIGINT[]"}, - {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT]>BIGINT[]"}, - {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT,BIGINT]>BIGINT[]"}, - {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, - "[TIMESTAMP,TIMESTAMP,INTERVAL]>TIMESTAMP[]"}, - {"generate_series", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ,TIMESTAMPTZ,INTERVAL]>TIMESTAMPTZ[]"}, - {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, - {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, - {"hour", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"isodow", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"isoyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"julian", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>DOUBLE"}, - {"julian", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DOUBLE"}, - {"julian", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DOUBLE"}, - {"last_day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>DATE"}, - {"last_day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DATE"}, - {"last_day", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DATE"}, - {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, - {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, - {"microsecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"millennium", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, - {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, - {"millisecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, - {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, - {"minute", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"month", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"monthname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>VARCHAR"}, - {"monthname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>VARCHAR"}, - {"monthname", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>VARCHAR"}, - {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"quarter", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT]>BIGINT[]"}, - {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT]>BIGINT[]"}, - {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT,BIGINT]>BIGINT[]"}, - {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP,TIMESTAMP,INTERVAL]>TIMESTAMP[]"}, - {"range", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ,TIMESTAMPTZ,INTERVAL]>TIMESTAMPTZ[]"}, - {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, - {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, - {"second", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE]>DATE"}, - {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE,DATE]>DATE"}, - {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE,INTERVAL]>DATE"}, - {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMP]>TIMESTAMP"}, - {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMP,INTERVAL]>TIMESTAMP"}, - {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMP,TIMESTAMP]>TIMESTAMP"}, - {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ]>TIMESTAMPTZ"}, - {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ,INTERVAL]>TIMESTAMPTZ"}, - {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ,TIMESTAMPTZ]>TIMESTAMPTZ"}, - {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ,VARCHAR]>TIMESTAMPTZ"}, - {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMETZ]>TIMETZ"}, - {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>TIMESTAMPTZ"}, - {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>TIMESTAMP"}, - {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>TIMETZ"}, - {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"timezone_hour", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"timezone_minute", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"week", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"weekday", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"weekofyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"year", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"yearweek", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>INTERVAL"}, + {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP,TIMESTAMP]>INTERVAL"}, + {"age", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>INTERVAL"}, + {"age", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ,TIMESTAMPTZ]>INTERVAL"}, + {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"century", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, + {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, + {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, + {"date_diff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',DATE]>STRUCT()"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',INTERVAL]>STRUCT()"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME]>STRUCT()"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMP]>STRUCT()"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMETZ]>STRUCT()"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>BIGINT"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>BIGINT"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME]>BIGINT"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>BIGINT"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>BIGINT"}, + {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMPTZ]>STRUCT()"}, + {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>BIGINT"}, + {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, + {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, + {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, + {"date_sub", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, + {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>TIMESTAMP"}, + {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>INTERVAL"}, + {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>TIMESTAMP"}, + {"date_trunc", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>TIMESTAMPTZ"}, + {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, + {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, + {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, + {"datediff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',DATE]>STRUCT()"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',INTERVAL]>STRUCT()"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME]>STRUCT()"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMP]>STRUCT()"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMETZ]>STRUCT()"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>BIGINT"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>BIGINT"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME]>BIGINT"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>BIGINT"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>BIGINT"}, + {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMPTZ]>STRUCT()"}, + {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>BIGINT"}, + {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, + {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, + {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, + {"datesub", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, + {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>TIMESTAMP"}, + {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>INTERVAL"}, + {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>TIMESTAMP"}, + {"datetrunc", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>TIMESTAMPTZ"}, + {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"day", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"dayname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>VARCHAR"}, + {"dayname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>VARCHAR"}, + {"dayname", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>VARCHAR"}, + {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"dayofmonth", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"dayofweek", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"dayofyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"decade", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>DOUBLE"}, + {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>DOUBLE"}, + {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>DOUBLE"}, + {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DOUBLE"}, + {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>DOUBLE"}, + {"epoch", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DOUBLE"}, + {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"era", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT]>BIGINT[]"}, + {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT]>BIGINT[]"}, + {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT,BIGINT]>BIGINT[]"}, + {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP,TIMESTAMP,INTERVAL]>TIMESTAMP[]"}, + {"generate_series", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ,TIMESTAMPTZ,INTERVAL]>TIMESTAMPTZ[]"}, + {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, + {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, + {"hour", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"isodow", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"isoyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"julian", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>DOUBLE"}, + {"julian", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DOUBLE"}, + {"julian", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DOUBLE"}, + {"last_day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>DATE"}, + {"last_day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DATE"}, + {"last_day", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DATE"}, + {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, + {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, + {"microsecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"millennium", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, + {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, + {"millisecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, + {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, + {"minute", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"month", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"monthname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>VARCHAR"}, + {"monthname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>VARCHAR"}, + {"monthname", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>VARCHAR"}, + {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"quarter", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT]>BIGINT[]"}, + {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT]>BIGINT[]"}, + {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT,BIGINT]>BIGINT[]"}, + {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP,TIMESTAMP,INTERVAL]>TIMESTAMP[]"}, + {"range", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ,TIMESTAMPTZ,INTERVAL]>TIMESTAMPTZ[]"}, + {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, + {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, + {"second", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE]>DATE"}, + {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE,DATE]>DATE"}, + {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE,INTERVAL]>DATE"}, + {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMP]>TIMESTAMP"}, + {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMP,INTERVAL]>TIMESTAMP"}, + {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMP,TIMESTAMP]>TIMESTAMP"}, + {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ]>TIMESTAMPTZ"}, + {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ,INTERVAL]>TIMESTAMPTZ"}, + {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ,TIMESTAMPTZ]>TIMESTAMPTZ"}, + {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ,VARCHAR]>TIMESTAMPTZ"}, + {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMETZ]>TIMETZ"}, + {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>TIMESTAMPTZ"}, + {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>TIMESTAMP"}, + {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>TIMETZ"}, + {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"timezone_hour", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"timezone_minute", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"week", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"weekday", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"weekofyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"year", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"yearweek", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, }; // END_OF_EXTENSION_FUNCTION_OVERLOADS static constexpr ExtensionEntry EXTENSION_SETTINGS[] = { - {"azure_account_name", "azure"}, - {"azure_context_caching", "azure"}, - {"azure_credential_chain", "azure"}, - {"azure_endpoint", "azure"}, - {"azure_http_proxy", "azure"}, - {"azure_http_stats", "azure"}, - {"azure_proxy_password", "azure"}, - {"azure_proxy_user_name", "azure"}, - {"azure_read_buffer_size", "azure"}, - {"azure_read_transfer_chunk_size", "azure"}, - {"azure_read_transfer_concurrency", "azure"}, - {"azure_storage_connection_string", "azure"}, - {"azure_transport_option_type", "azure"}, - {"binary_as_string", "parquet"}, - {"ca_cert_file", "httpfs"}, - {"calendar", "icu"}, - {"disable_parquet_prefetching", "parquet"}, - {"enable_geoparquet_conversion", "parquet"}, - {"enable_server_cert_verification", "httpfs"}, - {"force_download", "httpfs"}, - {"hf_max_per_page", "httpfs"}, - {"hnsw_ef_search", "vss"}, - {"hnsw_enable_experimental_persistence", "vss"}, - {"http_keep_alive", "httpfs"}, - {"http_retries", "httpfs"}, - {"http_retry_backoff", "httpfs"}, - {"http_retry_wait_ms", "httpfs"}, - {"http_timeout", "httpfs"}, - {"mysql_bit1_as_boolean", "mysql_scanner"}, - {"mysql_debug_show_queries", "mysql_scanner"}, - {"mysql_experimental_filter_pushdown", "mysql_scanner"}, - {"mysql_tinyint1_as_boolean", "mysql_scanner"}, - {"parquet_metadata_cache", "parquet"}, - {"pg_array_as_varchar", "postgres_scanner"}, - {"pg_connection_cache", "postgres_scanner"}, - {"pg_connection_limit", "postgres_scanner"}, - {"pg_debug_show_queries", "postgres_scanner"}, - {"pg_experimental_filter_pushdown", "postgres_scanner"}, - {"pg_null_byte_replacement", "postgres_scanner"}, - {"pg_pages_per_task", "postgres_scanner"}, - {"pg_use_binary_copy", "postgres_scanner"}, - {"pg_use_ctid_scan", "postgres_scanner"}, - {"prefetch_all_parquet_files", "parquet"}, - {"s3_access_key_id", "httpfs"}, - {"s3_endpoint", "httpfs"}, - {"s3_kms_key_id", "httpfs"}, - {"s3_region", "httpfs"}, - {"s3_secret_access_key", "httpfs"}, - {"s3_session_token", "httpfs"}, - {"s3_uploader_max_filesize", "httpfs"}, - {"s3_uploader_max_parts_per_file", "httpfs"}, - {"s3_uploader_thread_limit", "httpfs"}, - {"s3_url_compatibility_mode", "httpfs"}, - {"s3_url_style", "httpfs"}, - {"s3_use_ssl", "httpfs"}, - {"sqlite_all_varchar", "sqlite_scanner"}, - {"sqlite_debug_show_queries", "sqlite_scanner"}, - {"timezone", "icu"}, - {"ui_local_port", "ui"}, - {"ui_polling_interval", "ui"}, - {"ui_remote_url", "ui"}, - {"unsafe_enable_version_guessing", "iceberg"}, + {"azure_account_name", "azure"}, + {"azure_context_caching", "azure"}, + {"azure_credential_chain", "azure"}, + {"azure_endpoint", "azure"}, + {"azure_http_proxy", "azure"}, + {"azure_http_stats", "azure"}, + {"azure_proxy_password", "azure"}, + {"azure_proxy_user_name", "azure"}, + {"azure_read_buffer_size", "azure"}, + {"azure_read_transfer_chunk_size", "azure"}, + {"azure_read_transfer_concurrency", "azure"}, + {"azure_storage_connection_string", "azure"}, + {"azure_transport_option_type", "azure"}, + {"binary_as_string", "parquet"}, + {"ca_cert_file", "httpfs"}, + {"calendar", "icu"}, + {"disable_parquet_prefetching", "parquet"}, + {"ducklake_max_retry_count", "ducklake"}, + {"ducklake_retry_backoff", "ducklake"}, + {"ducklake_retry_wait_ms", "ducklake"}, + {"enable_geoparquet_conversion", "parquet"}, + {"enable_server_cert_verification", "httpfs"}, + {"force_download", "httpfs"}, + {"hf_max_per_page", "httpfs"}, + {"hnsw_ef_search", "vss"}, + {"hnsw_enable_experimental_persistence", "vss"}, + {"http_keep_alive", "httpfs"}, + {"http_retries", "httpfs"}, + {"http_retry_backoff", "httpfs"}, + {"http_retry_wait_ms", "httpfs"}, + {"http_timeout", "httpfs"}, + {"mysql_bit1_as_boolean", "mysql_scanner"}, + {"mysql_debug_show_queries", "mysql_scanner"}, + {"mysql_experimental_filter_pushdown", "mysql_scanner"}, + {"mysql_tinyint1_as_boolean", "mysql_scanner"}, + {"parquet_metadata_cache", "parquet"}, + {"pg_array_as_varchar", "postgres_scanner"}, + {"pg_connection_cache", "postgres_scanner"}, + {"pg_connection_limit", "postgres_scanner"}, + {"pg_debug_show_queries", "postgres_scanner"}, + {"pg_experimental_filter_pushdown", "postgres_scanner"}, + {"pg_null_byte_replacement", "postgres_scanner"}, + {"pg_pages_per_task", "postgres_scanner"}, + {"pg_use_binary_copy", "postgres_scanner"}, + {"pg_use_ctid_scan", "postgres_scanner"}, + {"prefetch_all_parquet_files", "parquet"}, + {"s3_access_key_id", "httpfs"}, + {"s3_endpoint", "httpfs"}, + {"s3_kms_key_id", "httpfs"}, + {"s3_region", "httpfs"}, + {"s3_secret_access_key", "httpfs"}, + {"s3_session_token", "httpfs"}, + {"s3_uploader_max_filesize", "httpfs"}, + {"s3_uploader_max_parts_per_file", "httpfs"}, + {"s3_uploader_thread_limit", "httpfs"}, + {"s3_url_compatibility_mode", "httpfs"}, + {"s3_url_style", "httpfs"}, + {"s3_use_ssl", "httpfs"}, + {"sqlite_all_varchar", "sqlite_scanner"}, + {"sqlite_debug_show_queries", "sqlite_scanner"}, + {"timezone", "icu"}, + {"ui_local_port", "ui"}, + {"ui_polling_interval", "ui"}, + {"ui_remote_url", "ui"}, + {"unsafe_enable_version_guessing", "iceberg"}, }; // END_OF_EXTENSION_SETTINGS static constexpr ExtensionEntry EXTENSION_SECRET_TYPES[] = { - {"aws", "httpfs"}, {"azure", "azure"}, {"ducklake", "ducklake"}, {"gcs", "httpfs"}, - {"huggingface", "httpfs"}, {"iceberg", "iceberg"}, {"mysql", "mysql_scanner"}, {"postgres", "postgres_scanner"}, - {"r2", "httpfs"}, {"s3", "httpfs"}, + {"aws", "httpfs"}, + {"azure", "azure"}, + {"ducklake", "ducklake"}, + {"gcs", "httpfs"}, + {"huggingface", "httpfs"}, + {"iceberg", "iceberg"}, + {"mysql", "mysql_scanner"}, + {"postgres", "postgres_scanner"}, + {"r2", "httpfs"}, + {"s3", "httpfs"}, }; // END_OF_EXTENSION_SECRET_TYPES // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb static constexpr ExtensionEntry EXTENSION_COPY_FUNCTIONS[] = { - {"parquet", "parquet"}, {"json", "json"}, {"avro", "avro"}}; // END_OF_EXTENSION_COPY_FUNCTIONS + {"parquet", "parquet"}, + {"json", "json"}, + {"avro", "avro"} +}; // END_OF_EXTENSION_COPY_FUNCTIONS // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb static constexpr ExtensionEntry EXTENSION_TYPES[] = { - {"json", "json"}, {"inet", "inet"}, {"geometry", "spatial"}}; // END_OF_EXTENSION_TYPES + {"json", "json"}, + {"inet", "inet"}, + {"geometry", "spatial"} +}; // END_OF_EXTENSION_TYPES // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb @@ -1089,68 +1103,80 @@ static constexpr ExtensionEntry EXTENSION_COLLATIONS[] = { // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb static constexpr ExtensionEntry EXTENSION_FILE_PREFIXES[] = { - {"http://", "httpfs"}, {"https://", "httpfs"}, {"s3://", "httpfs"}, {"s3a://", "httpfs"}, {"s3n://", "httpfs"}, - {"gcs://", "httpfs"}, {"gs://", "httpfs"}, {"r2://", "httpfs"}, {"azure://", "azure"}, {"az://", "azure"}, - {"abfss://", "azure"}, {"hf://", "httpfs"}}; // END_OF_EXTENSION_FILE_PREFIXES + {"http://", "httpfs"}, {"https://", "httpfs"}, {"s3://", "httpfs"}, {"s3a://", "httpfs"}, {"s3n://", "httpfs"}, + {"gcs://", "httpfs"}, {"gs://", "httpfs"}, {"r2://", "httpfs"}, {"azure://", "azure"}, {"az://", "azure"}, + {"abfss://", "azure"}, {"hf://", "httpfs"} +}; // END_OF_EXTENSION_FILE_PREFIXES // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb static constexpr ExtensionEntry EXTENSION_FILE_POSTFIXES[] = { - {".parquet", "parquet"}, {".json", "json"}, {".jsonl", "json"}, {".ndjson", "json"}, {".shp", "spatial"}, - {".gpkg", "spatial"}, {".fgb", "spatial"}, {".xlsx", "excel"}, {".avro", "avro"}, + {".parquet", "parquet"}, + {".json", "json"}, + {".jsonl", "json"}, + {".ndjson", "json"}, + {".shp", "spatial"}, + {".gpkg", "spatial"}, + {".fgb", "spatial"}, + {".xlsx", "excel"}, + {".avro", "avro"}, }; // END_OF_EXTENSION_FILE_POSTFIXES // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb -static constexpr ExtensionEntry EXTENSION_FILE_CONTAINS[] = {{".parquet?", "parquet"}, - {".json?", "json"}, - {".ndjson?", ".jsonl?"}, - {".jsonl?", ".ndjson?"}}; // EXTENSION_FILE_CONTAINS +static constexpr ExtensionEntry EXTENSION_FILE_CONTAINS[] = { + {".parquet?", "parquet"}, + {".json?", "json"}, + {".ndjson?", ".jsonl?"}, + {".jsonl?", ".ndjson?"} +}; // EXTENSION_FILE_CONTAINS // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb -static constexpr ExtensionEntry EXTENSION_SECRET_PROVIDERS[] = { - {"s3/config", "httpfs"}, - {"gcs/config", "httpfs"}, - {"r2/config", "httpfs"}, - {"s3/credential_chain", "aws"}, - {"gcs/credential_chain", "aws"}, - {"r2/credential_chain", "aws"}, - {"aws/credential_chain", "aws"}, - {"azure/access_token", "azure"}, - {"azure/config", "azure"}, - {"azure/credential_chain", "azure"}, - {"azure/service_principal", "azure"}, - {"huggingface/config", "httfps"}, - {"huggingface/credential_chain", "httpfs"}, - {"bearer/config", "httpfs"}, - {"mysql/config", "mysql_scanner"}, - {"postgres/config", "postgres_scanner"}}; // EXTENSION_SECRET_PROVIDERS +static constexpr ExtensionEntry EXTENSION_SECRET_PROVIDERS[] = {{"s3/config", "httpfs"}, + {"gcs/config", "httpfs"}, + {"r2/config", "httpfs"}, + {"s3/credential_chain", "aws"}, + {"gcs/credential_chain", "aws"}, + {"r2/credential_chain", "aws"}, + {"aws/credential_chain", "aws"}, + {"azure/access_token", "azure"}, + {"azure/config", "azure"}, + {"azure/credential_chain", "azure"}, + {"azure/service_principal", "azure"}, + {"huggingface/config", "httfps"}, + {"huggingface/credential_chain", "httpfs"}, + {"bearer/config", "httpfs"}, + {"mysql/config", "mysql_scanner"}, + {"postgres/config", "postgres_scanner"} +}; // EXTENSION_SECRET_PROVIDERS -static constexpr const char *AUTOLOADABLE_EXTENSIONS[] = {"avro", - "aws", - "azure", - "autocomplete", - "core_functions", - "delta", - "ducklake", - "encodings", - "excel", - "fts", - "httpfs", - "iceberg", - "inet", - "icu", - "json", - "motherduck", - "mysql_scanner", - "parquet", - "sqlite_scanner", - "sqlsmith", - "postgres_scanner", - "tpcds", - "tpch", - "uc_catalog", - "ui"}; // END_OF_AUTOLOADABLE_EXTENSIONS +static constexpr const char *AUTOLOADABLE_EXTENSIONS[] = { + "avro", + "aws", + "azure", + "autocomplete", + "core_functions", + "delta", + "ducklake", + "encodings", + "excel", + "fts", + "httpfs", + "iceberg", + "inet", + "icu", + "json", + "motherduck", + "mysql_scanner", + "parquet", + "sqlite_scanner", + "sqlsmith", + "postgres_scanner", + "tpcds", + "tpch", + "uc_catalog", + "ui" +}; // END_OF_AUTOLOADABLE_EXTENSIONS -} // namespace duckdb +} // namespace duckdb \ No newline at end of file From 1ea1ee9ea7f4ba9a689d4c78616355a61226f575 Mon Sep 17 00:00:00 2001 From: Christiaan Herrewijn Date: Mon, 7 Jul 2025 10:53:15 +0200 Subject: [PATCH 100/100] formatting fix --- src/include/duckdb/main/extension_entries.hpp | 2157 ++++++++--------- 1 file changed, 1067 insertions(+), 1090 deletions(-) diff --git a/src/include/duckdb/main/extension_entries.hpp b/src/include/duckdb/main/extension_entries.hpp index 3332b39a6cc1..af4f69ff4eb9 100644 --- a/src/include/duckdb/main/extension_entries.hpp +++ b/src/include/duckdb/main/extension_entries.hpp @@ -14,1065 +14,1054 @@ // NOTE: this file is generated by scripts/generate_extensions_function.py. // Example usage to refresh one extension (replace "icu" with the desired extension): // GENERATE_EXTENSION_ENTRIES=1 make debug -// python3 scripts/generate_extensions_function.py --extensions icu --shell build/debug/duckdb --extension_repository build/debug/repository +// python3 scripts/generate_extensions_function.py --extensions icu --shell build/debug/duckdb --extension_repository +// build/debug/repository // Check out the check-load-install-extensions job in .github/workflows/LinuxRelease.yml for more details namespace duckdb { struct ExtensionEntry { - char name[48]; - char extension[48]; + char name[48]; + char extension[48]; }; struct ExtensionFunctionEntry { - char name[48]; - char extension[48]; - CatalogType type; + char name[48]; + char extension[48]; + CatalogType type; }; struct ExtensionFunctionOverloadEntry { - char name[48]; - char extension[48]; - CatalogType type; - char signature[96]; + char name[48]; + char extension[48]; + CatalogType type; + char signature[96]; }; static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { - {"!__postfix", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"&&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"**", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"->>", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"<->", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"<<", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"<<=", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"<=>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"<@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {">>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {">>=", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"@>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"^", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"^@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"abs", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"acos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"acosh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"add_numbers_together", "demo_capi", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"add_parquet_key", "parquet", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"alias", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"approx_count_distinct", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"approx_quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"approx_top_k", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"arg_max", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"arg_max_null", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"arg_min", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"arg_min_null", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"argmax", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"argmin", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"array_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"array_aggr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_cosine_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_cosine_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_cross_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_distinct", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_has_all", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_has_any", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_negative_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_negative_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_reverse_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_slice", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_transform", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_unique", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"array_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ascii", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"asin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"asinh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"atan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"atan2", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"atanh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"avg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"bar", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"bin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"bit_and", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"bit_count", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"bit_or", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"bit_position", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"bit_xor", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"bitstring", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"bitstring_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"bool_and", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"bool_or", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"broadcast", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"can_cast_implicitly", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"cardinality", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"cast_to_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"cbrt", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ceil", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ceiling", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"check_peg_parser", "autocomplete", CatalogType::TABLE_FUNCTION_ENTRY}, - {"chr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"corr", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"cos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"cosh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"cot", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"count_if", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"countif", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"covar_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"covar_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"create_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"current_database", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_date", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_localtime", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_localtimestamp", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_query", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_schema", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_schemas", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"current_setting", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"damerau_levenshtein", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"dbgen", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, - {"decode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"degrees", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"delta_scan", "delta", CatalogType::TABLE_FUNCTION_ENTRY}, - {"drop_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"dsdgen", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, - {"duckdb_proj_compiled_version", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"duckdb_proj_version", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ducklake_add_data_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_cleanup_old_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_expire_snapshots", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_list_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_merge_adjacent_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_options", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_set_option", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_snapshots", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_table_changes", "ducklake", CatalogType::TABLE_MACRO_ENTRY}, - {"ducklake_table_deletions", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_table_info", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"ducklake_table_insertions", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, - {"editdist3", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"element_at", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"encode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"entropy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"enum_code", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"enum_first", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"enum_last", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"enum_range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"enum_range_boundary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"epoch_ms", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"epoch_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"epoch_us", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"equi_width_bins", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"even", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"excel_text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"exp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"factorial", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"family", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"favg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"flatten", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"floor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"format", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"format_bytes", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"formatreadabledecimalsize", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"formatreadablesize", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"from_base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"from_binary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"from_hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"from_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"from_json_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"fsum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"fuzz_all_functions", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, - {"fuzzyduck", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, - {"gamma", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"gcd", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"gen_random_uuid", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"get_bit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"get_current_time", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"get_current_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"greatest", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"greatest_common_divisor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"group_concat", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"hamming", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"hash", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"histogram", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"histogram_exact", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"hnsw_compact_index", "vss", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"hnsw_index_scan", "vss", CatalogType::TABLE_FUNCTION_ENTRY}, - {"host", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"html_escape", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"html_unescape", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"iceberg_metadata", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, - {"iceberg_scan", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, - {"iceberg_snapshots", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, - {"iceberg_to_ducklake", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, - {"icu_calendar_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY}, - {"icu_collate_af", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_am", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ar", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ar_sa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_as", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_az", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_be", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_bg", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_bn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_bo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_br", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_bs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ca", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ceb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_chr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_cs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_cy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_da", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_de", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_de_at", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_dsb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_dz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ee", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_el", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_en", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_en_us", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_eo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_es", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_et", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fa_af", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fil", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fr_ca", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_fy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ga", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_gl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_gu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ha", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_haw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_he", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_he_il", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_hi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_hr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_hsb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_hu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_hy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_id", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_id_id", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ig", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_is", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_it", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ja", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ka", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_kk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_kl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_km", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_kn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ko", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_kok", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ku", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ky", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_lb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_lkt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ln", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_lo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_lt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_lv", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_mk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ml", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_mn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_mr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ms", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_mt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_my", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_nb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_nb_no", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ne", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_nl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_nn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_noaccent", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_om", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_or", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_pa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_pa_in", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_pl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ps", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_pt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ro", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ru", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_se", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_si", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_smn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sq", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sr_ba", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sr_me", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sr_rs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sv", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_sw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ta", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_te", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_th", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_tk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_to", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_tr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ug", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_uk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_ur", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_uz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_vi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_wae", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_wo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_xh", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_yi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_yo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_yue", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_yue_cn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zh", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zh_cn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zh_hk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zh_mo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zh_sg", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zh_tw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_collate_zu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"icu_sort_key", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"in_search_path", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"instr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"is_histogram_other_bin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"isfinite", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"isinf", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"isnan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"jaccard", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"jaro_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"jaro_winkler_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json", "json", CatalogType::MACRO_ENTRY}, - {"json_array", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_array_length", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_contains", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_deserialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_each", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"json_execute_serialized_sql", "json", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"json_execute_serialized_sql", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"json_exists", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_extract", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_extract_path", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_extract_path_text", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_extract_string", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_group_array", "json", CatalogType::MACRO_ENTRY}, - {"json_group_object", "json", CatalogType::MACRO_ENTRY}, - {"json_group_structure", "json", CatalogType::MACRO_ENTRY}, - {"json_keys", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_merge_patch", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_object", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_pretty", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_quote", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_serialize_plan", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_serialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_structure", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_transform", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_transform_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_tree", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"json_type", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_valid", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"json_value", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"kahan_sum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"kurtosis", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"kurtosis_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"lcm", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"least", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"least_common_multiple", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"left", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"left_grapheme", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"levenshtein", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"lgamma", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"list_aggr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_cosine_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_cosine_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_distinct", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_has_all", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_has_any", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_negative_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_negative_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_pack", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_reverse_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_slice", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_transform", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_unique", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"list_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"listagg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"ln", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"load_aws_credentials", "aws", CatalogType::TABLE_FUNCTION_ENTRY}, - {"log", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"log10", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"log2", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"lpad", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ltrim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"mad", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"make_date", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"make_time", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"make_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"make_timestamp_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"make_timestamptz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_concat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_entries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_extract", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_extract_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_from_entries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_keys", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"map_values", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"max_by", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"mean", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"median", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"min_by", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"mismatches", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"mode", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"mysql_clear_cache", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"mysql_execute", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"mysql_query", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"nanosecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"netmask", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"network", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"nextafter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"normalized_interval", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"now", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ord", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"parquet_bloom_probe", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"parquet_file_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"parquet_kv_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"parquet_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"parquet_scan", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"parquet_schema", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"parse_dirname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"parse_dirpath", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"parse_filename", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"parse_path", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"pg_clear_cache", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"pg_timezone_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY}, - {"pi", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"position", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"postgres_attach", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"postgres_execute", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"postgres_query", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"postgres_scan", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"postgres_scan_pushdown", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"pow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"power", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"pragma_hnsw_index_info", "vss", CatalogType::TABLE_FUNCTION_ENTRY}, - {"pragma_rtree_index_info", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"printf", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"product", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"quantile_cont", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"quantile_disc", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"radians", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"random", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"read_avro", "avro", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_json", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_json_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_json_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_json_objects_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_ndjson", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_ndjson_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_ndjson_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_parquet", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, - {"read_xlsx", "excel", CatalogType::TABLE_FUNCTION_ENTRY}, - {"reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"reduce_sql_statement", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, - {"register_geoarrow_extensions", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"regr_avgx", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_avgy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_count", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_intercept", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_r2", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_slope", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_sxx", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_sxy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"regr_syy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"repeat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"replace", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"reservoir_quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"reverse", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"right", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"right_grapheme", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"round", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"row_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"rpad", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"rtree_index_dump", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"rtree_index_scan", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"rtrim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"sem", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"set_bit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"setseed", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"shapefile_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"sign", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"signbit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"sin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"sinh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"skewness", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"sql_auto_complete", "autocomplete", CatalogType::TABLE_FUNCTION_ENTRY}, - {"sqlite_attach", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"sqlite_query", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"sqlite_scan", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, - {"sqlsmith", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, - {"sqrt", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_affine", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_area", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_area_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_asgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_ashexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_assvg", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_astext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_aswkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_azimuth", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_boundary", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_buffer", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_buildarea", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_centroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_collect", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_collectionextract", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_concavehull", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_contains", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_containsproperly", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_convexhull", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_coverageinvalidedges", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_coverageinvalidedges_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_coveragesimplify", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_coveragesimplify_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_coverageunion", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_coverageunion_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_coveredby", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_covers", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_crosses", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_difference", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_dimension", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_disjoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_distance", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_distance_geos", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_distance_sphere", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_distance_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_drivers", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"st_dump", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_dwithin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_dwithin_geos", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_dwithin_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_endpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_envelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_envelope_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_equals", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_extent_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_extent_approx", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_exteriorring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_flipcoordinates", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_force2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_force3dm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_force3dz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_force4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_generatepoints", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"st_geometrytype", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_geomfromgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_geomfromhexewkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_geomfromhexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_geomfromtext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_geomfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_hasm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_hasz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_hilbert", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_intersection", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_intersection_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_intersects", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_intersects_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_isclosed", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_isempty", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_isring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_issimple", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_isvalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_length", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_length_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_lineinterpolatepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_lineinterpolatepoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_linemerge", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_linestring2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_linesubstring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_m", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_makeenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_makeline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_makepolygon", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_makevalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_maximuminscribedcircle", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_memunion_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_minimumrotatedrectangle", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_mmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_mmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_multi", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_ngeometries", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_ninteriorrings", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_node", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_normalize", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_npoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_numgeometries", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_numinteriorrings", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_numpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_overlaps", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_perimeter", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_perimeter_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_point", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_point2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_point2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_point3d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_point4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_pointn", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_pointonsurface", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_points", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_polygon2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_polygonize", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_quadkey", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_read", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"st_read_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"st_readosm", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"st_readshp", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, - {"st_reduceprecision", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_removerepeatedpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_reverse", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_rotate", "spatial", CatalogType::MACRO_ENTRY}, - {"st_rotatex", "spatial", CatalogType::MACRO_ENTRY}, - {"st_rotatey", "spatial", CatalogType::MACRO_ENTRY}, - {"st_rotatez", "spatial", CatalogType::MACRO_ENTRY}, - {"st_scale", "spatial", CatalogType::MACRO_ENTRY}, - {"st_shortestline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_simplify", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_simplifypreservetopology", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_startpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_tileenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_touches", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_transform", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_translate", "spatial", CatalogType::MACRO_ENTRY}, - {"st_transscale", "spatial", CatalogType::MACRO_ENTRY}, - {"st_union", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_union_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"st_voronoidiagram", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_within", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_withinproperly", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_x", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_xmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_xmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_y", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_ymax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_ymin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_z", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_zmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_zmflag", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"st_zmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"start_ui", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, - {"start_ui_server", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, - {"starts_with", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"stats", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"stddev", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"stddev_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"stddev_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"stem", "fts", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"stop_ui_server", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, - {"string_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"strpos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"struct_insert", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"sum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"sum_no_overflow", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"sumkahan", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"tan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"tanh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"timetz_byte_comparable", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_base", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_binary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_centuries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_days", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_decades", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_hours", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_microseconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_millennia", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_milliseconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_minutes", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_months", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_quarters", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_seconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_weeks", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"to_years", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"today", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"tpcds", "tpcds", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"tpcds_answers", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, - {"tpcds_queries", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, - {"tpch", "tpch", CatalogType::PRAGMA_FUNCTION_ENTRY}, - {"tpch_answers", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, - {"tpch_queries", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, - {"transaction_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"translate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"trim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"txid_current", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"typeof", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"ui_is_started", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, - {"unbin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"unhex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"unicode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"union_extract", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"union_tag", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"union_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"unpivot_list", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"url_decode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"url_encode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"uuid", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"uuid_extract_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"uuid_extract_version", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"uuidv4", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"uuidv7", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"var_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"var_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"variance", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, - {"vector_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"version", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"vss_join", "vss", CatalogType::TABLE_MACRO_ENTRY}, - {"vss_match", "vss", CatalogType::TABLE_MACRO_ENTRY}, - {"xor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"|", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, - {"~", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"!__postfix", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"&&", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"**", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"->>", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"<->", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"<<", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"<<=", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"<=>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"<@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {">>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {">>=", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"@>", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"^", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"^@", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"abs", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"acos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"acosh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"add_numbers_together", "demo_capi", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"add_parquet_key", "parquet", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"alias", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"approx_count_distinct", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"approx_quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"approx_top_k", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"arg_max", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"arg_max_null", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"arg_min", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"arg_min_null", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"argmax", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"argmin", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"array_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"array_aggr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_cosine_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_cosine_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_cross_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_distinct", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_has_all", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_has_any", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_negative_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_negative_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_reverse_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_slice", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_transform", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_unique", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"array_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ascii", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"asin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"asinh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"atan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"atan2", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"atanh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"avg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"bar", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"bin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"bit_and", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"bit_count", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"bit_or", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"bit_position", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"bit_xor", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"bitstring", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"bitstring_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"bool_and", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"bool_or", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"broadcast", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"can_cast_implicitly", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"cardinality", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"cast_to_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"cbrt", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ceil", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ceiling", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"check_peg_parser", "autocomplete", CatalogType::TABLE_FUNCTION_ENTRY}, + {"chr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"corr", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"cos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"cosh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"cot", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"count_if", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"countif", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"covar_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"covar_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"create_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"current_database", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_date", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_localtime", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_localtimestamp", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_query", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_schema", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_schemas", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"current_setting", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"damerau_levenshtein", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"dbgen", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, + {"decode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"degrees", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"delta_scan", "delta", CatalogType::TABLE_FUNCTION_ENTRY}, + {"drop_fts_index", "fts", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"dsdgen", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, + {"duckdb_proj_compiled_version", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"duckdb_proj_version", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ducklake_add_data_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_cleanup_old_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_expire_snapshots", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_list_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_merge_adjacent_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_options", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_set_option", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_snapshots", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_table_changes", "ducklake", CatalogType::TABLE_MACRO_ENTRY}, + {"ducklake_table_deletions", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_table_info", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"ducklake_table_insertions", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY}, + {"editdist3", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"element_at", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"encode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"entropy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"enum_code", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"enum_first", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"enum_last", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"enum_range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"enum_range_boundary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"epoch_ms", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"epoch_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"epoch_us", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"equi_width_bins", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"even", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"excel_text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"exp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"factorial", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"family", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"favg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"flatten", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"floor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"format", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"format_bytes", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"formatreadabledecimalsize", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"formatreadablesize", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_binary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"from_json_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"fsum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"fuzz_all_functions", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, + {"fuzzyduck", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, + {"gamma", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"gcd", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"gen_random_uuid", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"get_bit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"get_current_time", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"get_current_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"greatest", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"greatest_common_divisor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"group_concat", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"hamming", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"hash", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"histogram", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"histogram_exact", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"hnsw_compact_index", "vss", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"hnsw_index_scan", "vss", CatalogType::TABLE_FUNCTION_ENTRY}, + {"host", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"html_escape", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"html_unescape", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"iceberg_metadata", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, + {"iceberg_scan", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, + {"iceberg_snapshots", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, + {"iceberg_to_ducklake", "iceberg", CatalogType::TABLE_FUNCTION_ENTRY}, + {"icu_calendar_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY}, + {"icu_collate_af", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_am", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ar", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ar_sa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_as", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_az", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_be", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_bg", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_bn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_bo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_br", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_bs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ca", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ceb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_chr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_cs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_cy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_da", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_de", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_de_at", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_dsb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_dz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ee", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_el", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_en", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_en_us", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_eo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_es", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_et", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fa_af", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fil", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fr_ca", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_fy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ga", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_gl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_gu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ha", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_haw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_he", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_he_il", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_hi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_hr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_hsb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_hu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_hy", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_id", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_id_id", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ig", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_is", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_it", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ja", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ka", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_kk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_kl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_km", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_kn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ko", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_kok", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ku", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ky", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_lb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_lkt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ln", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_lo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_lt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_lv", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_mk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ml", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_mn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_mr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ms", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_mt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_my", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_nb", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_nb_no", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ne", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_nl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_nn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_noaccent", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_om", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_or", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_pa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_pa_in", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_pl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ps", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_pt", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ro", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ru", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sa", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_se", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_si", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sl", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_smn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sq", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sr_ba", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sr_me", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sr_rs", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sv", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_sw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ta", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_te", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_th", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_tk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_to", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_tr", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ug", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_uk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_ur", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_uz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_vi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_wae", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_wo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_xh", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_yi", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_yo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_yue", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_yue_cn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zh", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zh_cn", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zh_hk", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zh_mo", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zh_sg", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zh_tw", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_collate_zu", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"icu_sort_key", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"in_search_path", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"instr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"is_histogram_other_bin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"isfinite", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"isinf", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"isnan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"jaccard", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"jaro_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"jaro_winkler_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json", "json", CatalogType::MACRO_ENTRY}, + {"json_array", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_array_length", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_contains", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_deserialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_each", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"json_execute_serialized_sql", "json", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"json_execute_serialized_sql", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"json_exists", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_extract", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_extract_path", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_extract_path_text", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_extract_string", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_group_array", "json", CatalogType::MACRO_ENTRY}, + {"json_group_object", "json", CatalogType::MACRO_ENTRY}, + {"json_group_structure", "json", CatalogType::MACRO_ENTRY}, + {"json_keys", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_merge_patch", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_object", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_pretty", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_quote", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_serialize_plan", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_serialize_sql", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_structure", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_transform", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_transform_strict", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_tree", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"json_type", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_valid", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"json_value", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"kahan_sum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"kurtosis", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"kurtosis_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"lcm", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"least", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"least_common_multiple", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"left", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"left_grapheme", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"levenshtein", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"lgamma", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"list_aggr", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_aggregate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_apply", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_cosine_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_cosine_similarity", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_distance", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_distinct", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_filter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_has_all", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_has_any", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_negative_dot_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_negative_inner_product", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_pack", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_reverse_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_slice", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_sort", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_transform", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_unique", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"list_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"listagg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"ln", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"load_aws_credentials", "aws", CatalogType::TABLE_FUNCTION_ENTRY}, + {"log", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"log10", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"log2", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"lpad", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ltrim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"mad", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"make_date", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"make_time", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"make_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"make_timestamp_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"make_timestamptz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_concat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_entries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_extract", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_extract_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_from_entries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_keys", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"map_values", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"max_by", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"mean", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"median", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"min_by", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"mismatches", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"mode", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"mysql_clear_cache", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"mysql_execute", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"mysql_query", "mysql_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"nanosecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"netmask", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"network", "inet", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"nextafter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"normalized_interval", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"now", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ord", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"parquet_bloom_probe", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_file_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_kv_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_metadata", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_scan", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parquet_schema", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"parse_dirname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"parse_dirpath", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"parse_filename", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"parse_path", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"pg_clear_cache", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"pg_timezone_names", "icu", CatalogType::TABLE_FUNCTION_ENTRY}, + {"pi", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"position", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"postgres_attach", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"postgres_execute", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"postgres_query", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"postgres_scan", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"postgres_scan_pushdown", "postgres_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"pow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"power", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"pragma_hnsw_index_info", "vss", CatalogType::TABLE_FUNCTION_ENTRY}, + {"pragma_rtree_index_info", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"printf", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"product", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"quantile_cont", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"quantile_disc", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"radians", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"random", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"read_avro", "avro", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_json", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_json_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_json_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_json_objects_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_ndjson", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_ndjson_auto", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_ndjson_objects", "json", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_parquet", "parquet", CatalogType::TABLE_FUNCTION_ENTRY}, + {"read_xlsx", "excel", CatalogType::TABLE_FUNCTION_ENTRY}, + {"reduce", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"reduce_sql_statement", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, + {"register_geoarrow_extensions", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"regr_avgx", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_avgy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_count", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_intercept", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_r2", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_slope", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_sxx", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_sxy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"regr_syy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"repeat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"replace", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"reservoir_quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"reverse", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"right", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"right_grapheme", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"round", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"row_to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"rpad", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"rtree_index_dump", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"rtree_index_scan", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"rtrim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"sem", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"set_bit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"setseed", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"shapefile_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sign", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"signbit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"sin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"sinh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"skewness", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"sql_auto_complete", "autocomplete", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqlite_attach", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqlite_query", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqlite_scan", "sqlite_scanner", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqlsmith", "sqlsmith", CatalogType::TABLE_FUNCTION_ENTRY}, + {"sqrt", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_affine", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_area", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_area_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_asgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ashexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_assvg", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_astext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_aswkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_azimuth", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_boundary", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_buffer", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_buildarea", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_centroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_collect", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_collectionextract", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_concavehull", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_contains", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_containsproperly", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_convexhull", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_coverageinvalidedges", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_coverageinvalidedges_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_coveragesimplify", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_coveragesimplify_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_coverageunion", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_coverageunion_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_coveredby", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_covers", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_crosses", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_difference", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_dimension", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_disjoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_distance", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_distance_geos", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_distance_sphere", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_distance_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_drivers", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_dump", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_dwithin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_dwithin_geos", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_dwithin_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_endpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_envelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_envelope_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_equals", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_extent_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_extent_approx", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_exteriorring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_flipcoordinates", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_force2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_force3dm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_force3dz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_force4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_generatepoints", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_geometrytype", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromhexewkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromhexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromtext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_geomfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_hasm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_hasz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_hilbert", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_intersection", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_intersection_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_intersects", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_intersects_extent", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_isclosed", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_isempty", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_isring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_issimple", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_isvalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_length", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_length_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_lineinterpolatepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_lineinterpolatepoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_linemerge", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_linestring2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_linesubstring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_m", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makeenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makeline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makepolygon", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_makevalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_maximuminscribedcircle", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_memunion_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_minimumrotatedrectangle", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_mmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_mmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_multi", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ngeometries", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ninteriorrings", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_node", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_normalize", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_npoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_numgeometries", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_numinteriorrings", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_numpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_overlaps", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_perimeter", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_perimeter_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point3d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_point4d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_pointn", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_pointonsurface", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_points", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_polygon2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_polygonize", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_quadkey", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_read", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_read_meta", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_readosm", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_readshp", "spatial", CatalogType::TABLE_FUNCTION_ENTRY}, + {"st_reduceprecision", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_removerepeatedpoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_reverse", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_rotate", "spatial", CatalogType::MACRO_ENTRY}, + {"st_rotatex", "spatial", CatalogType::MACRO_ENTRY}, + {"st_rotatey", "spatial", CatalogType::MACRO_ENTRY}, + {"st_rotatez", "spatial", CatalogType::MACRO_ENTRY}, + {"st_scale", "spatial", CatalogType::MACRO_ENTRY}, + {"st_shortestline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_simplify", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_simplifypreservetopology", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_startpoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_tileenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_touches", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_transform", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_translate", "spatial", CatalogType::MACRO_ENTRY}, + {"st_transscale", "spatial", CatalogType::MACRO_ENTRY}, + {"st_union", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_union_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"st_voronoidiagram", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_within", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_withinproperly", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_x", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_xmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_xmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_y", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ymax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_ymin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_z", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_zmax", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_zmflag", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_zmin", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"start_ui", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, + {"start_ui_server", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, + {"starts_with", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"stats", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"stddev", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"stddev_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"stddev_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"stem", "fts", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"stop_ui_server", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, + {"string_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"strpos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"struct_insert", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"sum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"sum_no_overflow", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"sumkahan", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"tan", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"tanh", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"text", "excel", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"timetz_byte_comparable", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_base", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_base64", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_binary", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_centuries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_days", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_decades", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_hex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_hours", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_json", "json", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_microseconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_millennia", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_milliseconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_minutes", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_months", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_quarters", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_seconds", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_weeks", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"to_years", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"today", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"tpcds", "tpcds", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"tpcds_answers", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, + {"tpcds_queries", "tpcds", CatalogType::TABLE_FUNCTION_ENTRY}, + {"tpch", "tpch", CatalogType::PRAGMA_FUNCTION_ENTRY}, + {"tpch_answers", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, + {"tpch_queries", "tpch", CatalogType::TABLE_FUNCTION_ENTRY}, + {"transaction_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"translate", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"trim", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"txid_current", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"typeof", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"ui_is_started", "ui", CatalogType::TABLE_FUNCTION_ENTRY}, + {"unbin", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"unhex", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"unicode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"union_extract", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"union_tag", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"union_value", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"unpivot_list", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"url_decode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"url_encode", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"uuid", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"uuid_extract_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"uuid_extract_version", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"uuidv4", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"uuidv7", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"var_pop", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"var_samp", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"variance", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY}, + {"vector_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"version", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"vss_join", "vss", CatalogType::TABLE_MACRO_ENTRY}, + {"vss_match", "vss", CatalogType::TABLE_MACRO_ENTRY}, + {"xor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"|", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"~", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, }; // END_OF_EXTENSION_FUNCTIONS static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] = { - {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>INTERVAL"}, - {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP,TIMESTAMP]>INTERVAL"}, - {"age", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>INTERVAL"}, - {"age", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ,TIMESTAMPTZ]>INTERVAL"}, - {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"century", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, - {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, - {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, - {"date_diff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',DATE]>STRUCT()"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',INTERVAL]>STRUCT()"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME]>STRUCT()"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMP]>STRUCT()"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMETZ]>STRUCT()"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>BIGINT"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>BIGINT"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME]>BIGINT"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>BIGINT"}, - {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>BIGINT"}, - {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMPTZ]>STRUCT()"}, - {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>BIGINT"}, - {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, - {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, - {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, - {"date_sub", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, - {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>TIMESTAMP"}, - {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>INTERVAL"}, - {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>TIMESTAMP"}, - {"date_trunc", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>TIMESTAMPTZ"}, - {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, - {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, - {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, - {"datediff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',DATE]>STRUCT()"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',INTERVAL]>STRUCT()"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME]>STRUCT()"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMP]>STRUCT()"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMETZ]>STRUCT()"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>BIGINT"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>BIGINT"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME]>BIGINT"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>BIGINT"}, - {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>BIGINT"}, - {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMPTZ]>STRUCT()"}, - {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>BIGINT"}, - {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, - {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, - {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, - {"datesub", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, - {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>TIMESTAMP"}, - {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>INTERVAL"}, - {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>TIMESTAMP"}, - {"datetrunc", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>TIMESTAMPTZ"}, - {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"day", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"dayname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>VARCHAR"}, - {"dayname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>VARCHAR"}, - {"dayname", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>VARCHAR"}, - {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"dayofmonth", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"dayofweek", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"dayofyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"decade", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>DOUBLE"}, - {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>DOUBLE"}, - {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>DOUBLE"}, - {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DOUBLE"}, - {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>DOUBLE"}, - {"epoch", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DOUBLE"}, - {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"era", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT]>BIGINT[]"}, - {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT]>BIGINT[]"}, - {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT,BIGINT]>BIGINT[]"}, - {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP,TIMESTAMP,INTERVAL]>TIMESTAMP[]"}, - {"generate_series", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ,TIMESTAMPTZ,INTERVAL]>TIMESTAMPTZ[]"}, - {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, - {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, - {"hour", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"isodow", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"isoyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"julian", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>DOUBLE"}, - {"julian", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DOUBLE"}, - {"julian", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DOUBLE"}, - {"last_day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>DATE"}, - {"last_day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DATE"}, - {"last_day", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DATE"}, - {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, - {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, - {"microsecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"millennium", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, - {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, - {"millisecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, - {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, - {"minute", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"month", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"monthname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>VARCHAR"}, - {"monthname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>VARCHAR"}, - {"monthname", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>VARCHAR"}, - {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"quarter", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT]>BIGINT[]"}, - {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT]>BIGINT[]"}, - {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT,BIGINT]>BIGINT[]"}, - {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP,TIMESTAMP,INTERVAL]>TIMESTAMP[]"}, - {"range", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ,TIMESTAMPTZ,INTERVAL]>TIMESTAMPTZ[]"}, - {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, - {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, - {"second", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE]>DATE"}, - {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE,DATE]>DATE"}, - {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE,INTERVAL]>DATE"}, - {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMP]>TIMESTAMP"}, - {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMP,INTERVAL]>TIMESTAMP"}, - {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMP,TIMESTAMP]>TIMESTAMP"}, - {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ]>TIMESTAMPTZ"}, - {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ,INTERVAL]>TIMESTAMPTZ"}, - {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ,TIMESTAMPTZ]>TIMESTAMPTZ"}, - {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ,VARCHAR]>TIMESTAMPTZ"}, - {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMETZ]>TIMETZ"}, - {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>TIMESTAMPTZ"}, - {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>TIMESTAMP"}, - {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>TIMETZ"}, - {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"timezone_hour", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"timezone_minute", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"week", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"weekday", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"weekofyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"year", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, - {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, - {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, - {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, - {"yearweek", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>INTERVAL"}, + {"age", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP,TIMESTAMP]>INTERVAL"}, + {"age", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>INTERVAL"}, + {"age", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ,TIMESTAMPTZ]>INTERVAL"}, + {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"century", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"century", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, + {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, + {"date_diff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, + {"date_diff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',DATE]>STRUCT()"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',INTERVAL]>STRUCT()"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME]>STRUCT()"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMP]>STRUCT()"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMETZ]>STRUCT()"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>BIGINT"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>BIGINT"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME]>BIGINT"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>BIGINT"}, + {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>BIGINT"}, + {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMPTZ]>STRUCT()"}, + {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>BIGINT"}, + {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, + {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, + {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, + {"date_sub", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, + {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>TIMESTAMP"}, + {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>INTERVAL"}, + {"date_trunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>TIMESTAMP"}, + {"date_trunc", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>TIMESTAMPTZ"}, + {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, + {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, + {"datediff", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, + {"datediff", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',DATE]>STRUCT()"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',INTERVAL]>STRUCT()"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME]>STRUCT()"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMP]>STRUCT()"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMETZ]>STRUCT()"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>BIGINT"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>BIGINT"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME]>BIGINT"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>BIGINT"}, + {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>BIGINT"}, + {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMPTZ]>STRUCT()"}, + {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>BIGINT"}, + {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"}, + {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME,TIME]>BIGINT"}, + {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP,TIMESTAMP]>BIGINT"}, + {"datesub", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ,TIMESTAMPTZ]>BIGINT"}, + {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>TIMESTAMP"}, + {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>INTERVAL"}, + {"datetrunc", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>TIMESTAMP"}, + {"datetrunc", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>TIMESTAMPTZ"}, + {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"day", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"dayname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>VARCHAR"}, + {"dayname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>VARCHAR"}, + {"dayname", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>VARCHAR"}, + {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"dayofmonth", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"dayofmonth", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"dayofweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"dayofweek", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"dayofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"dayofyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"decade", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"decade", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>DOUBLE"}, + {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>DOUBLE"}, + {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>DOUBLE"}, + {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DOUBLE"}, + {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>DOUBLE"}, + {"epoch", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DOUBLE"}, + {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"era", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT]>BIGINT[]"}, + {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT]>BIGINT[]"}, + {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT,BIGINT]>BIGINT[]"}, + {"generate_series", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, + "[TIMESTAMP,TIMESTAMP,INTERVAL]>TIMESTAMP[]"}, + {"generate_series", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ,TIMESTAMPTZ,INTERVAL]>TIMESTAMPTZ[]"}, + {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, + {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, + {"hour", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"isodow", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"isoyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"isoyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"julian", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>DOUBLE"}, + {"julian", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DOUBLE"}, + {"julian", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DOUBLE"}, + {"last_day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>DATE"}, + {"last_day", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DATE"}, + {"last_day", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DATE"}, + {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, + {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, + {"microsecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"millennium", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, + {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, + {"millisecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, + {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, + {"minute", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"month", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"monthname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>VARCHAR"}, + {"monthname", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>VARCHAR"}, + {"monthname", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>VARCHAR"}, + {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"quarter", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"quarter", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT]>BIGINT[]"}, + {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT]>BIGINT[]"}, + {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[BIGINT,BIGINT,BIGINT]>BIGINT[]"}, + {"range", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP,TIMESTAMP,INTERVAL]>TIMESTAMP[]"}, + {"range", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ,TIMESTAMPTZ,INTERVAL]>TIMESTAMPTZ[]"}, + {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"}, + {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"}, + {"second", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE]>DATE"}, + {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE,DATE]>DATE"}, + {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE,INTERVAL]>DATE"}, + {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMP]>TIMESTAMP"}, + {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMP,INTERVAL]>TIMESTAMP"}, + {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMP,TIMESTAMP]>TIMESTAMP"}, + {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ]>TIMESTAMPTZ"}, + {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ,INTERVAL]>TIMESTAMPTZ"}, + {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ,TIMESTAMPTZ]>TIMESTAMPTZ"}, + {"time_bucket", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMESTAMPTZ,VARCHAR]>TIMESTAMPTZ"}, + {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,TIMETZ]>TIMETZ"}, + {"timezone", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>TIMESTAMPTZ"}, + {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>TIMESTAMP"}, + {"timezone", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>TIMETZ"}, + {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"timezone_hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"timezone_hour", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"timezone_minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"timezone_minute", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"week", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"week", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"weekday", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"weekday", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"weekofyear", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"weekofyear", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"year", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"year", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, + {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"}, + {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"}, + {"yearweek", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"}, + {"yearweek", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"}, }; // END_OF_EXTENSION_FUNCTION_OVERLOADS static constexpr ExtensionEntry EXTENSION_SETTINGS[] = { - {"azure_account_name", "azure"}, - {"azure_context_caching", "azure"}, - {"azure_credential_chain", "azure"}, - {"azure_endpoint", "azure"}, - {"azure_http_proxy", "azure"}, - {"azure_http_stats", "azure"}, - {"azure_proxy_password", "azure"}, - {"azure_proxy_user_name", "azure"}, - {"azure_read_buffer_size", "azure"}, - {"azure_read_transfer_chunk_size", "azure"}, - {"azure_read_transfer_concurrency", "azure"}, - {"azure_storage_connection_string", "azure"}, - {"azure_transport_option_type", "azure"}, - {"binary_as_string", "parquet"}, - {"ca_cert_file", "httpfs"}, - {"calendar", "icu"}, - {"disable_parquet_prefetching", "parquet"}, - {"ducklake_max_retry_count", "ducklake"}, - {"ducklake_retry_backoff", "ducklake"}, - {"ducklake_retry_wait_ms", "ducklake"}, - {"enable_geoparquet_conversion", "parquet"}, - {"enable_server_cert_verification", "httpfs"}, - {"force_download", "httpfs"}, - {"hf_max_per_page", "httpfs"}, - {"hnsw_ef_search", "vss"}, - {"hnsw_enable_experimental_persistence", "vss"}, - {"http_keep_alive", "httpfs"}, - {"http_retries", "httpfs"}, - {"http_retry_backoff", "httpfs"}, - {"http_retry_wait_ms", "httpfs"}, - {"http_timeout", "httpfs"}, - {"mysql_bit1_as_boolean", "mysql_scanner"}, - {"mysql_debug_show_queries", "mysql_scanner"}, - {"mysql_experimental_filter_pushdown", "mysql_scanner"}, - {"mysql_tinyint1_as_boolean", "mysql_scanner"}, - {"parquet_metadata_cache", "parquet"}, - {"pg_array_as_varchar", "postgres_scanner"}, - {"pg_connection_cache", "postgres_scanner"}, - {"pg_connection_limit", "postgres_scanner"}, - {"pg_debug_show_queries", "postgres_scanner"}, - {"pg_experimental_filter_pushdown", "postgres_scanner"}, - {"pg_null_byte_replacement", "postgres_scanner"}, - {"pg_pages_per_task", "postgres_scanner"}, - {"pg_use_binary_copy", "postgres_scanner"}, - {"pg_use_ctid_scan", "postgres_scanner"}, - {"prefetch_all_parquet_files", "parquet"}, - {"s3_access_key_id", "httpfs"}, - {"s3_endpoint", "httpfs"}, - {"s3_kms_key_id", "httpfs"}, - {"s3_region", "httpfs"}, - {"s3_secret_access_key", "httpfs"}, - {"s3_session_token", "httpfs"}, - {"s3_uploader_max_filesize", "httpfs"}, - {"s3_uploader_max_parts_per_file", "httpfs"}, - {"s3_uploader_thread_limit", "httpfs"}, - {"s3_url_compatibility_mode", "httpfs"}, - {"s3_url_style", "httpfs"}, - {"s3_use_ssl", "httpfs"}, - {"sqlite_all_varchar", "sqlite_scanner"}, - {"sqlite_debug_show_queries", "sqlite_scanner"}, - {"timezone", "icu"}, - {"ui_local_port", "ui"}, - {"ui_polling_interval", "ui"}, - {"ui_remote_url", "ui"}, - {"unsafe_enable_version_guessing", "iceberg"}, + {"azure_account_name", "azure"}, + {"azure_context_caching", "azure"}, + {"azure_credential_chain", "azure"}, + {"azure_endpoint", "azure"}, + {"azure_http_proxy", "azure"}, + {"azure_http_stats", "azure"}, + {"azure_proxy_password", "azure"}, + {"azure_proxy_user_name", "azure"}, + {"azure_read_buffer_size", "azure"}, + {"azure_read_transfer_chunk_size", "azure"}, + {"azure_read_transfer_concurrency", "azure"}, + {"azure_storage_connection_string", "azure"}, + {"azure_transport_option_type", "azure"}, + {"binary_as_string", "parquet"}, + {"ca_cert_file", "httpfs"}, + {"calendar", "icu"}, + {"disable_parquet_prefetching", "parquet"}, + {"ducklake_max_retry_count", "ducklake"}, + {"ducklake_retry_backoff", "ducklake"}, + {"ducklake_retry_wait_ms", "ducklake"}, + {"enable_geoparquet_conversion", "parquet"}, + {"enable_server_cert_verification", "httpfs"}, + {"force_download", "httpfs"}, + {"hf_max_per_page", "httpfs"}, + {"hnsw_ef_search", "vss"}, + {"hnsw_enable_experimental_persistence", "vss"}, + {"http_keep_alive", "httpfs"}, + {"http_retries", "httpfs"}, + {"http_retry_backoff", "httpfs"}, + {"http_retry_wait_ms", "httpfs"}, + {"http_timeout", "httpfs"}, + {"mysql_bit1_as_boolean", "mysql_scanner"}, + {"mysql_debug_show_queries", "mysql_scanner"}, + {"mysql_experimental_filter_pushdown", "mysql_scanner"}, + {"mysql_tinyint1_as_boolean", "mysql_scanner"}, + {"parquet_metadata_cache", "parquet"}, + {"pg_array_as_varchar", "postgres_scanner"}, + {"pg_connection_cache", "postgres_scanner"}, + {"pg_connection_limit", "postgres_scanner"}, + {"pg_debug_show_queries", "postgres_scanner"}, + {"pg_experimental_filter_pushdown", "postgres_scanner"}, + {"pg_null_byte_replacement", "postgres_scanner"}, + {"pg_pages_per_task", "postgres_scanner"}, + {"pg_use_binary_copy", "postgres_scanner"}, + {"pg_use_ctid_scan", "postgres_scanner"}, + {"prefetch_all_parquet_files", "parquet"}, + {"s3_access_key_id", "httpfs"}, + {"s3_endpoint", "httpfs"}, + {"s3_kms_key_id", "httpfs"}, + {"s3_region", "httpfs"}, + {"s3_secret_access_key", "httpfs"}, + {"s3_session_token", "httpfs"}, + {"s3_uploader_max_filesize", "httpfs"}, + {"s3_uploader_max_parts_per_file", "httpfs"}, + {"s3_uploader_thread_limit", "httpfs"}, + {"s3_url_compatibility_mode", "httpfs"}, + {"s3_url_style", "httpfs"}, + {"s3_use_ssl", "httpfs"}, + {"sqlite_all_varchar", "sqlite_scanner"}, + {"sqlite_debug_show_queries", "sqlite_scanner"}, + {"timezone", "icu"}, + {"ui_local_port", "ui"}, + {"ui_polling_interval", "ui"}, + {"ui_remote_url", "ui"}, + {"unsafe_enable_version_guessing", "iceberg"}, }; // END_OF_EXTENSION_SETTINGS static constexpr ExtensionEntry EXTENSION_SECRET_TYPES[] = { - {"aws", "httpfs"}, - {"azure", "azure"}, - {"ducklake", "ducklake"}, - {"gcs", "httpfs"}, - {"huggingface", "httpfs"}, - {"iceberg", "iceberg"}, - {"mysql", "mysql_scanner"}, - {"postgres", "postgres_scanner"}, - {"r2", "httpfs"}, - {"s3", "httpfs"}, + {"aws", "httpfs"}, {"azure", "azure"}, {"ducklake", "ducklake"}, {"gcs", "httpfs"}, + {"huggingface", "httpfs"}, {"iceberg", "iceberg"}, {"mysql", "mysql_scanner"}, {"postgres", "postgres_scanner"}, + {"r2", "httpfs"}, {"s3", "httpfs"}, }; // END_OF_EXTENSION_SECRET_TYPES // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb static constexpr ExtensionEntry EXTENSION_COPY_FUNCTIONS[] = { - {"parquet", "parquet"}, - {"json", "json"}, - {"avro", "avro"} -}; // END_OF_EXTENSION_COPY_FUNCTIONS + {"parquet", "parquet"}, {"json", "json"}, {"avro", "avro"}}; // END_OF_EXTENSION_COPY_FUNCTIONS // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb static constexpr ExtensionEntry EXTENSION_TYPES[] = { - {"json", "json"}, - {"inet", "inet"}, - {"geometry", "spatial"} -}; // END_OF_EXTENSION_TYPES + {"json", "json"}, {"inet", "inet"}, {"geometry", "spatial"}}; // END_OF_EXTENSION_TYPES // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb @@ -1103,80 +1092,68 @@ static constexpr ExtensionEntry EXTENSION_COLLATIONS[] = { // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb static constexpr ExtensionEntry EXTENSION_FILE_PREFIXES[] = { - {"http://", "httpfs"}, {"https://", "httpfs"}, {"s3://", "httpfs"}, {"s3a://", "httpfs"}, {"s3n://", "httpfs"}, - {"gcs://", "httpfs"}, {"gs://", "httpfs"}, {"r2://", "httpfs"}, {"azure://", "azure"}, {"az://", "azure"}, - {"abfss://", "azure"}, {"hf://", "httpfs"} -}; // END_OF_EXTENSION_FILE_PREFIXES + {"http://", "httpfs"}, {"https://", "httpfs"}, {"s3://", "httpfs"}, {"s3a://", "httpfs"}, {"s3n://", "httpfs"}, + {"gcs://", "httpfs"}, {"gs://", "httpfs"}, {"r2://", "httpfs"}, {"azure://", "azure"}, {"az://", "azure"}, + {"abfss://", "azure"}, {"hf://", "httpfs"}}; // END_OF_EXTENSION_FILE_PREFIXES // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb static constexpr ExtensionEntry EXTENSION_FILE_POSTFIXES[] = { - {".parquet", "parquet"}, - {".json", "json"}, - {".jsonl", "json"}, - {".ndjson", "json"}, - {".shp", "spatial"}, - {".gpkg", "spatial"}, - {".fgb", "spatial"}, - {".xlsx", "excel"}, - {".avro", "avro"}, + {".parquet", "parquet"}, {".json", "json"}, {".jsonl", "json"}, {".ndjson", "json"}, {".shp", "spatial"}, + {".gpkg", "spatial"}, {".fgb", "spatial"}, {".xlsx", "excel"}, {".avro", "avro"}, }; // END_OF_EXTENSION_FILE_POSTFIXES // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb -static constexpr ExtensionEntry EXTENSION_FILE_CONTAINS[] = { - {".parquet?", "parquet"}, - {".json?", "json"}, - {".ndjson?", ".jsonl?"}, - {".jsonl?", ".ndjson?"} -}; // EXTENSION_FILE_CONTAINS +static constexpr ExtensionEntry EXTENSION_FILE_CONTAINS[] = {{".parquet?", "parquet"}, + {".json?", "json"}, + {".ndjson?", ".jsonl?"}, + {".jsonl?", ".ndjson?"}}; // EXTENSION_FILE_CONTAINS // Note: these are currently hardcoded in scripts/generate_extensions_function.py // TODO: automate by passing though to script via duckdb -static constexpr ExtensionEntry EXTENSION_SECRET_PROVIDERS[] = {{"s3/config", "httpfs"}, - {"gcs/config", "httpfs"}, - {"r2/config", "httpfs"}, - {"s3/credential_chain", "aws"}, - {"gcs/credential_chain", "aws"}, - {"r2/credential_chain", "aws"}, - {"aws/credential_chain", "aws"}, - {"azure/access_token", "azure"}, - {"azure/config", "azure"}, - {"azure/credential_chain", "azure"}, - {"azure/service_principal", "azure"}, - {"huggingface/config", "httfps"}, - {"huggingface/credential_chain", "httpfs"}, - {"bearer/config", "httpfs"}, - {"mysql/config", "mysql_scanner"}, - {"postgres/config", "postgres_scanner"} -}; // EXTENSION_SECRET_PROVIDERS +static constexpr ExtensionEntry EXTENSION_SECRET_PROVIDERS[] = { + {"s3/config", "httpfs"}, + {"gcs/config", "httpfs"}, + {"r2/config", "httpfs"}, + {"s3/credential_chain", "aws"}, + {"gcs/credential_chain", "aws"}, + {"r2/credential_chain", "aws"}, + {"aws/credential_chain", "aws"}, + {"azure/access_token", "azure"}, + {"azure/config", "azure"}, + {"azure/credential_chain", "azure"}, + {"azure/service_principal", "azure"}, + {"huggingface/config", "httfps"}, + {"huggingface/credential_chain", "httpfs"}, + {"bearer/config", "httpfs"}, + {"mysql/config", "mysql_scanner"}, + {"postgres/config", "postgres_scanner"}}; // EXTENSION_SECRET_PROVIDERS -static constexpr const char *AUTOLOADABLE_EXTENSIONS[] = { - "avro", - "aws", - "azure", - "autocomplete", - "core_functions", - "delta", - "ducklake", - "encodings", - "excel", - "fts", - "httpfs", - "iceberg", - "inet", - "icu", - "json", - "motherduck", - "mysql_scanner", - "parquet", - "sqlite_scanner", - "sqlsmith", - "postgres_scanner", - "tpcds", - "tpch", - "uc_catalog", - "ui" -}; // END_OF_AUTOLOADABLE_EXTENSIONS +static constexpr const char *AUTOLOADABLE_EXTENSIONS[] = {"avro", + "aws", + "azure", + "autocomplete", + "core_functions", + "delta", + "ducklake", + "encodings", + "excel", + "fts", + "httpfs", + "iceberg", + "inet", + "icu", + "json", + "motherduck", + "mysql_scanner", + "parquet", + "sqlite_scanner", + "sqlsmith", + "postgres_scanner", + "tpcds", + "tpch", + "uc_catalog", + "ui"}; // END_OF_AUTOLOADABLE_EXTENSIONS -} // namespace duckdb \ No newline at end of file +} // namespace duckdb