duckdb 1.4.2-dev4.0 → 1.4.2

package/src/duckdb/src/logging/log_manager.cpp

@@ -205,7 +205,7 @@ void LogManager::SetEnableStructuredLoggers(vector<string> &enabled_logger_types
 			throw InvalidInputException("Unknown log type: '%s'", enabled_logger_type);
 		}
 
-		new_config.enabled_log_types.insert(enabled_logger_type);
+		new_config.enabled_log_types.insert(lookup->name);
 
 		min_log_level = MinValue(min_log_level, lookup->level);
 	}
@@ -266,6 +266,7 @@ void LogManager::RegisterDefaultLogTypes() {
 	RegisterLogType(make_uniq<HTTPLogType>());
 	RegisterLogType(make_uniq<QueryLogType>());
 	RegisterLogType(make_uniq<PhysicalOperatorLogType>());
+	RegisterLogType(make_uniq<MetricsLogType>());
 }
 
 } // namespace duckdb

package/src/duckdb/src/logging/log_types.cpp

@@ -14,6 +14,7 @@ constexpr LogLevel FileSystemLogType::LEVEL;
 constexpr LogLevel QueryLogType::LEVEL;
 constexpr LogLevel HTTPLogType::LEVEL;
 constexpr LogLevel PhysicalOperatorLogType::LEVEL;
+constexpr LogLevel MetricsLogType::LEVEL;
 constexpr LogLevel CheckpointLogType::LEVEL;
 
 //===--------------------------------------------------------------------===//
@@ -58,6 +59,8 @@ LogicalType HTTPLogType::GetLogType() {
 	child_list_t<LogicalType> request_child_list = {
 	    {"type", LogicalType::VARCHAR},
 	    {"url", LogicalType::VARCHAR},
+	    {"start_time", LogicalType::TIMESTAMP_TZ},
+	    {"duration_ms", LogicalType::BIGINT},
 	    {"headers", LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR)},
 	};
 	auto request_type = LogicalType::STRUCT(request_child_list);
