From e5ee3e1b6677c81cec16aa17720141a19a223a83 Mon Sep 17 00:00:00 2001 From: Sam Ansmink Date: Mon, 13 Jan 2025 13:16:52 +0100 Subject: [PATCH] format --- src/delta_extension.cpp | 11 ++-- src/delta_utils.cpp | 103 +++++++++++++++++----------------- src/include/delta_utils.hpp | 23 ++++---- src/storage/delta_catalog.cpp | 12 ++-- 4 files changed, 75 insertions(+), 74 deletions(-) diff --git a/src/delta_extension.cpp b/src/delta_extension.cpp index 2d9c03f..dac8888 100644 --- a/src/delta_extension.cpp +++ b/src/delta_extension.cpp @@ -65,12 +65,13 @@ static void LoadInternal(DatabaseInstance &instance) { "delta scan during explain analyze queries.", LogicalType::BOOLEAN, Value(true)); - config.AddExtensionOption("delta_kernel_logging", - "Forwards the internal logging of the Delta Kernel to the duckdb logger. Warning: this may impact " - "performance even with DuckDB logging disabled.", - LogicalType::BOOLEAN, Value(false), LoggerCallback::DuckDBSettingCallBack); + config.AddExtensionOption( + "delta_kernel_logging", + "Forwards the internal logging of the Delta Kernel to the duckdb logger. Warning: this may impact " + "performance even with DuckDB logging disabled.", + LogicalType::BOOLEAN, Value(false), LoggerCallback::DuckDBSettingCallBack); - LoggerCallback::Initialize(instance); + LoggerCallback::Initialize(instance); } void DeltaExtension::Load(DuckDB &db) { diff --git a/src/delta_utils.cpp b/src/delta_utils.cpp index e8ed7c9..f76c6e3 100644 --- a/src/delta_utils.cpp +++ b/src/delta_utils.cpp @@ -636,69 +636,70 @@ uintptr_t PredicateVisitor::VisitFilter(const string &col_name, const TableFilte } void LoggerCallback::Initialize(DatabaseInstance &db_p) { - auto &instance = GetInstance(); - unique_lock lck(instance.lock); - instance.db = db_p.shared_from_this(); + auto &instance = GetInstance(); + unique_lock lck(instance.lock); + instance.db = db_p.shared_from_this(); } void LoggerCallback::CallbackEvent(ffi::Event event) { - auto &instance = GetInstance(); - auto db_locked = instance.db.lock(); - if (db_locked) { - auto transformed_log_level = GetDuckDBLogLevel(event.level); - string constructed_log_message; - Logger::Log("delta.Kernel", *db_locked, transformed_log_level, [&]() { - auto log_type = KernelUtils::FromDeltaString(event.target); - auto message = KernelUtils::FromDeltaString(event.message); - auto file = KernelUtils::FromDeltaString(event.file); - if (!file.empty()) { - constructed_log_message = StringUtil::Format("[%s] %s@%u : %s ", log_type, file, event.line, message); - } else { - constructed_log_message = message; - } - - return constructed_log_message.c_str(); - }); - } + auto &instance = GetInstance(); + auto db_locked = instance.db.lock(); + if (db_locked) { + auto transformed_log_level = GetDuckDBLogLevel(event.level); + string constructed_log_message; + Logger::Log("delta.Kernel", *db_locked, transformed_log_level, [&]() { + auto log_type = KernelUtils::FromDeltaString(event.target); + auto message = KernelUtils::FromDeltaString(event.message); + auto file = KernelUtils::FromDeltaString(event.file); + if (!file.empty()) { + constructed_log_message = StringUtil::Format("[%s] %s@%u : %s ", log_type, file, event.line, message); + } else { + constructed_log_message = message; + } + + return constructed_log_message.c_str(); + }); + } } LogLevel LoggerCallback::GetDuckDBLogLevel(ffi::Level level) { - switch (level) { - case ffi::Level::TRACE: - return LogLevel::LOG_TRACE; - case ffi::Level::DEBUGGING: - return LogLevel::LOG_DEBUG; - case ffi::Level::INFO: - return LogLevel::LOG_INFO; - case ffi::Level::WARN: - return LogLevel::LOG_WARN; - case ffi::Level::ERROR: - return LogLevel::LOG_ERROR; - } + switch (level) { + case ffi::Level::TRACE: + return LogLevel::LOG_TRACE; + case ffi::Level::DEBUGGING: + return LogLevel::LOG_DEBUG; + case ffi::Level::INFO: + return LogLevel::LOG_INFO; + case ffi::Level::WARN: + return LogLevel::LOG_WARN; + case ffi::Level::ERROR: + return LogLevel::LOG_ERROR; + } } LoggerCallback &LoggerCallback::GetInstance() { - static LoggerCallback instance; - return instance; + static LoggerCallback instance; + return instance; } void LoggerCallback::DuckDBSettingCallBack(ClientContext &context, SetScope scope, Value ¶meter) { - Value current_setting; - auto res = context.TryGetCurrentSetting("delta_kernel_logging", current_setting); - - if (res.GetScope() == SettingScope::INVALID) { - throw InternalException("Failed to find setting 'delta_kernel_logging'"); - } - - if (current_setting.GetValue() && !parameter.GetValue()) { - throw InvalidInputException("Can not disable 'delta_kernel_logging' after enabling it. You can disable DuckDB " - "logging with SET enable_logging=false, but there will still be some performance overhead from 'delta_kernel_logging'" - "that can only be mitigated by restarting DuckDB"); - } - - if (!current_setting.GetValue() && parameter.GetValue()) { - ffi::enable_event_tracing(LoggerCallback::CallbackEvent, ffi::Level::TRACE); - } + Value current_setting; + auto res = context.TryGetCurrentSetting("delta_kernel_logging", current_setting); + + if (res.GetScope() == SettingScope::INVALID) { + throw InternalException("Failed to find setting 'delta_kernel_logging'"); + } + + if (current_setting.GetValue() && !parameter.GetValue()) { + throw InvalidInputException("Can not disable 'delta_kernel_logging' after enabling it. You can disable DuckDB " + "logging with SET enable_logging=false, but there will still be some performance " + "overhead from 'delta_kernel_logging'" + "that can only be mitigated by restarting DuckDB"); + } + + if (!current_setting.GetValue() && parameter.GetValue()) { + ffi::enable_event_tracing(LoggerCallback::CallbackEvent, ffi::Level::TRACE); + } } }; // namespace duckdb diff --git a/src/include/delta_utils.hpp b/src/include/delta_utils.hpp index f6d9671..5bf4e1d 100644 --- a/src/include/delta_utils.hpp +++ b/src/include/delta_utils.hpp @@ -340,23 +340,22 @@ class PredicateVisitor : public ffi::EnginePredicate { // Singleton class to forward logs to DuckDB class LoggerCallback { public: + //! The Callback for the DuckDB setting to hook up Delta Kernel Logging to the DuckDB logger + static void DuckDBSettingCallBack(ClientContext &context, SetScope scope, Value ¶meter); - //! The Callback for the DuckDB setting to hook up Delta Kernel Logging to the DuckDB logger - static void DuckDBSettingCallBack(ClientContext &context, SetScope scope, Value ¶meter); + //! Singleton GetInstance + static LoggerCallback &GetInstance(); + static void Initialize(DatabaseInstance &db); + static void CallbackEvent(ffi::Event log_line); - //! Singleton GetInstance - static LoggerCallback& GetInstance(); - static void Initialize(DatabaseInstance &db); - static void CallbackEvent(ffi::Event log_line); - - - static LogLevel GetDuckDBLogLevel(ffi::Level); + static LogLevel GetDuckDBLogLevel(ffi::Level); protected: - LoggerCallback() {} + LoggerCallback() { + } - mutex lock; - weak_ptr db; + mutex lock; + weak_ptr db; }; } // namespace duckdb diff --git a/src/storage/delta_catalog.cpp b/src/storage/delta_catalog.cpp index 5ecba54..fb301e2 100644 --- a/src/storage/delta_catalog.cpp +++ b/src/storage/delta_catalog.cpp @@ -60,22 +60,22 @@ bool DeltaCatalog::UseCachedSnapshot() { optional_idx DeltaCatalog::GetCatalogVersion(ClientContext &context) { auto &delta_transaction = DeltaTransaction::Get(context, *this); - idx_t version = DConstants::INVALID_INDEX; + idx_t version = DConstants::INVALID_INDEX; // Option 1: snapshot is cached table-wide auto cached_snapshot = main_schema->GetCachedTable(); if (cached_snapshot) { - version = cached_snapshot->snapshot->GetVersion(); + version = cached_snapshot->snapshot->GetVersion(); } // Option 2: snapshot is cached in transaction if (delta_transaction.table_entry) { - version = delta_transaction.table_entry->snapshot->GetVersion(); + version = delta_transaction.table_entry->snapshot->GetVersion(); } - if (version != DConstants::INVALID_INDEX) { - return version; - } + if (version != DConstants::INVALID_INDEX) { + return version; + } return optional_idx::Invalid(); }