duckdb 0.9.3-dev0.0 → 0.9.3-dev14.0

package/src/duckdb/src/function/function_binder.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/aggregate_function.hpp"
 #include "duckdb/function/cast_rules.hpp"
+#include "duckdb/parser/parsed_data/create_secret_info.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
@@ -51,7 +52,12 @@ int64_t FunctionBinder::BindFunctionCost(const SimpleFunction &func, const vecto
 		return -1;
 	}
 	int64_t cost = 0;
+	bool has_parameter = false;
 	for (idx_t i = 0; i < arguments.size(); i++) {
+		if (arguments[i].id() == LogicalTypeId::UNKNOWN) {
+			has_parameter = true;
+			continue;
+		}
 		int64_t cast_cost = CastFunctionSet::Get(context).ImplicitCastCost(arguments[i], func.arguments[i]);
 		if (cast_cost >= 0) {
 			// we can implicitly cast, add the cost to the total cost
@@ -61,12 +67,16 @@ int64_t FunctionBinder::BindFunctionCost(const SimpleFunction &func, const vecto
 			return -1;
 		}
 	}
+	if (has_parameter) {
+		// all arguments are implicitly castable and there is a parameter - return 0 as cost
+		return 0;
+	}
 	return cost;
 }
 
 template <class T>
 vector<idx_t> FunctionBinder::BindFunctionsFromArguments(const string &name, FunctionSet<T> &functions,
-                                                         const vector<LogicalType> &arguments, string &error) {
+                                                         const vector<LogicalType> &arguments, ErrorData &error) {
 	idx_t best_function = DConstants::INVALID_INDEX;
 	int64_t lowest_cost = NumericLimits<int64_t>::Maximum();
 	vector<idx_t> candidate_functions;
@@ -91,14 +101,11 @@ vector<idx_t> FunctionBinder::BindFunctionsFromArguments(const string &name, Fun
 	}
 	if (best_function == DConstants::INVALID_INDEX) {
 		// no matching function was found, throw an error
-		string call_str = Function::CallToString(name, arguments);
-		string candidate_str = "";
+		vector<string> candidates;
 		for (auto &f : functions.functions) {
-			candidate_str += "\t" + f.ToString() + "\n";
+			candidates.push_back(f.ToString());
 		}
-		error = StringUtil::Format("No function matches the given name and argument types '%s'. You might need to add "
-		                           "explicit type casts.\n\tCandidate functions:\n%s",
-		                           call_str, candidate_str);
+		error = ErrorData(BinderException::NoMatchingFunction(name, arguments, candidates));
 		return candidate_functions;
 	}
 	candidate_functions.push_back(best_function);
@@ -108,25 +115,27 @@ vector<idx_t> FunctionBinder::BindFunctionsFromArguments(const string &name, Fun
 template <class T>
 idx_t FunctionBinder::MultipleCandidateException(const string &name, FunctionSet<T> &functions,
                                                  vector<idx_t> &candidate_functions,
-                                                 const vector<LogicalType> &arguments, string &error) {
+                                                 const vector<LogicalType> &arguments, ErrorData &error) {
 	D_ASSERT(functions.functions.size() > 1);
 	// there are multiple possible function definitions
 	// throw an exception explaining which overloads are there
 	string call_str = Function::CallToString(name, arguments);
-	string candidate_str = "";
+	string candidate_str;
 	for (auto &conf : candidate_functions) {
 		T f = functions.GetFunctionByOffset(conf);
 		candidate_str += "\t" + f.ToString() + "\n";
 	}
-	error = StringUtil::Format("Could not choose a best candidate function for the function call \"%s\". In order to "
-	                           "select one, please add explicit type casts.\n\tCandidate functions:\n%s",
-	                           call_str, candidate_str);
+	error = ErrorData(
+	    ExceptionType::BINDER,
+	    StringUtil::Format("Could not choose a best candidate function for the function call \"%s\". In order to "
+	                       "select one, please add explicit type casts.\n\tCandidate functions:\n%s",
+	                       call_str, candidate_str));
 	return DConstants::INVALID_INDEX;
 }
 
 template <class T>
 idx_t FunctionBinder::BindFunctionFromArguments(const string &name, FunctionSet<T> &functions,
-                                                const vector<LogicalType> &arguments, string &error) {
+                                                const vector<LogicalType> &arguments, ErrorData &error) {
 	auto candidate_functions = BindFunctionsFromArguments<T>(name, functions, arguments, error);
 	if (candidate_functions.empty()) {
 		// no candidates
@@ -149,35 +158,36 @@ idx_t FunctionBinder::BindFunctionFromArguments(const string &name, FunctionSet<
 }
 
 idx_t FunctionBinder::BindFunction(const string &name, ScalarFunctionSet &functions,
-                                   const vector<LogicalType> &arguments, string &error) {
+                                   const vector<LogicalType> &arguments, ErrorData &error) {
 	return BindFunctionFromArguments(name, functions, arguments, error);
 }
 
 idx_t FunctionBinder::BindFunction(const string &name, AggregateFunctionSet &functions,
-                                   const vector<LogicalType> &arguments, string &error) {
+                                   const vector<LogicalType> &arguments, ErrorData &error) {
 	return BindFunctionFromArguments(name, functions, arguments, error);
 }
 
 idx_t FunctionBinder::BindFunction(const string &name, TableFunctionSet &functions,
-                                   const vector<LogicalType> &arguments, string &error) {
+                                   const vector<LogicalType> &arguments, ErrorData &error) {
 	return BindFunctionFromArguments(name, functions, arguments, error);
 }
 
-idx_t FunctionBinder::BindFunction(const string &name, PragmaFunctionSet &functions, PragmaInfo &info, string &error) {
+idx_t FunctionBinder::BindFunction(const string &name, PragmaFunctionSet &functions, vector<Value> &parameters,
+                                   ErrorData &error) {
 	vector<LogicalType> types;
-	for (auto &value : info.parameters) {
+	for (auto &value : parameters) {
 		types.push_back(value.type());
 	}
 	idx_t entry = BindFunctionFromArguments(name, functions, types, error);
 	if (entry == DConstants::INVALID_INDEX) {
-		throw BinderException(error);
+		error.Throw();
 	}
 	auto candidate_function = functions.GetFunctionByOffset(entry);
 	// cast the input parameters
-	for (idx_t i = 0; i < info.parameters.size(); i++) {
+	for (idx_t i = 0; i < parameters.size(); i++) {
 		auto target_type =
 		    i < candidate_function.arguments.size() ? candidate_function.arguments[i] : candidate_function.varargs;
-		info.parameters[i] = info.parameters[i].CastAs(context, target_type);
+		parameters[i] = parameters[i].CastAs(context, target_type);
 	}
 	return entry;
 }
@@ -186,25 +196,25 @@ vector<LogicalType> FunctionBinder::GetLogicalTypesFromExpressions(vector<unique
 	vector<LogicalType> types;
 	types.reserve(arguments.size());
 	for (auto &argument : arguments) {
-		types.push_back(argument->return_type);
+		types.push_back(ExpressionBinder::GetExpressionReturnType(*argument));
 	}
 	return types;
 }
 
 idx_t FunctionBinder::BindFunction(const string &name, ScalarFunctionSet &functions,
-                                   vector<unique_ptr<Expression>> &arguments, string &error) {
+                                   vector<unique_ptr<Expression>> &arguments, ErrorData &error) {
 	auto types = GetLogicalTypesFromExpressions(arguments);
 	return BindFunction(name, functions, types, error);
 }
 
 idx_t FunctionBinder::BindFunction(const string &name, AggregateFunctionSet &functions,
-                                   vector<unique_ptr<Expression>> &arguments, string &error) {
+                                   vector<unique_ptr<Expression>> &arguments, ErrorData &error) {
 	auto types = GetLogicalTypesFromExpressions(arguments);
 	return BindFunction(name, functions, types, error);
 }
 
 idx_t FunctionBinder::BindFunction(const string &name, TableFunctionSet &functions,
-                                   vector<unique_ptr<Expression>> &arguments, string &error) {
+                                   vector<unique_ptr<Expression>> &arguments, ErrorData &error) {
 	auto types = GetLogicalTypesFromExpressions(arguments);
 	return BindFunction(name, functions, types, error);
 }
@@ -221,12 +231,35 @@ LogicalTypeComparisonResult RequiresCast(const LogicalType &source_type, const L
 	if (source_type.id() == LogicalTypeId::LIST && target_type.id() == LogicalTypeId::LIST) {
 		return RequiresCast(ListType::GetChildType(source_type), ListType::GetChildType(target_type));
 	}
+	if (source_type.id() == LogicalTypeId::ARRAY && target_type.id() == LogicalTypeId::ARRAY) {
+		return RequiresCast(ArrayType::GetChildType(source_type), ArrayType::GetChildType(target_type));
+	}
 	return LogicalTypeComparisonResult::DIFFERENT_TYPES;
 }
 
+LogicalType PrepareTypeForCast(const LogicalType &type) {
+	if (type.id() == LogicalTypeId::ANY) {
+		return AnyType::GetTargetType(type);
+	}
+	if (type.id() == LogicalTypeId::LIST) {
+		return LogicalType::LIST(PrepareTypeForCast(ListType::GetChildType(type)));
+	}
+	return type;
+}
+
 void FunctionBinder::CastToFunctionArguments(SimpleFunction &function, vector<unique_ptr<Expression>> &children) {
+	for (auto &arg : function.arguments) {
+		arg = PrepareTypeForCast(arg);
+	}
+	function.varargs = PrepareTypeForCast(function.varargs);
+
 	for (idx_t i = 0; i < children.size(); i++) {
 		auto target_type = i < function.arguments.size() ? function.arguments[i] : function.varargs;
+		if (target_type.id() == LogicalTypeId::STRING_LITERAL || target_type.id() == LogicalTypeId::INTEGER_LITERAL) {
+			throw InternalException(
+			    "Function %s returned a STRING_LITERAL or INTEGER_LITERAL type - return an explicit type instead",
+			    function.name);
+		}
 		target_type.Verify();
 		// don't cast lambda children, they get removed before execution
 		if (children[i]->return_type.id() == LogicalTypeId::LAMBDA) {
@@ -244,7 +277,7 @@ void FunctionBinder::CastToFunctionArguments(SimpleFunction &function, vector<un
 }
 
 unique_ptr<Expression> FunctionBinder::BindScalarFunction(const string &schema, const string &name,
-                                                          vector<unique_ptr<Expression>> children, string &error,
+                                                          vector<unique_ptr<Expression>> children, ErrorData &error,
                                                           bool is_operator, Binder *binder) {
 	// bind the function
 	auto &function =
@@ -255,7 +288,7 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(const string &schema,
 }
 
 unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogEntry &func,
-                                                          vector<unique_ptr<Expression>> children, string &error,
+                                                          vector<unique_ptr<Expression>> children, ErrorData &error,
                                                           bool is_operator, Binder *binder) {
 	// bind the function
 	idx_t best_function = BindFunction(func.name, func.functions, children, error);
@@ -266,10 +299,28 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogE
 	// found a matching function!
 	auto bound_function = func.functions.GetFunctionByOffset(best_function);
 
+	// If any of the parameters are NULL, the function will just be replaced with a NULL constant
+	// But this NULL constant needs to have to correct type, because we use LogicalType::SQLNULL for binding macro's
+	// However, some functions may have an invalid return type, so we default to SQLNULL for those
+	LogicalType return_type_if_null;
+	switch (bound_function.return_type.id()) {
+	case LogicalTypeId::ANY:
+	case LogicalTypeId::DECIMAL:
+	case LogicalTypeId::STRUCT:
+	case LogicalTypeId::LIST:
+	case LogicalTypeId::MAP:
+	case LogicalTypeId::UNION:
+	case LogicalTypeId::ARRAY:
+		return_type_if_null = LogicalType::SQLNULL;
+		break;
+	default:
+		return_type_if_null = bound_function.return_type;
+	}
+
 	if (bound_function.null_handling == FunctionNullHandling::DEFAULT_NULL_HANDLING) {
 		for (auto &child : children) {
 			if (child->return_type == LogicalTypeId::SQLNULL) {
-				return make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL));
+				return make_uniq<BoundConstantExpression>(Value(return_type_if_null));
 			}
 			if (!child->IsFoldable()) {
 				continue;
@@ -279,7 +330,7 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(ScalarFunctionCatalogE
 				continue;
 			}
 			if (result.IsNull()) {
-				return make_uniq<BoundConstantExpression>(Value(LogicalType::SQLNULL));
+				return make_uniq<BoundConstantExpression>(Value(return_type_if_null));
 			}
 		}
 	}

package/src/duckdb/src/function/function_set.cpp

@@ -14,12 +14,12 @@ ScalarFunctionSet::ScalarFunctionSet(ScalarFunction fun) : FunctionSet(std::move
 }
 
 ScalarFunction ScalarFunctionSet::GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments) {
-	string error;
+	ErrorData error;
 	FunctionBinder binder(context);
 	idx_t index = binder.BindFunction(name, *this, arguments, error);
 	if (index == DConstants::INVALID_INDEX) {
 		throw InternalException("Failed to find function %s(%s)\n%s", name, StringUtil::ToString(arguments, ","),
-		                        error);
+		                        error.Message());
 	}
 	return GetFunctionByOffset(index);
 }
@@ -36,7 +36,7 @@ AggregateFunctionSet::AggregateFunctionSet(AggregateFunction fun) : FunctionSet(
 
 AggregateFunction AggregateFunctionSet::GetFunctionByArguments(ClientContext &context,
                                                                const vector<LogicalType> &arguments) {
-	string error;
+	ErrorData error;
 	FunctionBinder binder(context);
 	idx_t index = binder.BindFunction(name, *this, arguments, error);
 	if (index == DConstants::INVALID_INDEX) {
@@ -59,7 +59,7 @@ AggregateFunction AggregateFunctionSet::GetFunctionByArguments(ClientContext &co
 			}
 		}
 		throw InternalException("Failed to find function %s(%s)\n%s", name, StringUtil::ToString(arguments, ","),
-		                        error);
+		                        error.Message());
 	}
 	return GetFunctionByOffset(index);
 }
@@ -72,12 +72,12 @@ TableFunctionSet::TableFunctionSet(TableFunction fun) : FunctionSet(std::move(fu
 }
 
 TableFunction TableFunctionSet::GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments) {
-	string error;
+	ErrorData error;
 	FunctionBinder binder(context);
 	idx_t index = binder.BindFunction(name, *this, arguments, error);
 	if (index == DConstants::INVALID_INDEX) {
 		throw InternalException("Failed to find function %s(%s)\n%s", name, StringUtil::ToString(arguments, ","),
-		                        error);
+		                        error.Message());
 	}
 	return GetFunctionByOffset(index);
 }

package/src/duckdb/src/function/pragma/pragma_functions.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/main/query_profiler.hpp"
+#include "duckdb/main/secret/secret_manager.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
@@ -76,16 +77,16 @@ static void PragmaDisableExternalVerification(ClientContext &context, const Func
 	ClientConfig::GetConfig(context).verify_external = false;
 }
 
-static void PragmaEnableForceParallelism(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).verify_parallelism = true;
+static void PragmaEnableFetchRowVerification(ClientContext &context, const FunctionParameters &parameters) {
+	ClientConfig::GetConfig(context).verify_fetch_row = true;
 }
 
-static void PragmaEnableIndexJoin(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).enable_index_join = true;
+static void PragmaDisableFetchRowVerification(ClientContext &context, const FunctionParameters &parameters) {
+	ClientConfig::GetConfig(context).verify_fetch_row = false;
 }
 
-static void PragmaEnableForceIndexJoin(ClientContext &context, const FunctionParameters &parameters) {
-	ClientConfig::GetConfig(context).force_index_join = true;
+static void PragmaEnableForceParallelism(ClientContext &context, const FunctionParameters &parameters) {
+	ClientConfig::GetConfig(context).verify_parallelism = true;
 }
 
 static void PragmaForceCheckpoint(ClientContext &context, const FunctionParameters &parameters) {
@@ -132,6 +133,9 @@ void PragmaFunctions::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(PragmaFunction::PragmaStatement("verify_external", PragmaEnableExternalVerification));
 	set.AddFunction(PragmaFunction::PragmaStatement("disable_verify_external", PragmaDisableExternalVerification));
 
+	set.AddFunction(PragmaFunction::PragmaStatement("verify_fetch_row", PragmaEnableFetchRowVerification));
+	set.AddFunction(PragmaFunction::PragmaStatement("disable_verify_fetch_row", PragmaDisableFetchRowVerification));
+
 	set.AddFunction(PragmaFunction::PragmaStatement("verify_serializer", PragmaVerifySerializer));
 	set.AddFunction(PragmaFunction::PragmaStatement("disable_verify_serializer", PragmaDisableVerifySerializer));
 
@@ -144,8 +148,6 @@ void PragmaFunctions::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(PragmaFunction::PragmaStatement("enable_optimizer", PragmaEnableOptimizer));
 	set.AddFunction(PragmaFunction::PragmaStatement("disable_optimizer", PragmaDisableOptimizer));
 
-	set.AddFunction(PragmaFunction::PragmaStatement("enable_index_join", PragmaEnableIndexJoin));
-	set.AddFunction(PragmaFunction::PragmaStatement("force_index_join", PragmaEnableForceIndexJoin));
 	set.AddFunction(PragmaFunction::PragmaStatement("force_checkpoint", PragmaForceCheckpoint));
 
 	set.AddFunction(PragmaFunction::PragmaStatement("enable_progress_bar", PragmaEnableProgressBar));

package/src/duckdb/src/function/pragma/pragma_queries.cpp

@@ -14,10 +14,11 @@
 namespace duckdb {
 
 string PragmaTableInfo(ClientContext &context, const FunctionParameters &parameters) {
-	return StringUtil::Format("SELECT * FROM pragma_table_info('%s');", parameters.values[0].ToString());
+	return StringUtil::Format("SELECT * FROM pragma_table_info(%s);",
+	                          KeywordHelper::WriteQuoted(parameters.values[0].ToString(), '\''));
 }
 
-string PragmaShowTables(ClientContext &context, const FunctionParameters &parameters) {
+string PragmaShowTables() {
 	// clang-format off
 	return R"EOF(
 	with "tables" as
@@ -41,8 +42,11 @@ string PragmaShowTables(ClientContext &context, const FunctionParameters &parame
 	ORDER BY "name";)EOF";
 	// clang-format on
 }
+string PragmaShowTables(ClientContext &context, const FunctionParameters &parameters) {
+	return PragmaShowTables();
+}
 
-string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters &parameters) {
+string PragmaShowTablesExpanded() {
 	return R"(
 	SELECT
 		t.database_name AS database,
@@ -74,10 +78,18 @@ string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters
 	)";
 }
 
-string PragmaShowDatabases(ClientContext &context, const FunctionParameters &parameters) {
+string PragmaShowTablesExpanded(ClientContext &context, const FunctionParameters &parameters) {
+	return PragmaShowTablesExpanded();
+}
+
+string PragmaShowDatabases() {
 	return "SELECT database_name FROM duckdb_databases() WHERE NOT internal ORDER BY database_name;";
 }
 
+string PragmaShowDatabases(ClientContext &context, const FunctionParameters &parameters) {
+	return PragmaShowDatabases();
+}
+
 string PragmaAllProfiling(ClientContext &context, const FunctionParameters &parameters) {
 	return "SELECT * FROM pragma_last_profiling_output() JOIN pragma_detailed_profiling_output() ON "
 	       "(pragma_last_profiling_output.operator_id);";
@@ -99,41 +111,12 @@ string PragmaFunctionsQuery(ClientContext &context, const FunctionParameters &pa
 	       " ORDER BY 1;";
 }
 
-string PragmaShow(ClientContext &context, const FunctionParameters &parameters) {
-	// PRAGMA table_info but with some aliases
-	auto table = QualifiedName::Parse(parameters.values[0].ToString());
-
-	// clang-format off
-    string sql = R"(
-	SELECT
-		name AS "column_name",
-		type as "column_type",
-		CASE WHEN "notnull" THEN 'NO' ELSE 'YES' END AS "null",
-		(SELECT 
-			MIN(CASE 
-				WHEN constraint_type='PRIMARY KEY' THEN 'PRI'
-				WHEN constraint_type='UNIQUE' THEN 'UNI' 
-				ELSE NULL END) 
-		FROM duckdb_constraints() c  
-		WHERE c.table_oid=cols.table_oid 
-		AND list_contains(constraint_column_names, cols.column_name)) AS "key",
-		dflt_value AS "default", 
-		NULL AS "extra" 
-	FROM pragma_table_info('%func_param_table%') 
-	LEFT JOIN duckdb_columns cols 
-	ON cols.column_name = pragma_table_info.name 
-	AND cols.table_name='%table_name%'
-	AND cols.schema_name='%table_schema%'
-	AND cols.database_name = '%table_database%'
-	ORDER BY column_index;)";
-	// clang-format on
+string PragmaShow(const string &table_name) {
+	return StringUtil::Format("SELECT * FROM pragma_show(%s);", KeywordHelper::WriteQuoted(table_name, '\''));
+}
 
-	sql = StringUtil::Replace(sql, "%func_param_table%", parameters.values[0].ToString());
-	sql = StringUtil::Replace(sql, "%table_name%", table.name);
-	sql = StringUtil::Replace(sql, "%table_schema%", table.schema.empty() ? DEFAULT_SCHEMA : table.schema);
-	sql = StringUtil::Replace(sql, "%table_database%",
-	                          table.catalog.empty() ? DatabaseManager::GetDefaultDatabase(context) : table.catalog);
-	return sql;
+string PragmaShow(ClientContext &context, const FunctionParameters &parameters) {
+	return PragmaShow(parameters.values[0].ToString());
 }
 
 string PragmaVersion(ClientContext &context, const FunctionParameters &parameters) {
@@ -182,6 +165,17 @@ string PragmaImportDatabase(ClientContext &context, const FunctionParameters &pa
 	return final_query;
 }
 
+string PragmaCopyDatabase(ClientContext &context, const FunctionParameters &parameters) {
+	string copy_stmt = "COPY FROM DATABASE ";
+	copy_stmt += KeywordHelper::WriteOptionallyQuoted(parameters.values[0].ToString());
+	copy_stmt += " TO ";
+	copy_stmt += KeywordHelper::WriteOptionallyQuoted(parameters.values[1].ToString());
+	string final_query;
+	final_query += copy_stmt + " (SCHEMA);\n";
+	final_query += copy_stmt + " (DATA);";
+	return final_query;
+}
+
 string PragmaDatabaseSize(ClientContext &context, const FunctionParameters &parameters) {
 	return "SELECT * FROM pragma_database_size();";
 }
@@ -213,6 +207,8 @@ void PragmaQueries::RegisterFunction(BuiltinFunctions &set) {
 	set.AddFunction(PragmaFunction::PragmaStatement("database_size", PragmaDatabaseSize));
 	set.AddFunction(PragmaFunction::PragmaStatement("functions", PragmaFunctionsQuery));
 	set.AddFunction(PragmaFunction::PragmaCall("import_database", PragmaImportDatabase, {LogicalType::VARCHAR}));
+	set.AddFunction(
+	    PragmaFunction::PragmaCall("copy_database", PragmaCopyDatabase, {LogicalType::VARCHAR, LogicalType::VARCHAR}));
 	set.AddFunction(PragmaFunction::PragmaStatement("all_profiling_output", PragmaAllProfiling));
 	set.AddFunction(PragmaFunction::PragmaStatement("user_agent", PragmaUserAgent));
 }

package/src/duckdb/src/function/scalar/compressed_materialization/compress_integral.cpp

@@ -26,6 +26,14 @@ struct TemplatedIntegralCompress<hugeint_t, RESULT_TYPE> {
 	}
 };
 
+template <class RESULT_TYPE>
+struct TemplatedIntegralCompress<uhugeint_t, RESULT_TYPE> {
+	static inline RESULT_TYPE Operation(const uhugeint_t &input, const uhugeint_t &min_val) {
+		D_ASSERT(min_val <= input);
+		return (input - min_val).lower;
+	}
+};
+
 template <class INPUT_TYPE, class RESULT_TYPE>
 static void IntegralCompressFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 2);
@@ -75,6 +83,8 @@ static scalar_function_t GetIntegralCompressFunctionInputSwitch(const LogicalTyp
 		return GetIntegralCompressFunctionResultSwitch<uint32_t>(input_type, result_type);
 	case LogicalTypeId::UBIGINT:
 		return GetIntegralCompressFunctionResultSwitch<uint64_t>(input_type, result_type);
+	case LogicalTypeId::UHUGEINT:
+		return GetIntegralCompressFunctionResultSwitch<uhugeint_t>(input_type, result_type);
 	default:
 		throw InternalException("Unexpected input type in GetIntegralCompressFunctionInputSwitch");
 	}
@@ -124,6 +134,8 @@ static scalar_function_t GetIntegralDecompressFunctionResultSwitch(const Logical
 		return GetIntegralDecompressFunction<INPUT_TYPE, uint32_t>(input_type, result_type);
 	case LogicalTypeId::UBIGINT:
 		return GetIntegralDecompressFunction<INPUT_TYPE, uint64_t>(input_type, result_type);
+	case LogicalTypeId::UHUGEINT:
+		return GetIntegralDecompressFunction<INPUT_TYPE, uhugeint_t>(input_type, result_type);
 	default:
 		throw InternalException("Unexpected input type in GetIntegralDecompressFunctionSetSwitch");
 	}

package/src/duckdb/src/function/scalar/list/contains_or_position.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
 
 namespace duckdb {
 
@@ -20,6 +21,9 @@ static unique_ptr<FunctionData> ListContainsOrPositionBind(ClientContext &contex
                                                            vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(bound_function.arguments.size() == 2);
 
+	// If the first argument is an array, cast it to a list
+	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
+
 	const auto &list = arguments[0]->return_type; // change to list
 	const auto &value = arguments[1]->return_type;
 	if (list.id() == LogicalTypeId::UNKNOWN) {
@@ -37,7 +41,12 @@ static unique_ptr<FunctionData> ListContainsOrPositionBind(ClientContext &contex
 		bound_function.return_type = RETURN_TYPE;
 	} else {
 		auto const &child_type = ListType::GetChildType(list);
-		auto max_child_type = LogicalType::MaxLogicalType(child_type, value);
+		LogicalType max_child_type;
+		if (!LogicalType::TryGetMaxLogicalType(context, child_type, value, max_child_type)) {
+			throw BinderException(
+			    "Cannot get list_position of element of type %s in a list of type %s[] - an explicit cast is required",
+			    value.ToString(), child_type.ToString());
+		}
 		auto list_type = LogicalType::LIST(max_child_type);
 
 		bound_function.arguments[0] = list_type;

package/src/duckdb/src/function/scalar/list/list_concat.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
 
 namespace duckdb {
 
@@ -76,8 +77,13 @@ static unique_ptr<FunctionData> ListConcatBind(ClientContext &context, ScalarFun
                                                vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(bound_function.arguments.size() == 2);
 
+	// if either argument is an array, we cast it to a list
+	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
+	arguments[1] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[1]));
+
 	auto &lhs = arguments[0]->return_type;
 	auto &rhs = arguments[1]->return_type;
+
 	if (lhs.id() == LogicalTypeId::UNKNOWN || rhs.id() == LogicalTypeId::UNKNOWN) {
 		throw ParameterNotResolvedException();
 	} else if (lhs.id() == LogicalTypeId::SQLNULL || rhs.id() == LogicalTypeId::SQLNULL) {
@@ -93,7 +99,11 @@ static unique_ptr<FunctionData> ListConcatBind(ClientContext &context, ScalarFun
 		// Resolve list type
 		LogicalType child_type = LogicalType::SQLNULL;
 		for (const auto &argument : arguments) {
-			child_type = LogicalType::MaxLogicalType(child_type, ListType::GetChildType(argument->return_type));
+			auto &next_type = ListType::GetChildType(argument->return_type);
+			if (!LogicalType::TryGetMaxLogicalType(context, child_type, next_type, child_type)) {
+				throw BinderException("Cannot concatenate lists of types %s[] and %s[] - an explicit cast is required",
+				                      child_type.ToString(), next_type.ToString());
+			}
 		}
 		auto list_type = LogicalType::LIST(child_type);
 

package/src/duckdb/src/function/scalar/list/list_extract.cpp

@@ -1,12 +1,14 @@
 #include "duckdb/common/pair.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/chunk_collection.hpp"
+
 #include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/common/uhugeint.hpp"
 #include "duckdb/common/vector_operations/binary_executor.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/function/scalar/string_functions.hpp"
 #include "duckdb/parser/expression/bound_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/storage/statistics/list_stats.hpp"
 
 namespace duckdb {
@@ -113,6 +115,9 @@ static void ExecuteListExtractInternal(const idx_t count, UnifiedVectorFormat &l
 	case PhysicalType::UINT64:
 		ListExtractTemplate<uint64_t>(count, list, offsets, child_vector, list_size, result);
 		break;
+	case PhysicalType::UINT128:
+		ListExtractTemplate<uhugeint_t>(count, list, offsets, child_vector, list_size, result);
+		break;
 	case PhysicalType::FLOAT:
 		ListExtractTemplate<float>(count, list, offsets, child_vector, list_size, result);
 		break;
@@ -203,9 +208,14 @@ static void ListExtractFunction(DataChunk &args, ExpressionState &state, Vector
 static unique_ptr<FunctionData> ListExtractBind(ClientContext &context, ScalarFunction &bound_function,
                                                 vector<unique_ptr<Expression>> &arguments) {
 	D_ASSERT(bound_function.arguments.size() == 2);
+	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
+
 	D_ASSERT(LogicalTypeId::LIST == arguments[0]->return_type.id());
 	// list extract returns the child type of the list as return type
-	bound_function.return_type = ListType::GetChildType(arguments[0]->return_type);
+	auto child_type = ListType::GetChildType(arguments[0]->return_type);
+
+	bound_function.return_type = child_type;
+	bound_function.arguments[0] = LogicalType::LIST(child_type);
 	return make_uniq<VariableReturnBindData>(bound_function.return_type);
 }
 
@@ -238,7 +248,8 @@ void ListExtractFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet array_extract("array_extract");
 	array_extract.AddFunction(lfun);
 	array_extract.AddFunction(sfun);
-	array_extract.AddFunction(StructExtractFun::GetFunction());
+	array_extract.AddFunction(StructExtractFun::KeyExtractFunction());
+	array_extract.AddFunction(StructExtractFun::IndexExtractFunction());
 	set.AddFunction(array_extract);
 }
 

package/src/duckdb/src/function/scalar/list/list_resize.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/function/scalar_function.hpp"
 #include "duckdb/function/built_in_functions.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
 
 namespace duckdb {
 
@@ -115,6 +116,9 @@ static unique_ptr<FunctionData> ListResizeBind(ClientContext &context, ScalarFun
 	D_ASSERT(bound_function.arguments.size() == 2 || arguments.size() == 3);
 	bound_function.arguments[1] = LogicalType::UBIGINT;
 
+	// If the first argument is an array, cast it to a list
+	arguments[0] = BoundCastExpression::AddArrayCastToList(context, std::move(arguments[0]));
+
 	// first argument is constant NULL
 	if (arguments[0]->return_type == LogicalType::SQLNULL) {
 		bound_function.arguments[0] = LogicalType::SQLNULL;