duckdb 0.8.2-dev77.0 → 0.9.0

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

@@ -2,7 +2,10 @@
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/main/prepared_statement_data.hpp"
 #include "duckdb/common/types/decimal.hpp"
+#include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/common/case_insensitive_map.hpp"
 
+using duckdb::case_insensitive_map_t;
 using duckdb::Connection;
 using duckdb::date_t;
 using duckdb::dtime_t;
@@ -10,8 +13,10 @@ using duckdb::ExtractStatementsWrapper;
 using duckdb::hugeint_t;
 using duckdb::LogicalType;
 using duckdb::MaterializedQueryResult;
+using duckdb::optional_ptr;
 using duckdb::PreparedStatementWrapper;
 using duckdb::QueryResultType;
+using duckdb::StringUtil;
 using duckdb::timestamp_t;
 using duckdb::Value;
 
@@ -84,16 +89,51 @@ idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement) {
 	return wrapper->statement->n_param;
 }
 
+static duckdb::string duckdb_parameter_name_internal(duckdb_prepared_statement prepared_statement, idx_t index) {
+	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
+		return duckdb::string();
+	}
+	if (index > wrapper->statement->n_param) {
+		return duckdb::string();
+	}
+	for (auto &item : wrapper->statement->named_param_map) {
+		auto &identifier = item.first;
+		auto &param_idx = item.second;
+		if (param_idx == index) {
+			// Found the matching parameter
+			return identifier;
+		}
+	}
+	// No parameter was found with this index
+	return duckdb::string();
+}
+
+const char *duckdb_parameter_name(duckdb_prepared_statement prepared_statement, idx_t index) {
+	auto identifier = duckdb_parameter_name_internal(prepared_statement, index);
+	if (identifier == duckdb::string()) {
+		return NULL;
+	}
+	return strdup(identifier.c_str());
+}
+
 duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
 	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DUCKDB_TYPE_INVALID;
 	}
 	LogicalType param_type;
-	if (!wrapper->statement->data->TryGetType(param_idx, param_type)) {
-		return DUCKDB_TYPE_INVALID;
+	auto identifier = std::to_string(param_idx);
+	if (wrapper->statement->data->TryGetType(identifier, param_type)) {
+		return ConvertCPPTypeToC(param_type);
+	}
+	// The value_map is gone after executing the prepared statement
+	// See if this is the case and we still have a value registered for it
+	auto it = wrapper->values.find(identifier);
+	if (it != wrapper->values.end()) {
+		return ConvertCPPTypeToC(it->second.type());
 	}
-	return ConvertCPPTypeToC(param_type);
+	return DUCKDB_TYPE_INVALID;
 }
 
 duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement) {
@@ -105,39 +145,65 @@ duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement)
 	return DuckDBSuccess;
 }
 
-static duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx, Value val) {
+duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_value val) {
+	auto value = reinterpret_cast<Value *>(val);
 	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DuckDBError;
 	}
 	if (param_idx <= 0 || param_idx > wrapper->statement->n_param) {
+		wrapper->statement->error =
+		    duckdb::InvalidInputException("Can not bind to parameter number %d, statement only has %d parameter(s)",
+		                                  param_idx, wrapper->statement->n_param);
 		return DuckDBError;
 	}
-	if (param_idx > wrapper->values.size()) {
-		wrapper->values.resize(param_idx);
-	}
-	wrapper->values[param_idx - 1] = val;
+	auto identifier = duckdb_parameter_name_internal(prepared_statement, param_idx);
+	wrapper->values[identifier] = *value;
 	return DuckDBSuccess;
 }
 
+duckdb_state duckdb_bind_parameter_index(duckdb_prepared_statement prepared_statement, idx_t *param_idx_out,
+                                         const char *name_p) {
+	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
+		return DuckDBError;
+	}
+	if (!name_p || !param_idx_out) {
+		return DuckDBError;
+	}
+	auto name = std::string(name_p);
+	for (auto &pair : wrapper->statement->named_param_map) {
+		if (duckdb::StringUtil::CIEquals(pair.first, name)) {
+			*param_idx_out = pair.second;
+			return DuckDBSuccess;
+		}
+	}
+	return DuckDBError;
+}
+
 duckdb_state duckdb_bind_boolean(duckdb_prepared_statement prepared_statement, idx_t param_idx, bool val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::BOOLEAN(val));
