duckdb 1.3.4 → 1.4.1-dev2.0

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

@@ -258,9 +258,6 @@ struct MacroExtractor {
 			auto &colref = param->Cast<ColumnRefExpression>();
 			results.emplace_back(colref.GetColumnName());
 		}
-		for (auto &param_entry : macro_entry.default_parameters) {
-			results.emplace_back(param_entry.first);
-		}
 		return results;
 	}
 
@@ -268,10 +265,8 @@ struct MacroExtractor {
 		vector<Value> results;
 		auto &macro_entry = *entry.macros[offset];
 		for (idx_t i = 0; i < macro_entry.parameters.size(); i++) {
-			results.emplace_back(LogicalType::VARCHAR);
-		}
-		for (idx_t i = 0; i < macro_entry.default_parameters.size(); i++) {
-			results.emplace_back(LogicalType::VARCHAR);
+			const auto has_type = !macro_entry.types.empty() && macro_entry.types[i] != LogicalType::UNKNOWN;
+			results.emplace_back(has_type ? macro_entry.types[i].ToString() : Value(LogicalType::VARCHAR));
 		}
 		return Value::LIST(LogicalType::VARCHAR, std::move(results));
 	}
@@ -280,10 +275,7 @@ struct MacroExtractor {
 		vector<LogicalType> results;
 		auto &macro_entry = *entry.macros[offset];
 		for (idx_t i = 0; i < macro_entry.parameters.size(); i++) {
-			results.emplace_back(LogicalType::UNKNOWN);
-		}
-		for (idx_t i = 0; i < macro_entry.default_parameters.size(); i++) {
-			results.emplace_back(LogicalType::UNKNOWN);
+			results.emplace_back(macro_entry.types.empty() ? LogicalType::UNKNOWN : macro_entry.types[i]);
 		}
 		return results;
 	}
@@ -329,9 +321,6 @@ struct TableMacroExtractor {
 			auto &colref = param->Cast<ColumnRefExpression>();
 			results.emplace_back(colref.GetColumnName());
 		}
-		for (auto &param_entry : macro_entry.default_parameters) {
-			results.emplace_back(param_entry.first);
-		}
 		return results;
 	}
 
@@ -339,10 +328,8 @@ struct TableMacroExtractor {
 		vector<Value> results;
 		auto &macro_entry = *entry.macros[offset];
 		for (idx_t i = 0; i < macro_entry.parameters.size(); i++) {
-			results.emplace_back(LogicalType::VARCHAR);
-		}
-		for (idx_t i = 0; i < macro_entry.default_parameters.size(); i++) {
-			results.emplace_back(LogicalType::VARCHAR);
+			const auto has_type = !macro_entry.types.empty() && macro_entry.types[i] != LogicalType::UNKNOWN;
+			results.emplace_back(has_type ? macro_entry.types[i].ToString() : Value(LogicalType::VARCHAR));
 		}
 		return Value::LIST(LogicalType::VARCHAR, std::move(results));
 	}
@@ -351,10 +338,7 @@ struct TableMacroExtractor {
 		vector<LogicalType> results;
 		auto &macro_entry = *entry.macros[offset];
 		for (idx_t i = 0; i < macro_entry.parameters.size(); i++) {
-			results.emplace_back(LogicalType::UNKNOWN);
-		}
-		for (idx_t i = 0; i < macro_entry.default_parameters.size(); i++) {
-			results.emplace_back(LogicalType::UNKNOWN);
+			results.emplace_back(macro_entry.types.empty() ? LogicalType::UNKNOWN : macro_entry.types[i]);
 		}
 		return results;
 	}

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

