duckdb 0.7.2-dev2740.0 → 0.7.2-dev2867.0

package/binding.gyp

@@ -36,6 +36,25 @@
                 "src/duckdb/src/common/vector_operations/vector_copy.cpp", 
                 "src/duckdb/src/common/vector_operations/vector_hash.cpp", 
                 "src/duckdb/src/common/vector_operations/vector_storage.cpp", 
+                "src/duckdb/ub_src_core_functions_aggregate_algebraic.cpp", 
+                "src/duckdb/ub_src_core_functions_aggregate_distributive.cpp", 
+                "src/duckdb/ub_src_core_functions_aggregate_holistic.cpp", 
+                "src/duckdb/ub_src_core_functions_aggregate_nested.cpp", 
+                "src/duckdb/ub_src_core_functions_aggregate_regression.cpp", 
+                "src/duckdb/ub_src_core_functions.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_bit.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_blob.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_date.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_enum.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_generic.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_list.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_map.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_math.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_operators.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_random.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_string.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_struct.cpp", 
+                "src/duckdb/ub_src_core_functions_scalar_union.cpp", 
                 "src/duckdb/ub_src_execution.cpp", 
                 "src/duckdb/ub_src_execution_expression_executor.cpp", 
                 "src/duckdb/ub_src_execution_index_art.cpp", 
@@ -51,31 +70,20 @@
                 "src/duckdb/ub_src_execution_operator_schema.cpp", 
                 "src/duckdb/ub_src_execution_operator_set.cpp", 
                 "src/duckdb/ub_src_execution_physical_plan.cpp", 
-                "src/duckdb/ub_src_function_aggregate_algebraic.cpp", 
-                "src/duckdb/ub_src_function_aggregate.cpp", 
                 "src/duckdb/ub_src_function_aggregate_distributive.cpp", 
-                "src/duckdb/ub_src_function_aggregate_holistic.cpp", 
-                "src/duckdb/ub_src_function_aggregate_nested.cpp", 
-                "src/duckdb/ub_src_function_aggregate_regression.cpp", 
+                "src/duckdb/ub_src_function_aggregate.cpp", 
                 "src/duckdb/ub_src_function.cpp", 
                 "src/duckdb/ub_src_function_cast.cpp", 
                 "src/duckdb/ub_src_function_pragma.cpp", 
-                "src/duckdb/ub_src_function_scalar_bit.cpp", 
-                "src/duckdb/ub_src_function_scalar_blob.cpp", 
-                "src/duckdb/ub_src_function_scalar_date.cpp", 
-                "src/duckdb/ub_src_function_scalar.cpp", 
-                "src/duckdb/ub_src_function_scalar_enum.cpp", 
                 "src/duckdb/ub_src_function_scalar_generic.cpp", 
+                "src/duckdb/ub_src_function_scalar.cpp", 
                 "src/duckdb/ub_src_function_scalar_list.cpp", 
-                "src/duckdb/ub_src_function_scalar_map.cpp", 
-                "src/duckdb/ub_src_function_scalar_math.cpp", 
                 "src/duckdb/ub_src_function_scalar_operators.cpp", 
                 "src/duckdb/ub_src_function_scalar_sequence.cpp", 
                 "src/duckdb/ub_src_function_scalar_string.cpp", 
                 "src/duckdb/ub_src_function_scalar_string_regexp.cpp", 
                 "src/duckdb/ub_src_function_scalar_struct.cpp", 
                 "src/duckdb/ub_src_function_scalar_system.cpp", 
-                "src/duckdb/ub_src_function_scalar_union.cpp", 
                 "src/duckdb/ub_src_function_table.cpp", 
                 "src/duckdb/ub_src_function_table_system.cpp", 
                 "src/duckdb/ub_src_function_table_version.cpp", 

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev2740.0",
+  "version": "0.7.2-dev2867.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

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

@@ -203,6 +203,14 @@ struct ICUDatePart : public ICUDateFunc {
 		return Date::EpochToDate(ExtractEpoch(calendar, 0));
 	}
 
