duckdb 0.10.1-dev9.0 → 0.10.2-dev0.0

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

@@ -33,8 +33,10 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, str
     : CatalogEntry(CatalogType::DATABASE_ENTRY, catalog_p, std::move(name_p)), db(db), parent_catalog(&catalog_p) {
 	type = access_mode == AccessMode::READ_ONLY ? AttachedDatabaseType::READ_ONLY_DATABASE
 	                                            : AttachedDatabaseType::READ_WRITE_DATABASE;
-	storage = make_uniq<SingleFileStorageManager>(*this, std::move(file_path_p), access_mode == AccessMode::READ_ONLY);
 	catalog = make_uniq<DuckCatalog>(*this);
+	// do this after catalog to guarnatee we allow extension to instantionate DuckCatalog causing creation
+	// of the storage
+	storage = make_uniq<SingleFileStorageManager>(*this, std::move(file_path_p), access_mode == AccessMode::READ_ONLY);
 	transaction_manager = make_uniq<DuckTransactionManager>(*this);
 	internal = true;
 }
@@ -50,6 +52,10 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, Sto
 	if (!catalog) {
 		throw InternalException("AttachedDatabase - attach function did not return a catalog");
 	}
+	if (catalog->IsDuckCatalog()) {
+		// DuckCatalog, instantiate storage
+		storage = make_uniq<SingleFileStorageManager>(*this, info.path, access_mode == AccessMode::READ_ONLY);
+	}
 	transaction_manager =
 	    storage_extension.create_transaction_manager(storage_extension.storage_info.get(), *this, *catalog);
 	if (!transaction_manager) {
@@ -60,31 +66,7 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, Sto
 }
 
 AttachedDatabase::~AttachedDatabase() {
-	D_ASSERT(catalog);
-
-	if (!IsSystem() && !catalog->InMemory()) {
-		db.GetDatabaseManager().EraseDatabasePath(catalog->GetDBPath());
-	}
-
-	if (Exception::UncaughtException()) {
-		return;
-	}
-	if (!storage) {
-		return;
-	}
-
-	// shutting down: attempt to checkpoint the database
-	// but only if we are not cleaning up as part of an exception unwind
-	try {
-		if (!storage->InMemory()) {
-			auto &config = DBConfig::GetConfig(db);
-			if (!config.options.checkpoint_on_shutdown) {
-				return;
-			}
-			storage->CreateCheckpoint(true);
-		}
-	} catch (...) {
-	}
+	Close();
 }
 
 bool AttachedDatabase::IsSystem() const {
@@ -99,11 +81,19 @@ bool AttachedDatabase::IsReadOnly() const {
 	return type == AttachedDatabaseType::READ_ONLY_DATABASE;
 }
 
+bool AttachedDatabase::NameIsReserved(const string &name) {
+	return name == DEFAULT_SCHEMA || name == TEMP_CATALOG;
+}
+
 string AttachedDatabase::ExtractDatabaseName(const string &dbpath, FileSystem &fs) {
 	if (dbpath.empty() || dbpath == IN_MEMORY_PATH) {
 		return "memory";
 	}
-	return fs.ExtractBaseName(dbpath);
+	auto name = fs.ExtractBaseName(dbpath);
+	if (NameIsReserved(name)) {
+		name += "_db";
+	}
+	return name;
 }
 
 void AttachedDatabase::Initialize() {
@@ -144,4 +134,36 @@ void AttachedDatabase::SetInitialDatabase() {
 	is_initial_database = true;
 }
 
+void AttachedDatabase::Close() {
+	D_ASSERT(catalog);
+	if (is_closed) {
+		return;
+	}
+	is_closed = true;
+
+	if (!IsSystem() && !catalog->InMemory()) {
+		db.GetDatabaseManager().EraseDatabasePath(catalog->GetDBPath());
+	}
+
+	if (Exception::UncaughtException()) {
+		return;
+	}
+	if (!storage) {
+		return;
+	}
+
+	// shutting down: attempt to checkpoint the database
+	// but only if we are not cleaning up as part of an exception unwind
+	try {
+		if (!storage->InMemory()) {
+			auto &config = DBConfig::GetConfig(db);
+			if (!config.options.checkpoint_on_shutdown) {
+				return;
+			}
+			storage->CreateCheckpoint(true);
+		}
+	} catch (...) {
+	}
+}
+
 } // namespace duckdb

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

@@ -197,7 +197,7 @@ duckdb_state duckdb_append_varchar(duckdb_appender appender, const char *val) {
 }
 
 duckdb_state duckdb_append_varchar_length(duckdb_appender appender, const char *val, idx_t length) {
-	return duckdb_append_internal<string_t>(appender, string_t(val, length));
+	return duckdb_append_internal<string_t>(appender, string_t(val, duckdb::UnsafeNumericCast<uint32_t>(length)));
 }
 duckdb_state duckdb_append_blob(duckdb_appender appender, const void *data, idx_t length) {
 	auto value = duckdb::Value::BLOB((duckdb::const_data_ptr_t)data, length);

package/src/duckdb/src/main/capi/cast/ub_duckdb_main_capi_cast.cpp

@@ -0,0 +1,3 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/main/capi/cast/utils-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/cast/from_decimal-c.cpp>

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

@@ -68,7 +68,7 @@ duckdb_blob FetchDefaultValue::Operation() {
 
 template <>
 bool FromCBlobCastWrapper::Operation(duckdb_blob input, duckdb_string &result) {
-	string_t input_str(const_char_ptr_cast(input.data), input.size);
+	string_t input_str(const_char_ptr_cast(input.data), UnsafeNumericCast<uint32_t>(input.size));
 	return ToCStringCastWrapper<duckdb::CastFromBlob>::template Operation<string_t, duckdb_string>(input_str, result);
 }
 

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

@@ -110,7 +110,7 @@ void duckdb_vector_assign_string_element_len(duckdb_vector vector, idx_t index,
 	}
 	auto v = reinterpret_cast<duckdb::Vector *>(vector);
 	auto data = duckdb::FlatVector::GetData<duckdb::string_t>(*v);
-	data[index] = duckdb::StringVector::AddString(*v, str, str_len);
+	data[index] = duckdb::StringVector::AddStringOrBlob(*v, str, str_len);
 }
 
 duckdb_vector duckdb_list_vector_get_child(duckdb_vector vector) {
@@ -155,6 +155,14 @@ duckdb_vector duckdb_struct_vector_get_child(duckdb_vector vector, idx_t index)
 	return reinterpret_cast<duckdb_vector>(duckdb::StructVector::GetEntries(*v)[index].get());
 }
 
+duckdb_vector duckdb_array_vector_get_child(duckdb_vector vector) {
+	if (!vector) {
+		return nullptr;
+	}
+	auto v = reinterpret_cast<duckdb::Vector *>(vector);
+	return reinterpret_cast<duckdb_vector>(&duckdb::ArrayVector::GetEntry(*v));
+}
+
 bool duckdb_validity_row_is_valid(uint64_t *validity, idx_t row) {
 	if (!validity) {
 		return true;

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

@@ -1,4 +1,5 @@
 #include "duckdb/main/capi/capi_internal.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/types/date.hpp"
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
@@ -17,8 +18,8 @@ duckdb_date_struct duckdb_from_date(duckdb_date date) {
 
 	duckdb_date_struct result;
 	result.year = year;
-	result.month = month;
-	result.day = day;
+	result.month = duckdb::UnsafeNumericCast<int8_t>(month);
+	result.day = duckdb::UnsafeNumericCast<int8_t>(day);
 	return result;
 }
 
@@ -37,18 +38,23 @@ duckdb_time_struct duckdb_from_time(duckdb_time time) {
 	Time::Convert(dtime_t(time.micros), hour, minute, second, micros);
 
 	duckdb_time_struct result;
-	result.hour = hour;
-	result.min = minute;
-	result.sec = second;
+	result.hour = duckdb::UnsafeNumericCast<int8_t>(hour);
+	result.min = duckdb::UnsafeNumericCast<int8_t>(minute);
+	result.sec = duckdb::UnsafeNumericCast<int8_t>(second);
 	result.micros = micros;
 	return result;
 }
 
 duckdb_time_tz_struct duckdb_from_time_tz(duckdb_time_tz input) {
-	duckdb::dtime_tz_t time(input.bits);
 	duckdb_time_tz_struct result;
-	result.time.micros = time.time().micros;
-	result.offset = time.offset();
+	duckdb_time time;
+
+	duckdb::dtime_tz_t time_tz(input.bits);
+
+	time.micros = time_tz.time().micros;
+
+	result.time = duckdb_from_time(time);
+	result.offset = time_tz.offset();
 	return result;
 }
 

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

@@ -73,7 +73,7 @@ duckdb_value duckdb_create_struct_value(duckdb_logical_type type, duckdb_value *
 	}
 	duckdb::Value *struct_value = new duckdb::Value;
 	try {
-		*struct_value = duckdb::Value::STRUCT(ltype, unwrapped_values);
+		*struct_value = duckdb::Value::STRUCT(ltype, std::move(unwrapped_values));
 	} catch (...) {
 		delete struct_value;
 		return nullptr;
@@ -96,10 +96,37 @@ duckdb_value duckdb_create_list_value(duckdb_logical_type type, duckdb_value *va
 	}
 	duckdb::Value *list_value = new duckdb::Value;
 	try {
-		*list_value = duckdb::Value::LIST(ltype, unwrapped_values);
+		*list_value = duckdb::Value::LIST(ltype, std::move(unwrapped_values));
 	} catch (...) {
 		delete list_value;
 		return nullptr;
 	}
 	return WrapValue(list_value);
 }
+
+duckdb_value duckdb_create_array_value(duckdb_logical_type type, duckdb_value *values, idx_t value_count) {
+	if (!type || !values) {
+		return nullptr;
+	}
+	if (value_count >= duckdb::ArrayType::MAX_ARRAY_SIZE) {
+		return nullptr;
+	}
+	auto &ltype = UnwrapType(type);
+	duckdb::vector<duckdb::Value> unwrapped_values;
+
+	for (idx_t i = 0; i < value_count; i++) {
+		auto value = values[i];
+		if (!value) {
+			return nullptr;
+		}
+		unwrapped_values.push_back(UnwrapValue(value));
+	}
+	duckdb::Value *array_value = new duckdb::Value;
+	try {
+		*array_value = duckdb::Value::ARRAY(ltype, std::move(unwrapped_values));
+	} catch (...) {
+		delete array_value;
+		return nullptr;
+	}
+	return WrapValue(array_value);
+}

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

@@ -126,6 +126,8 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
 		return DUCKDB_TYPE_UNION;
 	case LogicalTypeId::UUID:
 		return DUCKDB_TYPE_UUID;
+	case LogicalTypeId::ARRAY:
+		return DUCKDB_TYPE_ARRAY;
 	default: // LCOV_EXCL_START
 		D_ASSERT(0);
 		return DUCKDB_TYPE_INVALID;

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

@@ -77,6 +77,7 @@ double duckdb_decimal_to_double(duckdb_decimal val) {
 	hugeint_t value;
 	value.lower = val.value.lower;
 	value.upper = val.value.upper;
-	duckdb::TryCastFromDecimal::Operation<hugeint_t, double>(value, result, nullptr, val.width, val.scale);
+	duckdb::CastParameters parameters;
+	duckdb::TryCastFromDecimal::Operation<hugeint_t, double>(value, result, parameters, val.width, val.scale);
 	return result;
 }

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

@@ -35,6 +35,18 @@ duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type) {
 	return reinterpret_cast<duckdb_logical_type>(ltype);
 }
 
+duckdb_logical_type duckdb_create_array_type(duckdb_logical_type type, idx_t array_size) {
+	if (!type) {
+		return nullptr;
+	}
+	if (array_size >= duckdb::ArrayType::MAX_ARRAY_SIZE) {
+		return nullptr;
+	}
+	duckdb::LogicalType *ltype = new duckdb::LogicalType;
+	*ltype = duckdb::LogicalType::ARRAY(*reinterpret_cast<duckdb::LogicalType *>(type), array_size);
+	return reinterpret_cast<duckdb_logical_type>(ltype);
+}
+
 duckdb_logical_type duckdb_create_union_type(duckdb_logical_type *member_types_p, const char **member_names,
                                              idx_t member_count) {
 	if (!member_types_p || !member_names) {
@@ -179,7 +191,7 @@ uint32_t duckdb_enum_dictionary_size(duckdb_logical_type type) {
 		return 0;
 	}
 	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
-	return duckdb::EnumType::GetSize(ltype);
+	return duckdb::NumericCast<uint32_t>(duckdb::EnumType::GetSize(ltype));
 }
 
 char *duckdb_enum_dictionary_value(duckdb_logical_type type, idx_t index) {
@@ -204,6 +216,28 @@ duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type) {
 	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(duckdb::ListType::GetChildType(ltype)));
 }
 
+duckdb_logical_type duckdb_array_type_child_type(duckdb_logical_type type) {
+	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::ARRAY)) {
+		return nullptr;
+	}
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
+	if (ltype.id() != duckdb::LogicalTypeId::ARRAY) {
+		return nullptr;
+	}
+	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(duckdb::ArrayType::GetChildType(ltype)));
+}
+
+idx_t duckdb_array_type_array_size(duckdb_logical_type type) {
+	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::ARRAY)) {
+		return 0;
+	}
+	auto &ltype = *(reinterpret_cast<duckdb::LogicalType *>(type));
+	if (ltype.id() != duckdb::LogicalTypeId::ARRAY) {
+		return 0;
+	}
+	return duckdb::ArrayType::GetSize(ltype);
+}
+
 duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type) {
 	if (!AssertLogicalTypeId(type, duckdb::LogicalTypeId::MAP)) {
 		return nullptr;

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

@@ -54,6 +54,9 @@ struct CBlobConverter {
 struct CTimestampMsConverter : public CBaseConverter {
 	template <class SRC, class DST>
 	static DST Convert(SRC input) {
+		if (!Timestamp::IsFinite(input)) {
+			return input;
+		}
 		return Timestamp::FromEpochMs(input.value);
 	}
 };
@@ -61,6 +64,9 @@ struct CTimestampMsConverter : public CBaseConverter {
 struct CTimestampNsConverter : public CBaseConverter {
 	template <class SRC, class DST>
 	static DST Convert(SRC input) {
+		if (!Timestamp::IsFinite(input)) {
+			return input;
+		}
 		return Timestamp::FromEpochNanoSeconds(input.value);
 	}
 };
@@ -68,6 +74,9 @@ struct CTimestampNsConverter : public CBaseConverter {
 struct CTimestampSecConverter : public CBaseConverter {
 	template <class SRC, class DST>
 	static DST Convert(SRC input) {
+		if (!Timestamp::IsFinite(input)) {
+			return input;
+		}
 		return Timestamp::FromEpochSeconds(input.value);
 	}
 };

package/src/duckdb/src/main/capi/ub_duckdb_main_capi.cpp

@@ -0,0 +1,19 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/main/capi/appender-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/arrow-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/config-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/data_chunk-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/datetime-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/duckdb-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/duckdb_value-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/helper-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/hugeint-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/logical_types-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/pending-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/prepared-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/replacement_scan-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/result-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/stream-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/table_function-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/threading-c.cpp>
+#include </Users/carlo/duckdb/src/main/capi/value-c.cpp>

package/src/duckdb/src/main/chunk_scan_state/ub_duckdb_main_chunk_scan_state.cpp

@@ -0,0 +1,2 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/main/chunk_scan_state/query_result.cpp>

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

@@ -116,6 +116,22 @@ struct DebugClientContextState : public ClientContextState {
 		}
 		active_transaction = false;
 	}
+#ifdef DUCKDB_DEBUG_REBIND
+	RebindQueryInfo OnPlanningError(ClientContext &context, SQLStatement &statement, ErrorData &error) override {
+		return RebindQueryInfo::ATTEMPT_TO_REBIND;
+	}
+	RebindQueryInfo OnFinalizePrepare(ClientContext &context, PreparedStatementData &prepared,
+	                                  PreparedStatementMode mode) override {
+		if (mode == PreparedStatementMode::PREPARE_AND_EXECUTE) {
+			return RebindQueryInfo::ATTEMPT_TO_REBIND;
+		}
+		return RebindQueryInfo::DO_NOT_REBIND;
+	}
+	RebindQueryInfo OnExecutePrepared(ClientContext &context, PreparedStatementData &prepared_statement,
+	                                  RebindQueryInfo current_rebind) override {
+		return RebindQueryInfo::ATTEMPT_TO_REBIND;
+	}
+#endif
 };
 #endif
 
@@ -292,8 +308,9 @@ static bool IsExplainAnalyze(SQLStatement *statement) {
 }
 
 shared_ptr<PreparedStatementData>
-ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-                                       optional_ptr<case_insensitive_map_t<Value>> values) {
+ClientContext::CreatePreparedStatementInternal(ClientContextLock &lock, const string &query,
+                                               unique_ptr<SQLStatement> statement,
+                                               optional_ptr<case_insensitive_map_t<Value>> values) {
 	StatementType statement_type = statement->type;
 	auto result = make_shared<PreparedStatementData>(statement_type);
 
@@ -319,7 +336,6 @@ ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &qu
 	result->types = planner.types;
 	result->value_map = std::move(planner.value_map);
 	result->catalog_version = MetaTransaction::Get(*this).catalog_version;
-
 	if (!planner.properties.bound_all_parameters) {
 		return result;
 	}
@@ -351,15 +367,85 @@ ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &qu
 	return result;
 }
 
+shared_ptr<PreparedStatementData>
+ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
+                                       optional_ptr<case_insensitive_map_t<Value>> values, PreparedStatementMode mode) {
+	// check if any client context state could request a rebind
+	bool can_request_rebind = false;
+	for (auto const &s : registered_state) {
+		if (s.second->CanRequestRebind()) {
+			can_request_rebind = true;
+			break;
+		}
+	}
+	if (can_request_rebind) {
+		bool rebind = false;
+		// if any registered state can request a rebind we do the binding on a copy first
+		shared_ptr<PreparedStatementData> result;
+		try {
+			result = CreatePreparedStatementInternal(lock, query, statement->Copy(), values);
+		} catch (std::exception &ex) {
+			ErrorData error(ex);
+			// check if any registered client context state wants to try a rebind
+			for (auto const &s : registered_state) {
+				auto info = s.second->OnPlanningError(*this, *statement, error);
+				if (info == RebindQueryInfo::ATTEMPT_TO_REBIND) {
+					rebind = true;
+				}
+			}
+			if (!rebind) {
+				throw;
+			}
+		}
+		if (result) {
+			D_ASSERT(!rebind);
+			for (auto const &s : registered_state) {
+				auto info = s.second->OnFinalizePrepare(*this, *result, mode);
+				if (info == RebindQueryInfo::ATTEMPT_TO_REBIND) {
+					rebind = true;
+				}
+			}
+		}
+		if (!rebind) {
+			return result;
+		}
+		// an extension wants to do a rebind - do it once
+	}
+
+	return CreatePreparedStatementInternal(lock, query, std::move(statement), values);
+}
+
 QueryProgress ClientContext::GetQueryProgress() {
 	return query_progress;
 }
 
-unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientContextLock &lock,
-                                                                       shared_ptr<PreparedStatementData> statement_p,
-                                                                       const PendingQueryParameters &parameters) {
-	D_ASSERT(active_query);
-	auto &statement = *statement_p;
+void BindPreparedStatementParameters(PreparedStatementData &statement, const PendingQueryParameters &parameters) {
+	case_insensitive_map_t<Value> owned_values;
+	if (parameters.parameters) {
+		auto &params = *parameters.parameters;
+		for (auto &val : params) {
+			owned_values.emplace(val);
+		}
+	}
+	statement.Bind(std::move(owned_values));
+}
+
+void ClientContext::RebindPreparedStatement(ClientContextLock &lock, const string &query,
+                                            shared_ptr<PreparedStatementData> &prepared,
+                                            const PendingQueryParameters &parameters) {
+	if (!prepared->unbound_statement) {
+		throw InternalException("ClientContext::RebindPreparedStatement called but PreparedStatementData did not have "
+		                        "an unbound statement so rebinding cannot be done");
+	}
+	// catalog was modified: rebind the statement before execution
+	auto new_prepared =
+	    CreatePreparedStatement(lock, query, prepared->unbound_statement->Copy(), parameters.parameters);
+	D_ASSERT(new_prepared->properties.bound_all_parameters);
+	prepared = std::move(new_prepared);
+	prepared->properties.bound_all_parameters = false;
+}
+
+void ClientContext::CheckIfPreparedStatementIsExecutable(PreparedStatementData &statement) {
 	if (ValidChecker::IsInvalidated(ActiveTransaction()) && statement.properties.requires_valid_transaction) {
 		throw ErrorManager::InvalidatedTransaction(*this);
 	}
@@ -377,16 +463,15 @@ unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientCon
 		}
 		meta_transaction.ModifyDatabase(*entry);
 	}
+}
 
