duckdb 0.8.2-dev5080.0 → 0.8.2-dev5154.0

package/src/duckdb/extension/icu/icu-timezone.cpp

@@ -2,6 +2,7 @@
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/main/extension_util.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
 #include "include/icu-datefunc.hpp"
@@ -143,8 +144,8 @@ struct ICUFromNaiveTimestamp : public ICUDateFunc {
 		return BoundCastInfo(CastFromNaive, std::move(cast_data));
 	}
 
-	static void AddCasts(ClientContext &context) {
-		auto &config = DBConfig::GetConfig(context);
+	static void AddCasts(DatabaseInstance &db) {
+		auto &config = DBConfig::GetConfig(db);
 		auto &casts = config.GetCastFunctions();
 
 		casts.RegisterCastFunction(LogicalType::TIMESTAMP, LogicalType::TIMESTAMP_TZ, BindCastFromNaive);
@@ -206,8 +207,8 @@ struct ICUToNaiveTimestamp : public ICUDateFunc {
 		return BoundCastInfo(CastToNaive, std::move(cast_data));
 	}
 
-	static void AddCasts(ClientContext &context) {
-		auto &config = DBConfig::GetConfig(context);
+	static void AddCasts(DatabaseInstance &db) {
+		auto &config = DBConfig::GetConfig(db);
 		auto &casts = config.GetCastFunctions();
 
 		casts.RegisterCastFunction(LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP, BindCastToNaive);
@@ -262,18 +263,14 @@ struct ICULocalTimestampFunc : public ICUDateFunc {
 		rdata[0] = GetLocalTimestamp(state);
 	}
 
-	static void AddFunction(const string &name, ClientContext &context) {
+	static void AddFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(ScalarFunction({}, LogicalType::TIMESTAMP, Execute, BindNow));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 
 struct ICULocalTimeFunc : public ICUDateFunc {
-
 	static void Execute(DataChunk &input, ExpressionState &state, Vector &result) {
 		D_ASSERT(input.ColumnCount() == 0);
 		result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -282,13 +279,10 @@ struct ICULocalTimeFunc : public ICUDateFunc {
 		rdata[0] = Timestamp::GetTime(local);
 	}
 
-	static void AddFunction(const string &name, ClientContext &context) {
+	static void AddFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(ScalarFunction({}, LogicalType::TIME, Execute, ICULocalTimestampFunc::BindNow));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::RegisterFunction(db, set);
 	}
 };
 
@@ -326,16 +320,13 @@ struct ICUTimeZoneFunc : public ICUDateFunc {
 		}
 	}
 
-	static void AddFunction(const string &name, ClientContext &context) {
+	static void AddFunction(const string &name, DatabaseInstance &db) {
 		ScalarFunctionSet set(name);
 		set.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP_TZ,
 		                               Execute<ICUFromNaiveTimestamp>, Bind));
 		set.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP_TZ}, LogicalType::TIMESTAMP,
 		                               Execute<ICUToNaiveTimestamp>, Bind));
-
-		CreateScalarFunctionInfo func_info(set);
-		auto &catalog = Catalog::GetSystemCatalog(context);
-		catalog.AddFunction(context, func_info);
+		ExtensionUtil::AddFunctionOverload(db, set);
 	}
 };
 
@@ -343,21 +334,19 @@ timestamp_t ICUDateFunc::FromNaive(icu::Calendar *calendar, timestamp_t naive) {
 	return ICUFromNaiveTimestamp::Operation(calendar, naive);
 }
 
