duckdb 1.2.1-dev6.0 → 1.2.1

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

@@ -247,7 +247,7 @@ void AttachedDatabase::Close() {
 			}
 			CheckpointOptions options;
 			options.wal_action = CheckpointWALAction::DELETE_WAL;
-			storage->CreateCheckpoint(options);
+			storage->CreateCheckpoint(nullptr, options);
 		}
 	} catch (...) { // NOLINT
 	}

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

@@ -35,7 +35,11 @@ duckdb_state duckdb_open_internal(DBInstanceCacheWrapper *cache, const char *pat
 		}
 
 		if (cache) {
-			wrapper->database = cache->instance_cache->GetOrCreateInstance(path, *db_config, true);
+			duckdb::string path_str;
+			if (path) {
+				path_str = path;
+			}
+			wrapper->database = cache->instance_cache->GetOrCreateInstance(path_str, *db_config, true);
 		} else {
 			wrapper->database = duckdb::make_shared_ptr<DuckDB>(path, db_config);
 		}

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

@@ -78,6 +78,10 @@ LogicalTypeId ConvertCTypeToCPP(duckdb_type c_type) {
 		return LogicalTypeId::VARINT;
 	case DUCKDB_TYPE_SQLNULL:
 		return LogicalTypeId::SQLNULL;
+	case DUCKDB_TYPE_STRING_LITERAL:
+		return LogicalTypeId::STRING_LITERAL;
+	case DUCKDB_TYPE_INTEGER_LITERAL:
+		return LogicalTypeId::INTEGER_LITERAL;
 	default: // LCOV_EXCL_START
 		D_ASSERT(0);
 		return LogicalTypeId::INVALID;
@@ -160,6 +164,10 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
 		return DUCKDB_TYPE_ANY;
 	case LogicalTypeId::SQLNULL:
 		return DUCKDB_TYPE_SQLNULL;
+	case LogicalTypeId::STRING_LITERAL:
+		return DUCKDB_TYPE_STRING_LITERAL;
+	case LogicalTypeId::INTEGER_LITERAL:
+		return DUCKDB_TYPE_INTEGER_LITERAL;
 	default: // LCOV_EXCL_START
 		D_ASSERT(0);
 		return DUCKDB_TYPE_INVALID;

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

@@ -380,7 +380,13 @@ void DBConfig::AddExtensionOption(const string &name, string description, Logica
                                   const Value &default_value, set_option_callback_t function) {
 	extension_parameters.insert(
 	    make_pair(name, ExtensionOption(std::move(description), std::move(parameter), function, default_value)));
-	if (!default_value.IsNull()) {
+	// copy over unrecognized options, if they match the new extension option
+	auto iter = options.unrecognized_options.find(name);
+	if (iter != options.unrecognized_options.end()) {
+		options.set_variables[name] = iter->second;
+		options.unrecognized_options.erase(iter);
+	}
+	if (!default_value.IsNull() && options.set_variables.find(name) == options.set_variables.end()) {
 		// Default value is set, insert it into the 'set_variables' list
 		options.set_variables[name] = default_value;
 	}

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

@@ -225,10 +225,11 @@ static void ThrowExtensionSetUnrecognizedOptions(const case_insensitive_map_t<Va
 }
 
 void DatabaseInstance::LoadExtensionSettings() {
-	auto &unrecognized_options = config.options.unrecognized_options;
+	// copy the map, to protect against modifications during
+	auto unrecognized_options_copy = config.options.unrecognized_options;
 
 	if (config.options.autoload_known_extensions) {
-		if (unrecognized_options.empty()) {
+		if (unrecognized_options_copy.empty()) {
 			// Nothing to do
 			return;
 		}
@@ -237,7 +238,7 @@ void DatabaseInstance::LoadExtensionSettings() {
 		con.BeginTransaction();
 
 		vector<string> extension_options;
-		for (auto &option : unrecognized_options) {
+		for (auto &option : unrecognized_options_copy) {
 			auto &name = option.first;
 			auto &value = option.second;
 
@@ -254,18 +255,17 @@ void DatabaseInstance::LoadExtensionSettings() {
 			if (it == config.extension_parameters.end()) {
 				throw InternalException("Extension %s did not provide the '%s' config setting", extension_name, name);
 			}
+			// if the extension provided the option, it should no longer be unrecognized.
+			D_ASSERT(config.options.unrecognized_options.find(name) == config.options.unrecognized_options.end());
 			auto &context = *con.context;
 			PhysicalSet::SetExtensionVariable(context, it->second, name, SetScope::GLOBAL, value);
 			extension_options.push_back(name);
 		}
 
-		for (auto &option : extension_options) {
-			unrecognized_options.erase(option);
-		}
 		con.Commit();
 	}
-	if (!unrecognized_options.empty()) {
-		ThrowExtensionSetUnrecognizedOptions(unrecognized_options);
+	if (!config.options.unrecognized_options.empty()) {
+		ThrowExtensionSetUnrecognizedOptions(config.options.unrecognized_options);
 	}
 }
 

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

@@ -121,6 +121,7 @@ static const DefaultExtension internal_extensions[] = {
     {"vss", "Adds indexing support to accelerate Vector Similarity Search", false},
     {"delta", "Adds support for Delta Lake", false},
     {"fts", "Adds support for Full-Text Search Indexes", false},
+    {"ui", "Adds local UI for DuckDB", false},
     {nullptr, nullptr, false}};
 
 idx_t ExtensionHelper::DefaultExtensionCount() {
@@ -139,7 +140,8 @@ DefaultExtension ExtensionHelper::GetDefaultExtension(idx_t index) {
 // Allow Auto-Install Extensions
 //===--------------------------------------------------------------------===//
 static const char *const auto_install[] = {"motherduck", "postgres_scanner", "mysql_scanner", "sqlite_scanner",
-                                           "delta",      "iceberg",          "uc_catalog",    nullptr};
+                                           "delta",      "iceberg",          "uc_catalog",    "ui",
+                                           nullptr};
 
 // TODO: unify with new autoload mechanism
 bool ExtensionHelper::AllowAutoInstall(const string &extension) {

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

@@ -71,15 +71,11 @@ struct ExtensionAccess {
 	static void SetError(duckdb_extension_info info, const char *error) {
 		auto &load_state = DuckDBExtensionLoadState::Get(info);
 
-		if (error) {
-			load_state.has_error = true;
-			load_state.error_data = ErrorData(error);
-		} else {
-			load_state.has_error = true;
-			load_state.error_data = ErrorData(
-			    ExceptionType::UNKNOWN_TYPE,
-			    "Extension has indicated an error occured during initialization, but did not set an error message.");
-		}
+		load_state.has_error = true;
+		load_state.error_data =
+		    error ? ErrorData(error)
+		          : ErrorData(ExceptionType::UNKNOWN_TYPE, "Extension has indicated an error occured during "
+		                                                   "initialization, but did not set an error message.");
 	}
 
 	//! Called by the extension get a pointer to the database that is loading it
@@ -92,9 +88,11 @@ struct ExtensionAccess {
 			load_state.database_data->database = make_shared_ptr<DuckDB>(load_state.db);
 			return reinterpret_cast<duckdb_database *>(load_state.database_data.get());
 		} catch (std::exception &ex) {
+			load_state.has_error = true;
 			load_state.error_data = ErrorData(ex);
 			return nullptr;
 		} catch (...) {
+			load_state.has_error = true;
 			load_state.error_data =
 			    ErrorData(ExceptionType::UNKNOWN_TYPE, "Unknown error in GetDatabase when trying to load extension!");
 			return nullptr;
@@ -125,8 +123,9 @@ struct ExtensionAccess {
 			load_state.has_error = true;
 			load_state.error_data =
 			    ErrorData(ExceptionType::UNKNOWN_TYPE,
-			              StringUtil::Format("Unknown ABI Type '%s' found when loading extension '%s'",
-			                                 load_state.init_result.abi_type, load_state.init_result.filename));
+			              StringUtil::Format("Unknown ABI Type of value '%d' found when loading extension '%s'",
+			                                 static_cast<uint8_t>(load_state.init_result.abi_type),
+			                                 load_state.init_result.filename));
 			return nullptr;
 		}
 
@@ -590,7 +589,8 @@ void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs
 		return;
 	}
 
-	throw IOException("Unknown ABI type '%s' for extension '%s'", extension_init_result.abi_type, extension);
+	throw IOException("Unknown ABI type of value '%s' for extension '%s'",
+	                  static_cast<uint8_t>(extension_init_result.abi_type), extension);
 #endif
 }
 

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

@@ -108,6 +108,7 @@ void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) {
 		//! 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_GET:
 	case LogicalOperatorType::LOGICAL_UNION:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
 	case LogicalOperatorType::LOGICAL_INTERSECT:

package/src/duckdb/src/optimizer/join_order/query_graph_manager.cpp

@@ -265,7 +265,6 @@ GenerateJoinRelation QueryGraphManager::GenerateJoins(vector<unique_ptr<LogicalO
 					break;
 				}
 			}
-
 			auto join = make_uniq<LogicalComparisonJoin>(chosen_filter->join_type);
 			// Here we optimize build side probe side. Our build side is the right side
 			// So the right plans should have lower cardinalities.
@@ -288,8 +287,9 @@ GenerateJoinRelation QueryGraphManager::GenerateJoins(vector<unique_ptr<LogicalO
 				bool invert = !JoinRelationSet::IsSubset(*left.set, *f->left_set);
 				// If the left and right set are inverted AND it is a semi or anti join
 				// swap left and right children back.
+
 				if (invert && (f->join_type == JoinType::SEMI || f->join_type == JoinType::ANTI)) {
-					std::swap(left, right);
+					std::swap(join->children[0], join->children[1]);
 					invert = false;
 				}
 

package/src/duckdb/src/optimizer/late_materialization.cpp

@@ -13,6 +13,7 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/main/client_config.hpp"
+#include "duckdb/main/config.hpp"
 
 namespace duckdb {
 
@@ -357,9 +358,22 @@ bool LateMaterialization::TryLateMaterialization(unique_ptr<LogicalOperator> &op
 	return true;
 }
 
-bool LateMaterialization::OptimizeLargeLimit(LogicalOperator &child) {
-	// we only support large limits if the only
-	reference<LogicalOperator> current_op = child;
+bool LateMaterialization::OptimizeLargeLimit(LogicalLimit &limit, idx_t limit_val, bool has_offset) {
+	auto &config = DBConfig::GetConfig(optimizer.context);
+	if (!has_offset && !config.options.preserve_insertion_order) {
+		// we avoid optimizing large limits if preserve insertion order is false
+		// since the limit is executed in parallel anyway
+		return false;
+	}
+	// we only perform this optimization until a certain amount of maximum values to reduce memory constraints
+	// since we still materialize the set of row-ids in the hash table this optimization can increase memory pressure
+	// FIXME: make this configurable as well
+	static constexpr const idx_t LIMIT_MAX_VAL = 1000000;
+	if (limit_val > LIMIT_MAX_VAL) {
+		return false;
+	}
+	// we only support large limits if they are directly below the source
+	reference<LogicalOperator> current_op = *limit.children[0];
 	while (current_op.get().type != LogicalOperatorType::LOGICAL_GET) {
 		if (current_op.get().type != LogicalOperatorType::LOGICAL_PROJECTION) {
 			return false;
@@ -376,11 +390,18 @@ unique_ptr<LogicalOperator> LateMaterialization::Optimize(unique_ptr<LogicalOper
 		if (limit.limit_val.Type() != LimitNodeType::CONSTANT_VALUE) {
 			break;
 		}
-		if (limit.limit_val.GetConstantValue() > max_row_count) {
+		auto limit_val = limit.limit_val.GetConstantValue();
+		bool has_offset = limit.offset_val.Type() != LimitNodeType::UNSET;
+		if (limit_val > max_row_count) {
 			// for large limits - we may still want to do this optimization if the limit is consecutive
 			// this is the case if there are only projections/get below the limit
 			// if the row-ids are not consecutive doing the join can worsen performance
-			if (!OptimizeLargeLimit(*limit.children[0])) {
+			if (!OptimizeLargeLimit(limit, limit_val, has_offset)) {
+				break;
+			}
+		} else {
+			// optimizing small limits really only makes sense if we have an offset
+			if (!has_offset) {
 				break;
 			}
 		}

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

@@ -272,12 +272,23 @@ unique_ptr<LogicalOperator> Optimizer::Optimize(unique_ptr<LogicalOperator> plan
 
 	this->plan = std::move(plan_p);
 
+	for (auto &pre_optimizer_extension : DBConfig::GetConfig(context).optimizer_extensions) {
+		RunOptimizer(OptimizerType::EXTENSION, [&]() {
+			OptimizerExtensionInput input {GetContext(), *this, pre_optimizer_extension.optimizer_info.get()};
+			if (pre_optimizer_extension.pre_optimize_function) {
+				pre_optimizer_extension.pre_optimize_function(input, plan);
+			}
+		});
+	}
+
 	RunBuiltInOptimizers();
 
 	for (auto &optimizer_extension : DBConfig::GetConfig(context).optimizer_extensions) {
 		RunOptimizer(OptimizerType::EXTENSION, [&]() {
 			OptimizerExtensionInput input {GetContext(), *this, optimizer_extension.optimizer_info.get()};
-			optimizer_extension.optimize_function(input, plan);
+			if (optimizer_extension.optimize_function) {
+				optimizer_extension.optimize_function(input, plan);
+			}
 		});
 	}
 

package/src/duckdb/src/parallel/executor_task.cpp

@@ -1,4 +1,5 @@
-#include "duckdb/parallel/task.hpp"
+#include "duckdb/parallel/executor_task.hpp"
+#include "duckdb/parallel/task_notifier.hpp"
 #include "duckdb/execution/executor.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/parallel/thread_context.hpp"
@@ -6,13 +7,13 @@
 namespace duckdb {
 
 ExecutorTask::ExecutorTask(Executor &executor_p, shared_ptr<Event> event_p)
-    : executor(executor_p), event(std::move(event_p)) {
+    : executor(executor_p), event(std::move(event_p)), context(executor_p.context) {
 	executor.RegisterTask();
 }
 
-ExecutorTask::ExecutorTask(ClientContext &context, shared_ptr<Event> event_p, const PhysicalOperator &op_p)
-    : executor(Executor::Get(context)), event(std::move(event_p)), op(&op_p) {
-	thread_context = make_uniq<ThreadContext>(context);
+ExecutorTask::ExecutorTask(ClientContext &context_p, shared_ptr<Event> event_p, const PhysicalOperator &op_p)
+    : executor(Executor::Get(context_p)), event(std::move(event_p)), op(&op_p), context(context_p) {
+	thread_context = make_uniq<ThreadContext>(context_p);
 	executor.RegisterTask();
 }
 
@@ -38,6 +39,7 @@ TaskExecutionResult ExecutorTask::Execute(TaskExecutionMode mode) {
 		if (thread_context) {
 			TaskExecutionResult result;
 			do {
+				TaskNotifier task_notifier {context};
 				thread_context->profiler.StartOperator(op);
 				// to allow continuous profiling, always execute in small steps
 				result = ExecuteTask(TaskExecutionMode::PROCESS_PARTIAL);
@@ -46,7 +48,9 @@ TaskExecutionResult ExecutorTask::Execute(TaskExecutionMode mode) {
 			} while (mode == TaskExecutionMode::PROCESS_ALL && result == TaskExecutionResult::TASK_NOT_FINISHED);
 			return result;
 		} else {
-			return ExecuteTask(mode);
+			TaskNotifier task_notifier {context};
+			auto result = ExecuteTask(mode);
+			return result;
 		}
 	} catch (std::exception &ex) {
 		executor.PushError(ErrorData(ex));

package/src/duckdb/src/parallel/task_executor.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/parallel/task_executor.hpp"
+#include "duckdb/parallel/task_notifier.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
 
 namespace duckdb {
@@ -7,7 +8,8 @@ TaskExecutor::TaskExecutor(TaskScheduler &scheduler)
     : scheduler(scheduler), token(scheduler.CreateProducer()), completed_tasks(0), total_tasks(0) {
 }
 
-TaskExecutor::TaskExecutor(ClientContext &context) : TaskExecutor(TaskScheduler::GetScheduler(context)) {
+TaskExecutor::TaskExecutor(ClientContext &context_p) : TaskExecutor(TaskScheduler::GetScheduler(context_p)) {
+	context = context_p;
 }
 
 TaskExecutor::~TaskExecutor() {
@@ -69,6 +71,7 @@ TaskExecutionResult BaseExecutorTask::Execute(TaskExecutionMode mode) {
 		return TaskExecutionResult::TASK_FINISHED;
 	}
 	try {
+		TaskNotifier task_notifier {executor.context};
 		ExecuteTask();
 		executor.FinishTask();
 		return TaskExecutionResult::TASK_FINISHED;

package/src/duckdb/src/parallel/task_notifier.cpp

@@ -0,0 +1,23 @@
+#include "duckdb/parallel/task_notifier.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/main/client_context_state.hpp"
+
+namespace duckdb {
+
+TaskNotifier::TaskNotifier(optional_ptr<ClientContext> context_p) : context(context_p) {
+	if (context) {
+		for (auto &state : context->registered_state->States()) {
+			state->OnTaskStart(*context);
+		}
+	}
+}
+
+TaskNotifier::~TaskNotifier() {
+	if (context) {
+		for (auto &state : context->registered_state->States()) {
+			state->OnTaskStop(*context);
+		}
+	}
+}
+
+} // namespace duckdb

package/src/duckdb/src/parallel/task_scheduler.cpp

@@ -284,6 +284,39 @@ int32_t TaskScheduler::NumberOfThreads() {
 	return current_thread_count.load();
 }
 
+idx_t TaskScheduler::GetNumberOfTasks() const {
+#ifndef DUCKDB_NO_THREADS
+	return queue->q.size_approx();
+#else
+	idx_t task_count = 0;
+	for (auto &producer : queue->q) {
+		task_count += producer.second.size();
+	}
+	return task_count;
+#endif
+}
+
+idx_t TaskScheduler::GetProducerCount() const {
+#ifndef DUCKDB_NO_THREADS
+	return queue->q.size_producers_approx();
+#else
+	return queue->q.size();
+#endif
+}
+
+idx_t TaskScheduler::GetTaskCountForProducer(ProducerToken &token) const {
+#ifndef DUCKDB_NO_THREADS
+	lock_guard<mutex> producer_lock(token.producer_lock);
+	return queue->q.size_producer_approx(token.token->queue_token);
+#else
+	const auto it = queue->q.find(std::ref(*token.token));
+	if (it == queue->q.end()) {
+		return 0;
+	}
+	return it->second.size();
+#endif
+}
+
 void TaskScheduler::SetThreads(idx_t total_threads, idx_t external_threads) {
 	if (total_threads == 0) {
 		throw SyntaxException("Number of threads must be positive!");

package/src/duckdb/src/parser/transform/expression/transform_subquery.cpp

@@ -107,6 +107,7 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 			}
 		}
 		// transform constants (e.g. ORDER BY 1) into positional references (ORDER BY #1)
+		idx_t array_idx = 0;
 		if (aggr->order_bys) {
 			for (auto &order : aggr->order_bys->orders) {
 				if (order.expression->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
@@ -120,8 +121,10 @@ unique_ptr<ParsedExpression> Transformer::TransformSubquery(duckdb_libpgquery::P
 					}
 				} else if (sub_select) {
 					// if we have a SELECT we can push the ORDER BY clause into the SELECT list and reference it
+					auto alias = "__array_internal_idx_" + to_string(++array_idx);
+					order.expression->alias = alias;
 					sub_select->select_list.push_back(std::move(order.expression));
-					order.expression = make_uniq<PositionalReferenceExpression>(sub_select->select_list.size() - 1);
+					order.expression = make_uniq<ColumnRefExpression>(alias);
 				} else {
 					// otherwise we remove order qualifications
 					RemoveOrderQualificationRecursive(order.expression);

package/src/duckdb/src/planner/binder/expression/bind_subquery_expression.cpp

@@ -153,7 +153,7 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 			}
 			child = BoundCastExpression::AddCastToType(context, std::move(child), compare_type);
 			result->child_types.push_back(subquery_type);
-			result->child_target = compare_type;
+			result->child_targets.push_back(compare_type);
 			result->children.push_back(std::move(child));
 		}
 	}

package/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp

@@ -168,7 +168,8 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 			cond.left = std::move(expr.children[child_idx]);
 			auto &child_type = expr.child_types[child_idx];
 			cond.right = BoundCastExpression::AddDefaultCastToType(
-			    make_uniq<BoundColumnRefExpression>(child_type, plan_columns[child_idx]), expr.child_target);
+			    make_uniq<BoundColumnRefExpression>(child_type, plan_columns[child_idx]),
+			    expr.child_targets[child_idx]);
 			cond.comparison = expr.comparison_type;
 			join->conditions.push_back(std::move(cond));
 		}
@@ -371,7 +372,8 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 			compare_cond.left = std::move(expr.children[child_idx]);
 			auto &child_type = expr.child_types[child_idx];
 			compare_cond.right = BoundCastExpression::AddDefaultCastToType(
-			    make_uniq<BoundColumnRefExpression>(child_type, plan_columns[child_idx]), expr.child_target);
+			    make_uniq<BoundColumnRefExpression>(child_type, plan_columns[child_idx]),
+			    expr.child_targets[child_idx]);
 			compare_cond.comparison = expr.comparison_type;
 			delim_join->conditions.push_back(std::move(compare_cond));
 		}

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -46,6 +46,7 @@
 namespace duckdb {
 
 void Binder::BindSchemaOrCatalog(ClientContext &context, string &catalog, string &schema) {
+	CatalogEntryRetriever retriever(context);
 	if (catalog.empty() && !schema.empty()) {
 		// schema is specified - but catalog is not
 		// try searching for the catalog instead
@@ -60,8 +61,12 @@ void Binder::BindSchemaOrCatalog(ClientContext &context, string &catalog, string
 				catalog_names.push_back(DatabaseManager::GetDefaultDatabase(context));
 			}
 			for (auto &catalog_name : catalog_names) {
-				auto &catalog = Catalog::GetCatalog(context, catalog_name);
-				if (catalog.CheckAmbiguousCatalogOrSchema(context, schema)) {
+				auto catalog = Catalog::GetCatalogEntry(retriever, catalog_name);
+				if (!catalog) {
+					continue;
+				}
+				if (catalog->CheckAmbiguousCatalogOrSchema(context, schema)) {
+
 					throw BinderException(
 					    "Ambiguous reference to catalog or schema \"%s\" - use a fully qualified path like \"%s.%s\"",
 					    schema, catalog_name, schema);

package/src/duckdb/src/planner/binder/statement/bind_create_table.cpp

@@ -271,13 +271,14 @@ void Binder::BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expr
 		schema_name = DEFAULT_SCHEMA;
 	}
 
-	// FIXME: We might want to save the existing search path of the binder
 	vector<CatalogSearchEntry> defaults_search_path;
 	defaults_search_path.emplace_back(catalog_name, schema_name);
 	if (schema_name != DEFAULT_SCHEMA) {
 		defaults_search_path.emplace_back(catalog_name, DEFAULT_SCHEMA);
 	}
-	entry_retriever.SetSearchPath(std::move(defaults_search_path));
+
+	auto default_binder = Binder::CreateBinder(context, *this);
+	default_binder->entry_retriever.SetSearchPath(std::move(defaults_search_path));
 
 	for (auto &column : columns.Physical()) {
 		unique_ptr<Expression> bound_default;
@@ -288,9 +289,9 @@ void Binder::BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expr
 			if (default_copy->HasParameter()) {
 				throw BinderException("DEFAULT values cannot contain parameters");
 			}
-			ConstantBinder default_binder(*this, context, "DEFAULT value");
-			default_binder.target_type = column.Type();
-			bound_default = default_binder.Bind(default_copy);
+			ConstantBinder default_value_binder(*default_binder, context, "DEFAULT value");
+			default_value_binder.target_type = column.Type();
+			bound_default = default_value_binder.Bind(default_copy);
 		} else {
 			// no default value specified: push a default value of constant null
 			bound_default = make_uniq<BoundConstantExpression>(Value(column.Type()));

package/src/duckdb/src/storage/checkpoint/table_data_writer.cpp

@@ -10,7 +10,8 @@
 
 namespace duckdb {
 
-TableDataWriter::TableDataWriter(TableCatalogEntry &table_p) : table(table_p.Cast<DuckTableEntry>()) {
+TableDataWriter::TableDataWriter(TableCatalogEntry &table_p, optional_ptr<ClientContext> client_context_p)
+    : table(table_p.Cast<DuckTableEntry>()), client_context(client_context_p) {
 	D_ASSERT(table_p.IsDuckTable());
 }
 
@@ -40,7 +41,8 @@ DatabaseInstance &TableDataWriter::GetDatabase() {
 
 SingleFileTableDataWriter::SingleFileTableDataWriter(SingleFileCheckpointWriter &checkpoint_manager,
                                                      TableCatalogEntry &table, MetadataWriter &table_data_writer)
-    : TableDataWriter(table), checkpoint_manager(checkpoint_manager), table_data_writer(table_data_writer) {
+    : TableDataWriter(table, checkpoint_manager.GetClientContext()), checkpoint_manager(checkpoint_manager),
+      table_data_writer(table_data_writer) {
 }
 
 unique_ptr<RowGroupWriter> SingleFileTableDataWriter::GetRowGroupWriter(RowGroup &row_group) {

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -36,10 +36,11 @@ namespace duckdb {
 
 void ReorderTableEntries(catalog_entry_vector_t &tables);
 
-SingleFileCheckpointWriter::SingleFileCheckpointWriter(AttachedDatabase &db, BlockManager &block_manager,
+SingleFileCheckpointWriter::SingleFileCheckpointWriter(optional_ptr<ClientContext> client_context_p,
+                                                       AttachedDatabase &db, BlockManager &block_manager,
                                                        CheckpointType checkpoint_type)
-    : CheckpointWriter(db), partial_block_manager(block_manager, PartialBlockType::FULL_CHECKPOINT),
-      checkpoint_type(checkpoint_type) {
+    : CheckpointWriter(db), client_context(client_context_p),
+      partial_block_manager(block_manager, PartialBlockType::FULL_CHECKPOINT), checkpoint_type(checkpoint_type) {
 }
 
 BlockManager &SingleFileCheckpointWriter::GetBlockManager() {

package/src/duckdb/src/storage/compression/string_uncompressed.cpp

@@ -385,12 +385,19 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V
 		uint32_t remaining = length;
 		offset += sizeof(uint32_t);
 
-		// allocate a buffer to store the string
-		auto alloc_size = MaxValue<idx_t>(block_manager.GetBlockSize(), length);
-		// allocate a buffer to store the compressed string
-		// TODO: profile this to check if we need to reuse buffer
-		auto target_handle = buffer_manager.Allocate(MemoryTag::OVERFLOW_STRINGS, alloc_size);
-		auto target_ptr = target_handle.Ptr();
+		BufferHandle target_handle;
+		string_t overflow_string;
+		data_ptr_t target_ptr;
+		bool allocate_block = length >= block_manager.GetBlockSize();
+		if (allocate_block) {
+			// overflow string is bigger than a block - allocate a temporary buffer for it
+			target_handle = buffer_manager.Allocate(MemoryTag::OVERFLOW_STRINGS, length);
+			target_ptr = target_handle.Ptr();
+		} else {
+			// overflow string is smaller than a block - add it to the vector directly
+			overflow_string = StringVector::EmptyString(result, length);
+			target_ptr = data_ptr_cast(overflow_string.GetDataWriteable());
+		}
 
 		// now append the string to the single buffer
 		while (remaining > 0) {
@@ -408,10 +415,14 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V
 				offset = 0;
 			}
 		}
-
-		auto final_buffer = target_handle.Ptr();
-		StringVector::AddHandle(result, std::move(target_handle));
-		return ReadString(final_buffer, 0, length);
+		if (allocate_block) {
+			auto final_buffer = target_handle.Ptr();
+			StringVector::AddHandle(result, std::move(target_handle));
+			return ReadString(final_buffer, 0, length);
+		} else {
+			overflow_string.Finalize();
+			return overflow_string;
+		}
 	}
 
 	// read the overflow string from memory

package/src/duckdb/src/storage/storage_info.cpp

@@ -77,6 +77,7 @@ static const StorageVersionInfo storage_version_info[] = {
 	{"v1.1.2", 64},
 	{"v1.1.3", 64},
 	{"v1.2.0", 65},
+	{"v1.2.1", 65},
 	{nullptr, 0}
 };
 // END OF STORAGE VERSION INFO
@@ -96,6 +97,7 @@ static const SerializationVersionInfo serialization_version_info[] = {
 	{"v1.1.2", 3},
 	{"v1.1.3", 3},
 	{"v1.2.0", 4},
+	{"v1.2.1", 4},
 	{"latest", 4},
 	{nullptr, 0}
 };

package/src/duckdb/src/storage/storage_manager.cpp

@@ -355,7 +355,7 @@ bool SingleFileStorageManager::IsCheckpointClean(MetaBlockPointer checkpoint_id)
 	return block_manager->IsRootBlock(checkpoint_id);
 }
 
-void SingleFileStorageManager::CreateCheckpoint(CheckpointOptions options) {
+void SingleFileStorageManager::CreateCheckpoint(optional_ptr<ClientContext> client_context, CheckpointOptions options) {
 	if (InMemory() || read_only || !load_complete) {
 		return;
 	}
@@ -366,7 +366,7 @@ void SingleFileStorageManager::CreateCheckpoint(CheckpointOptions options) {
 	if (GetWALSize() > 0 || config.options.force_checkpoint || options.action == CheckpointAction::ALWAYS_CHECKPOINT) {
 		// we only need to checkpoint if there is anything in the WAL
 		try {
-			SingleFileCheckpointWriter checkpointer(db, *block_manager, options.type);
+			SingleFileCheckpointWriter checkpointer(client_context, db, *block_manager, options.type);
 			checkpointer.CreateCheckpoint();
 		} catch (std::exception &ex) {
 			ErrorData error(ex);