duckdb 1.1.4-dev13.0 → 1.1.4-dev14.0

package/src/duckdb/src/logging/logger.cpp

@@ -9,6 +9,14 @@
 
 namespace duckdb {
 
+void Logger::WriteLog(const char *log_type, LogLevel log_level, const string &message) {
+	WriteLog(log_type, log_level, message.c_str());
+}
+void Logger::WriteLog(const char *log_type, LogLevel log_level, const string_t &message) {
+	string copied_string = message.GetString();
+	WriteLog(log_type, log_level, copied_string.c_str());
+}
+
 Logger &Logger::Get(const DatabaseInstance &db) {
 	return db.GetLogManager().GlobalLogger();
 }
@@ -29,46 +37,6 @@ Logger &Logger::Get(const FileOpener &opener) {
 	return opener.GetLogger();
 }
 
-void Logger::Log(const char *log_type, LogLevel log_level, const char *log_message) {
-	if (ShouldLog(log_type, log_level)) {
-		WriteLog(log_type, log_level, log_message);
-	}
-}
-
-void Logger::Log(LogLevel log_level, const char *log_message) {
-	if (ShouldLog(log_level)) {
-		WriteLog(log_level, log_message);
-	}
-}
-
-void Logger::Log(const char *log_type, LogLevel log_level, const string_t &log_message) {
-	if (ShouldLog(log_type, log_level)) {
-		auto string_copy = log_message.GetString();
-		WriteLog(log_type, log_level, string_copy.c_str());
-	}
-}
-
-void Logger::Log(LogLevel log_level, const string_t &log_message) {
-	if (ShouldLog(log_level)) {
-		auto string_copy = log_message.GetString();
-		WriteLog(log_level, string_copy.c_str());
-	}
-}
-
-void Logger::Log(const char *log_type, LogLevel log_level, std::function<string()> callback) { // NOLINT
-	if (ShouldLog(log_type, log_level)) {
-		auto string = callback();
-		WriteLog(log_type, log_level, string.c_str());
-	}
-}
-
-void Logger::Log(LogLevel log_level, std::function<string()> callback) { // NOLINT
-	if (ShouldLog(log_level)) {
-		auto string = callback();
-		WriteLog(log_level, string.c_str());
-	}
-}
-
 ThreadSafeLogger::ThreadSafeLogger(LogConfig &config_p, LoggingContext &context_p, LogManager &manager)
     : ThreadSafeLogger(config_p, manager.RegisterLoggingContext(context_p), manager) {
 }
@@ -95,19 +63,10 @@ bool ThreadSafeLogger::ShouldLog(const char *log_type, LogLevel log_level) {
 	return true;
 }
 
-bool ThreadSafeLogger::ShouldLog(LogLevel log_level) {
-	return ShouldLog(context.context.default_log_type, log_level);
-}
-
 void ThreadSafeLogger::WriteLog(const char *log_type, LogLevel log_level, const char *log_message) {
 	manager.WriteLogEntry(Timestamp::GetCurrentTimestamp(), log_type, log_level, log_message, context);
 }
 
-void ThreadSafeLogger::WriteLog(LogLevel log_level, const char *log_message) {
-	manager.WriteLogEntry(Timestamp::GetCurrentTimestamp(), context.context.default_log_type, log_level, log_message,
-	                      context);
-}
-
 void ThreadSafeLogger::Flush() {
 	manager.Flush();
 	// NOP
@@ -127,18 +86,10 @@ bool ThreadLocalLogger::ShouldLog(const char *log_type, LogLevel log_level) {
 	throw NotImplementedException("ThreadLocalLogger::ShouldLog");
 }
 
-bool ThreadLocalLogger::ShouldLog(LogLevel log_level) {
-	throw NotImplementedException("ThreadLocalLogger::ShouldLog");
-}
-
 void ThreadLocalLogger::WriteLog(const char *log_type, LogLevel log_level, const char *log_message) {
 	throw NotImplementedException("ThreadLocalLogger::WriteLog");
 }
 
-void ThreadLocalLogger::WriteLog(LogLevel log_level, const char *log_message) {
-	throw NotImplementedException("ThreadLocalLogger::WriteLog");
-}
-
 void ThreadLocalLogger::Flush() {
 	manager.Flush();
 }
@@ -168,11 +119,6 @@ void MutableLogger::WriteLog(const char *log_type, LogLevel log_level, const cha
 	manager.WriteLogEntry(Timestamp::GetCurrentTimestamp(), log_type, log_level, log_message, context);
 }
 
-void MutableLogger::WriteLog(LogLevel log_level, const char *log_message) {
-	manager.WriteLogEntry(Timestamp::GetCurrentTimestamp(), context.context.default_log_type, log_level, log_message,
-	                      context);
-}
-
 bool MutableLogger::ShouldLog(const char *log_type, LogLevel log_level) {
 	if (!enabled) {
 		return false;
@@ -200,10 +146,6 @@ bool MutableLogger::ShouldLog(const char *log_type, LogLevel log_level) {
 	throw InternalException("Should be unreachable (MutableLogger::ShouldLog)");
 }
 
-bool MutableLogger::ShouldLog(LogLevel log_level) {
-	return ShouldLog(context.context.default_log_type, log_level);
-}
-
 void MutableLogger::Flush() {
 	manager.Flush();
 }

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

@@ -99,9 +99,11 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, str
 		if (StringUtil::CIEquals(entry.first, "row_group_size")) {
 			continue;
 		}
+		if (StringUtil::CIEquals(entry.first, "storage_version")) {
+			continue;
+		}
 		throw BinderException("Unrecognized option for attach \"%s\"", entry.first);
 	}
-
 	// We create the storage after the catalog to guarantee we allow extensions to instantiate the DuckCatalog.
 	catalog = make_uniq<DuckCatalog>(*this);
 	auto read_only = options.access_mode == AccessMode::READ_ONLY;

package/src/duckdb/src/main/client_context.cpp

@@ -218,7 +218,7 @@ void ClientContext::BeginQueryInternal(ClientContextLock &lock, const string &qu
 	context.client_context = reinterpret_cast<idx_t>(this);
 	context.transaction_id = transaction.GetActiveQuery();
 	logger = db->GetLogManager().CreateLogger(context, true);
-	Logger::Info("duckdb.ClientContext.BeginQuery", *this, query);
+	DUCKDB_LOG_INFO(*this, "duckdb.ClientContext.BeginQuery", query);
 }
 
 ErrorData ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, bool invalidate_transaction,
@@ -1049,7 +1049,9 @@ unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const string &query,
 
 		return PendingQueryInternal(*lock, std::move(statements[0]), params, true);
 	} catch (std::exception &ex) {
-		return make_uniq<PendingQueryResult>(ErrorData(ex));
+		ErrorData error(ex);
+		ProcessError(error, query);
+		return make_uniq<PendingQueryResult>(std::move(error));
 	}
 }
 

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

@@ -7,6 +7,7 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/main/settings.hpp"
 #include "duckdb/storage/storage_extension.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
 
 #ifndef DUCKDB_NO_THREADS
 #include "duckdb/common/thread.hpp"
@@ -92,6 +93,7 @@ static const ConfigurationOption internal_options[] = {
     DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting),
     DUCKDB_GLOBAL(DefaultOrderSetting),
     DUCKDB_GLOBAL(DefaultSecretStorageSetting),
+    DUCKDB_GLOBAL(DisabledCompressionMethodsSetting),
     DUCKDB_GLOBAL(DisabledFilesystemsSetting),
     DUCKDB_GLOBAL(DisabledLogTypes),
     DUCKDB_GLOBAL(DisabledOptimizersSetting),
@@ -460,7 +462,7 @@ idx_t DBConfig::GetSystemMaxThreads(FileSystem &fs) {
 	}
 	return MaxValue<idx_t>(CGroups::GetCPULimit(fs, physical_cores), 1);
 #else
-	return physical_cores;
+	return MaxValue<idx_t>(physical_cores, 1);
 #endif
 #endif
 }