-void RegisterICUTimeZoneFunctions(ClientContext &context) {
+void RegisterICUTimeZoneFunctions(DatabaseInstance &db) {
 	//	Table functions
-	auto &catalog = Catalog::GetSystemCatalog(context);
 	TableFunction tz_names("pg_timezone_names", {}, ICUTimeZoneFunction, ICUTimeZoneBind, ICUTimeZoneInit);
-	CreateTableFunctionInfo tz_names_info(std::move(tz_names));
-	catalog.CreateTableFunction(context, tz_names_info);
+	ExtensionUtil::RegisterFunction(db, tz_names);
 
 	//	Scalar functions
-	ICUTimeZoneFunc::AddFunction("timezone", context);
-	ICULocalTimestampFunc::AddFunction("current_localtimestamp", context);
-	ICULocalTimeFunc::AddFunction("current_localtime", context);
+	ICUTimeZoneFunc::AddFunction("timezone", db);
+	ICULocalTimestampFunc::AddFunction("current_localtimestamp", db);
+	ICULocalTimeFunc::AddFunction("current_localtime", db);
 
 	// 	Casts
-	ICUFromNaiveTimestamp::AddCasts(context);
-	ICUToNaiveTimestamp::AddCasts(context);
+	ICUFromNaiveTimestamp::AddCasts(db);
+	ICUToNaiveTimestamp::AddCasts(db);
 }
 
 } // namespace duckdb

package/src/duckdb/extension/icu/icu_extension.cpp

@@ -8,6 +8,7 @@
 #include "duckdb/main/config.hpp"
 #include "duckdb/main/connection.hpp"
 #include "duckdb/main/database.hpp"
+#include "duckdb/main/extension_util.hpp"
 #include "duckdb/parser/parsed_data/create_collation_info.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
@@ -220,11 +221,9 @@ static void SetICUCalendar(ClientContext &context, SetScope scope, Value &parame
 	}
 }
 
