duckdb 0.7.2-dev2706.0 → 0.7.2-dev2820.0

package/src/duckdb/src/function/table/system/duckdb_functions.cpp

@@ -67,6 +67,9 @@ static unique_ptr<FunctionData> DuckDBFunctionsBind(ClientContext &context, Tabl
 	names.emplace_back("function_oid");
 	return_types.emplace_back(LogicalType::BIGINT);
 
+	names.emplace_back("example");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
 	return nullptr;
 }
 
@@ -105,20 +108,16 @@ struct ScalarFunctionExtractor {
 		return Value("scalar");
 	}
 
-	static Value GetFunctionDescription(ScalarFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
 	static Value GetReturnType(ScalarFunctionCatalogEntry &entry, idx_t offset) {
 		return Value(entry.functions.GetFunctionByOffset(offset).return_type.ToString());
 	}
 
-	static Value GetParameters(ScalarFunctionCatalogEntry &entry, idx_t offset) {
+	static vector<Value> GetParameters(ScalarFunctionCatalogEntry &entry, idx_t offset) {
 		vector<Value> results;
 		for (idx_t i = 0; i < entry.functions.GetFunctionByOffset(offset).arguments.size(); i++) {
 			results.emplace_back("col" + to_string(i));
 		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
+		return results;
 	}
 
 	static Value GetParameterTypes(ScalarFunctionCatalogEntry &entry, idx_t offset) {
@@ -154,20 +153,16 @@ struct AggregateFunctionExtractor {
 		return Value("aggregate");
 	}
 
-	static Value GetFunctionDescription(AggregateFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
 	static Value GetReturnType(AggregateFunctionCatalogEntry &entry, idx_t offset) {
 		return Value(entry.functions.GetFunctionByOffset(offset).return_type.ToString());
 	}
 
-	static Value GetParameters(AggregateFunctionCatalogEntry &entry, idx_t offset) {
+	static vector<Value> GetParameters(AggregateFunctionCatalogEntry &entry, idx_t offset) {
 		vector<Value> results;
 		for (idx_t i = 0; i < entry.functions.GetFunctionByOffset(offset).arguments.size(); i++) {
 			results.emplace_back("col" + to_string(i));
 		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
+		return results;
 	}
 
 	static Value GetParameterTypes(AggregateFunctionCatalogEntry &entry, idx_t offset) {
@@ -203,15 +198,11 @@ struct MacroExtractor {
 		return Value("macro");
 	}
 
-	static Value GetFunctionDescription(ScalarMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
 	static Value GetReturnType(ScalarMacroCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
 
-	static Value GetParameters(ScalarMacroCatalogEntry &entry, idx_t offset) {
+	static vector<Value> GetParameters(ScalarMacroCatalogEntry &entry, idx_t offset) {
 		vector<Value> results;
 		for (auto &param : entry.function->parameters) {
 			D_ASSERT(param->type == ExpressionType::COLUMN_REF);
@@ -221,7 +212,7 @@ struct MacroExtractor {
 		for (auto &param_entry : entry.function->default_parameters) {
 			results.emplace_back(param_entry.first);
 		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
+		return results;
 	}
 
 	static Value GetParameterTypes(ScalarMacroCatalogEntry &entry, idx_t offset) {
@@ -259,15 +250,11 @@ struct TableMacroExtractor {
 		return Value("table_macro");
 	}
 
-	static Value GetFunctionDescription(TableMacroCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
 	static Value GetReturnType(TableMacroCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
 
-	static Value GetParameters(TableMacroCatalogEntry &entry, idx_t offset) {
+	static vector<Value> GetParameters(TableMacroCatalogEntry &entry, idx_t offset) {
 		vector<Value> results;
 		for (auto &param : entry.function->parameters) {
 			D_ASSERT(param->type == ExpressionType::COLUMN_REF);
@@ -277,7 +264,7 @@ struct TableMacroExtractor {
 		for (auto &param_entry : entry.function->default_parameters) {
 			results.emplace_back(param_entry.first);
 		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
+		return results;
 	}
 
 	static Value GetParameterTypes(TableMacroCatalogEntry &entry, idx_t offset) {
@@ -317,15 +304,11 @@ struct TableFunctionExtractor {
 		return Value("table");
 	}
 
-	static Value GetFunctionDescription(TableFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
 	static Value GetReturnType(TableFunctionCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
 
-	static Value GetParameters(TableFunctionCatalogEntry &entry, idx_t offset) {
+	static vector<Value> GetParameters(TableFunctionCatalogEntry &entry, idx_t offset) {
 		vector<Value> results;
 		auto fun = entry.functions.GetFunctionByOffset(offset);
 		for (idx_t i = 0; i < fun.arguments.size(); i++) {
@@ -334,7 +317,7 @@ struct TableFunctionExtractor {
 		for (auto &param : fun.named_parameters) {
 			results.emplace_back(param.first);
 		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
+		return results;
 	}
 
 	static Value GetParameterTypes(TableFunctionCatalogEntry &entry, idx_t offset) {
@@ -373,15 +356,11 @@ struct PragmaFunctionExtractor {
 		return Value("pragma");
 	}
 
-	static Value GetFunctionDescription(PragmaFunctionCatalogEntry &entry, idx_t offset) {
-		return Value();
-	}
-
 	static Value GetReturnType(PragmaFunctionCatalogEntry &entry, idx_t offset) {
 		return Value();
 	}
 
-	static Value GetParameters(PragmaFunctionCatalogEntry &entry, idx_t offset) {
+	static vector<Value> GetParameters(PragmaFunctionCatalogEntry &entry, idx_t offset) {
 		vector<Value> results;
 		auto fun = entry.functions.GetFunctionByOffset(offset);
 
@@ -391,7 +370,7 @@ struct PragmaFunctionExtractor {
 		for (auto &param : fun.named_parameters) {
 			results.emplace_back(param.first);
 		}
-		return Value::LIST(LogicalType::VARCHAR, std::move(results));
+		return results;
 	}
 
 	static Value GetParameterTypes(PragmaFunctionCatalogEntry &entry, idx_t offset) {
@@ -422,7 +401,7 @@ struct PragmaFunctionExtractor {
 };
 
 template <class T, class OP>
-bool ExtractFunctionData(CatalogEntry &entry, idx_t function_idx, DataChunk &output, idx_t output_offset) {
+bool ExtractFunctionData(FunctionEntry &entry, idx_t function_idx, DataChunk &output, idx_t output_offset) {
 	auto &function = entry.Cast<T>();
 	idx_t col = 0;
 
@@ -439,13 +418,18 @@ bool ExtractFunctionData(CatalogEntry &entry, idx_t function_idx, DataChunk &out
 	output.SetValue(col++, output_offset, Value(OP::GetFunctionType()));
 
 	// function_description, LogicalType::VARCHAR
-	output.SetValue(col++, output_offset, OP::GetFunctionDescription(function, function_idx));
+	output.SetValue(col++, output_offset, entry.description.empty() ? Value() : entry.description);
 
 	// return_type, LogicalType::VARCHAR
 	output.SetValue(col++, output_offset, OP::GetReturnType(function, function_idx));
 
 	// parameters, LogicalType::LIST(LogicalType::VARCHAR)
-	output.SetValue(col++, output_offset, OP::GetParameters(function, function_idx));
+	auto parameters = OP::GetParameters(function, function_idx);
+	for (idx_t param_idx = 0; param_idx < function.parameter_names.size() && param_idx < parameters.size();
+	     param_idx++) {
+		parameters[param_idx] = Value(function.parameter_names[param_idx]);
+	}
+	output.SetValue(col++, output_offset, Value::LIST(LogicalType::VARCHAR, std::move(parameters)));
 
 	// parameter_types, LogicalType::LIST(LogicalType::VARCHAR)
 	output.SetValue(col++, output_offset, OP::GetParameterTypes(function, function_idx));
@@ -465,6 +449,9 @@ bool ExtractFunctionData(CatalogEntry &entry, idx_t function_idx, DataChunk &out
 	// function_oid, LogicalType::BIGINT
 	output.SetValue(col++, output_offset, Value::BIGINT(function.oid));
 
+	// example, LogicalType::VARCHAR
+	output.SetValue(col++, output_offset, entry.example.empty() ? Value() : entry.example);
+
 	return function_idx + 1 == OP::FunctionCount(function);
 }
 
@@ -478,7 +465,7 @@ void DuckDBFunctionsFunction(ClientContext &context, TableFunctionInput &data_p,
 	// either fill up the chunk or return all the remaining columns
 	idx_t count = 0;
 	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
-		auto &entry = data.entries[data.offset].get();
+		auto &entry = data.entries[data.offset].get().Cast<FunctionEntry>();
 		bool finished;
 
 		switch (entry.type) {

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev2706"
+#define DUCKDB_VERSION "0.7.2-dev2820"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "43a97f9078"
+#define DUCKDB_SOURCE_ID "fc797c18cf"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/catalog/standard_entry.hpp"
+#include "duckdb/catalog/catalog_entry/function_entry.hpp"
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp"
@@ -16,14 +16,14 @@
 namespace duckdb {
 
 //! An aggregate function in the catalog
-class AggregateFunctionCatalogEntry : public StandardEntry {
+class AggregateFunctionCatalogEntry : public FunctionEntry {
 public:
 	static constexpr const CatalogType Type = CatalogType::AGGREGATE_FUNCTION_ENTRY;
 	static constexpr const char *Name = "aggregate function";
 
 public:
 	AggregateFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateAggregateFunctionInfo &info)
-	    : StandardEntry(CatalogType::AGGREGATE_FUNCTION_ENTRY, schema, catalog, info.name), functions(info.functions) {
+	    : FunctionEntry(CatalogType::AGGREGATE_FUNCTION_ENTRY, catalog, schema, info), functions(info.functions) {
 	}
 
 	//! The aggregate functions

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/function_entry.hpp

@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_entry/function_entry.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/catalog/standard_entry.hpp"
+#include "duckdb/parser/parsed_data/create_function_info.hpp"
+
+namespace duckdb {
+
+//! An aggregate function in the catalog
+class FunctionEntry : public StandardEntry {
+public:
+	FunctionEntry(CatalogType type, Catalog &catalog, SchemaCatalogEntry &schema, CreateFunctionInfo &info)
+	    : StandardEntry(type, schema, catalog, info.name) {
+		description = std::move(info.description);
+		parameter_names = std::move(info.parameter_names);
+		example = std::move(info.example);
+	}
+
+	//! The description (if any)
+	string description;
+	//! Parameter names (if any)
+	vector<string> parameter_names;
+	//! The example (if any)
+	string example;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/macro_catalog_entry.hpp

@@ -9,14 +9,14 @@
 #pragma once
 
 #include "duckdb/catalog/catalog_set.hpp"
-#include "duckdb/catalog/standard_entry.hpp"
+#include "duckdb/catalog/catalog_entry/function_entry.hpp"
 #include "duckdb/function/macro_function.hpp"
 #include "duckdb/parser/parsed_data/create_macro_info.hpp"
 
 namespace duckdb {
 
 //! A macro function in the catalog
-class MacroCatalogEntry : public StandardEntry {
+class MacroCatalogEntry : public FunctionEntry {
 public:
 	MacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info);
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/catalog/standard_entry.hpp"
+#include "duckdb/catalog/catalog_entry/function_entry.hpp"
 #include "duckdb/function/pragma_function.hpp"
 #include "duckdb/function/function_set.hpp"
 
@@ -18,7 +18,7 @@ class Catalog;
 struct CreatePragmaFunctionInfo;
 
 //! A table function in the catalog
-class PragmaFunctionCatalogEntry : public StandardEntry {
+class PragmaFunctionCatalogEntry : public FunctionEntry {
 public:
 	static constexpr const CatalogType Type = CatalogType::PRAGMA_FUNCTION_ENTRY;
 	static constexpr const char *Name = "pragma function";

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/catalog/standard_entry.hpp"
+#include "duckdb/catalog/catalog_entry/function_entry.hpp"
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
@@ -16,7 +16,7 @@
 namespace duckdb {
 
 //! A table function in the catalog
-class ScalarFunctionCatalogEntry : public StandardEntry {
+class ScalarFunctionCatalogEntry : public FunctionEntry {
 public:
 	static constexpr const CatalogType Type = CatalogType::SCALAR_FUNCTION_ENTRY;
 	static constexpr const char *Name = "scalar function";

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include "duckdb/catalog/standard_entry.hpp"
+#include "duckdb/catalog/catalog_entry/function_entry.hpp"
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"
@@ -16,7 +16,7 @@
 namespace duckdb {
 
 //! A table function in the catalog
-class TableFunctionCatalogEntry : public StandardEntry {
+class TableFunctionCatalogEntry : public FunctionEntry {
 public:
 	static constexpr const CatalogType Type = CatalogType::TABLE_FUNCTION_ENTRY;
 	static constexpr const char *Name = "table function";

package/src/duckdb/src/include/duckdb/catalog/catalog_transaction.hpp

@@ -28,6 +28,8 @@ struct CatalogTransaction {
 	transaction_t start_time;
 
 	ClientContext &GetContext();
+
+	static CatalogTransaction GetSystemTransaction(DatabaseInstance &db);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/algorithm.hpp

@@ -9,3 +9,4 @@
 #pragma once
 
 #include <algorithm>
+#include <cmath>

package/src/duckdb/src/include/duckdb/common/types/vector.hpp

@@ -419,12 +419,16 @@ struct FSSTVector {
 	DUCKDB_API static idx_t GetCount(Vector &vector);
 };
 
+enum class MapInvalidReason : uint8_t { VALID, NULL_KEY_LIST, NULL_KEY, DUPLICATE_KEY };
+
 struct MapVector {
 	DUCKDB_API static const Vector &GetKeys(const Vector &vector);
 	DUCKDB_API static const Vector &GetValues(const Vector &vector);
 	DUCKDB_API static Vector &GetKeys(Vector &vector);
 	DUCKDB_API static Vector &GetValues(Vector &vector);
-	static vector<idx_t> Search(Vector &keys, idx_t count, const Value &key, list_entry_t &entry);
+	DUCKDB_API static MapInvalidReason
+	CheckMapValidity(Vector &map, idx_t count, const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
+	DUCKDB_API static void MapConversionVerify(Vector &vector, idx_t count);
 };
 
 struct StructVector {
@@ -432,6 +436,8 @@ struct StructVector {
 	DUCKDB_API static vector<unique_ptr<Vector>> &GetEntries(Vector &vector);
 };
 
+enum class UnionInvalidReason : uint8_t { VALID, TAG_OUT_OF_RANGE, NO_MEMBERS, VALIDITY_OVERLAP };
+
 struct UnionVector {
 	// Unions are stored as structs, but the first child is always the "tag"
 	// vector, specifying the currently selected member for that row.
@@ -465,6 +471,10 @@ struct UnionVector {
 	//! This will also handle invalidation of the non-selected members
 	DUCKDB_API static void SetToMember(Vector &vector, union_tag_t tag, Vector &member_vector, idx_t count,
 	                                   bool keep_tags_for_null);
+
+	DUCKDB_API static UnionInvalidReason
+	CheckUnionValidity(Vector &vector, idx_t count,
+	                   const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
 };
 
 struct SequenceVector {

package/src/duckdb/src/include/duckdb/{function → core_functions}/aggregate/algebraic/corr.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/function/aggregate/algebraic/corr.hpp
+// duckdb/core_functions/aggregate/algebraic/corr.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -9,9 +9,8 @@
 #pragma once
 
 #include "duckdb/function/aggregate_function.hpp"
-#include "duckdb/function/aggregate/algebraic_functions.hpp"
-#include "duckdb/function/aggregate/algebraic/covar.hpp"
-#include "duckdb/function/aggregate/algebraic/stddev.hpp"
+#include "duckdb/core_functions/aggregate/algebraic/covar.hpp"
+#include "duckdb/core_functions/aggregate/algebraic/stddev.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/{function → core_functions}/aggregate/algebraic/covar.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/function/aggregate/algebraic/covar.hpp
+// duckdb/core_functions/aggregate/algebraic/covar.hpp
 //
 //
 //===----------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/{function → core_functions}/aggregate/algebraic/stddev.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/function/aggregate/algebraic/stddev.hpp
+// duckdb/core_functions/aggregate/algebraic/stddev.hpp
 //
 //
 //===----------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/core_functions/aggregate/algebraic_functions.hpp

@@ -0,0 +1,124 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/core_functions/aggregate/algebraic_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+// This file is generated by scripts/generate_functions.py
+
+#pragma once
+
+#include "duckdb/function/function_set.hpp"
+
+namespace duckdb {
+
+struct AvgFun {
+	static constexpr const char *Name = "avg";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Calculates the average value for all tuples in x.";
+	static constexpr const char *Example = "SUM(x) / COUNT(*)";
+
+	static AggregateFunctionSet GetFunctions();
+};
+
+struct MeanFun {
+	using ALIAS = AvgFun;
+
+	static constexpr const char *Name = "mean";
+};
+
+struct CorrFun {
+	static constexpr const char *Name = "corr";
+	static constexpr const char *Parameters = "y,x";
+	static constexpr const char *Description = "Returns the correlation coefficient for non-null pairs in a group.";
+	static constexpr const char *Example = "COVAR_POP(y, x) / (STDDEV_POP(x) * STDDEV_POP(y))";
+
+	static AggregateFunction GetFunction();
+};
+
+struct CovarPopFun {
+	static constexpr const char *Name = "covar_pop";
+	static constexpr const char *Parameters = "y,x";
+	static constexpr const char *Description = "Returns the population covariance of input values.";
+	static constexpr const char *Example = "(SUM(x*y) - SUM(x) * SUM(y) / COUNT(*)) / COUNT(*)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct CovarSampFun {
+	static constexpr const char *Name = "covar_samp";
+	static constexpr const char *Parameters = "y,x";
+	static constexpr const char *Description = "Returns the sample covariance for non-null pairs in a group.";
+	static constexpr const char *Example = "(SUM(x*y) - SUM(x) * SUM(y) / COUNT(*)) / (COUNT(*) - 1)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct FAvgFun {
+	static constexpr const char *Name = "favg";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Calculates the average using a more accurate floating point summation (Kahan Sum)";
+	static constexpr const char *Example = "favg(A)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct StandardErrorOfTheMeanFun {
+	static constexpr const char *Name = "sem";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the standard error of the mean";
+	static constexpr const char *Example = "";
+
+	static AggregateFunction GetFunction();
+};
+
+struct StdDevPopFun {
+	static constexpr const char *Name = "stddev_pop";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the population standard deviation.";
+	static constexpr const char *Example = "sqrt(var_pop(x))";
+
+	static AggregateFunction GetFunction();
+};
+
+struct StdDevSampFun {
+	static constexpr const char *Name = "stddev_samp";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the sample standard deviation";
+	static constexpr const char *Example = "sqrt(var_samp(x))";
+
+	static AggregateFunction GetFunction();
+};
+
+struct StddevFun {
+	using ALIAS = StdDevSampFun;
+
+	static constexpr const char *Name = "stddev";
+};
+
+struct VarPopFun {
+	static constexpr const char *Name = "var_pop";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the population variance.";
+	static constexpr const char *Example = "";
+
+	static AggregateFunction GetFunction();
+};
+
+struct VarSampFun {
+	static constexpr const char *Name = "var_samp";
+	static constexpr const char *Parameters = "x";
+	static constexpr const char *Description = "Returns the sample variance of all input values.";
+	static constexpr const char *Example = "(SUM(x^2) - SUM(x)^2 / COUNT(x)) / (COUNT(x) - 1)";
+
+	static AggregateFunction GetFunction();
+};
+
+struct VarianceFun {
+	using ALIAS = VarSampFun;
+
+	static constexpr const char *Name = "variance";
+};
+
+} // namespace duckdb