@@ -11,8 +11,8 @@ namespace duckdb {
 
 struct DuckDBLogData : public GlobalTableFunctionState {
 	explicit DuckDBLogData(shared_ptr<LogStorage> log_storage_p) : log_storage(std::move(log_storage_p)) {
-		scan_state = log_storage->CreateScanEntriesState();
-		log_storage->InitializeScanEntries(*scan_state);
+		scan_state = log_storage->CreateScanState(LoggingTargetTable::LOG_ENTRIES);
+		log_storage->InitializeScan(*scan_state);
 	}
 	DuckDBLogData() : log_storage(nullptr) {
 	}
@@ -28,7 +28,7 @@ static unique_ptr<FunctionData> DuckDBLogBind(ClientContext &context, TableFunct
 	return_types.emplace_back(LogicalType::UBIGINT);
 
 	names.emplace_back("timestamp");
-	return_types.emplace_back(LogicalType::TIMESTAMP);
+	return_types.emplace_back(LogicalType::TIMESTAMP_TZ);
 
 	names.emplace_back("type");
 	return_types.emplace_back(LogicalType::VARCHAR);
@@ -43,7 +43,7 @@ static unique_ptr<FunctionData> DuckDBLogBind(ClientContext &context, TableFunct
 }
 
 unique_ptr<GlobalTableFunctionState> DuckDBLogInit(ClientContext &context, TableFunctionInitInput &input) {
-	if (LogManager::Get(context).CanScan()) {
+	if (LogManager::Get(context).CanScan(LoggingTargetTable::LOG_ENTRIES)) {
 		return make_uniq<DuckDBLogData>(LogManager::Get(context).GetLogStorage());
 	}
 	return make_uniq<DuckDBLogData>();
@@ -52,12 +52,48 @@ unique_ptr<GlobalTableFunctionState> DuckDBLogInit(ClientContext &context, Table
 void DuckDBLogFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &data = data_p.global_state->Cast<DuckDBLogData>();
 	if (data.log_storage) {
-		data.log_storage->ScanEntries(*data.scan_state, output);
+		data.log_storage->Scan(*data.scan_state, output);
 	}
 }
 
+unique_ptr<TableRef> DuckDBLogBindReplace(ClientContext &context, TableFunctionBindInput &input) {
+	auto log_storage = LogManager::Get(context).GetLogStorage();
+
+	bool denormalized_table = false;
+	auto denormalized_table_setting = input.named_parameters.find("denormalized_table");
+	if (denormalized_table_setting != input.named_parameters.end()) {
+		denormalized_table = denormalized_table_setting->second.GetValue<bool>();
+	}
+
+	// Without join contexts we simply scan the LOG_ENTRIES tables
+	if (!denormalized_table) {
+		auto res = log_storage->BindReplace(context, input, LoggingTargetTable::LOG_ENTRIES);
+		return res;
+	}
+
+	// If the storage can bind replace for LoggingTargetTable::ALL_LOGS, we use that since that will be most efficient
+	auto all_log_scan = log_storage->BindReplace(context, input, LoggingTargetTable::ALL_LOGS);
+	if (all_log_scan) {
+		return all_log_scan;
+	}
+
+	// We cannot scan ALL_LOGS but denormalized_table was requested: we need to inject the join between LOG_ENTRIES and
+	// LOG_CONTEXTS
+	string sub_query_string = "SELECT l.context_id, scope, connection_id, transaction_id, query_id, thread_id, "
+	                          "timestamp, type, log_level, message"
+	                          " FROM (SELECT row_number() OVER () AS rowid, * FROM duckdb_logs()) as l JOIN "
+	                          "duckdb_log_contexts() as c ON l.context_id=c.context_id order by timestamp, l.rowid;";
+	Parser parser(context.GetParserOptions());
+	parser.ParseQuery(sub_query_string);
+	auto select_stmt = unique_ptr_cast<SQLStatement, SelectStatement>(std::move(parser.statements[0]));
+
+	return duckdb::make_uniq<SubqueryRef>(std::move(select_stmt));
+}
+
 void DuckDBLogFun::RegisterFunction(BuiltinFunctions &set) {
 	TableFunction logs_fun("duckdb_logs", {}, DuckDBLogFunction, DuckDBLogBind, DuckDBLogInit);
+	logs_fun.bind_replace = DuckDBLogBindReplace;
+	logs_fun.named_parameters["denormalized_table"] = LogicalType::BOOLEAN;
 	set.AddFunction(logs_fun);
 }
 

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

@@ -12,8 +12,8 @@ namespace duckdb {
 
 struct DuckDBLogContextData : public GlobalTableFunctionState {
 	explicit DuckDBLogContextData(shared_ptr<LogStorage> log_storage_p) : log_storage(std::move(log_storage_p)) {
-		scan_state = log_storage->CreateScanContextsState();
-		log_storage->InitializeScanContexts(*scan_state);
+		scan_state = log_storage->CreateScanState(LoggingTargetTable::LOG_CONTEXTS);
+		log_storage->InitializeScan(*scan_state);
 	}
 	DuckDBLogContextData() : log_storage(nullptr) {
 	}
@@ -47,7 +47,7 @@ static unique_ptr<FunctionData> DuckDBLogContextBind(ClientContext &context, Tab
 }
 
 unique_ptr<GlobalTableFunctionState> DuckDBLogContextInit(ClientContext &context, TableFunctionInitInput &input) {
-	if (LogManager::Get(context).CanScan()) {
+	if (LogManager::Get(context).CanScan(LoggingTargetTable::LOG_CONTEXTS)) {
 		return make_uniq<DuckDBLogContextData>(LogManager::Get(context).GetLogStorage());
 	}
 	return make_uniq<DuckDBLogContextData>();
@@ -56,13 +56,22 @@ unique_ptr<GlobalTableFunctionState> DuckDBLogContextInit(ClientContext &context
 void DuckDBLogContextFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
 	auto &data = data_p.global_state->Cast<DuckDBLogContextData>();
 	if (data.log_storage) {
-		data.log_storage->ScanContexts(*data.scan_state, output);
+		data.log_storage->Scan(*data.scan_state, output);
 	}
 }
 
+static unique_ptr<TableRef> DuckDBLogContextsBindReplace(ClientContext &context, TableFunctionBindInput &input) {
+	auto log_storage = LogManager::Get(context).GetLogStorage();
+
+	// Attempt to let the storage BindReplace the scan function
+	return log_storage->BindReplace(context, input, LoggingTargetTable::LOG_CONTEXTS);
+}
+
 void DuckDBLogContextFun::RegisterFunction(BuiltinFunctions &set) {
-	set.AddFunction(
-	    TableFunction("duckdb_log_contexts", {}, DuckDBLogContextFunction, DuckDBLogContextBind, DuckDBLogContextInit));
+	auto fun =
+	    TableFunction("duckdb_log_contexts", {}, DuckDBLogContextFunction, DuckDBLogContextBind, DuckDBLogContextInit);
+	fun.bind_replace = DuckDBLogContextsBindReplace;
+	set.AddFunction(fun);
 }
 
 } // namespace duckdb

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

@@ -7,10 +7,15 @@ namespace duckdb {
 
 struct DuckDBSettingValue {
 	string name;
-	string value;
+	Value value;
 	string description;
 	string input_type;
 	string scope;
+	vector<Value> aliases;
+
+	inline bool operator<(const DuckDBSettingValue &rhs) const {
+		return name < rhs.name;
+	};
 };
 
 struct DuckDBSettingsData : public GlobalTableFunctionState {
@@ -38,12 +43,21 @@ static unique_ptr<FunctionData> DuckDBSettingsBind(ClientContext &context, Table
 	names.emplace_back("scope");
 	return_types.emplace_back(LogicalType::VARCHAR);
 
+	names.emplace_back("aliases");
+	return_types.emplace_back(LogicalType::LIST(LogicalType::VARCHAR));
+
 	return nullptr;
 }
 
 unique_ptr<GlobalTableFunctionState> DuckDBSettingsInit(ClientContext &context, TableFunctionInitInput &input) {
 	auto result = make_uniq<DuckDBSettingsData>();
 
+	unordered_map<idx_t, vector<Value>> aliases;
+	for (idx_t i = 0; i < DBConfig::GetAliasCount(); i++) {
+		auto alias = DBConfig::GetAliasByIndex(i);
+		aliases[alias->option_index].emplace_back(alias->alias);
+	}
+
 	auto &config = DBConfig::GetConfig(context);
 	auto options_count = DBConfig::GetOptionCount();
 	for (idx_t i = 0; i < options_count; i++) {
@@ -52,31 +66,48 @@ unique_ptr<GlobalTableFunctionState> DuckDBSettingsInit(ClientContext &context,
 		DuckDBSettingValue value;
 		auto scope = option->set_global ? SettingScope::GLOBAL : SettingScope::LOCAL;
 		value.name = option->name;
-		value.value = option->get_setting(context).ToString();
+		if (option->get_setting) {
+			value.value = option->get_setting(context);
+		} else {
+			auto lookup_result = context.TryGetCurrentSetting(value.name, value.value);
+			if (lookup_result) {
+				scope = lookup_result.GetScope();
+			} else {
+				value.value = option->default_value;
+			}
+		}
 		value.description = option->description;
 		value.input_type = option->parameter_type;
 		value.scope = EnumUtil::ToString(scope);
-
+		auto entry = aliases.find(i);
+		if (entry != aliases.end()) {
+			value.aliases = std::move(entry->second);
+		}
+		for (auto &alias : value.aliases) {
+			DuckDBSettingValue alias_value = value;
+			alias_value.name = StringValue::Get(alias);
+			alias_value.aliases.clear();
+			result->settings.push_back(std::move(alias_value));
+		}
 		result->settings.push_back(std::move(value));
 	}
 	for (auto &ext_param : config.extension_parameters) {
 		Value setting_val;
-		string setting_str_val;
 		auto scope = SettingScope::GLOBAL;
 		auto lookup_result = context.TryGetCurrentSetting(ext_param.first, setting_val);
 		if (lookup_result) {
-			setting_str_val = setting_val.ToString();
 			scope = lookup_result.GetScope();
 		}
 		DuckDBSettingValue value;
 		value.name = ext_param.first;
-		value.value = std::move(setting_str_val);
+		value.value = std::move(setting_val);
 		value.description = ext_param.second.description;
 		value.input_type = ext_param.second.type.ToString();
 		value.scope = EnumUtil::ToString(scope);
 
 		result->settings.push_back(std::move(value));
 	}
+	std::sort(result->settings.begin(), result->settings.end());
 	return std::move(result);
 }
 
@@ -96,13 +127,15 @@ void DuckDBSettingsFunction(ClientContext &context, TableFunctionInput &data_p,
 		// name, LogicalType::VARCHAR
 		output.SetValue(0, count, Value(entry.name));
 		// value, LogicalType::VARCHAR
-		output.SetValue(1, count, Value(entry.value));
+		output.SetValue(1, count, entry.value.CastAs(context, LogicalType::VARCHAR));
 		// description, LogicalType::VARCHAR
 		output.SetValue(2, count, Value(entry.description));
 		// input_type, LogicalType::VARCHAR
 		output.SetValue(3, count, Value(entry.input_type));
 		// scope, LogicalType::VARCHAR
 		output.SetValue(4, count, Value(entry.scope));
+		// aliases, LogicalType::VARCHAR[]
+		output.SetValue(5, count, Value::LIST(LogicalType::VARCHAR, std::move(entry.aliases)));
 		count++;
 	}
 	output.SetCardinality(count);

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

@@ -160,10 +160,14 @@ void DuckDBTypesFunction(ClientContext &context, TableFunctionInput &data_p, Dat
 			break;
 		case LogicalTypeId::STRUCT:
 		case LogicalTypeId::LIST:
+		case LogicalTypeId::ARRAY:
 		case LogicalTypeId::MAP:
 		case LogicalTypeId::UNION:
 			category = "COMPOSITE";
 			break;
+		case LogicalTypeId::VARIANT:
+			category = "VARIANT";
+			break;
 		default:
 			break;
 		}

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

@@ -0,0 +1,154 @@
+#include "duckdb/function/table/system_functions.hpp"
+
+#include "duckdb/catalog/catalog_entry/collate_catalog_entry.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/function/table_function.hpp"
+#include "duckdb/logging/log_manager.hpp"
+#include "duckdb/logging/logging.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/main/database.hpp"
+
+namespace duckdb {
+
+class EnableLoggingBindData : public TableFunctionData {
+public:
+	EnableLoggingBindData() {
+	}
+
+	case_insensitive_map_t<Value> storage_config;
+	LogConfig config;
+	vector<string> log_types_to_set;
+};
+
+static void EnableLogging(ClientContext &context, TableFunctionInput &data, DataChunk &output) {
+	auto bind_data = data.bind_data->Cast<EnableLoggingBindData>();
+
+	auto &log_manager = context.db->GetLogManager();
+
+	// Apply the config generated from the input
+	log_manager.SetConfig(*context.db, bind_data.config);
+
+	if (bind_data.log_types_to_set.empty()) {
+		log_manager.SetEnableLogging(true);
+		log_manager.SetLogMode(LogMode::LEVEL_ONLY);
+	} else {
+		log_manager.SetEnableStructuredLoggers(bind_data.log_types_to_set);
+	}
+
+	if (!bind_data.storage_config.empty()) {
+		log_manager.UpdateLogStorageConfig(*context.db, bind_data.storage_config);
+	}
+}
+
+static unique_ptr<FunctionData> BindEnableLogging(ClientContext &context, TableFunctionBindInput &input,
+                                                  vector<LogicalType> &return_types, vector<string> &names) {
+	if (input.inputs.size() > 1) {
+		throw InvalidInputException("EnableLogging: expected 0 or 1 parameter");
+	}
+
+	auto result = make_uniq<EnableLoggingBindData>();
+
+	bool storage_isset = false;
+	bool storage_path_isset = false;
+
+	for (const auto &param : input.named_parameters) {
+		auto key = StringUtil::Lower(param.first);
+		if (key == "level") {
+			result->config.level = EnumUtil::FromString<LogLevel>(param.second.ToString());
+		} else if (key == "storage") {
+			storage_isset = true;
+			result->config.storage = param.second.ToString();
+		} else if (key == "storage_config") {
+			if (param.second.type().id() != LogicalTypeId::STRUCT) {
+				throw InvalidInputException("EnableLogging: storage_config must be a struct");
+			}
+			auto &children = StructValue::GetChildren(param.second);
+			for (idx_t i = 0; i < children.size(); i++) {
+				result->storage_config[StructType::GetChildName(param.second.type(), i)] = children[i];
+			}
+		} else if (key == "storage_path") {
+			storage_path_isset = true;
+			result->storage_config["path"] = param.second;
+		} else if (key == "storage_normalize") {
+			result->storage_config["normalize"] = param.second;
+		} else if (key == "storage_buffer_size") {
+			result->storage_config["buffer_size"] = param.second;
+		} else {
+			throw InvalidInputException("EnableLogging: unknown named parameter: %s", param.first.c_str());
+		}
+	}
+
+	// This will implicitly set the log storage if the storage_path param is set and the storage is omitted
+	if (!storage_isset && storage_path_isset) {
+		result->config.storage = LogConfig::FILE_STORAGE_NAME;
+	}
+
+	// Process positional params
+	if (!input.inputs.empty()) {
+		if (input.inputs[0].type() == LogicalType::VARCHAR) {
+			result->log_types_to_set.push_back(input.inputs[0].GetValue<string>());
+		} else if (input.inputs[0].type() == LogicalType::LIST(LogicalType::VARCHAR)) {
+			for (const auto &child : ListValue::GetChildren(input.inputs[0])) {
+				result->log_types_to_set.push_back(child.GetValue<string>());
+			}
+		} else {
+			throw BinderException("Unexpected type positional parameter to enable_logging");
+		}
+	}
+
+	return_types.emplace_back(LogicalType::BOOLEAN);
+	names.emplace_back("Success");
+
+	return std::move(result);
+}
+
+//! Reset the logmanager to the defaults
+static void DisableLogging(ClientContext &context, TableFunctionInput &data, DataChunk &output) {
+	context.db->GetLogManager().SetEnableLogging(false);
+}
+
+//! Truncate the current log storage
+static void TruncateLogs(ClientContext &context, TableFunctionInput &data, DataChunk &output) {
+	context.db->GetLogManager().TruncateLogStorage();
+}
+
+static unique_ptr<FunctionData> BindDisableLogging(ClientContext &context, TableFunctionBindInput &input,
+                                                   vector<LogicalType> &return_types, vector<string> &names) {
+	return_types.emplace_back(LogicalType::BOOLEAN);
+	names.emplace_back("Success");
+
+	return std::move(make_uniq<EnableLoggingBindData>());
+}
+
+static unique_ptr<FunctionData> BindTruncateLogs(ClientContext &context, TableFunctionBindInput &input,
+                                                 vector<LogicalType> &return_types, vector<string> &names) {
+	return_types.emplace_back(LogicalType::BOOLEAN);
+	names.emplace_back("Success");
+
+	return make_uniq<EnableLoggingBindData>();
+}
+
+void EnableLoggingFun::RegisterFunction(BuiltinFunctions &set) {
+	auto enable_fun = TableFunction("enable_logging", {}, EnableLogging, BindEnableLogging, nullptr, nullptr);
+
+	// Base config
+	enable_fun.named_parameters.emplace("level", LogicalType::VARCHAR);
+	enable_fun.named_parameters.emplace("storage", LogicalType::VARCHAR);
+	enable_fun.named_parameters.emplace("storage_config", LogicalType::ANY);
+
+	// Config that is forwarded to the storage_config struct as syntactic sugar
+	enable_fun.named_parameters.emplace("storage_path", LogicalType::VARCHAR);
+	enable_fun.named_parameters.emplace("storage_normalize", LogicalType::BOOLEAN);
+	enable_fun.named_parameters.emplace("storage_buffer_size", LogicalType::UBIGINT);
+
+	enable_fun.varargs = LogicalType::ANY;
+	set.AddFunction(enable_fun);
+
+	auto disable_fun = TableFunction("disable_logging", {}, DisableLogging, BindDisableLogging, nullptr, nullptr);
+	set.AddFunction(disable_fun);
+
+	auto truncate_fun = TableFunction("truncate_duckdb_logs", {}, TruncateLogs, BindTruncateLogs, nullptr, nullptr);
+	set.AddFunction(truncate_fun);
+}
+
+} // namespace duckdb

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

@@ -15,7 +15,7 @@ struct PragmaDatabaseSizeData : public GlobalTableFunctionState {
 	}
 
 	idx_t index;
-	vector<reference<AttachedDatabase>> databases;
+	vector<shared_ptr<AttachedDatabase>> databases;
 	Value memory_usage;
 	Value memory_limit;
 };
@@ -68,7 +68,7 @@ void PragmaDatabaseSizeFunction(ClientContext &context, TableFunctionInput &data
 	auto &data = data_p.global_state->Cast<PragmaDatabaseSizeData>();
 	idx_t row = 0;
 	for (; data.index < data.databases.size() && row < STANDARD_VECTOR_SIZE; data.index++) {
-		auto &db = data.databases[data.index].get();
+		auto &db = *data.databases[data.index];
 		if (db.IsSystem() || db.IsTemporary()) {
 			continue;
 		}

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

@@ -1,6 +1,5 @@
 #include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/pair.hpp"
-#include "duckdb/common/types/bit.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/function/table/system_functions.hpp"
@@ -8,6 +7,8 @@
 #include <cmath>
 #include <limits>
 
+#include "duckdb/common/types/bignum.hpp"
+
 namespace duckdb {
 
 struct TestAllTypesData : public GlobalTableFunctionState {
@@ -18,7 +19,7 @@ struct TestAllTypesData : public GlobalTableFunctionState {
 	idx_t offset;
 };
 
-vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum) {
+vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum, bool use_large_bignum) {
 	vector<TestType> result;
 	// scalar types/numerics
 	result.emplace_back(LogicalType::BOOLEAN, "bool");
@@ -32,7 +33,24 @@ vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum) {
 	result.emplace_back(LogicalType::USMALLINT, "usmallint");
 	result.emplace_back(LogicalType::UINTEGER, "uint");
 	result.emplace_back(LogicalType::UBIGINT, "ubigint");
-	result.emplace_back(LogicalType::VARINT, "varint");
+	if (use_large_bignum) {
+		string data;
+		idx_t total_data_size = Bignum::BIGNUM_HEADER_SIZE + Bignum::MAX_DATA_SIZE;
+		data.resize(total_data_size);
+		// Let's set our header
+		Bignum::SetHeader(&data[0], Bignum::MAX_DATA_SIZE, false);
+		// Set all our other bits
+		memset(&data[Bignum::BIGNUM_HEADER_SIZE], 0xFF, Bignum::MAX_DATA_SIZE);
+		auto max = Value::BIGNUM(data);
+		// Let's set our header
+		Bignum::SetHeader(&data[0], Bignum::MAX_DATA_SIZE, true);
+		// Set all our other bits
+		memset(&data[Bignum::BIGNUM_HEADER_SIZE], 0x00, Bignum::MAX_DATA_SIZE);
+		auto min = Value::BIGNUM(data);
+		result.emplace_back(LogicalType::BIGNUM, "bignum", min, max);
+	} else {
+		result.emplace_back(LogicalType::BIGNUM, "bignum");
+	}
 	result.emplace_back(LogicalType::DATE, "date");
 	result.emplace_back(LogicalType::TIME, "time");
 	result.emplace_back(LogicalType::TIMESTAMP, "timestamp");
@@ -126,7 +144,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum) {
 	auto timestamp_list =
 	    Value::LIST(LogicalType::TIMESTAMP, {Value::TIMESTAMP(timestamp_t()), Value::TIMESTAMP(timestamp_t::infinity()),
 	                                         Value::TIMESTAMP(timestamp_t::ninfinity()), Value(LogicalType::TIMESTAMP),
-	                                         Value::TIMESTAMP(Timestamp::FromString("2022-05-12 16:23:45"))});
+	                                         Value::TIMESTAMP(Timestamp::FromString("2022-05-12 16:23:45", false))});
 	result.emplace_back(timestamp_list_type, "timestamp_array", empty_timestamp_list, timestamp_list);
 
 	auto timestamptz_list_type = LogicalType::LIST(LogicalType::TIMESTAMP_TZ);
@@ -135,7 +153,7 @@ vector<TestType> TestAllTypesFun::GetTestTypes(bool use_large_enum) {
 	    Value::LIST(LogicalType::TIMESTAMP_TZ,
 	                {Value::TIMESTAMPTZ(timestamp_tz_t()), Value::TIMESTAMPTZ(timestamp_tz_t(timestamp_t::infinity())),
 	                 Value::TIMESTAMPTZ(timestamp_tz_t(timestamp_t::ninfinity())), Value(LogicalType::TIMESTAMP_TZ),
-	                 Value::TIMESTAMPTZ(timestamp_tz_t(Timestamp::FromString("2022-05-12 16:23:45-07")))});
+	                 Value::TIMESTAMPTZ(timestamp_tz_t(Timestamp::FromString("2022-05-12 16:23:45-07", true)))});
 	result.emplace_back(timestamptz_list_type, "timestamptz_array", empty_timestamptz_list, timestamptz_list);
 
 	auto varchar_list_type = LogicalType::LIST(LogicalType::VARCHAR);
@@ -298,11 +316,16 @@ static unique_ptr<FunctionData> TestAllTypesBind(ClientContext &context, TableFu
                                                  vector<LogicalType> &return_types, vector<string> &names) {
 	auto result = make_uniq<TestAllTypesBindData>();
 	bool use_large_enum = false;
+	bool use_large_bignum = false;
 	auto entry = input.named_parameters.find("use_large_enum");
 	if (entry != input.named_parameters.end()) {
 		use_large_enum = BooleanValue::Get(entry->second);
 	}
-	result->test_types = TestAllTypesFun::GetTestTypes(use_large_enum);
+	entry = input.named_parameters.find("use_large_bignum");
+	if (entry != input.named_parameters.end()) {
+		use_large_bignum = BooleanValue::Get(entry->second);
+	}
+	result->test_types = TestAllTypesFun::GetTestTypes(use_large_enum, use_large_bignum);
 	for (auto &test_type : result->test_types) {
 		return_types.push_back(test_type.type);
 		names.push_back(test_type.name);
@@ -346,6 +369,7 @@ void TestAllTypesFunction(ClientContext &context, TableFunctionInput &data_p, Da
 void TestAllTypesFun::RegisterFunction(BuiltinFunctions &set) {
 	TableFunction test_all_types("test_all_types", {}, TestAllTypesFunction, TestAllTypesBind, TestAllTypesInit);
 	test_all_types.named_parameters["use_large_enum"] = LogicalType::BOOLEAN;
+	test_all_types.named_parameters["use_large_bignum"] = LogicalType::BOOLEAN;
 	set.AddFunction(test_all_types);
 }
 

package/src/duckdb/src/function/table/system_functions.cpp

@@ -18,6 +18,8 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	PragmaDatabaseSize::RegisterFunction(*this);
 	PragmaUserAgent::RegisterFunction(*this);
 
+	DuckDBConnectionCountFun::RegisterFunction(*this);
+	DuckDBApproxDatabaseCountFun::RegisterFunction(*this);
 	DuckDBColumnsFun::RegisterFunction(*this);
 	DuckDBConstraintsFun::RegisterFunction(*this);
 	DuckDBDatabasesFun::RegisterFunction(*this);
@@ -44,6 +46,7 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	DuckDBTypesFun::RegisterFunction(*this);
 	DuckDBVariablesFun::RegisterFunction(*this);
 	DuckDBViewsFun::RegisterFunction(*this);
+	EnableLoggingFun::RegisterFunction(*this);
 	TestAllTypesFun::RegisterFunction(*this);
 	TestVectorTypesFun::RegisterFunction(*this);
 }