-void IcuExtension::Load(DuckDB &db) {
-	Connection con(db);
-	con.BeginTransaction();
-
-	auto &catalog = Catalog::GetSystemCatalog(*con.context);
+void IcuExtension::Load(DuckDB &ddb) {
+	auto &db = *ddb.instance;
+	auto &catalog = Catalog::GetSystemCatalog(db);
 
 	// iterate over all the collations
 	int32_t count;
@@ -241,17 +240,14 @@ void IcuExtension::Load(DuckDB &db) {
 		collation = StringUtil::Lower(collation);
 
 		CreateCollationInfo info(collation, GetICUFunction(collation), false, true);
-		info.on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-		catalog.CreateCollation(*con.context, info);
+		ExtensionUtil::RegisterCollation(db, info);
 	}
 	ScalarFunction sort_key("icu_sort_key", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::VARCHAR,
 	                        ICUCollateFunction, ICUSortKeyBind);
-
-	CreateScalarFunctionInfo sort_key_info(std::move(sort_key));
-	catalog.CreateFunction(*con.context, sort_key_info);
+	ExtensionUtil::RegisterFunction(db, sort_key);
 
 	// Time Zones
-	auto &config = DBConfig::GetConfig(*db.instance);
+	auto &config = DBConfig::GetConfig(db);
 	duckdb::unique_ptr<icu::TimeZone> tz(icu::TimeZone::createDefault());
 	icu::UnicodeString tz_id;
 	std::string tz_string;
@@ -259,16 +255,16 @@ void IcuExtension::Load(DuckDB &db) {
 	config.AddExtensionOption("TimeZone", "The current time zone", LogicalType::VARCHAR, Value(tz_string),
 	                          SetICUTimeZone);
 
-	RegisterICUDateAddFunctions(*con.context);
-	RegisterICUDatePartFunctions(*con.context);
-	RegisterICUDateSubFunctions(*con.context);
-	RegisterICUDateTruncFunctions(*con.context);
-	RegisterICUMakeDateFunctions(*con.context);
-	RegisterICUTableRangeFunctions(*con.context);
-	RegisterICUListRangeFunctions(*con.context);
-	RegisterICUStrptimeFunctions(*con.context);
-	RegisterICUTimeBucketFunctions(*con.context);
-	RegisterICUTimeZoneFunctions(*con.context);
+	RegisterICUDateAddFunctions(db);
+	RegisterICUDatePartFunctions(db);
+	RegisterICUDateSubFunctions(db);
+	RegisterICUDateTruncFunctions(db);
+	RegisterICUMakeDateFunctions(db);
+	RegisterICUTableRangeFunctions(db);
+	RegisterICUListRangeFunctions(db);
+	RegisterICUStrptimeFunctions(db);
+	RegisterICUTimeBucketFunctions(db);
+	RegisterICUTimeZoneFunctions(db);
 
 	// Calendars
 	UErrorCode status = U_ZERO_ERROR;
@@ -277,10 +273,7 @@ void IcuExtension::Load(DuckDB &db) {
 	                          SetICUCalendar);
 
 	TableFunction cal_names("icu_calendar_names", {}, ICUCalendarFunction, ICUCalendarBind, ICUCalendarInit);
-	CreateTableFunctionInfo cal_names_info(std::move(cal_names));
-	catalog.CreateTableFunction(*con.context, cal_names_info);
-
-	con.Commit();
+	ExtensionUtil::RegisterFunction(db, cal_names);
 }
 
 std::string IcuExtension::Name() {

package/src/duckdb/extension/icu/include/icu-dateadd.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUDateAddFunctions(ClientContext &context);
+void RegisterICUDateAddFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-datepart.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUDatePartFunctions(ClientContext &context);
+void RegisterICUDatePartFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-datesub.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUDateSubFunctions(ClientContext &context);
+void RegisterICUDateSubFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-datetrunc.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUDateTruncFunctions(ClientContext &context);
+void RegisterICUDateTruncFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-list-range.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUListRangeFunctions(ClientContext &context);
+void RegisterICUListRangeFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-makedate.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUMakeDateFunctions(ClientContext &context);
+void RegisterICUMakeDateFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-strptime.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUStrptimeFunctions(ClientContext &context);
+void RegisterICUStrptimeFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-table-range.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUTableRangeFunctions(ClientContext &context);
+void RegisterICUTableRangeFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-timebucket.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUTimeBucketFunctions(ClientContext &context);
+void RegisterICUTimeBucketFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/icu/include/icu-timezone.hpp

@@ -12,6 +12,6 @@
 
 namespace duckdb {
 
-void RegisterICUTimeZoneFunctions(ClientContext &context);
+void RegisterICUTimeZoneFunctions(DatabaseInstance &db);
 
 } // namespace duckdb

package/src/duckdb/extension/json/json_functions/read_json.cpp

@@ -229,6 +229,21 @@ unique_ptr<FunctionData> ReadJSONBind(ClientContext &context, TableFunctionBindI
 	transform_options.error_unknown_key = bind_data->auto_detect && !bind_data->ignore_errors;
 	transform_options.delay_error = true;
 
+	if (bind_data->auto_detect) {
+		// JSON may contain columns such as "id" and "Id", which are duplicates for us due to case-insensitivity
+		// We rename them so we can parse the file anyway. Note that we can't change bind_data->names,
+		// because the JSON reader gets columns by exact name, not position
+		case_insensitive_map_t<idx_t> name_count_map;
+		for (auto &name : names) {
+			auto it = name_count_map.find(name);
+			if (it == name_count_map.end()) {
+				name_count_map[name] = 1;
+			} else {
+				name = StringUtil::Format("%s_%llu", name, it->second++);
+			}
+		}
+	}
+
 	return std::move(bind_data);
 }
 

package/src/duckdb/src/catalog/catalog.cpp

@@ -479,6 +479,8 @@ bool Catalog::AutoLoadExtensionByCatalogEntry(ClientContext &context, CatalogTyp
 			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
 		} else if (type == CatalogType::TYPE_ENTRY) {
 			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
+		} else if (type == CatalogType::COLLATION_ENTRY) {
+			extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COLLATIONS);
 		}
 
 		if (!extension_name.empty() && ExtensionHelper::CanAutoloadExtension(extension_name)) {
@@ -536,6 +538,8 @@ CatalogException Catalog::CreateMissingEntryException(ClientContext &context, co
 		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
 	} else if (type == CatalogType::COPY_FUNCTION_ENTRY) {
 		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
+	} else if (type == CatalogType::COLLATION_ENTRY) {
+		extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COLLATIONS);
 	}
 
 	// if we found an extension that can handle this catalog entry, create an error hinting the user

package/src/duckdb/src/core_functions/aggregate/holistic/quantile.cpp

@@ -288,12 +288,40 @@ struct QuantileCompare {
 	}
 };
 
+//	Avoid using naked Values in inner loops...
+struct QuantileValue {
+	explicit QuantileValue(const Value &v) : val(v), dbl(v.GetValue<double>()) {
+		const auto &type = val.type();
+		switch (type.id()) {
+		case LogicalTypeId::DECIMAL: {
+			integral = IntegralValue::Get(v);
+			scaling = Hugeint::POWERS_OF_TEN[DecimalType::GetScale(type)];
+			break;
+		}
+		default:
+			break;
+		}
+	}
+
+	Value val;
+
+	//	DOUBLE
+	double dbl;
+
+	//	DECIMAL
+	hugeint_t integral;
+	hugeint_t scaling;
+};
+
+bool operator==(const QuantileValue &x, const QuantileValue &y) {
+	return x.val == y.val;
+}
+
 // Continuous interpolation
 template <bool DISCRETE>
 struct Interpolator {
-	Interpolator(const Value &q, const idx_t n_p, const bool desc_p)
-	    : desc(desc_p), RN((double)(n_p - 1) * q.GetValue<double>()), FRN(floor(RN)), CRN(ceil(RN)), begin(0),
-	      end(n_p) {
+	Interpolator(const QuantileValue &q, const idx_t n_p, const bool desc_p)
+	    : desc(desc_p), RN((double)(n_p - 1) * q.dbl), FRN(floor(RN)), CRN(ceil(RN)), begin(0), end(n_p) {
 	}
 
 	template <class INPUT_TYPE, class TARGET_TYPE, typename ACCESSOR = QuantileDirect<INPUT_TYPE>>
@@ -336,21 +364,20 @@ struct Interpolator {
 // Discrete "interpolation"
 template <>
 struct Interpolator<true> {
-	static inline idx_t Index(const Value &q, const idx_t n) {
+	static inline idx_t Index(const QuantileValue &q, const idx_t n) {
 		idx_t floored;
-		const auto &type = q.type();
-		switch (type.id()) {
+		switch (q.val.type().id()) {
 		case LogicalTypeId::DECIMAL: {
 			//	Integer arithmetic for accuracy
-			const auto integral = IntegralValue::Get(q);
-			const auto scaling = Hugeint::POWERS_OF_TEN[DecimalType::GetScale(type)];
+			const auto integral = q.integral;
+			const auto scaling = q.scaling;
 			const auto scaled_q = DecimalMultiplyOverflowCheck::Operation<hugeint_t, hugeint_t, hugeint_t>(n, integral);
 			const auto scaled_n = DecimalMultiplyOverflowCheck::Operation<hugeint_t, hugeint_t, hugeint_t>(n, scaling);
 			floored = Cast::Operation<hugeint_t, idx_t>((scaled_n - scaled_q) / scaling);
 			break;
 		}
 		default:
-			const auto scaled_q = (double)(n * q.GetValue<double>());
+			const auto scaled_q = (double)(n * q.dbl);
 			floored = floor(n - scaled_q);
 			break;
 		}
@@ -358,7 +385,7 @@ struct Interpolator<true> {
 		return MaxValue<idx_t>(1, n - floored) - 1;
 	}
 
-	Interpolator(const Value &q, const idx_t n_p, bool desc_p)
+	Interpolator(const QuantileValue &q, const idx_t n_p, bool desc_p)
 	    : desc(desc_p), FRN(Index(q, n_p)), CRN(FRN), begin(0), end(n_p) {
 	}
 
@@ -420,17 +447,18 @@ struct QuantileBindData : public FunctionData {
 	}
 
 	explicit QuantileBindData(const Value &quantile_p)
-	    : quantiles(1, QuantileAbs(quantile_p)), order(1, 0), desc(quantile_p < 0) {
+	    : quantiles(1, QuantileValue(QuantileAbs(quantile_p))), order(1, 0), desc(quantile_p < 0) {
 	}
 
 	explicit QuantileBindData(const vector<Value> &quantiles_p) {
+		vector<Value> normalised;
 		size_t pos = 0;
 		size_t neg = 0;
 		for (idx_t i = 0; i < quantiles_p.size(); ++i) {
 			const auto &q = quantiles_p[i];
 			pos += (q > 0);
 			neg += (q < 0);
-			quantiles.emplace_back(QuantileAbs(q));
+			normalised.emplace_back(QuantileAbs(q));
 			order.push_back(i);
 		}
 		if (pos && neg) {
@@ -438,8 +466,12 @@ struct QuantileBindData : public FunctionData {
 		}
 		desc = (neg > 0);
 
-		IndirectLess<Value> lt(quantiles.data());
+		IndirectLess<Value> lt(normalised.data());
 		std::sort(order.begin(), order.end(), lt);
+
+		for (const auto &q : normalised) {
+			quantiles.emplace_back(QuantileValue(q));
+		}
 	}
 
 	QuantileBindData(const QuantileBindData &other) : order(other.order), desc(other.desc) {
@@ -460,16 +492,24 @@ struct QuantileBindData : public FunctionData {
 	static void Serialize(Serializer &serializer, const optional_ptr<FunctionData> bind_data_p,
 	                      const AggregateFunction &function) {
 		auto &bind_data = bind_data_p->Cast<QuantileBindData>();
-		serializer.WriteProperty(100, "quantiles", bind_data.quantiles);
+		vector<Value> raw;
+		for (const auto &q : bind_data.quantiles) {
+			raw.emplace_back(q.val);
+		}
+		serializer.WriteProperty(100, "quantiles", raw);
 		serializer.WriteProperty(101, "order", bind_data.order);
 		serializer.WriteProperty(102, "desc", bind_data.desc);
 	}
 
 	static unique_ptr<FunctionData> Deserialize(Deserializer &deserializer, AggregateFunction &function) {
 		auto result = make_uniq<QuantileBindData>();
-		deserializer.ReadProperty(100, "quantiles", result->quantiles);
+		vector<Value> raw;
+		deserializer.ReadProperty(100, "quantiles", raw);
 		deserializer.ReadProperty(101, "order", result->order);
 		deserializer.ReadProperty(102, "desc", result->desc);
+		for (const auto &r : raw) {
+			result->quantiles.emplace_back(QuantileValue(r));
+		}
 		return std::move(result);
 	}
 
@@ -478,7 +518,7 @@ struct QuantileBindData : public FunctionData {
 		throw NotImplementedException("FIXME: serializing quantiles with decimals is not supported right now");
 	}
 
-	vector<Value> quantiles;
+	vector<QuantileValue> quantiles;
 	vector<idx_t> order;
 	bool desc;
 };
@@ -566,7 +606,7 @@ struct QuantileScalarOperation : public QuantileOperation {
 		auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
 
 		// Find the two positions needed
-		const auto q = bind_data.quantiles[0];
+		const auto &q = bind_data.quantiles[0];
 
 		bool replace = false;
 		if (frame.start == prev.start + 1 && frame.end == prev.end + 1) {
@@ -1041,7 +1081,11 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 			return;
 		}
 		using SAVE_TYPE = typename STATE::SaveType;
-		Interpolator<false> interp(0.5, state.v.size(), false);
+		D_ASSERT(finalize_data.input.bind_data);
+		auto &bind_data = finalize_data.input.bind_data->Cast<QuantileBindData>();
+		D_ASSERT(bind_data.quantiles.size() == 1);
+		const auto &q = bind_data.quantiles[0];
+		Interpolator<false> interp(q, state.v.size(), false);
 		const auto med = interp.template Operation<SAVE_TYPE, MEDIAN_TYPE>(state.v.data(), finalize_data.result);
 
 		MadAccessor<SAVE_TYPE, T, MEDIAN_TYPE> accessor(med);
@@ -1050,8 +1094,8 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 
 	template <class STATE, class INPUT_TYPE, class RESULT_TYPE>
 	static void Window(const INPUT_TYPE *data, const ValidityMask &fmask, const ValidityMask &dmask,
-	                   AggregateInputData &, STATE &state, const FrameBounds &frame, const FrameBounds &prev,
-	                   Vector &result, idx_t ridx, idx_t bias) {
+	                   AggregateInputData &aggr_input_data, STATE &state, const FrameBounds &frame,
+	                   const FrameBounds &prev, Vector &result, idx_t ridx, idx_t bias) {
 		auto rdata = FlatVector::GetData<RESULT_TYPE>(result);
 		auto &rmask = FlatVector::Validity(result);
 
@@ -1079,7 +1123,10 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 		std::partition(index2, index2 + state.pos, included);
 
 		// Find the two positions needed for the median
-		const float q = 0.5;
+		D_ASSERT(aggr_input_data.bind_data);
+		auto &bind_data = aggr_input_data.bind_data->Cast<QuantileBindData>();
+		D_ASSERT(bind_data.quantiles.size() == 1);
+		const auto &q = bind_data.quantiles[0];
 
 		bool replace = false;
 		if (frame.start == prev.start + 1 && frame.end == prev.end + 1) {
@@ -1124,12 +1171,18 @@ struct MedianAbsoluteDeviationOperation : public QuantileOperation {
 	}
 };
 
+unique_ptr<FunctionData> BindMedian(ClientContext &context, AggregateFunction &function,
+                                    vector<unique_ptr<Expression>> &arguments) {
+	return make_uniq<QuantileBindData>(Value::DECIMAL(int16_t(5), 2, 1));
+}
+
 template <typename INPUT_TYPE, typename MEDIAN_TYPE, typename TARGET_TYPE>
 AggregateFunction GetTypedMedianAbsoluteDeviationAggregateFunction(const LogicalType &input_type,
                                                                    const LogicalType &target_type) {
 	using STATE = QuantileState<INPUT_TYPE>;
 	using OP = MedianAbsoluteDeviationOperation<MEDIAN_TYPE>;
 	auto fun = AggregateFunction::UnaryAggregateDestructor<STATE, INPUT_TYPE, TARGET_TYPE, OP>(input_type, target_type);
+	fun.bind = BindMedian;
 	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	fun.window = AggregateFunction::UnaryWindow<STATE, INPUT_TYPE, TARGET_TYPE, OP>;
 	return fun;
@@ -1173,11 +1226,6 @@ AggregateFunction GetMedianAbsoluteDeviationAggregateFunction(const LogicalType
 	}
 }
 
-unique_ptr<FunctionData> BindMedian(ClientContext &context, AggregateFunction &function,
-                                    vector<unique_ptr<Expression>> &arguments) {
-	return make_uniq<QuantileBindData>(Value::DECIMAL(int16_t(5), 2, 1));
-}
-
 unique_ptr<FunctionData> BindMedianDecimal(ClientContext &context, AggregateFunction &function,
                                            vector<unique_ptr<Expression>> &arguments) {
 	auto bind_data = BindMedian(context, function, arguments);
@@ -1195,7 +1243,7 @@ unique_ptr<FunctionData> BindMedianAbsoluteDeviationDecimal(ClientContext &conte
 	function = GetMedianAbsoluteDeviationAggregateFunction(arguments[0]->return_type);
 	function.name = "mad";
 	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
-	return nullptr;
+	return BindMedian(context, function, arguments);
 }
 
 static const Value &CheckQuantile(const Value &quantile_val) {

package/src/duckdb/src/core_functions/function_list.cpp

@@ -281,7 +281,7 @@ static StaticFunctionDefinition internal_functions[] = {
 	DUCKDB_SCALAR_FUNCTION(RightFun),
 	DUCKDB_SCALAR_FUNCTION(RightGraphemeFun),
 	DUCKDB_SCALAR_FUNCTION_SET(RoundFun),
-	DUCKDB_SCALAR_FUNCTION_ALIAS(RowFun),
+	DUCKDB_SCALAR_FUNCTION(RowFun),
 	DUCKDB_SCALAR_FUNCTION(RpadFun),
 	DUCKDB_SCALAR_FUNCTION_SET(RtrimFun),
 	DUCKDB_SCALAR_FUNCTION_SET(SecondsFun),

package/src/duckdb/src/core_functions/scalar/struct/struct_pack.cpp

@@ -30,6 +30,7 @@ static void StructPackFunction(DataChunk &args, ExpressionState &state, Vector &
 	result.Verify(args.size());
 }
 
+template <bool IS_STRUCT_PACK>
 static unique_ptr<FunctionData> StructPackBind(ClientContext &context, ScalarFunction &bound_function,
                                                vector<unique_ptr<Expression>> &arguments) {
 	case_insensitive_set_t name_collision_set;
@@ -39,25 +40,20 @@ static unique_ptr<FunctionData> StructPackBind(ClientContext &context, ScalarFun
 		throw Exception("Can't pack nothing into a struct");
 	}
 	child_list_t<LogicalType> struct_children;
-	bool unnamed = false;
 	for (idx_t i = 0; i < arguments.size(); i++) {
 		auto &child = arguments[i];
-		if (child->alias.empty()) {
-			if (bound_function.name == "struct_pack") {
+		string alias;
+		if (IS_STRUCT_PACK) {
+			if (child->alias.empty()) {
 				throw BinderException("Need named argument for struct pack, e.g. STRUCT_PACK(a := b)");
-			} else {
-				D_ASSERT(bound_function.name == "row");
-				if (i > 1) {
-					D_ASSERT(unnamed);
-				}
-				unnamed = true;
 			}
+			alias = child->alias;
+			if (name_collision_set.find(alias) != name_collision_set.end()) {
+				throw BinderException("Duplicate struct entry name \"%s\"", alias);
+			}
+			name_collision_set.insert(alias);
 		}
-		if (!child->alias.empty() && name_collision_set.find(child->alias) != name_collision_set.end()) {
-			throw BinderException("Duplicate struct entry name \"%s\"", child->alias);
-		}
-		name_collision_set.insert(child->alias);
-		struct_children.push_back(make_pair(child->alias, arguments[i]->return_type));
+		struct_children.push_back(make_pair(alias, arguments[i]->return_type));
 	}
 
 	// this is more for completeness reasons
@@ -75,10 +71,10 @@ unique_ptr<BaseStatistics> StructPackStats(ClientContext &context, FunctionStati
 	return struct_stats.ToUnique();
 }
 
-ScalarFunction StructPackFun::GetFunction() {
-	// the arguments and return types are actually set in the binder function
-	ScalarFunction fun("struct_pack", {}, LogicalTypeId::STRUCT, StructPackFunction, StructPackBind, nullptr,
-	                   StructPackStats);
+template <bool IS_STRUCT_PACK>
+ScalarFunction GetStructPackFunction() {
+	ScalarFunction fun(IS_STRUCT_PACK ? "struct_pack" : "row", {}, LogicalTypeId::STRUCT, StructPackFunction,
+	                   StructPackBind<IS_STRUCT_PACK>, nullptr, StructPackStats);
 	fun.varargs = LogicalType::ANY;
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 	fun.serialize = VariableReturnBindData::Serialize;
@@ -86,4 +82,12 @@ ScalarFunction StructPackFun::GetFunction() {
 	return fun;
 }
 
+ScalarFunction StructPackFun::GetFunction() {
+	return GetStructPackFunction<true>();
+}
+
+ScalarFunction RowFun::GetFunction() {
+	return GetStructPackFunction<false>();
+}
+
 } // namespace duckdb

package/src/duckdb/src/execution/operator/schema/physical_attach.cpp

@@ -56,7 +56,10 @@ SourceResultType PhysicalAttach::GetData(ExecutionContext &context, DataChunk &c
 
 	// if we are loading a database type from an extension - check if that extension is loaded
 	if (!type.empty()) {
-		if (!db.ExtensionIsLoaded(type)) {
+		if (!Catalog::TryAutoLoad(context.client, type)) {
+			// FIXME: Here it might be preferrable to use an AutoLoadOrThrow kind of function
+			// so that either there will be success or a message to throw, and load will be
+			// attempted only once respecting the autoloading options
 			ExtensionHelper::LoadExternalExtension(context.client, type);
 		}
 	}