-	// bind the bound values before execution
-	case_insensitive_map_t<Value> owned_values;
-	if (parameters.parameters) {
-		auto &params = *parameters.parameters;
-		for (auto &val : params) {
-			owned_values.emplace(val);
-		}
-	}
-	statement.Bind(std::move(owned_values));
+unique_ptr<PendingQueryResult>
+ClientContext::PendingPreparedStatementInternal(ClientContextLock &lock, shared_ptr<PreparedStatementData> statement_p,
+                                                const PendingQueryParameters &parameters) {
+	D_ASSERT(active_query);
+	auto &statement = *statement_p;
+
+	BindPreparedStatementParameters(statement, parameters);
 
 	active_query->executor = make_uniq<Executor>(*this);
 	auto &executor = *active_query->executor;
@@ -424,6 +509,27 @@ unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientCon
 	return pending_result;
 }
 
+unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientContextLock &lock, const string &query,
+                                                                       shared_ptr<PreparedStatementData> prepared,
+                                                                       const PendingQueryParameters &parameters) {
+	CheckIfPreparedStatementIsExecutable(*prepared);
+
+	RebindQueryInfo rebind = RebindQueryInfo::DO_NOT_REBIND;
+	if (prepared->RequireRebind(*this, parameters.parameters)) {
+		rebind = RebindQueryInfo::ATTEMPT_TO_REBIND;
+	}
+	for (auto const &s : registered_state) {
+		auto new_rebind = s.second->OnExecutePrepared(*this, *prepared, rebind);
+		if (new_rebind == RebindQueryInfo::ATTEMPT_TO_REBIND) {
+			rebind = RebindQueryInfo::ATTEMPT_TO_REBIND;
+		}
+	}
+	if (rebind == RebindQueryInfo::ATTEMPT_TO_REBIND) {
+		RebindPreparedStatement(lock, query, prepared, parameters);
+	}
+	return PendingPreparedStatementInternal(lock, prepared, parameters);
+}
+
 PendingExecutionResult ClientContext::ExecuteTaskInternal(ClientContextLock &lock, BaseQueryResult &result,
                                                           bool dry_run) {
 	D_ASSERT(active_query);
@@ -447,7 +553,7 @@ PendingExecutionResult ClientContext::ExecuteTaskInternal(ClientContextLock &loc
 				invalidate_transaction = true;
 			} else {
 				// Interrupted by an exception caused in a worker thread
-				auto error = executor.GetError();
+				error = executor.GetError();
 				invalidate_transaction = Exception::InvalidatesTransaction(error.Type());
 				result.SetError(error);
 			}
@@ -458,6 +564,7 @@ PendingExecutionResult ClientContext::ExecuteTaskInternal(ClientContextLock &loc
 			auto &db_instance = DatabaseInstance::GetDatabase(*this);
 			ValidChecker::Invalidate(db_instance, error.RawMessage());
 		}
+		ProcessError(error, active_query->query);
 		result.SetError(std::move(error));
 	} catch (...) { // LCOV_EXCL_START
 		result.SetError(ErrorData("Unhandled exception in ExecuteTaskInternal"));
@@ -610,7 +717,8 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementInternal(ClientCon
                                                                        unique_ptr<SQLStatement> statement,
                                                                        const PendingQueryParameters &parameters) {
 	// prepare the query for execution
-	auto prepared = CreatePreparedStatement(lock, query, std::move(statement), parameters.parameters);
+	auto prepared = CreatePreparedStatement(lock, query, std::move(statement), parameters.parameters,
+	                                        PreparedStatementMode::PREPARE_AND_EXECUTE);
 	idx_t parameter_count = !parameters.parameters ? 0 : parameters.parameters->size();
 	if (prepared->properties.parameter_count > 0 && parameter_count == 0) {
 		string error_message = StringUtil::Format("Expected %lld parameters, but none were supplied",
@@ -621,7 +729,8 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementInternal(ClientCon
 		return ErrorResult<PendingQueryResult>(ErrorData("Not all parameters were bound"), query);
 	}
 	// execute the prepared statement
-	return PendingPreparedStatement(lock, std::move(prepared), parameters);
+	CheckIfPreparedStatementIsExecutable(*prepared);
+	return PendingPreparedStatementInternal(lock, std::move(prepared), parameters);
 }
 
 unique_ptr<QueryResult> ClientContext::RunStatementInternal(ClientContextLock &lock, const string &query,
@@ -728,16 +837,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 		if (statement) {
 			pending = PendingStatementInternal(lock, query, std::move(statement), parameters);
 		} else {
-			if (prepared->RequireRebind(*this, parameters.parameters)) {
-				// catalog was modified: rebind the statement before execution
-				auto new_prepared =
-				    CreatePreparedStatement(lock, query, prepared->unbound_statement->Copy(), parameters.parameters);
-				D_ASSERT(new_prepared->properties.bound_all_parameters);
-				new_prepared->unbound_statement = std::move(prepared->unbound_statement);
-				prepared = std::move(new_prepared);
-				prepared->properties.bound_all_parameters = false;
-			}
-			pending = PendingPreparedStatement(lock, prepared, parameters);
+			pending = PendingPreparedStatement(lock, query, prepared, parameters);
 		}
 	} catch (std::exception &ex) {
 		ErrorData error(ex);
@@ -1135,13 +1235,13 @@ unique_ptr<QueryResult> ClientContext::Execute(const shared_ptr<Relation> &relat
 	return ErrorResult<MaterializedQueryResult>(ErrorData(err_str));
 }
 
-bool ClientContext::TryGetCurrentSetting(const std::string &key, Value &result) {
+SettingLookupResult ClientContext::TryGetCurrentSetting(const std::string &key, Value &result) {
 	// first check the built-in settings
 	auto &db_config = DBConfig::GetConfig(*this);
 	auto option = db_config.GetOptionByName(key);
 	if (option) {
 		result = option->get_setting(*this);
-		return true;
+		return SettingLookupResult(SettingScope::LOCAL);
 	}
 
 	// check the client session values
@@ -1151,7 +1251,7 @@ bool ClientContext::TryGetCurrentSetting(const std::string &key, Value &result)
 	bool found_session_value = session_value != session_config_map.end();
 	if (found_session_value) {
 		result = session_value->second;
-		return true;
+		return SettingLookupResult(SettingScope::LOCAL);
 	}
 	// finally check the global session values
 	return db->TryGetCurrentSetting(key, result);