@@ -90,7 +93,10 @@ string HTTPLogType::ConstructLogMessage(BaseRequest &request, optional_ptr<HTTPR
 	    {"type", Value(EnumUtil::ToString(request.type))},
 	    {"url", Value(request.url)},
 	    {"headers", CreateHTTPHeadersValue(request.headers)},
-	};
+	    {"start_time", request.have_request_timing ? Value::TIMESTAMP(request.request_start) : Value()},
+	    {"duration_ms", request.have_request_timing ? Value::BIGINT(Timestamp::GetEpochMs(request.request_end) -
+	                                                                Timestamp::GetEpochMs(request.request_start))
+	                                                : Value()}};
 	auto request_value = Value::STRUCT(request_child_list);
 	Value response_value;
 	if (response) {
@@ -147,6 +153,29 @@ string PhysicalOperatorLogType::ConstructLogMessage(const PhysicalOperator &phys
 
 	return Value::STRUCT(std::move(child_list)).ToString();
 }
+
+//===--------------------------------------------------------------------===//
+// MetricsLogType
+//===--------------------------------------------------------------------===//
+MetricsLogType::MetricsLogType() : LogType(NAME, LEVEL, GetLogType()) {
+}
+
+LogicalType MetricsLogType::GetLogType() {
+	child_list_t<LogicalType> child_list = {
+	    {"metric", LogicalType::VARCHAR},
+	    {"value", LogicalType::VARCHAR},
+	};
+	return LogicalType::STRUCT(child_list);
+}
+
+string MetricsLogType::ConstructLogMessage(const MetricsType &metric, const Value &value) {
+	child_list_t<Value> child_list = {
+	    {"metric", EnumUtil::ToString(metric)},
+	    {"value", value.ToString()},
+	};
+	return Value::STRUCT(std::move(child_list)).ToString();
+}
+
 //===--------------------------------------------------------------------===//
 // CheckpointLogType
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/main/attached_database.cpp

@@ -14,8 +14,9 @@
 
 namespace duckdb {
 
-StoredDatabasePath::StoredDatabasePath(DatabaseFilePathManager &manager, string path_p, const string &name)
-    : manager(manager), path(std::move(path_p)) {
+StoredDatabasePath::StoredDatabasePath(DatabaseManager &db_manager, DatabaseFilePathManager &manager, string path_p,
+                                       const string &name)
+    : db_manager(db_manager), manager(manager), path(std::move(path_p)) {
 }
 
 StoredDatabasePath::~StoredDatabasePath() {
@@ -23,7 +24,7 @@ StoredDatabasePath::~StoredDatabasePath() {
 }
 
 void StoredDatabasePath::OnDetach() {
-	manager.DetachDatabase(path);
+	manager.DetachDatabase(db_manager, path);
 }
 
 //===--------------------------------------------------------------------===//
@@ -271,10 +272,6 @@ void AttachedDatabase::Close() {
 	catalog.reset();
 	storage.reset();
 	stored_database_path.reset();
-
-	if (Allocator::SupportsFlush()) {
-		Allocator::FlushAll();
-	}
 }
 
 } // namespace duckdb

package/src/duckdb/src/main/buffered_data/batched_buffered_data.cpp

@@ -14,9 +14,8 @@ void BatchedBufferedData::BlockSink(const InterruptState &blocked_sink, idx_t ba
 	blocked_sinks.emplace(batch, blocked_sink);
 }
 
-BatchedBufferedData::BatchedBufferedData(weak_ptr<ClientContext> context)
-    : BufferedData(BufferedData::Type::BATCHED, std::move(context)), buffer_byte_count(0), read_queue_byte_count(0),
-      min_batch(0) {
+BatchedBufferedData::BatchedBufferedData(ClientContext &context)
+    : BufferedData(BufferedData::Type::BATCHED, context), buffer_byte_count(0), read_queue_byte_count(0), min_batch(0) {
 	read_queue_capacity = (idx_t)(static_cast<double>(total_buffer_size) * 0.6);
 	buffer_capacity = (idx_t)(static_cast<double>(total_buffer_size) * 0.4);
 }

package/src/duckdb/src/main/buffered_data/buffered_data.cpp

@@ -4,9 +4,8 @@
 
 namespace duckdb {
 
-BufferedData::BufferedData(Type type, weak_ptr<ClientContext> context_p) : type(type), context(std::move(context_p)) {
-	auto client_context = context.lock();
-	auto &config = ClientConfig::GetConfig(*client_context);
+BufferedData::BufferedData(Type type, ClientContext &context_p) : type(type), context(context_p.shared_from_this()) {
+	auto &config = ClientConfig::GetConfig(context_p);
 	total_buffer_size = config.streaming_buffer_size;
 }
 

package/src/duckdb/src/main/buffered_data/simple_buffered_data.cpp

@@ -6,8 +6,7 @@
 
 namespace duckdb {
 
-SimpleBufferedData::SimpleBufferedData(weak_ptr<ClientContext> context)
-    : BufferedData(BufferedData::Type::SIMPLE, std::move(context)) {
+SimpleBufferedData::SimpleBufferedData(ClientContext &context) : BufferedData(BufferedData::Type::SIMPLE, context) {
 	buffered_count = 0;
 	buffer_size = total_buffer_size;
 }

package/src/duckdb/src/main/capi/prepared-c.cpp

@@ -88,7 +88,13 @@ duckdb_state duckdb_prepare(duckdb_connection connection, const char *query,
 
 const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement) {
 	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
-	if (!wrapper || !wrapper->statement || !wrapper->statement->HasError()) {
+	if (!wrapper) {
+		return nullptr;
+	}
+	if (!wrapper->success) {
+		return wrapper->error_data.Message().c_str();
+	}
+	if (!wrapper->statement || !wrapper->statement->HasError()) {
 		return nullptr;
 	}
 	return wrapper->statement->error.Message().c_str();
@@ -229,9 +235,10 @@ duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx
 		return DuckDBError;
 	}
 	if (param_idx <= 0 || param_idx > wrapper->statement->named_param_map.size()) {
-		wrapper->statement->error =
+		wrapper->error_data =
 		    duckdb::InvalidInputException("Can not bind to parameter number %d, statement only has %d parameter(s)",
 		                                  param_idx, wrapper->statement->named_param_map.size());
+		wrapper->success = false;
 		return DuckDBError;
 	}
 	auto identifier = duckdb_parameter_name_internal(prepared_statement, param_idx);

package/src/duckdb/src/main/config.cpp

@@ -86,6 +86,7 @@ static const ConfigurationOption internal_options[] = {
     DUCKDB_LOCAL(DebugForceExternalSetting),
     DUCKDB_SETTING(DebugForceNoCrossProductSetting),
     DUCKDB_SETTING(DebugSkipCheckpointOnCommitSetting),
+    DUCKDB_SETTING(DebugVerifyBlocksSetting),
     DUCKDB_SETTING_CALLBACK(DebugVerifyVectorSetting),
     DUCKDB_SETTING_CALLBACK(DebugWindowModeSetting),
     DUCKDB_GLOBAL(DefaultBlockSizeSetting),
@@ -177,12 +178,12 @@ static const ConfigurationOption internal_options[] = {
     DUCKDB_GLOBAL(ZstdMinStringLengthSetting),
     FINAL_SETTING};
 
-static const ConfigurationAlias setting_aliases[] = {DUCKDB_SETTING_ALIAS("memory_limit", 83),
-                                                     DUCKDB_SETTING_ALIAS("null_order", 33),
-                                                     DUCKDB_SETTING_ALIAS("profiling_output", 102),
-                                                     DUCKDB_SETTING_ALIAS("user", 116),
+static const ConfigurationAlias setting_aliases[] = {DUCKDB_SETTING_ALIAS("memory_limit", 84),
+                                                     DUCKDB_SETTING_ALIAS("null_order", 34),
+                                                     DUCKDB_SETTING_ALIAS("profiling_output", 103),
+                                                     DUCKDB_SETTING_ALIAS("user", 117),
                                                      DUCKDB_SETTING_ALIAS("wal_autocheckpoint", 20),
-                                                     DUCKDB_SETTING_ALIAS("worker_threads", 115),
+                                                     DUCKDB_SETTING_ALIAS("worker_threads", 116),
                                                      FINAL_ALIAS};
 
 vector<ConfigurationOption> DBConfig::GetOptions() {

package/src/duckdb/src/main/database.cpp

@@ -285,7 +285,7 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 		buffer_manager = make_uniq<StandardBufferManager>(*this, config.options.temporary_directory);
 	}
 
-	log_manager = make_shared_ptr<LogManager>(*this, LogConfig());
+	log_manager = make_uniq<LogManager>(*this, LogConfig());
 	log_manager->Initialize();
 
 	external_file_cache = make_uniq<ExternalFileCache>(*this, config.options.enable_external_file_cache);
@@ -507,12 +507,18 @@ SettingLookupResult DatabaseInstance::TryGetCurrentSetting(const string &key, Va
 	return db_config.TryGetCurrentSetting(key, result);
 }
 
-shared_ptr<EncryptionUtil> DatabaseInstance::GetEncryptionUtil() const {
+shared_ptr<EncryptionUtil> DatabaseInstance::GetEncryptionUtil() {
+	if (!config.encryption_util || !config.encryption_util->SupportsEncryption()) {
+		ExtensionHelper::TryAutoLoadExtension(*this, "httpfs");
+	}
+
 	if (config.encryption_util) {
 		return config.encryption_util;
 	}
 
-	return make_shared_ptr<duckdb_mbedtls::MbedTlsWrapper::AESStateMBEDTLSFactory>();
+	auto result = make_shared_ptr<duckdb_mbedtls::MbedTlsWrapper::AESStateMBEDTLSFactory>();
+
+	return std::move(result);
 }
 
 ValidChecker &DatabaseInstance::GetValidChecker() {

package/src/duckdb/src/main/database_file_path_manager.cpp

@@ -5,35 +5,57 @@
 
 namespace duckdb {
 
+DatabasePathInfo::DatabasePathInfo(DatabaseManager &manager, string name_p, AccessMode access_mode)
+    : name(std::move(name_p)), access_mode(access_mode) {
+	attached_databases.insert(manager);
+}
+
 idx_t DatabaseFilePathManager::ApproxDatabaseCount() const {
 	lock_guard<mutex> path_lock(db_paths_lock);
 	return db_paths.size();
 }
 
-InsertDatabasePathResult DatabaseFilePathManager::InsertDatabasePath(const string &path, const string &name,
-                                                                     OnCreateConflict on_conflict,
+InsertDatabasePathResult DatabaseFilePathManager::InsertDatabasePath(DatabaseManager &manager, const string &path,
+                                                                     const string &name, OnCreateConflict on_conflict,
                                                                      AttachOptions &options) {
 	if (path.empty() || path == IN_MEMORY_PATH) {
 		return InsertDatabasePathResult::SUCCESS;
 	}
 
 	lock_guard<mutex> path_lock(db_paths_lock);
-	auto entry = db_paths.emplace(path, DatabasePathInfo(name));
+	auto entry = db_paths.emplace(path, DatabasePathInfo(manager, name, options.access_mode));
 	if (!entry.second) {
 		auto &existing = entry.first->second;
+		bool already_exists = false;
+		bool attached_in_this_system = false;
 		if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT && existing.name == name) {
-			if (existing.is_attached) {
+			already_exists = true;
+			attached_in_this_system = existing.attached_databases.find(manager) != existing.attached_databases.end();
+		}
+		if (options.access_mode == AccessMode::READ_ONLY && existing.access_mode == AccessMode::READ_ONLY) {
+			if (attached_in_this_system) {
 				return InsertDatabasePathResult::ALREADY_EXISTS;
 			}
-			throw BinderException("Unique file handle conflict: Cannot attach \"%s\" - the database file \"%s\" is in "
-			                      "the process of being detached",
-			                      name, path);
+			// all attaches are in read-only mode - there is no conflict, just increase the reference count
+			existing.attached_databases.insert(manager);
+			existing.reference_count++;
+		} else {
+			if (already_exists) {
+				if (attached_in_this_system) {
+					return InsertDatabasePathResult::ALREADY_EXISTS;
+				}
+				throw BinderException(
+				    "Unique file handle conflict: Cannot attach \"%s\" - the database file \"%s\" is in "
+				    "the process of being detached",
+				    name, path);
+			}
+			throw BinderException(
+			    "Unique file handle conflict: Cannot attach \"%s\" - the database file \"%s\" is already "
+			    "attached by database \"%s\"",
+			    name, path, existing.name);
 		}
-		throw BinderException("Unique file handle conflict: Cannot attach \"%s\" - the database file \"%s\" is already "
-		                      "attached by database \"%s\"",
-		                      name, path, existing.name);
 	}
-	options.stored_database_path = make_uniq<StoredDatabasePath>(*this, path, name);
+	options.stored_database_path = make_uniq<StoredDatabasePath>(manager, *this, path, name);
 	return InsertDatabasePathResult::SUCCESS;
 }
 
@@ -42,17 +64,24 @@ void DatabaseFilePathManager::EraseDatabasePath(const string &path) {
 		return;
 	}
 	lock_guard<mutex> path_lock(db_paths_lock);
-	db_paths.erase(path);
+	auto entry = db_paths.find(path);
+	if (entry != db_paths.end()) {
+		if (entry->second.reference_count <= 1) {
+			db_paths.erase(entry);
+		} else {
+			entry->second.reference_count--;
+		}
+	}
 }
 
-void DatabaseFilePathManager::DetachDatabase(const string &path) {
+void DatabaseFilePathManager::DetachDatabase(DatabaseManager &manager, const string &path) {
 	if (path.empty() || path == IN_MEMORY_PATH) {
 		return;
 	}
 	lock_guard<mutex> path_lock(db_paths_lock);
 	auto entry = db_paths.find(path);
 	if (entry != db_paths.end()) {
-		entry->second.is_attached = false;
+		entry->second.attached_databases.erase(manager);
 	}
 }
 

package/src/duckdb/src/main/database_manager.cpp

@@ -199,7 +199,7 @@ idx_t DatabaseManager::ApproxDatabaseCount() {
 }
 
 InsertDatabasePathResult DatabaseManager::InsertDatabasePath(const AttachInfo &info, AttachOptions &options) {
-	return path_manager->InsertDatabasePath(info.path, info.name, info.on_conflict, options);
+	return path_manager->InsertDatabasePath(*this, info.path, info.name, info.on_conflict, options);
 }
 
 vector<string> DatabaseManager::GetAttachedDatabasePaths() {

package/src/duckdb/src/main/http/http_util.cpp

@@ -130,9 +130,12 @@ BaseRequest::BaseRequest(RequestType type, const string &url, const HTTPHeaders
 class HTTPLibClient : public HTTPClient {
 public:
 	HTTPLibClient(HTTPParams &http_params, const string &proto_host_port) {
+		client = make_uniq<duckdb_httplib::Client>(proto_host_port);
+		Initialize(http_params);
+	}
+	void Initialize(HTTPParams &http_params) override {
 		auto sec = static_cast<time_t>(http_params.timeout);
 		auto usec = static_cast<time_t>(http_params.timeout_usec);
-		client = make_uniq<duckdb_httplib::Client>(proto_host_port);
 		client->set_follow_location(http_params.follow_location);
 		client->set_keep_alive(http_params.keep_alive);
 		client->set_write_timeout(sec, usec);
@@ -228,12 +231,27 @@ unique_ptr<HTTPResponse> HTTPUtil::SendRequest(BaseRequest &request, unique_ptr<
 
 	std::function<unique_ptr<HTTPResponse>(void)> on_request([&]() {
 		unique_ptr<HTTPResponse> response;
+
+		// When logging is enabled, we collect request timings
+		if (request.params.logger) {
+			request.have_request_timing = request.params.logger->ShouldLog(HTTPLogType::NAME, HTTPLogType::LEVEL);
+		}
+
 		try {
+			if (request.have_request_timing) {
+				request.request_start = Timestamp::GetCurrentTimestamp();
+			}
 			response = client->Request(request);
 		} catch (...) {
+			if (request.have_request_timing) {
+				request.request_end = Timestamp::GetCurrentTimestamp();
+			}
 			LogRequest(request, nullptr);
 			throw;
 		}
+		if (request.have_request_timing) {
+			request.request_end = Timestamp::GetCurrentTimestamp();
+		}
 		LogRequest(request, response ? response.get() : nullptr);
 		return response;
 	});

package/src/duckdb/src/main/profiling_info.cpp

@@ -2,6 +2,7 @@
 
 #include "duckdb/common/enum_util.hpp"
 #include "duckdb/main/query_profiler.hpp"
+#include "duckdb/logging/log_manager.hpp"
 
 #include "yyjson.hpp"
 
@@ -169,6 +170,16 @@ string ProfilingInfo::GetMetricAsString(const MetricsType metric) const {
 	return metrics.at(metric).ToString();
 }
 
+void ProfilingInfo::WriteMetricsToLog(ClientContext &context) {
+	auto &logger = Logger::Get(context);
+	if (logger.ShouldLog(MetricsLogType::NAME, MetricsLogType::LEVEL)) {
+		for (auto &metric : settings) {
+			logger.WriteLog(MetricsLogType::NAME, MetricsLogType::LEVEL,
+			                MetricsLogType::ConstructLogMessage(metric, metrics[metric]));
+		}
+	}
+}
+
 void ProfilingInfo::WriteMetricsToJSON(yyjson_mut_doc *doc, yyjson_mut_val *dest) {
 	for (auto &metric : settings) {
 		auto metric_str = StringUtil::Lower(EnumUtil::ToString(metric));

package/src/duckdb/src/main/query_profiler.cpp

@@ -297,6 +297,9 @@ void QueryProfiler::EndQuery() {
 
 	guard.unlock();
 
+	// To log is inexpensive, whether to log or not depends on whether logging is active
+	ToLog();
+
 	if (emit_output) {
 		string tree = ToString();
 		auto save_location = GetSaveLocation();
@@ -797,6 +800,19 @@ static string StringifyAndFree(yyjson_mut_doc *doc, yyjson_mut_val *object) {
 	return result;
 }
 
+void QueryProfiler::ToLog() const {
+	lock_guard<std::mutex> guard(lock);
+
+	if (!root) {
+		// No root, not much to do
+		return;
+	}
+
+	auto &settings = root->GetProfilingInfo();
+
+	settings.WriteMetricsToLog(context);
+}
+
 string QueryProfiler::ToJSON() const {
 	lock_guard<std::mutex> guard(lock);
 	auto doc = yyjson_mut_doc_new(nullptr);

package/src/duckdb/src/main/relation/create_table_relation.cpp

@@ -14,12 +14,21 @@ CreateTableRelation::CreateTableRelation(shared_ptr<Relation> child_p, string sc
 	TryBindRelation(columns);
 }
 
+CreateTableRelation::CreateTableRelation(shared_ptr<Relation> child_p, string catalog_name, string schema_name,
+                                         string table_name, bool temporary_p, OnCreateConflict on_conflict)
+    : Relation(child_p->context, RelationType::CREATE_TABLE_RELATION), child(std::move(child_p)),
+      catalog_name(std::move(catalog_name)), schema_name(std::move(schema_name)), table_name(std::move(table_name)),
+      temporary(temporary_p), on_conflict(on_conflict) {
+	TryBindRelation(columns);
+}
+
 BoundStatement CreateTableRelation::Bind(Binder &binder) {
 	auto select = make_uniq<SelectStatement>();
 	select->node = child->GetQueryNode();
 
 	CreateStatement stmt;
 	auto info = make_uniq<CreateTableInfo>();
+	info->catalog = catalog_name;
 	info->schema = schema_name;
 	info->table = table_name;
 	info->query = std::move(select);

package/src/duckdb/src/main/relation/insert_relation.cpp

@@ -13,11 +13,18 @@ InsertRelation::InsertRelation(shared_ptr<Relation> child_p, string schema_name,
 	TryBindRelation(columns);
 }
 
+InsertRelation::InsertRelation(shared_ptr<Relation> child_p, string catalog_name, string schema_name, string table_name)
+    : Relation(child_p->context, RelationType::INSERT_RELATION), child(std::move(child_p)),
+      catalog_name(std::move(catalog_name)), schema_name(std::move(schema_name)), table_name(std::move(table_name)) {
+	TryBindRelation(columns);
+}
+
 BoundStatement InsertRelation::Bind(Binder &binder) {
 	InsertStatement stmt;
 	auto select = make_uniq<SelectStatement>();
 	select->node = child->GetQueryNode();
 
+	stmt.catalog = catalog_name;
 	stmt.schema = schema_name;
 	stmt.table = table_name;
 	stmt.select_statement = std::move(select);

package/src/duckdb/src/main/relation/table_relation.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/expression/star_expression.hpp"
 #include "duckdb/main/relation/delete_relation.hpp"
+#include "duckdb/main/relation/value_relation.hpp"
 #include "duckdb/main/relation/update_relation.hpp"
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/main/client_context.hpp"
@@ -87,4 +88,17 @@ void TableRelation::Delete(const string &condition) {
 	del->Execute();
 }
 
+void TableRelation::Insert(const vector<vector<Value>> &values) {
+	vector<string> column_names;
+	auto rel = make_shared_ptr<ValueRelation>(context->GetContext(), values, std::move(column_names), "values");
+	rel->Insert(description->database, description->schema, description->table);
+}
+
+void TableRelation::Insert(vector<vector<unique_ptr<ParsedExpression>>> &&expressions) {
+	vector<string> column_names;
+	auto rel = make_shared_ptr<ValueRelation>(context->GetContext(), std::move(expressions), std::move(column_names),
+	                                          "values");
+	rel->Insert(description->database, description->schema, description->table);
+}
+
 } // namespace duckdb

package/src/duckdb/src/main/relation.cpp

@@ -241,7 +241,12 @@ BoundStatement Relation::Bind(Binder &binder) {
 }
 
 shared_ptr<Relation> Relation::InsertRel(const string &schema_name, const string &table_name) {
-	return make_shared_ptr<InsertRelation>(shared_from_this(), schema_name, table_name);
+	return InsertRel(INVALID_CATALOG, schema_name, table_name);
+}
+
+shared_ptr<Relation> Relation::InsertRel(const string &catalog_name, const string &schema_name,
+                                         const string &table_name) {
+	return make_shared_ptr<InsertRelation>(shared_from_this(), catalog_name, schema_name, table_name);
 }
 
 void Relation::Insert(const string &table_name) {
@@ -249,7 +254,11 @@ void Relation::Insert(const string &table_name) {
 }
 
 void Relation::Insert(const string &schema_name, const string &table_name) {
-	auto insert = InsertRel(schema_name, table_name);
+	Insert(INVALID_CATALOG, schema_name, table_name);
+}
+
+void Relation::Insert(const string &catalog_name, const string &schema_name, const string &table_name) {
+	auto insert = InsertRel(catalog_name, schema_name, table_name);
 	auto res = insert->Execute();
 	if (res->HasError()) {
 		const string prepended_message = "Failed to insert into table '" + table_name + "': ";
@@ -258,30 +267,37 @@ void Relation::Insert(const string &schema_name, const string &table_name) {
 }
 
 void Relation::Insert(const vector<vector<Value>> &values) {
-	vector<string> column_names;
-	auto rel = make_shared_ptr<ValueRelation>(context->GetContext(), values, std::move(column_names), "values");
-	rel->Insert(GetAlias());
+	throw InvalidInputException("INSERT with values can only be used on base tables!");
 }
 
 void Relation::Insert(vector<vector<unique_ptr<ParsedExpression>>> &&expressions) {
-	vector<string> column_names;
-	auto rel = make_shared_ptr<ValueRelation>(context->GetContext(), std::move(expressions), std::move(column_names),
-	                                          "values");
-	rel->Insert(GetAlias());
+	(void)std::move(expressions);
+	throw InvalidInputException("INSERT with expressions can only be used on base tables!");
 }
 
 shared_ptr<Relation> Relation::CreateRel(const string &schema_name, const string &table_name, bool temporary,
                                          OnCreateConflict on_conflict) {
-	return make_shared_ptr<CreateTableRelation>(shared_from_this(), schema_name, table_name, temporary, on_conflict);
+	return CreateRel(INVALID_CATALOG, schema_name, table_name, temporary, on_conflict);
+}
+
+shared_ptr<Relation> Relation::CreateRel(const string &catalog_name, const string &schema_name,
+                                         const string &table_name, bool temporary, OnCreateConflict on_conflict) {
+	return make_shared_ptr<CreateTableRelation>(shared_from_this(), catalog_name, schema_name, table_name, temporary,
+	                                            on_conflict);
 }
 
 void Relation::Create(const string &table_name, bool temporary, OnCreateConflict on_conflict) {
-	Create(INVALID_SCHEMA, table_name, temporary, on_conflict);
+	Create(INVALID_CATALOG, INVALID_SCHEMA, table_name, temporary, on_conflict);
 }
 
 void Relation::Create(const string &schema_name, const string &table_name, bool temporary,
                       OnCreateConflict on_conflict) {
-	auto create = CreateRel(schema_name, table_name, temporary, on_conflict);
+	Create(INVALID_CATALOG, schema_name, table_name, temporary, on_conflict);
+}
+
+void Relation::Create(const string &catalog_name, const string &schema_name, const string &table_name, bool temporary,
+                      OnCreateConflict on_conflict) {
+	auto create = CreateRel(catalog_name, schema_name, table_name, temporary, on_conflict);
 	auto res = create->Execute();
 	if (res->HasError()) {
 		const string prepended_message = "Failed to create table '" + table_name + "': ";

package/src/duckdb/src/main/settings/custom_settings.cpp

@@ -961,9 +961,15 @@ void ForceCompressionSetting::SetGlobal(DatabaseInstance *db, DBConfig &config,
 	} else {
 		auto compression_type = CompressionTypeFromString(compression);
 		//! FIXME: do we want to try to retrieve the AttachedDatabase here to get the StorageManager ??
-		if (CompressionTypeIsDeprecated(compression_type)) {
-			throw ParserException("Attempted to force a deprecated compression type (%s)",
-			                      CompressionTypeToString(compression_type));
+		auto compression_availability_result = CompressionTypeIsAvailable(compression_type);
+		if (!compression_availability_result.IsAvailable()) {
+			if (compression_availability_result.IsDeprecated()) {
+				throw ParserException("Attempted to force a deprecated compression type (%s)",
+				                      CompressionTypeToString(compression_type));
+			} else {
+				throw ParserException("Attempted to force a compression type that isn't available yet (%s)",
+				                      CompressionTypeToString(compression_type));
+			}
 		}
 		if (compression_type == CompressionType::COMPRESSION_AUTO) {
 			auto compression_types = StringUtil::Join(ListCompressionTypes(), ", ");

package/src/duckdb/src/optimizer/filter_pullup.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_cross_product.hpp"
 #include "duckdb/planner/operator/logical_join.hpp"
+#include "duckdb/planner/operator/logical_distinct.hpp"
 
 namespace duckdb {
 
@@ -26,6 +27,7 @@ unique_ptr<LogicalOperator> FilterPullup::Rewrite(unique_ptr<LogicalOperator> op
 	case LogicalOperatorType::LOGICAL_EXCEPT:
 		return PullupSetOperation(std::move(op));
 	case LogicalOperatorType::LOGICAL_DISTINCT:
+		return PullupDistinct(std::move(op));
 	case LogicalOperatorType::LOGICAL_ORDER_BY: {
 		// we can just pull directly through these operations without any rewriting
 		op->children[0] = Rewrite(std::move(op->children[0]));
@@ -115,6 +117,18 @@ unique_ptr<LogicalOperator> FilterPullup::PullupCrossProduct(unique_ptr<LogicalO
 	return PullupBothSide(std::move(op));
 }
 
+unique_ptr<LogicalOperator> FilterPullup::PullupDistinct(unique_ptr<LogicalOperator> op) {
+	const auto &distinct = op->Cast<LogicalDistinct>();
+	if (distinct.distinct_type == DistinctType::DISTINCT) {
+		// Can pull up through a DISTINCT
+		op->children[0] = Rewrite(std::move(op->children[0]));
+		return op;
+	}
+	// Cannot pull up through a DISTINCT ON (see #19327)
+	D_ASSERT(distinct.distinct_type == DistinctType::DISTINCT_ON);
+	return FinishPullup(std::move(op));
+}
+
 unique_ptr<LogicalOperator> FilterPullup::GeneratePullupFilter(unique_ptr<LogicalOperator> child,
                                                                vector<unique_ptr<Expression>> &expressions) {
 	unique_ptr<LogicalFilter> filter = make_uniq<LogicalFilter>();