+	auto value = Value::BOOLEAN(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_int8(duckdb_prepared_statement prepared_statement, idx_t param_idx, int8_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::TINYINT(val));
+	auto value = Value::TINYINT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_int16(duckdb_prepared_statement prepared_statement, idx_t param_idx, int16_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::SMALLINT(val));
+	auto value = Value::SMALLINT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_int32(duckdb_prepared_statement prepared_statement, idx_t param_idx, int32_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::INTEGER(val));
+	auto value = Value::INTEGER(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_int64(duckdb_prepared_statement prepared_statement, idx_t param_idx, int64_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::BIGINT(val));
+	auto value = Value::BIGINT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 static hugeint_t duckdb_internal_hugeint(duckdb_hugeint val) {
@@ -148,53 +214,65 @@ static hugeint_t duckdb_internal_hugeint(duckdb_hugeint val) {
 }
 
 duckdb_state duckdb_bind_hugeint(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_hugeint val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::HUGEINT(duckdb_internal_hugeint(val)));
+	auto value = Value::HUGEINT(duckdb_internal_hugeint(val));
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_uint8(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint8_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::UTINYINT(val));
+	auto value = Value::UTINYINT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_uint16(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint16_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::USMALLINT(val));
+	auto value = Value::USMALLINT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_uint32(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint32_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::UINTEGER(val));
+	auto value = Value::UINTEGER(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_uint64(duckdb_prepared_statement prepared_statement, idx_t param_idx, uint64_t val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::UBIGINT(val));
+	auto value = Value::UBIGINT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_float(duckdb_prepared_statement prepared_statement, idx_t param_idx, float val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::FLOAT(val));
+	auto value = Value::FLOAT(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_double(duckdb_prepared_statement prepared_statement, idx_t param_idx, double val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::DOUBLE(val));
+	auto value = Value::DOUBLE(val);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_date(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_date val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::DATE(date_t(val.days)));
+	auto value = Value::DATE(date_t(val.days));
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_time(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_time val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::TIME(dtime_t(val.micros)));
+	auto value = Value::TIME(dtime_t(val.micros));
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_timestamp(duckdb_prepared_statement prepared_statement, idx_t param_idx,
                                    duckdb_timestamp val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::TIMESTAMP(timestamp_t(val.micros)));
+	auto value = Value::TIMESTAMP(timestamp_t(val.micros));
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_interval(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_interval val) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::INTERVAL(val.months, val.days, val.micros));
+	auto value = Value::INTERVAL(val.months, val.days, val.micros);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_varchar(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val) {
 	try {
-		return duckdb_bind_value(prepared_statement, param_idx, Value(val));
+		auto value = Value(val);
+		return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 	} catch (...) {
 		return DuckDBError;
 	}
@@ -203,7 +281,8 @@ duckdb_state duckdb_bind_varchar(duckdb_prepared_statement prepared_statement, i
 duckdb_state duckdb_bind_varchar_length(duckdb_prepared_statement prepared_statement, idx_t param_idx, const char *val,
                                         idx_t length) {
 	try {
-		return duckdb_bind_value(prepared_statement, param_idx, Value(std::string(val, length)));
+		auto value = Value(std::string(val, length));
+		return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 	} catch (...) {
 		return DuckDBError;
 	}
@@ -212,19 +291,23 @@ duckdb_state duckdb_bind_varchar_length(duckdb_prepared_statement prepared_state
 duckdb_state duckdb_bind_decimal(duckdb_prepared_statement prepared_statement, idx_t param_idx, duckdb_decimal val) {
 	auto hugeint_val = duckdb_internal_hugeint(val.value);
 	if (val.width > duckdb::Decimal::MAX_WIDTH_INT64) {
-		return duckdb_bind_value(prepared_statement, param_idx, Value::DECIMAL(hugeint_val, val.width, val.scale));
+		auto value = Value::DECIMAL(hugeint_val, val.width, val.scale);
+		return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 	}
 	auto value = hugeint_val.lower;
-	return duckdb_bind_value(prepared_statement, param_idx, Value::DECIMAL((int64_t)value, val.width, val.scale));
+	auto duck_val = Value::DECIMAL((int64_t)value, val.width, val.scale);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&duck_val);
 }
 
 duckdb_state duckdb_bind_blob(duckdb_prepared_statement prepared_statement, idx_t param_idx, const void *data,
                               idx_t length) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value::BLOB(duckdb::const_data_ptr_cast(data), length));
+	auto value = Value::BLOB(duckdb::const_data_ptr_cast(data), length);
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
-	return duckdb_bind_value(prepared_statement, param_idx, Value());
+	auto value = Value();
+	return duckdb_bind_value(prepared_statement, param_idx, (duckdb_value)&value);
 }
 
 duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statement, duckdb_result *out_result) {
@@ -232,6 +315,7 @@ duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statemen
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DuckDBError;
 	}
+
 	auto result = wrapper->statement->Execute(wrapper->values, false);
 	return duckdb_translate_result(std::move(result), out_result);
 }

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

@@ -182,9 +182,11 @@ duckdb_state deprecated_duckdb_translate_column(MaterializedQueryResult &result,
 		WriteData<date_t>(column, collection, column_ids);
 		break;
 	case LogicalTypeId::TIME:
-	case LogicalTypeId::TIME_TZ:
 		WriteData<dtime_t>(column, collection, column_ids);
 		break;
+	case LogicalTypeId::TIME_TZ:
+		WriteData<dtime_tz_t>(column, collection, column_ids);
+		break;
 	case LogicalTypeId::TIMESTAMP:
 	case LogicalTypeId::TIMESTAMP_TZ:
 		WriteData<timestamp_t>(column, collection, column_ids);

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

@@ -0,0 +1,53 @@
+#include "duckdb/main/query_result.hpp"
+#include "duckdb/main/stream_query_result.hpp"
+#include "duckdb/main/chunk_scan_state/query_result.hpp"
+
+namespace duckdb {
+
+QueryResultChunkScanState::QueryResultChunkScanState(QueryResult &result) : ChunkScanState(), result(result) {
+}
+
+QueryResultChunkScanState::~QueryResultChunkScanState() {
+}
+
+bool QueryResultChunkScanState::InternalLoad(PreservedError &error) {
+	D_ASSERT(!finished);
+	if (result.type == QueryResultType::STREAM_RESULT) {
+		auto &stream_result = result.Cast<StreamQueryResult>();
+		if (!stream_result.IsOpen()) {
+			return true;
+		}
+	}
+	return result.TryFetch(current_chunk, error);
+}
+
+bool QueryResultChunkScanState::HasError() const {
+	return result.HasError();
+}
+
+PreservedError &QueryResultChunkScanState::GetError() {
+	D_ASSERT(result.HasError());
+	return result.GetErrorObject();
+}
+
+const vector<LogicalType> &QueryResultChunkScanState::Types() const {
+	return result.types;
+}
+
+const vector<string> &QueryResultChunkScanState::Names() const {
+	return result.names;
+}
+
+bool QueryResultChunkScanState::LoadNextChunk(PreservedError &error) {
+	if (finished) {
+		return !finished;
+	}
+	auto load_result = InternalLoad(error);
+	if (!load_result) {
+		finished = true;
+	}
+	offset = 0;
+	return !finished;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,48 @@
+#include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/main/chunk_scan_state.hpp"
+
+namespace duckdb {
+
+ChunkScanState::ChunkScanState() {
+}
+
+ChunkScanState::~ChunkScanState() {
+}
+
+idx_t ChunkScanState::CurrentOffset() const {
+	return offset;
+}
+
+void ChunkScanState::IncreaseOffset(idx_t increment, bool unsafe) {
+	D_ASSERT(unsafe || increment <= RemainingInChunk());
+	offset += increment;
+}
+
+bool ChunkScanState::ChunkIsEmpty() const {
+	return !current_chunk || current_chunk->size() == 0;
+}
+
+bool ChunkScanState::Finished() const {
+	return finished;
+}
+
+bool ChunkScanState::ScanStarted() const {
+	return !ChunkIsEmpty();
+}
+
+DataChunk &ChunkScanState::CurrentChunk() {
+	// Scan must already be started
+	D_ASSERT(current_chunk);
+	return *current_chunk;
+}
+
+idx_t ChunkScanState::RemainingInChunk() const {
+	if (ChunkIsEmpty()) {
+		return 0;
+	}
+	D_ASSERT(current_chunk);
+	D_ASSERT(offset <= current_chunk->size());
+	return current_chunk->size() - offset;
+}
+
+} // namespace duckdb

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

@@ -7,9 +7,7 @@
 #include "duckdb/common/http_state.hpp"
 #include "duckdb/common/preserved_error.hpp"
 #include "duckdb/common/progress_bar/progress_bar.hpp"
-#include "duckdb/common/serializer/buffered_deserializer.hpp"
 #include "duckdb/common/serializer/buffered_file_writer.hpp"
-#include "duckdb/common/serializer/buffered_serializer.hpp"
 #include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/execution/column_binding_resolver.hpp"
 #include "duckdb/execution/operator/helper/physical_result_collector.hpp"
@@ -27,11 +25,9 @@
 #include "duckdb/main/relation.hpp"
 #include "duckdb/main/stream_query_result.hpp"
 #include "duckdb/optimizer/optimizer.hpp"
-#include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/parameter_expression.hpp"
 #include "duckdb/parser/parsed_data/create_function_info.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/statement/drop_statement.hpp"
@@ -43,9 +39,7 @@
 #include "duckdb/planner/operator/logical_execute.hpp"
 #include "duckdb/planner/planner.hpp"
 #include "duckdb/planner/pragma_handler.hpp"
-#include "duckdb/storage/data_table.hpp"
 #include "duckdb/transaction/meta_transaction.hpp"
-#include "duckdb/transaction/transaction.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
 
 namespace duckdb {
@@ -304,9 +298,9 @@ static bool IsExplainAnalyze(SQLStatement *statement) {
 	return explain.explain_type == ExplainType::EXPLAIN_ANALYZE;
 }
 
-shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &query,
-                                                                         unique_ptr<SQLStatement> statement,
-                                                                         vector<Value> *values) {
+shared_ptr<PreparedStatementData>
+ClientContext::CreatePreparedStatement(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);
 
@@ -315,8 +309,9 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 	profiler.StartPhase("planner");
 	Planner planner(*this);
 	if (values) {
-		for (auto &value : *values) {
-			planner.parameter_data.emplace_back(value);
+		auto &parameter_values = *values;
+		for (auto &value : parameter_values) {
+			planner.parameter_data.emplace(value.first, BoundParameterData(value.second));
 		}
 	}
 
@@ -370,7 +365,7 @@ double ClientContext::GetProgress() {
 
 unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientContextLock &lock,
                                                                        shared_ptr<PreparedStatementData> statement_p,
-                                                                       PendingQueryParameters parameters) {
+                                                                       const PendingQueryParameters &parameters) {
 	D_ASSERT(active_query);
 	auto &statement = *statement_p;
 	if (ValidChecker::IsInvalidated(ActiveTransaction()) && statement.properties.requires_valid_transaction) {
@@ -392,7 +387,14 @@ unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientCon
 	}
 
 	// bind the bound values before execution
-	statement.Bind(parameters.parameters ? *parameters.parameters : vector<Value>());
+	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));
 
 	active_query->executor = make_uniq<Executor>(*this);
 	auto &executor = *active_query->executor;
@@ -566,7 +568,7 @@ unique_ptr<PreparedStatement> ClientContext::Prepare(const string &query) {
 
 unique_ptr<PendingQueryResult> ClientContext::PendingQueryPreparedInternal(ClientContextLock &lock, const string &query,
                                                                            shared_ptr<PreparedStatementData> &prepared,
-                                                                           PendingQueryParameters parameters) {
+                                                                           const PendingQueryParameters &parameters) {
 	try {
 		InitialCleanup(lock);
 	} catch (const Exception &ex) {
@@ -579,13 +581,13 @@ unique_ptr<PendingQueryResult> ClientContext::PendingQueryPreparedInternal(Clien
 
 unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const string &query,
                                                            shared_ptr<PreparedStatementData> &prepared,
-                                                           PendingQueryParameters parameters) {
+                                                           const PendingQueryParameters &parameters) {
 	auto lock = LockContext();
 	return PendingQueryPreparedInternal(*lock, query, prepared, parameters);
 }
 
 unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-                                               PendingQueryParameters parameters) {
+                                               const PendingQueryParameters &parameters) {
 	auto lock = LockContext();
 	auto pending = PendingQueryPreparedInternal(*lock, query, prepared, parameters);
 	if (pending->HasError()) {
@@ -595,7 +597,7 @@ unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<P
 }
 
 unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-                                               vector<Value> &values, bool allow_stream_result) {
+                                               case_insensitive_map_t<Value> &values, bool allow_stream_result) {
 	PendingQueryParameters parameters;
 	parameters.parameters = &values;
 	parameters.allow_stream_result = allow_stream_result;
@@ -604,10 +606,11 @@ unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<P
 
 unique_ptr<PendingQueryResult> ClientContext::PendingStatementInternal(ClientContextLock &lock, const string &query,
                                                                        unique_ptr<SQLStatement> statement,
-                                                                       PendingQueryParameters parameters) {
+                                                                       const PendingQueryParameters &parameters) {
 	// prepare the query for execution
 	auto prepared = CreatePreparedStatement(lock, query, std::move(statement), parameters.parameters);
-	if (prepared->properties.parameter_count > 0 && !parameters.parameters) {
+	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",
 		                                          prepared->properties.parameter_count);
 		return make_uniq<PendingQueryResult>(PreservedError(error_message));
@@ -640,7 +643,7 @@ bool ClientContext::IsActiveResult(ClientContextLock &lock, BaseQueryResult *res
 
 unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatementInternal(
     ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-    shared_ptr<PreparedStatementData> &prepared, PendingQueryParameters parameters) {
+    shared_ptr<PreparedStatementData> &prepared, const PendingQueryParameters &parameters) {
 	// check if we are on AutoCommit. In this case we should start a transaction.
 	if (statement && config.AnyVerification()) {
 		// query verification is enabled
@@ -697,7 +700,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 
 unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatement(
     ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
-    shared_ptr<PreparedStatementData> &prepared, PendingQueryParameters parameters) {
+    shared_ptr<PreparedStatementData> &prepared, const PendingQueryParameters &parameters) {
 	unique_ptr<PendingQueryResult> result;
 
 	try {
@@ -722,7 +725,7 @@ unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatemen
 		if (statement) {
 			result = PendingStatementInternal(lock, query, std::move(statement), parameters);
 		} else {
-			if (prepared->RequireRebind(*this, *parameters.parameters)) {
+			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);
@@ -884,7 +887,8 @@ unique_ptr<PendingQueryResult> ClientContext::PendingQuery(unique_ptr<SQLStateme
 
 unique_ptr<PendingQueryResult> ClientContext::PendingQueryInternal(ClientContextLock &lock,
                                                                    unique_ptr<SQLStatement> statement,
-                                                                   PendingQueryParameters parameters, bool verify) {
+                                                                   const PendingQueryParameters &parameters,
+                                                                   bool verify) {
 	auto query = statement->query;
 	shared_ptr<PreparedStatementData> prepared;
 	if (verify) {
@@ -1155,8 +1159,21 @@ ParserOptions ClientContext::GetParserOptions() const {
 }
 
 ClientProperties ClientContext::GetClientProperties() const {
-	auto client_context = ClientConfig::GetConfig(*this);
-	return {client_context.ExtractTimezone(), db->config.options.arrow_offset_size};
+	string timezone = "UTC";
+	Value result;
+	// 1) Check Set Variable
+	auto &client_config = ClientConfig::GetConfig(*this);
+	auto tz_config = client_config.set_variables.find("timezone");
+	if (tz_config == client_config.set_variables.end()) {
+		// 2) Check for Default Value
+		auto default_value = db->config.extension_parameters.find("timezone");
+		if (default_value != db->config.extension_parameters.end()) {
+			timezone = default_value->second.default_value.GetValue<string>();
+		}
+	} else {
+		timezone = tz_config->second.GetValue<string>();
+	}
+	return {timezone, db->config.options.arrow_offset_size};
 }
 
 bool ClientContext::ExecutionIsFinished() {

package/src/duckdb/src/main/client_context_file_opener.cpp

@@ -1,5 +1,6 @@
 #include "duckdb/main/client_context_file_opener.hpp"
 
+#include "duckdb/common/file_opener.hpp"
 #include "duckdb/main/client_context.hpp"
 
 namespace duckdb {
@@ -8,6 +9,11 @@ bool ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &res
 	return context.TryGetCurrentSetting(key, result);
 }
 
+// LCOV_EXCL_START
+bool ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &) {
+	return context.TryGetCurrentSetting(key, result);
+}
+
 ClientContext *FileOpener::TryGetClientContext(FileOpener *opener) {
 	if (!opener) {
 		return nullptr;
@@ -22,4 +28,15 @@ bool FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Val
 	return opener->TryGetCurrentSetting(key, result);
 }
 
+bool FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result, FileOpenerInfo &info) {
+	if (!opener) {
+		return false;
+	}
+	return opener->TryGetCurrentSetting(key, result, info);
+}
+
+bool FileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info) {
+	return this->TryGetCurrentSetting(key, result);
+}
+// LCOV_EXCL_STOP
 } // namespace duckdb

package/src/duckdb/src/main/client_verify.cpp

@@ -7,6 +7,20 @@
 
 namespace duckdb {
 
+static void ThrowIfExceptionIsInternal(StatementVerifier &verifier) {
+	if (!verifier.materialized_result) {
+		return;
+	}
+	auto &result = *verifier.materialized_result;
+	if (!result.HasError()) {
+		return;
+	}
+	auto &error = result.GetErrorObject();
+	if (error.Type() == ExceptionType::INTERNAL) {
+		error.Throw();
+	}
+}
+
 PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
                                           unique_ptr<SQLStatement> statement) {
 	D_ASSERT(statement->type == StatementType::SELECT_STATEMENT);
@@ -26,7 +40,6 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 	if (config.query_verification_enabled) {
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::COPIED, stmt));
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::DESERIALIZED, stmt));
-		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::DESERIALIZED_V2, stmt));
 		statement_verifiers.emplace_back(StatementVerifier::Create(VerificationType::UNOPTIMIZED, stmt));
 		prepared_statement_verifier = StatementVerifier::Create(VerificationType::PREPARED, stmt);
 #ifdef DUCKDB_DEBUG_ASYNC_SINK_SOURCE
@@ -81,6 +94,9 @@ PreservedError ClientContext::VerifyQuery(ClientContextLock &lock, const string
 		if (!failed) {
 			// PreparedStatementVerifier fails if it runs into a ParameterNotAllowedException, which is OK
 			statement_verifiers.push_back(std::move(prepared_statement_verifier));
+		} else {
+			// If it does fail, let's make sure it's not an internal exception
+			ThrowIfExceptionIsInternal(*prepared_statement_verifier);
 		}
 	} else {
 		if (ValidChecker::IsInvalidated(*db)) {