@@ -740,6 +742,22 @@ bool DBConfig::CanAccessFile(const string &input_path, FileType type) {
 	return true;
 }
 
+SerializationOptions::SerializationOptions(AttachedDatabase &db) {
+	serialization_compatibility = SerializationCompatibility::FromDatabase(db);
+}
+
+SerializationCompatibility SerializationCompatibility::FromDatabase(AttachedDatabase &db) {
+	return FromIndex(db.GetStorageManager().GetStorageVersion());
+}
+
+SerializationCompatibility SerializationCompatibility::FromIndex(const idx_t version) {
+	SerializationCompatibility result;
+	result.duckdb_version = "";
+	result.serialization_version = version;
+	result.manually_set = false;
+	return result;
+}
+
 SerializationCompatibility SerializationCompatibility::FromString(const string &input) {
 	if (input.empty()) {
 		throw InvalidInputException("Version string can not be empty");
@@ -748,7 +766,7 @@ SerializationCompatibility SerializationCompatibility::FromString(const string &
 	auto serialization_version = GetSerializationVersion(input.c_str());
 	if (!serialization_version.IsValid()) {
 		auto candidates = GetSerializationCandidates();
-		throw InvalidInputException("The version string '%s' is not a valid DuckDB version, valid options are: %s",
+		throw InvalidInputException("The version string '%s' is not a known DuckDB version, valid options are: %s",
 		                            input, StringUtil::Join(candidates, ", "));
 	}
 	SerializationCompatibility result;

package/src/duckdb/src/main/connection.cpp

@@ -28,9 +28,10 @@ Connection::Connection(DatabaseInstance &database)
 }
 
 Connection::Connection(DuckDB &database) : Connection(*database.instance) {
+	// Initialization of warning_cb happens in the other constructor
 }
 
-Connection::Connection(Connection &&other) noexcept {
+Connection::Connection(Connection &&other) noexcept : warning_cb(nullptr) {
 	std::swap(context, other.context);
 	std::swap(warning_cb, other.warning_cb);
 }
@@ -98,34 +99,6 @@ unique_ptr<MaterializedQueryResult> Connection::Query(const string &query) {
 	return unique_ptr_cast<QueryResult, MaterializedQueryResult>(std::move(result));
 }
 
-DUCKDB_API string Connection::GetSubstrait(const string &query) {
-	vector<Value> params;
-	params.emplace_back(query);
-	auto result = TableFunction("get_substrait", params)->Execute();
-	auto protobuf = result->FetchRaw()->GetValue(0, 0);
-	return protobuf.GetValueUnsafe<string_t>().GetString();
-}
-
-DUCKDB_API unique_ptr<QueryResult> Connection::FromSubstrait(const string &proto) {
-	vector<Value> params;
-	params.emplace_back(Value::BLOB_RAW(proto));
-	return TableFunction("from_substrait", params)->Execute();
-}
-
-DUCKDB_API string Connection::GetSubstraitJSON(const string &query) {
-	vector<Value> params;
-	params.emplace_back(query);
-	auto result = TableFunction("get_substrait_json", params)->Execute();
-	auto protobuf = result->FetchRaw()->GetValue(0, 0);
-	return protobuf.GetValueUnsafe<string_t>().GetString();
-}
-
-DUCKDB_API unique_ptr<QueryResult> Connection::FromSubstraitJSON(const string &json) {
-	vector<Value> params;
-	params.emplace_back(json);
-	return TableFunction("from_substrait_json", params)->Execute();
-}
-
 unique_ptr<MaterializedQueryResult> Connection::Query(unique_ptr<SQLStatement> statement) {
 	auto result = context->Query(std::move(statement), false);
 	D_ASSERT(result->type == QueryResultType::MATERIALIZED_RESULT);

package/src/duckdb/src/main/connection_manager.cpp

@@ -5,7 +5,7 @@
 
 namespace duckdb {
 
-ConnectionManager::ConnectionManager() {
+ConnectionManager::ConnectionManager() : connection_count(0) {
 }
 
 void ConnectionManager::AddConnection(ClientContext &context) {
@@ -14,6 +14,7 @@ void ConnectionManager::AddConnection(ClientContext &context) {
 		callback->OnConnectionOpened(context);
 	}
 	connections[context] = weak_ptr<ClientContext>(context.shared_from_this());
+	connection_count = connections.size();
 }
 
 void ConnectionManager::RemoveConnection(ClientContext &context) {
@@ -22,11 +23,11 @@ void ConnectionManager::RemoveConnection(ClientContext &context) {
 		callback->OnConnectionClosed(context);
 	}
 	connections.erase(context);
+	connection_count = connections.size();
 }
 
 idx_t ConnectionManager::GetConnectionCount() const {
-	lock_guard<mutex> lock(connections_lock);
-	return connections.size();
+	return connection_count;
 }
 
 vector<shared_ptr<ClientContext>> ConnectionManager::GetConnectionList() {
@@ -36,6 +37,7 @@ vector<shared_ptr<ClientContext>> ConnectionManager::GetConnectionList() {
 		auto connection = it.second.lock();
 		if (!connection) {
 			connections.erase(it.first);
+			connection_count = connections.size();
 			continue;
 		} else {
 			result.push_back(std::move(connection));

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

@@ -462,7 +462,7 @@ void DatabaseInstance::Configure(DBConfig &new_config, const char *database_path
 		                                                 config.options.buffer_manager_track_eviction_timestamps,
 		                                                 config.options.allocator_bulk_deallocation_flush_threshold);
 	}
-	config.db_cache_entry = new_config.db_cache_entry;
+	config.db_cache_entry = std::move(new_config.db_cache_entry);
 }
 
 DBConfig &DBConfig::GetConfig(ClientContext &context) {
@@ -508,7 +508,7 @@ void DatabaseInstance::SetExtensionLoaded(const string &name, ExtensionInstallIn
 	for (auto &callback : callbacks) {
 		callback->OnExtensionLoaded(*this, name);
 	}
-	Logger::Info("duckdb.Extensions.ExtensionLoaded", *this, name);
+	DUCKDB_LOG_INFO(*this, "duckdb.Extensions.ExtensionLoaded", name);
 }
 
 SettingLookupResult DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &result) const {

package/src/duckdb/src/main/extension/extension_helper.cpp

@@ -114,7 +114,6 @@ static const DefaultExtension internal_extensions[] = {
     {"postgres_scanner", "Adds support for connecting to a Postgres database", false},
     {"inet", "Adds support for IP-related data types and functions", false},
     {"spatial", "Geospatial extension that adds support for working with spatial data and functions", false},
-    {"substrait", "Adds support for the Substrait integration", false},
     {"aws", "Provides features that depend on the AWS SDK", false},
     {"arrow", "A zero-copy data integration between Apache Arrow and DuckDB", false},
     {"azure", "Adds a filesystem abstraction for Azure blob storage to DuckDB", false},
@@ -140,13 +139,13 @@ DefaultExtension ExtensionHelper::GetDefaultExtension(idx_t index) {
 // Allow Auto-Install Extensions
 //===--------------------------------------------------------------------===//
 static const char *const auto_install[] = {"motherduck", "postgres_scanner", "mysql_scanner", "sqlite_scanner",
-                                           nullptr};
+                                           "delta",      "iceberg",          "uc_catalog",    nullptr};
 
 // TODO: unify with new autoload mechanism
 bool ExtensionHelper::AllowAutoInstall(const string &extension) {
-	auto lcase = StringUtil::Lower(extension);
+	auto extension_name = ApplyExtensionAlias(extension);
 	for (idx_t i = 0; auto_install[i]; i++) {
-		if (lcase == auto_install[i]) {
+		if (extension_name == auto_install[i]) {
 			return true;
 		}
 	}
@@ -389,7 +388,7 @@ void ExtensionHelper::AutoLoadExtension(DatabaseInstance &db, const string &exte
 		}
 #endif
 		ExtensionHelper::LoadExternalExtension(db, *fs, extension_name);
-		Logger::Info("duckdb.Extensions.ExtensionAutoloaded", db, extension_name);
+		DUCKDB_LOG_INFO(db, "duckdb.Extensions.ExtensionAutoloaded", extension_name);
 
 	} catch (std::exception &e) {
 		ErrorData error(e);

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -56,6 +56,18 @@ const vector<string> ExtensionHelper::PathComponents() {
 	return vector<string> {GetVersionDirectoryName(), DuckDB::Platform()};
 }
 
+string ExtensionHelper::ExtensionInstallDocumentationLink(const string &extension_name) {
+	auto components = PathComponents();
+
+	string link = "https://duckdb.org/docs/extensions/troubleshooting";
+
+	if (components.size() >= 2) {
+		link += "/?version=" + components[0] + "&platform=" + components[1] + "&extension=" + extension_name;
+	}
+
+	return link;
+}
+
 duckdb::string ExtensionHelper::DefaultExtensionFolder(FileSystem &fs) {
 	string home_directory = fs.GetHomeDirectory();
 	// exception if the home directory does not exist, don't create whatever we think is home
@@ -90,6 +102,12 @@ string ExtensionHelper::GetExtensionDirectoryPath(DatabaseInstance &db, FileSyst
 	extension_directory = fs.ConvertSeparators(extension_directory);
 	// expand ~ in extension directory
 	extension_directory = fs.ExpandPath(extension_directory);
+
+	auto path_components = PathComponents();
+	for (auto &path_ele : path_components) {
+		extension_directory = fs.JoinPath(extension_directory, path_ele);
+	}
+
 	return extension_directory;
 }
 
@@ -117,13 +135,6 @@ string ExtensionHelper::ExtensionDirectory(DatabaseInstance &db, FileSystem &fs)
 	}
 	D_ASSERT(fs.DirectoryExists(extension_directory));
 
-	auto path_components = PathComponents();
-	for (auto &path_ele : path_components) {
-		extension_directory = fs.JoinPath(extension_directory, path_ele);
-		if (!fs.DirectoryExists(extension_directory)) {
-			fs.CreateDirectory(extension_directory);
-		}
-	}
 	return extension_directory;
 }
 
@@ -445,9 +456,11 @@ static unique_ptr<ExtensionInstallInfo> InstallFromHttpUrl(DatabaseInstance &db,
 		if (!should_retry || retry_count >= MAX_RETRY_COUNT) {
 			// if we should not retry or exceeded the number of retries - bubble up the error
 			string message;
-			auto exact_match = ExtensionHelper::CreateSuggestions(extension_name, message);
-			if (exact_match && !ExtensionHelper::IsRelease(DuckDB::LibraryVersion())) {
-				message += "\nAre you using a development build? In this case, extensions might not (yet) be uploaded.";
+			ExtensionHelper::CreateSuggestions(extension_name, message);
+
+			auto documentation_link = ExtensionHelper::ExtensionInstallDocumentationLink(extension_name);
+			if (!documentation_link.empty()) {
+				message += "\nFor more info, visit " + documentation_link;
 			}
 			if (res.error() == duckdb_httplib::Error::Success) {
 				throw HTTPException(res.value(), "Failed to download extension \"%s\" at URL \"%s%s\" (HTTP %n)\n%s",

package/src/duckdb/src/main/extension/extension_load.cpp

@@ -399,15 +399,13 @@ bool ExtensionHelper::TryInitialLoad(DatabaseInstance &db, FileSystem &fs, const
 			signature_valid = false;
 		}
 
-		if (!signature_valid) {
-			throw IOException(db.config.error_manager->FormatException(ErrorType::UNSIGNED_EXTENSION, filename) +
-			                  metadata_mismatch_error);
-		}
-
 		if (!metadata_mismatch_error.empty()) {
-			// Signed extensions perform the full check
 			throw InvalidInputException(metadata_mismatch_error);
 		}
+
+		if (!signature_valid) {
+			throw IOException(db.config.error_manager->FormatException(ErrorType::UNSIGNED_EXTENSION, filename));
+		}
 	} else if (!db.config.options.allow_extensions_metadata_mismatch) {
 		if (!metadata_mismatch_error.empty()) {
 			// Unsigned extensions AND configuration allowing n, loading allowed, mainly for
@@ -483,7 +481,8 @@ ExtensionInitResult ExtensionHelper::InitialLoad(DatabaseInstance &db, FileSyste
 	string error;
 	ExtensionInitResult result;
 	if (!TryInitialLoad(db, fs, extension, result, error)) {
-		if (!ExtensionHelper::AllowAutoInstall(extension)) {
+		auto &config = DBConfig::GetConfig(db);
+		if (!config.options.autoinstall_known_extensions || !ExtensionHelper::AllowAutoInstall(extension)) {
 			throw IOException(error);
 		}
 		// the extension load failed - try installing the extension

package/src/duckdb/src/main/extension.cpp

@@ -50,18 +50,29 @@ string ParsedExtensionMetaData::GetInvalidMetadataError() {
 		const string engine_version = string(ExtensionHelper::GetVersionDirectoryName());
 
 		if (engine_version != duckdb_version) {
-			result += StringUtil::Format("The file was built for DuckDB version '%s', but we can only load extensions "
-			                             "built for DuckDB version '%s'.",
+			result += StringUtil::Format("The file was built specifically for DuckDB version '%s' and can only be "
+			                             "loaded with that version of DuckDB. (this version of DuckDB is '%s')",
 			                             PrettyPrintString(duckdb_version), engine_version);
 		}
-		// C_STRUCT ABI versioning works when current duckdb version >= required version
+		// C_STRUCT ABI versioning
 	} else if (abi_type == ExtensionABIType::C_STRUCT) {
-
-		if (!VersioningUtils::IsSupportedCAPIVersion(duckdb_capi_version)) {
-			result += StringUtil::Format("The file was built for DuckDB version '%s', but we can only load extensions "
-			                             "built for DuckDB C API 'v%lld.%lld.%lld' and lower.",
-			                             duckdb_capi_version, DUCKDB_EXTENSION_API_VERSION_MAJOR,
-			                             DUCKDB_EXTENSION_API_VERSION_MINOR, DUCKDB_EXTENSION_API_VERSION_PATCH);
+		idx_t major, minor, patch;
+		if (!VersioningUtils::ParseSemver(duckdb_capi_version, major, minor, patch)) {
+			result += StringUtil::Format("The file was built for DuckDB C API version '%s', which failed to parse as a "
+			                             "recognized version string",
+			                             duckdb_capi_version, DUCKDB_EXTENSION_API_VERSION_MAJOR);
+		} else if (major != DUCKDB_EXTENSION_API_VERSION_MAJOR) {
+			// Special case where the extension is built for a completely unsupported API
+			result +=
+			    StringUtil::Format("The file was built for DuckDB C API version '%s', but we can only load extensions "
+			                       "built for DuckDB C API 'v%lld.x.y'.",
+			                       duckdb_capi_version, DUCKDB_EXTENSION_API_VERSION_MAJOR);
+		} else if (!VersioningUtils::IsSupportedCAPIVersion(major, minor, patch)) {
+			result +=
+			    StringUtil::Format("The file was built for DuckDB C API version '%s', but we can only load extensions "
+			                       "built for DuckDB C API 'v%lld.%lld.%lld' and lower.",
+			                       duckdb_capi_version, DUCKDB_EXTENSION_API_VERSION_MAJOR,
+			                       DUCKDB_EXTENSION_API_VERSION_MINOR, DUCKDB_EXTENSION_API_VERSION_PATCH);
 		}
 	} else {
 		throw InternalException("Unknown ABI type for extension: " + extension_abi_metadata);
@@ -137,4 +148,11 @@ bool VersioningUtils::ParseSemver(string &semver, idx_t &major_out, idx_t &minor
 	return true;
 }
 
+const char *Extension::DefaultVersion() {
+	if (ExtensionHelper::IsRelease(DuckDB::LibraryVersion())) {
+		return DuckDB::LibraryVersion();
+	}
+	return DuckDB::SourceID();
+}
+
 } // namespace duckdb

package/src/duckdb/src/main/secret/secret_manager.cpp

@@ -489,6 +489,17 @@ vector<SecretEntry> SecretManager::AllSecrets(CatalogTransaction transaction) {
 	return result;
 }
 
+vector<SecretType> SecretManager::AllSecretTypes() {
+	unique_lock<mutex> lck(manager_lock);
+	vector<SecretType> result;
+
+	for (const auto &secret : secret_types) {
+		result.push_back(secret.second);
+	}
+
+	return result;
+}
+
 void SecretManager::ThrowOnSettingChangeIfInitialized() {
 	if (initialized) {
 		throw InvalidInputException(

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

@@ -499,6 +499,50 @@ Value DefaultSecretStorageSetting::GetSetting(const ClientContext &context) {
 	return config.secret_manager->DefaultStorage();
 }
 
+//===----------------------------------------------------------------------===//
+// Disabled Compression Methods
+//===----------------------------------------------------------------------===//
+void DisabledCompressionMethodsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	auto list = StringUtil::Split(input.ToString(), ",");
+	set<CompressionType> disabled_compression_methods;
+	for (auto &entry : list) {
+		auto param = StringUtil::Lower(entry);
+		StringUtil::Trim(param);
+		if (param.empty()) {
+			continue;
+		}
+		if (param == "none") {
+			disabled_compression_methods.clear();
+			break;
+		}
+		auto compression_type = CompressionTypeFromString(param);
+		if (compression_type == CompressionType::COMPRESSION_UNCOMPRESSED) {
+			throw InvalidInputException("Uncompressed compression cannot be disabled");
+		}
+		if (compression_type == CompressionType::COMPRESSION_AUTO) {
+			throw InvalidInputException("Unrecognized compression method \"%s\"", entry);
+		}
+		disabled_compression_methods.insert(compression_type);
+	}
+	config.options.disabled_compression_methods = std::move(disabled_compression_methods);
+}
+
+void DisabledCompressionMethodsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.disabled_compression_methods = DBConfig().options.disabled_compression_methods;
+}
+
+Value DisabledCompressionMethodsSetting::GetSetting(const ClientContext &context) {
+	auto &config = DBConfig::GetConfig(context);
+	string result;
+	for (auto &optimizer : config.options.disabled_compression_methods) {
+		if (!result.empty()) {
+			result += ",";
+		}
+		result += CompressionTypeToString(optimizer);
+	}
+	return Value(result);
+}
+
 //===----------------------------------------------------------------------===//
 // Disabled Filesystems
 //===----------------------------------------------------------------------===//

package/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp

@@ -102,6 +102,12 @@ void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) {
 		GenerateProjectionMap(op.children[1]->GetColumnBindings(), rhs_unused, comp_join.right_projection_map);
 		return;
 	}
+	case LogicalOperatorType::LOGICAL_INSERT:
+	case LogicalOperatorType::LOGICAL_UPDATE:
+	case LogicalOperatorType::LOGICAL_DELETE:
+		//! When RETURNING is used, a PROJECTION is the top level operator for INSERTS, UPDATES, and DELETES
+		//! We still need to project all values from these operators so the projection
+		//! on top of them can select from only the table values being inserted.
 	case LogicalOperatorType::LOGICAL_UNION:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
 	case LogicalOperatorType::LOGICAL_INTERSECT:

package/src/duckdb/src/optimizer/filter_combiner.cpp

@@ -78,6 +78,7 @@ FilterResult FilterCombiner::AddConstantComparison(vector<ExpressionValueInforma
 			return FilterResult::SUCCESS;
 		case ValueComparisonResult::UNSATISFIABLE_CONDITION:
 			// combination of filters is unsatisfiable: prune the entire branch
+			info_list.push_back(info);
 			return FilterResult::UNSATISFIABLE;
 		default:
 			// prune nothing, move to the next condition
@@ -792,11 +793,15 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression &expr) {
 		auto transitive_filter = FindTransitiveFilter(non_scalar);
 		if (transitive_filter != nullptr) {
 			// try to add transitive filters
-			if (AddTransitiveFilters(transitive_filter->Cast<BoundComparisonExpression>()) ==
-			    FilterResult::UNSUPPORTED) {
+			auto transitive_result = AddTransitiveFilters(transitive_filter->Cast<BoundComparisonExpression>());
+			if (transitive_result == FilterResult::UNSUPPORTED) {
 				// in case of unsuccessful re-add filter into remaining ones
 				remaining_filters.push_back(std::move(transitive_filter));
 			}
+			if (transitive_result == FilterResult::UNSATISFIABLE) {
+				// in case transitive filter is unsatisfiable - abort filter pushdown
+				return FilterResult::UNSATISFIABLE;
+			}
 		}
 		return ret;
 	} else {
@@ -1067,10 +1072,15 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 			if (transitive_filter != nullptr) {
 				// try to add transitive filters
 				auto &transitive_cast = transitive_filter->Cast<BoundComparisonExpression>();
-				if (AddTransitiveFilters(transitive_cast, false) == FilterResult::UNSUPPORTED) {
+				auto transitive_result = AddTransitiveFilters(transitive_cast, false);
+				if (transitive_result == FilterResult::UNSUPPORTED) {
 					// in case of unsuccessful re-add filter into remaining ones
 					remaining_filters.push_back(std::move(transitive_filter));
 				}
+				if (transitive_result == FilterResult::UNSATISFIABLE) {
+					// while adding transitive filters we discovered the filter is unsatisfisable - we can prune
+					return FilterResult::UNSATISFIABLE;
+				}
 			}
 		}
 		return FilterResult::SUCCESS;