+	static string_t MonthName(icu::Calendar *calendar, const uint64_t micros) {
+		return Date::MONTH_NAMES[ExtractMonth(calendar, micros) - 1];
+	}
+
+	static string_t DayName(icu::Calendar *calendar, const uint64_t micros) {
+		return Date::DAY_NAMES[ExtractDayOfWeek(calendar, micros)];
+	}
+
 	template <typename RESULT_TYPE>
 	struct BindAdapterData : public BindData {
 		using result_t = RESULT_TYPE;
@@ -246,7 +254,7 @@ struct ICUDatePart : public ICUDateFunc {
 				                                                         return info.adapters[0](calendar, micros);
 			                                                         } else {
 				                                                         mask.SetInvalid(idx);
-				                                                         return RESULT_TYPE(0);
+				                                                         return RESULT_TYPE();
 			                                                         }
 		                                                         });
 	}
@@ -482,6 +490,44 @@ struct ICUDatePart : public ICUDateFunc {
 		CreateScalarFunctionInfo func_info(set);
 		catalog.AddFunction(context, func_info);
 	}
+
+	static unique_ptr<FunctionData> BindMonthName(ClientContext &context, ScalarFunction &bound_function,
+	                                              vector<unique_ptr<Expression>> &arguments) {
+		using data_t = BindAdapterData<string_t>;
+		return BindAdapter<data_t>(context, bound_function, arguments, MonthName);
+	}
+
+	template <typename INPUT_TYPE>
+	static ScalarFunction GetMonthNameFunction(const LogicalType &temporal_type) {
+		return ScalarFunction({temporal_type}, LogicalType::VARCHAR, UnaryTimestampFunction<INPUT_TYPE, string_t>,
+		                      BindMonthName);
+	}
+	static void AddMonthNameFunctions(const string &name, ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+		ScalarFunctionSet set(name);
+		set.AddFunction(GetMonthNameFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
+		CreateScalarFunctionInfo func_info(set);
+		catalog.AddFunction(context, func_info);
+	}
+
+	static unique_ptr<FunctionData> BindDayName(ClientContext &context, ScalarFunction &bound_function,
+	                                            vector<unique_ptr<Expression>> &arguments) {
+		using data_t = BindAdapterData<string_t>;
+		return BindAdapter<data_t>(context, bound_function, arguments, DayName);
+	}
+
+	template <typename INPUT_TYPE>
+	static ScalarFunction GetDayNameFunction(const LogicalType &temporal_type) {
+		return ScalarFunction({temporal_type}, LogicalType::VARCHAR, UnaryTimestampFunction<INPUT_TYPE, string_t>,
+		                      BindDayName);
+	}
+	static void AddDayNameFunctions(const string &name, ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+		ScalarFunctionSet set(name);
+		set.AddFunction(GetDayNameFunction<timestamp_t>(LogicalType::TIMESTAMP_TZ));
+		CreateScalarFunctionInfo func_info(set);
+		catalog.AddFunction(context, func_info);
+	}
 };
 
 void RegisterICUDatePartFunctions(ClientContext &context) {
@@ -520,6 +566,10 @@ void RegisterICUDatePartFunctions(ClientContext &context) {
 	//  register the last_day function
 	ICUDatePart::AddLastDayFunctions("last_day", context);
 
+	// register the dayname/monthname functions
+	ICUDatePart::AddMonthNameFunctions("monthname", context);
+	ICUDatePart::AddDayNameFunctions("dayname", context);
+
 	// finally the actual date_part function
 	ICUDatePart::AddDatePartFunctions("date_part", context);
 	ICUDatePart::AddDatePartFunctions("datepart", context);

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

@@ -9,7 +9,7 @@
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/vector_operations/binary_executor.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/scalar/strftime.hpp"
+#include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"

package/src/duckdb/extension/json/include/json_functions.hpp

@@ -8,9 +8,7 @@
 
 #pragma once
 
-#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
-#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "duckdb/main/extension_util.hpp"
 #include "json_common.hpp"
 
 namespace duckdb {
@@ -66,40 +64,40 @@ public:
 
 class JSONFunctions {
 public:
-	static vector<CreateScalarFunctionInfo> GetScalarFunctions();
-	static vector<CreatePragmaFunctionInfo> GetPragmaFunctions();
-	static vector<CreateTableFunctionInfo> GetTableFunctions();
+	static vector<ScalarFunctionSet> GetScalarFunctions();
+	static vector<PragmaFunctionSet> GetPragmaFunctions();
+	static vector<TableFunctionSet> GetTableFunctions();
 	static unique_ptr<TableRef> ReadJSONReplacement(ClientContext &context, const string &table_name,
 	                                                ReplacementScanData *data);
 	static TableFunction GetReadJSONTableFunction(shared_ptr<JSONScanInfo> function_info);
-	static CreateCopyFunctionInfo GetJSONCopyFunction();
+	static CopyFunction GetJSONCopyFunction();
 	static void RegisterCastFunctions(CastFunctionSet &casts);
 
 private:
 	// Scalar functions
-	static CreateScalarFunctionInfo GetExtractFunction();
-	static CreateScalarFunctionInfo GetExtractStringFunction();
-
-	static CreateScalarFunctionInfo GetArrayFunction();
-	static CreateScalarFunctionInfo GetObjectFunction();
-	static CreateScalarFunctionInfo GetToJSONFunction();
-	static CreateScalarFunctionInfo GetArrayToJSONFunction();
-	static CreateScalarFunctionInfo GetRowToJSONFunction();
-	static CreateScalarFunctionInfo GetMergePatchFunction();
-
-	static CreateScalarFunctionInfo GetStructureFunction();
-	static CreateScalarFunctionInfo GetTransformFunction();
-	static CreateScalarFunctionInfo GetTransformStrictFunction();
-
-	static CreateScalarFunctionInfo GetArrayLengthFunction();
-	static CreateScalarFunctionInfo GetContainsFunction();
-	static CreateScalarFunctionInfo GetKeysFunction();
-	static CreateScalarFunctionInfo GetTypeFunction();
-	static CreateScalarFunctionInfo GetValidFunction();
-	static CreateScalarFunctionInfo GetSerializeSqlFunction();
-	static CreateScalarFunctionInfo GetDeserializeSqlFunction();
-
-	static CreatePragmaFunctionInfo GetExecuteJsonSerializedSqlPragmaFunction();
+	static ScalarFunctionSet GetExtractFunction();
+	static ScalarFunctionSet GetExtractStringFunction();
+
+	static ScalarFunctionSet GetArrayFunction();
+	static ScalarFunctionSet GetObjectFunction();
+	static ScalarFunctionSet GetToJSONFunction();
+	static ScalarFunctionSet GetArrayToJSONFunction();
+	static ScalarFunctionSet GetRowToJSONFunction();
+	static ScalarFunctionSet GetMergePatchFunction();
+
+	static ScalarFunctionSet GetStructureFunction();
+	static ScalarFunctionSet GetTransformFunction();
+	static ScalarFunctionSet GetTransformStrictFunction();
+
+	static ScalarFunctionSet GetArrayLengthFunction();
+	static ScalarFunctionSet GetContainsFunction();
+	static ScalarFunctionSet GetKeysFunction();
+	static ScalarFunctionSet GetTypeFunction();
+	static ScalarFunctionSet GetValidFunction();
+	static ScalarFunctionSet GetSerializeSqlFunction();
+	static ScalarFunctionSet GetDeserializeSqlFunction();
+
+	static PragmaFunctionSet GetExecuteJsonSerializedSqlPragmaFunction();
 
 	template <class FUNCTION_INFO>
 	static void AddAliases(const vector<string> &names, FUNCTION_INFO fun, vector<FUNCTION_INFO> &functions) {
@@ -111,13 +109,13 @@ private:
 
 private:
 	// Table functions
-	static CreateTableFunctionInfo GetReadJSONObjectsFunction();
-	static CreateTableFunctionInfo GetReadNDJSONObjectsFunction();
-	static CreateTableFunctionInfo GetReadJSONFunction();
-	static CreateTableFunctionInfo GetReadNDJSONFunction();
-	static CreateTableFunctionInfo GetReadJSONAutoFunction();
-	static CreateTableFunctionInfo GetReadNDJSONAutoFunction();
-	static CreateTableFunctionInfo GetExecuteJsonSerializedSqlFunction();
+	static TableFunctionSet GetReadJSONObjectsFunction();
+	static TableFunctionSet GetReadNDJSONObjectsFunction();
+	static TableFunctionSet GetReadJSONFunction();
+	static TableFunctionSet GetReadNDJSONFunction();
+	static TableFunctionSet GetReadJSONAutoFunction();
+	static TableFunctionSet GetReadNDJSONAutoFunction();
+	static TableFunctionSet GetExecuteJsonSerializedSqlFunction();
 };
 
 } // namespace duckdb

package/src/duckdb/extension/json/include/json_scan.hpp

@@ -10,7 +10,7 @@
 
 #include "buffered_json_reader.hpp"
 #include "duckdb/common/mutex.hpp"
-#include "duckdb/function/scalar/strftime.hpp"
+#include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/function/table_function.hpp"
 #include "json_transform.hpp"
 

package/src/duckdb/extension/json/include/json_transform.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/function/scalar/strftime.hpp"
+#include "duckdb/function/scalar/strftime_format.hpp"
 #include "json_common.hpp"
 
 namespace duckdb {

package/src/duckdb/extension/json/json-extension.cpp

@@ -3,13 +3,12 @@
 
 #include "duckdb/catalog/catalog_entry/macro_catalog_entry.hpp"
 #include "duckdb/catalog/default/default_functions.hpp"
+#include "duckdb/main/extension_util.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"
+#include "duckdb/function/copy_function.hpp"
 #include "json_common.hpp"
 #include "json_functions.hpp"
 
@@ -23,34 +22,27 @@ static DefaultMacro json_macros[] = {
     {nullptr, nullptr, {nullptr}, nullptr}};
 
 void JSONExtension::Load(DuckDB &db) {
-	Connection con(db);
-	con.BeginTransaction();
-	auto &context = *con.context;
-	auto &catalog = Catalog::GetSystemCatalog(context);
-
+	auto &db_instance = *db.instance;
 	// JSON type
 	auto json_type = JSONCommon::JSONType();
-	CreateTypeInfo type_info(JSONCommon::JSON_TYPE_NAME, json_type);
-	type_info.temporary = true;
-	type_info.internal = true;
-	catalog.CreateType(context, type_info);
+	ExtensionUtil::RegisterType(db_instance, JSONCommon::JSON_TYPE_NAME, std::move(json_type));
 
 	// JSON casts
-	JSONFunctions::RegisterCastFunctions(DBConfig::GetConfig(context).GetCastFunctions());
+	JSONFunctions::RegisterCastFunctions(DBConfig::GetConfig(db_instance).GetCastFunctions());
 
 	// JSON scalar functions
 	for (auto &fun : JSONFunctions::GetScalarFunctions()) {
-		catalog.CreateFunction(context, fun);
+		ExtensionUtil::RegisterFunction(db_instance, fun);
 	}
 
 	// JSON table functions
 	for (auto &fun : JSONFunctions::GetTableFunctions()) {
-		catalog.CreateTableFunction(context, fun);
+		ExtensionUtil::RegisterFunction(db_instance, fun);
 	}
 
 	// JSON pragma functions
 	for (auto &fun : JSONFunctions::GetPragmaFunctions()) {
-		catalog.CreatePragmaFunction(context, fun);
+		ExtensionUtil::RegisterFunction(db_instance, fun);
 	}
 
 	// JSON replacement scan
@@ -59,15 +51,13 @@ void JSONExtension::Load(DuckDB &db) {
 
 	// JSON copy function
 	auto copy_fun = JSONFunctions::GetJSONCopyFunction();
-	catalog.CreateCopyFunction(context, copy_fun);
+	ExtensionUtil::RegisterFunction(db_instance, std::move(copy_fun));
 
 	// JSON macro's
 	for (idx_t index = 0; json_macros[index].name != nullptr; index++) {
 		auto info = DefaultFunctionGenerator::CreateInternalMacroInfo(json_macros[index]);
-		catalog.CreateFunction(context, *info);
+		ExtensionUtil::RegisterFunction(db_instance, *info);
 	}
-
-	con.Commit();
 }
 
 std::string JSONExtension::Name() {

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

@@ -106,7 +106,7 @@ static duckdb::unique_ptr<FunctionData> CopyFromJSONBind(ClientContext &context,
 	return std::move(bind_data);
 }
 
-CreateCopyFunctionInfo JSONFunctions::GetJSONCopyFunction() {
+CopyFunction JSONFunctions::GetJSONCopyFunction() {
 	CopyFunction function("json");
 	function.extension = "json";
 
@@ -116,7 +116,7 @@ CreateCopyFunctionInfo JSONFunctions::GetJSONCopyFunction() {
 	function.copy_from_function = JSONFunctions::GetReadJSONTableFunction(
 	    make_shared<JSONScanInfo>(JSONScanType::READ_JSON, JSONFormat::AUTO_DETECT, JSONRecordType::RECORDS, false));
 
-	return CreateCopyFunctionInfo(function);
+	return function;
 }
 
 } // namespace duckdb

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

@@ -28,12 +28,11 @@ static void GetArrayLengthFunctionsInternal(ScalarFunctionSet &set, const Logica
 	                               JSONReadManyFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetArrayLengthFunction() {
+ScalarFunctionSet JSONFunctions::GetArrayLengthFunction() {
 	ScalarFunctionSet set("json_array_length");
 	GetArrayLengthFunctionsInternal(set, LogicalType::VARCHAR);
 	GetArrayLengthFunctionsInternal(set, JSONCommon::JSONType());
-
-	return CreateScalarFunctionInfo(std::move(set));
+	return set;
 }
 
 } // namespace duckdb

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

@@ -139,7 +139,7 @@ static void GetContainsFunctionInternal(ScalarFunctionSet &set, const LogicalTyp
 	                               JSONFunctionLocalState::Init));
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetContainsFunction() {
+ScalarFunctionSet JSONFunctions::GetContainsFunction() {
 	ScalarFunctionSet set("json_contains");
 	GetContainsFunctionInternal(set, LogicalType::VARCHAR, LogicalType::VARCHAR);
 	GetContainsFunctionInternal(set, LogicalType::VARCHAR, JSONCommon::JSONType());
@@ -147,7 +147,7 @@ CreateScalarFunctionInfo JSONFunctions::GetContainsFunction() {
 	GetContainsFunctionInternal(set, JSONCommon::JSONType(), JSONCommon::JSONType());
 	// TODO: implement json_contains that accepts path argument as well
 
-	return CreateScalarFunctionInfo(std::move(set));
+	return set;
 }
 
 } // namespace duckdb

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

@@ -515,41 +515,41 @@ static void ToJSONFunction(DataChunk &args, ExpressionState &state, Vector &resu
 	}
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetObjectFunction() {
-	auto fun = ScalarFunction("json_object", {}, JSONCommon::JSONType(), ObjectFunction, JSONObjectBind, nullptr,
-	                          nullptr, JSONFunctionLocalState::Init);
+ScalarFunctionSet JSONFunctions::GetObjectFunction() {
+	ScalarFunction fun("json_object", {}, JSONCommon::JSONType(), ObjectFunction, JSONObjectBind, nullptr, nullptr,
+	                   JSONFunctionLocalState::Init);
 	fun.varargs = LogicalType::ANY;
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return CreateScalarFunctionInfo(fun);
+	return ScalarFunctionSet(fun);
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetArrayFunction() {
-	auto fun = ScalarFunction("json_array", {}, JSONCommon::JSONType(), ArrayFunction, JSONArrayBind, nullptr, nullptr,
-	                          JSONFunctionLocalState::Init);
+ScalarFunctionSet JSONFunctions::GetArrayFunction() {
+	ScalarFunction fun("json_array", {}, JSONCommon::JSONType(), ArrayFunction, JSONArrayBind, nullptr, nullptr,
+	                   JSONFunctionLocalState::Init);
 	fun.varargs = LogicalType::ANY;
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
-	return CreateScalarFunctionInfo(fun);
+	return ScalarFunctionSet(fun);
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetToJSONFunction() {
-	auto fun = ScalarFunction("to_json", {}, JSONCommon::JSONType(), ToJSONFunction, ToJSONBind, nullptr, nullptr,
-	                          JSONFunctionLocalState::Init);
+ScalarFunctionSet JSONFunctions::GetToJSONFunction() {
+	ScalarFunction fun("to_json", {}, JSONCommon::JSONType(), ToJSONFunction, ToJSONBind, nullptr, nullptr,
+	                   JSONFunctionLocalState::Init);
 	fun.varargs = LogicalType::ANY;
-	return CreateScalarFunctionInfo(fun);
+	return ScalarFunctionSet(fun);
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetArrayToJSONFunction() {
-	auto fun = ScalarFunction("array_to_json", {}, JSONCommon::JSONType(), ToJSONFunction, ArrayToJSONBind, nullptr,
-	                          nullptr, JSONFunctionLocalState::Init);
+ScalarFunctionSet JSONFunctions::GetArrayToJSONFunction() {
+	ScalarFunction fun("array_to_json", {}, JSONCommon::JSONType(), ToJSONFunction, ArrayToJSONBind, nullptr, nullptr,
+	                   JSONFunctionLocalState::Init);
 	fun.varargs = LogicalType::ANY;
-	return CreateScalarFunctionInfo(fun);
+	return ScalarFunctionSet(fun);
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetRowToJSONFunction() {
-	auto fun = ScalarFunction("row_to_json", {}, JSONCommon::JSONType(), ToJSONFunction, RowToJSONBind, nullptr,
-	                          nullptr, JSONFunctionLocalState::Init);
+ScalarFunctionSet JSONFunctions::GetRowToJSONFunction() {
+	ScalarFunction fun("row_to_json", {}, JSONCommon::JSONType(), ToJSONFunction, RowToJSONBind, nullptr, nullptr,
+	                   JSONFunctionLocalState::Init);
 	fun.varargs = LogicalType::ANY;
-	return CreateScalarFunctionInfo(fun);
+	return ScalarFunctionSet(fun);
 }
 
 } // namespace duckdb

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

@@ -35,13 +35,12 @@ static void GetExtractFunctionsInternal(ScalarFunctionSet &set, const LogicalTyp
 	                               JSONReadManyFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetExtractFunction() {
+ScalarFunctionSet JSONFunctions::GetExtractFunction() {
 	// Generic extract function
 	ScalarFunctionSet set("json_extract");
 	GetExtractFunctionsInternal(set, LogicalType::VARCHAR);
 	GetExtractFunctionsInternal(set, JSONCommon::JSONType());
-
-	return CreateScalarFunctionInfo(set);
+	return set;
 }
 
 static void GetExtractStringFunctionsInternal(ScalarFunctionSet &set, const LogicalType &input_type) {
@@ -52,13 +51,12 @@ static void GetExtractStringFunctionsInternal(ScalarFunctionSet &set, const Logi
 	                               JSONReadManyFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetExtractStringFunction() {
+ScalarFunctionSet JSONFunctions::GetExtractStringFunction() {
 	// String extract function
 	ScalarFunctionSet set("json_extract_string");
 	GetExtractStringFunctionsInternal(set, LogicalType::VARCHAR);
 	GetExtractStringFunctionsInternal(set, JSONCommon::JSONType());
-
-	return CreateScalarFunctionInfo(set);
+	return set;
 }
 
 } // namespace duckdb

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

@@ -49,12 +49,11 @@ static void GetJSONKeysFunctionsInternal(ScalarFunctionSet &set, const LogicalTy
 	                               JSONReadManyFunctionData::Bind, nullptr, nullptr, JSONFunctionLocalState::Init));
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetKeysFunction() {
+ScalarFunctionSet JSONFunctions::GetKeysFunction() {
 	ScalarFunctionSet set("json_keys");
 	GetJSONKeysFunctionsInternal(set, LogicalType::VARCHAR);
 	GetJSONKeysFunctionsInternal(set, JSONCommon::JSONType());
-
-	return CreateScalarFunctionInfo(std::move(set));
+	return set;
 }
 
 } // namespace duckdb

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

@@ -96,13 +96,13 @@ static void MergePatchFunction(DataChunk &args, ExpressionState &state, Vector &
 	}
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetMergePatchFunction() {
+ScalarFunctionSet JSONFunctions::GetMergePatchFunction() {
 	ScalarFunction fun("json_merge_patch", {}, JSONCommon::JSONType(), MergePatchFunction, JSONMergePatchBind, nullptr,
 	                   nullptr, JSONFunctionLocalState::Init);
 	fun.varargs = LogicalType::ANY;
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
 
-	return CreateScalarFunctionInfo(fun);
+	return ScalarFunctionSet(fun);
 }
 
 } // namespace duckdb

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

@@ -132,7 +132,7 @@ static void JsonSerializeFunction(DataChunk &args, ExpressionState &state, Vecto
 	});
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetSerializeSqlFunction() {
+ScalarFunctionSet JSONFunctions::GetSerializeSqlFunction() {
 	ScalarFunctionSet set("json_serialize_sql");
 	set.AddFunction(ScalarFunction({LogicalType::VARCHAR}, JSONCommon::JSONType(), JsonSerializeFunction,
 	                               JsonSerializeBind, nullptr, nullptr, JSONFunctionLocalState::Init));
@@ -150,7 +150,7 @@ CreateScalarFunctionInfo JSONFunctions::GetSerializeSqlFunction() {
 	                   JSONCommon::JSONType(), JsonSerializeFunction, JsonSerializeBind, nullptr, nullptr,
 	                   JSONFunctionLocalState::Init));
 
-	return CreateScalarFunctionInfo(set);
+	return set;
 }
 
 //----------------------------------------------------------------------
@@ -204,11 +204,11 @@ static void JsonDeserializeFunction(DataChunk &args, ExpressionState &state, Vec
 	});
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetDeserializeSqlFunction() {
+ScalarFunctionSet JSONFunctions::GetDeserializeSqlFunction() {
 	ScalarFunctionSet set("json_deserialize_sql");
 	set.AddFunction(ScalarFunction({JSONCommon::JSONType()}, LogicalType::VARCHAR, JsonDeserializeFunction, nullptr,
 	                               nullptr, nullptr, JSONFunctionLocalState::Init));
-	return CreateScalarFunctionInfo(set);
+	return set;
 }
 
 //----------------------------------------------------------------------
@@ -223,8 +223,8 @@ static string ExecuteJsonSerializedSqlPragmaFunction(ClientContext &context, con
 	return stmt->ToString();
 }
 
-CreatePragmaFunctionInfo JSONFunctions::GetExecuteJsonSerializedSqlPragmaFunction() {
-	return CreatePragmaFunctionInfo(PragmaFunction::PragmaCall(
+PragmaFunctionSet JSONFunctions::GetExecuteJsonSerializedSqlPragmaFunction() {
+	return PragmaFunctionSet(PragmaFunction::PragmaCall(
 	    "json_execute_serialized_sql", ExecuteJsonSerializedSqlPragmaFunction, {LogicalType::VARCHAR}));
 }
 
@@ -270,10 +270,10 @@ struct ExecuteSqlTableFunction {
 	}
 };
 
-CreateTableFunctionInfo JSONFunctions::GetExecuteJsonSerializedSqlFunction() {
+TableFunctionSet JSONFunctions::GetExecuteJsonSerializedSqlFunction() {
 	TableFunction func("json_execute_serialized_sql", {LogicalType::VARCHAR}, ExecuteSqlTableFunction::Function,
 	                   ExecuteSqlTableFunction::Bind);
-	return CreateTableFunctionInfo(func);
+	return TableFunctionSet(func);
 }
 
 } // namespace duckdb

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

@@ -476,11 +476,11 @@ static void GetStructureFunctionInternal(ScalarFunctionSet &set, const LogicalTy
 	                               JSONFunctionLocalState::Init));
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetStructureFunction() {
+ScalarFunctionSet JSONFunctions::GetStructureFunction() {
 	ScalarFunctionSet set("json_structure");
 	GetStructureFunctionInternal(set, LogicalType::VARCHAR);
 	GetStructureFunctionInternal(set, JSONCommon::JSONType());
-	return CreateScalarFunctionInfo(set);
+	return set;
 }
 
 static LogicalType StructureToTypeArray(ClientContext &context, const JSONStructureNode &node, const idx_t max_depth,

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

@@ -685,11 +685,11 @@ static void GetTransformFunctionInternal(ScalarFunctionSet &set, const LogicalTy
 	                               JSONTransformBind, nullptr, nullptr, JSONFunctionLocalState::Init));
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetTransformFunction() {
+ScalarFunctionSet JSONFunctions::GetTransformFunction() {
 	ScalarFunctionSet set("json_transform");
 	GetTransformFunctionInternal(set, LogicalType::VARCHAR);
 	GetTransformFunctionInternal(set, JSONCommon::JSONType());
-	return CreateScalarFunctionInfo(set);
+	return set;
 }
 
 static void GetTransformStrictFunctionInternal(ScalarFunctionSet &set, const LogicalType &input_type) {
@@ -697,11 +697,11 @@ static void GetTransformStrictFunctionInternal(ScalarFunctionSet &set, const Log
 	                               JSONTransformBind, nullptr, nullptr, JSONFunctionLocalState::Init));
 }
 
-CreateScalarFunctionInfo JSONFunctions::GetTransformStrictFunction() {
+ScalarFunctionSet JSONFunctions::GetTransformStrictFunction() {
 	ScalarFunctionSet set("json_transform_strict");
 	GetTransformStrictFunctionInternal(set, LogicalType::VARCHAR);
 	GetTransformStrictFunctionInternal(set, JSONCommon::JSONType());
-	return CreateScalarFunctionInfo(set);
+	return set;
 }
 
 } // namespace duckdb