duckdb 0.8.1-dev31.0 → 0.8.1-dev327.0

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

@@ -14,7 +14,7 @@ duckdb_state duckdb_pending_prepared_internal(duckdb_prepared_statement prepared
 	if (!prepared_statement || !out_result) {
 		return DuckDBError;
 	}
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	auto result = new PendingStatementWrapper();
 	result->allow_streaming = allow_streaming;
 	try {
@@ -25,7 +25,7 @@ duckdb_state duckdb_pending_prepared_internal(duckdb_prepared_statement prepared
 		result->statement = make_uniq<PendingQueryResult>(duckdb::PreservedError(ex));
 	}
 	duckdb_state return_value = !result->statement->HasError() ? DuckDBSuccess : DuckDBError;
-	*out_result = (duckdb_pending_result)result;
+	*out_result = reinterpret_cast<duckdb_pending_result>(result);
 
 	return return_value;
 }
@@ -43,7 +43,7 @@ void duckdb_destroy_pending(duckdb_pending_result *pending_result) {
 	if (!pending_result || !*pending_result) {
 		return;
 	}
-	auto wrapper = (PendingStatementWrapper *)*pending_result;
+	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(*pending_result);
 	if (wrapper->statement) {
 		wrapper->statement->Close();
 	}
@@ -55,7 +55,7 @@ const char *duckdb_pending_error(duckdb_pending_result pending_result) {
 	if (!pending_result) {
 		return nullptr;
 	}
-	auto wrapper = (PendingStatementWrapper *)pending_result;
+	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(pending_result);
 	if (!wrapper->statement) {
 		return nullptr;
 	}
@@ -66,7 +66,7 @@ duckdb_pending_state duckdb_pending_execute_task(duckdb_pending_result pending_r
 	if (!pending_result) {
 		return DUCKDB_PENDING_ERROR;
 	}
-	auto wrapper = (PendingStatementWrapper *)pending_result;
+	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(pending_result);
 	if (!wrapper->statement) {
 		return DUCKDB_PENDING_ERROR;
 	}
@@ -97,7 +97,7 @@ duckdb_state duckdb_execute_pending(duckdb_pending_result pending_result, duckdb
 	if (!pending_result || !out_result) {
 		return DuckDBError;
 	}
-	auto wrapper = (PendingStatementWrapper *)pending_result;
+	auto wrapper = reinterpret_cast<PendingStatementWrapper *>(pending_result);
 	if (!wrapper->statement) {
 		return DuckDBError;
 	}

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

@@ -21,7 +21,7 @@ idx_t duckdb_extract_statements(duckdb_connection connection, const char *query,
 		return 0;
 	}
 	auto wrapper = new ExtractStatementsWrapper();
-	Connection *conn = (Connection *)connection;
+	Connection *conn = reinterpret_cast<Connection *>(connection);
 	try {
 		wrapper->statements = conn->ExtractStatements(query);
 	} catch (const duckdb::ParserException &e) {
@@ -35,7 +35,7 @@ idx_t duckdb_extract_statements(duckdb_connection connection, const char *query,
 duckdb_state duckdb_prepare_extracted_statement(duckdb_connection connection,
                                                 duckdb_extracted_statements extracted_statements, idx_t index,
                                                 duckdb_prepared_statement *out_prepared_statement) {
-	Connection *conn = (Connection *)connection;
+	Connection *conn = reinterpret_cast<Connection *>(connection);
 	auto source_wrapper = (ExtractStatementsWrapper *)extracted_statements;
 
 	if (!connection || !out_prepared_statement || index >= source_wrapper->statements.size()) {
@@ -62,14 +62,14 @@ duckdb_state duckdb_prepare(duckdb_connection connection, const char *query,
 		return DuckDBError;
 	}
 	auto wrapper = new PreparedStatementWrapper();
-	Connection *conn = (Connection *)connection;
+	Connection *conn = reinterpret_cast<Connection *>(connection);
 	wrapper->statement = conn->Prepare(query);
 	*out_prepared_statement = (duckdb_prepared_statement)wrapper;
 	return !wrapper->statement->HasError() ? DuckDBSuccess : DuckDBError;
 }
 
 const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || !wrapper->statement->HasError()) {
 		return nullptr;
 	}
@@ -77,7 +77,7 @@ const char *duckdb_prepare_error(duckdb_prepared_statement prepared_statement) {
 }
 
 idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return 0;
 	}
@@ -85,7 +85,7 @@ idx_t duckdb_nparams(duckdb_prepared_statement prepared_statement) {
 }
 
 duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DUCKDB_TYPE_INVALID;
 	}
@@ -97,7 +97,7 @@ duckdb_type duckdb_param_type(duckdb_prepared_statement prepared_statement, idx_
 }
 
 duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DuckDBError;
 	}
@@ -106,7 +106,7 @@ duckdb_state duckdb_clear_bindings(duckdb_prepared_statement prepared_statement)
 }
 
 static duckdb_state duckdb_bind_value(duckdb_prepared_statement prepared_statement, idx_t param_idx, Value val) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DuckDBError;
 	}
@@ -220,7 +220,7 @@ duckdb_state duckdb_bind_decimal(duckdb_prepared_statement prepared_statement, i
 
 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_t)data, length));
+	return duckdb_bind_value(prepared_statement, param_idx, Value::BLOB(duckdb::const_data_ptr_cast(data), length));
 }
 
 duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_t param_idx) {
@@ -228,7 +228,7 @@ duckdb_state duckdb_bind_null(duckdb_prepared_statement prepared_statement, idx_
 }
 
 duckdb_state duckdb_execute_prepared(duckdb_prepared_statement prepared_statement, duckdb_result *out_result) {
-	auto wrapper = (PreparedStatementWrapper *)prepared_statement;
+	auto wrapper = reinterpret_cast<PreparedStatementWrapper *>(prepared_statement);
 	if (!wrapper || !wrapper->statement || wrapper->statement->HasError()) {
 		return DuckDBError;
 	}

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

@@ -30,7 +30,7 @@ struct CAPIReplacementScanInfo {
 
 unique_ptr<TableRef> duckdb_capi_replacement_callback(ClientContext &context, const string &table_name,
                                                       ReplacementScanData *data) {
-	auto &scan_data = (CAPIReplacementScanData &)*data;
+	auto &scan_data = reinterpret_cast<CAPIReplacementScanData &>(*data);
 
 	CAPIReplacementScanInfo info(&scan_data);
 	scan_data.callback((duckdb_replacement_scan_info)&info, table_name.c_str(), scan_data.extra_data);
@@ -57,7 +57,7 @@ void duckdb_add_replacement_scan(duckdb_database db, duckdb_replacement_callback
 	if (!db || !replacement) {
 		return;
 	}
-	auto wrapper = (duckdb::DatabaseData *)db;
+	auto wrapper = reinterpret_cast<duckdb::DatabaseData *>(db);
 	auto scan_info = duckdb::make_uniq<duckdb::CAPIReplacementScanData>();
 	scan_info->callback = replacement;
 	scan_info->extra_data = extra_data;
@@ -72,7 +72,7 @@ void duckdb_replacement_scan_set_function_name(duckdb_replacement_scan_info info
 	if (!info_p || !function_name) {
 		return;
 	}
-	auto info = (duckdb::CAPIReplacementScanInfo *)info_p;
+	auto info = reinterpret_cast<duckdb::CAPIReplacementScanInfo *>(info_p);
 	info->function_name = function_name;
 }
 
@@ -80,8 +80,8 @@ void duckdb_replacement_scan_add_parameter(duckdb_replacement_scan_info info_p,
 	if (!info_p || !parameter) {
 		return;
 	}
-	auto info = (duckdb::CAPIReplacementScanInfo *)info_p;
-	auto val = (duckdb::Value *)parameter;
+	auto info = reinterpret_cast<duckdb::CAPIReplacementScanInfo *>(info_p);
+	auto val = reinterpret_cast<duckdb::Value *>(parameter);
 	info->parameters.push_back(*val);
 }
 
@@ -89,6 +89,6 @@ void duckdb_replacement_scan_set_error(duckdb_replacement_scan_info info_p, cons
 	if (!info_p || !error) {
 		return;
 	}
-	auto info = (duckdb::CAPIReplacementScanInfo *)info_p;
+	auto info = reinterpret_cast<duckdb::CAPIReplacementScanInfo *>(info_p);
 	info->error = error;
 }

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

@@ -19,10 +19,10 @@ struct CStandardConverter : public CBaseConverter {
 struct CStringConverter {
 	template <class SRC, class DST>
 	static DST Convert(SRC input) {
-		auto result = (char *)duckdb_malloc(input.GetSize() + 1);
+		auto result = char_ptr_cast(duckdb_malloc(input.GetSize() + 1));
 		assert(result);
 		memcpy((void *)result, input.GetData(), input.GetSize());
-		auto write_arr = (char *)result;
+		auto write_arr = char_ptr_cast(result);
 		write_arr[input.GetSize()] = '\0';
 		return result;
 	}
@@ -37,10 +37,10 @@ struct CBlobConverter {
 	template <class SRC, class DST>
 	static DST Convert(SRC input) {
 		duckdb_blob result;
-		result.data = (char *)duckdb_malloc(input.GetSize());
+		result.data = char_ptr_cast(duckdb_malloc(input.GetSize()));
 		result.size = input.GetSize();
 		assert(result.data);
-		memcpy((void *)result.data, input.GetData(), input.GetSize());
+		memcpy(result.data, input.GetData(), input.GetSize());
 		return result;
 	}
 
@@ -266,7 +266,7 @@ duckdb_state duckdb_translate_result(unique_ptr<QueryResult> result_p, duckdb_re
 
 	if (result.HasError()) {
 		// write the error message
-		out->__deprecated_error_message = (char *)result.GetError().c_str();
+		out->__deprecated_error_message = (char *)result.GetError().c_str(); // NOLINT
 		return DuckDBError;
 	}
 	// copy the data
@@ -280,7 +280,7 @@ bool deprecated_materialize_result(duckdb_result *result) {
 	if (!result) {
 		return false;
 	}
-	auto result_data = (duckdb::DuckDBResultData *)result->internal_data;
+	auto result_data = reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data);
 	if (result_data->result->HasError()) {
 		return false;
 	}
@@ -310,14 +310,14 @@ bool deprecated_materialize_result(duckdb_result *result) {
 		result_data->result = stream_result.Materialize();
 	}
 	D_ASSERT(result_data->result->type == QueryResultType::MATERIALIZED_RESULT);
-	auto &materialized = (MaterializedQueryResult &)*result_data->result;
+	auto &materialized = reinterpret_cast<MaterializedQueryResult &>(*result_data->result);
 
 	// convert the result to a materialized result
 	// zero initialize the columns (so we can cleanly delete it in case a malloc fails)
 	memset(result->__deprecated_columns, 0, sizeof(duckdb_column) * column_count);
 	for (idx_t i = 0; i < column_count; i++) {
 		result->__deprecated_columns[i].__deprecated_type = ConvertCPPTypeToC(result_data->result->types[i]);
-		result->__deprecated_columns[i].__deprecated_name = (char *)result_data->result->names[i].c_str();
+		result->__deprecated_columns[i].__deprecated_name = (char *)result_data->result->names[i].c_str(); // NOLINT
 	}
 	result->__deprecated_row_count = materialized.RowCount();
 	if (result->__deprecated_row_count > 0 &&
@@ -344,7 +344,7 @@ static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
 	if (column.__deprecated_data) {
 		if (column.__deprecated_type == DUCKDB_TYPE_VARCHAR) {
 			// varchar, delete individual strings
-			auto data = (char **)column.__deprecated_data;
+			auto data = reinterpret_cast<char **>(column.__deprecated_data);
 			for (idx_t i = 0; i < count; i++) {
 				if (data[i]) {
 					duckdb_free(data[i]);
@@ -352,7 +352,7 @@ static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
 			}
 		} else if (column.__deprecated_type == DUCKDB_TYPE_BLOB) {
 			// blob, delete individual blobs
-			auto data = (duckdb_blob *)column.__deprecated_data;
+			auto data = reinterpret_cast<duckdb_blob *>(column.__deprecated_data);
 			for (idx_t i = 0; i < count; i++) {
 				if (data[i].data) {
 					duckdb_free((void *)data[i].data);
@@ -374,7 +374,7 @@ void duckdb_destroy_result(duckdb_result *result) {
 		duckdb_free(result->__deprecated_columns);
 	}
 	if (result->internal_data) {
-		auto result_data = (duckdb::DuckDBResultData *)result->internal_data;
+		auto result_data = reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data);
 		delete result_data;
 	}
 	memset(result, 0, sizeof(duckdb_result));
@@ -384,7 +384,7 @@ const char *duckdb_column_name(duckdb_result *result, idx_t col) {
 	if (!result || col >= duckdb_column_count(result)) {
 		return nullptr;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	return result_data.result->names[col].c_str();
 }
 
@@ -392,7 +392,7 @@ duckdb_type duckdb_column_type(duckdb_result *result, idx_t col) {
 	if (!result || col >= duckdb_column_count(result)) {
 		return DUCKDB_TYPE_INVALID;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	return duckdb::ConvertCPPTypeToC(result_data.result->types[col]);
 }
 
@@ -400,7 +400,7 @@ duckdb_logical_type duckdb_column_logical_type(duckdb_result *result, idx_t col)
 	if (!result || col >= duckdb_column_count(result)) {
 		return nullptr;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	return reinterpret_cast<duckdb_logical_type>(new duckdb::LogicalType(result_data.result->types[col]));
 }
 
@@ -408,7 +408,7 @@ idx_t duckdb_column_count(duckdb_result *result) {
 	if (!result) {
 		return 0;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	return result_data.result->ColumnCount();
 }
 
@@ -416,12 +416,12 @@ idx_t duckdb_row_count(duckdb_result *result) {
 	if (!result) {
 		return 0;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	if (result_data.result->type == duckdb::QueryResultType::STREAM_RESULT) {
 		// We can't know the row count beforehand
 		return 0;
 	}
-	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
+	auto &materialized = reinterpret_cast<duckdb::MaterializedQueryResult &>(*result_data.result);
 	return materialized.RowCount();
 }
 
@@ -459,7 +459,7 @@ const char *duckdb_result_error(duckdb_result *result) {
 	if (!result) {
 		return nullptr;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result->internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result->internal_data));
 	return !result_data.result->HasError() ? nullptr : result_data.result->GetError().c_str();
 }
 
@@ -467,7 +467,7 @@ idx_t duckdb_result_chunk_count(duckdb_result result) {
 	if (!result.internal_data) {
 		return 0;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
 	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
 		return 0;
 	}
@@ -475,7 +475,7 @@ idx_t duckdb_result_chunk_count(duckdb_result result) {
 		// Can't know beforehand how many chunks are returned.
 		return 0;
 	}
-	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
+	auto &materialized = reinterpret_cast<duckdb::MaterializedQueryResult &>(*result_data.result);
 	return materialized.Collection().ChunkCount();
 }
 
@@ -483,7 +483,7 @@ duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx)
 	if (!result.internal_data) {
 		return nullptr;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
 	if (result_data.result_set_type == duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_DEPRECATED) {
 		return nullptr;
 	}
@@ -492,7 +492,7 @@ duckdb_data_chunk duckdb_result_get_chunk(duckdb_result result, idx_t chunk_idx)
 		return nullptr;
 	}
 	result_data.result_set_type = duckdb::CAPIResultSetType::CAPI_RESULT_TYPE_MATERIALIZED;
-	auto &materialized = (duckdb::MaterializedQueryResult &)*result_data.result;
+	auto &materialized = reinterpret_cast<duckdb::MaterializedQueryResult &>(*result_data.result);
 	auto &collection = materialized.Collection();
 	if (chunk_idx >= collection.ChunkCount()) {
 		return nullptr;
@@ -510,6 +510,6 @@ bool duckdb_result_is_streaming(duckdb_result result) {
 	if (duckdb_result_error(&result) != nullptr) {
 		return false;
 	}
-	auto &result_data = *((duckdb::DuckDBResultData *)result.internal_data);
+	auto &result_data = *(reinterpret_cast<duckdb::DuckDBResultData *>(result.internal_data));
 	return result_data.result->type == duckdb::QueryResultType::STREAM_RESULT;
 }

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

@@ -311,7 +311,7 @@ void duckdb_bind_add_result_column(duckdb_bind_info info, const char *name, duck
 	}
 	auto bind_info = (duckdb::CTableInternalBindInfo *)info;
 	bind_info->names.push_back(name);
-	bind_info->return_types.push_back(*((duckdb::LogicalType *)type));
+	bind_info->return_types.push_back(*(reinterpret_cast<duckdb::LogicalType *>(type)));
 }
 
 idx_t duckdb_bind_get_parameter_count(duckdb_bind_info info) {

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

@@ -774,8 +774,8 @@ void ClientContext::LogQueryInternal(ClientContextLock &, const string &query) {
 #endif
 	}
 	// log query path is set: log the query
-	client_data->log_query_writer->WriteData((const_data_ptr_t)query.c_str(), query.size());
-	client_data->log_query_writer->WriteData((const_data_ptr_t) "\n", 1);
+	client_data->log_query_writer->WriteData(const_data_ptr_cast(query.c_str()), query.size());
+	client_data->log_query_writer->WriteData(const_data_ptr_cast("\n"), 1);
 	client_data->log_query_writer->Flush();
 	client_data->log_query_writer->Sync();
 }
@@ -918,7 +918,7 @@ void ClientContext::RegisterFunction(CreateFunctionInfo &info) {
 		auto existing_function = Catalog::GetEntry<ScalarFunctionCatalogEntry>(*this, INVALID_CATALOG, info.schema,
 		                                                                       info.name, OnEntryNotFound::RETURN_NULL);
 		if (existing_function) {
-			auto &new_info = (CreateScalarFunctionInfo &)info;
+			auto &new_info = info.Cast<CreateScalarFunctionInfo>();
 			if (new_info.functions.MergeFunctionSet(existing_function->functions)) {
 				// function info was updated from catalog entry, rewrite is needed
 				info.on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;

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

@@ -82,6 +82,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL(ForceBitpackingModeSetting),
                                                  DUCKDB_LOCAL(HomeDirectorySetting),
                                                  DUCKDB_LOCAL(LogQueryPathSetting),
+                                                 DUCKDB_GLOBAL(LockConfigurationSetting),
                                                  DUCKDB_GLOBAL(ImmediateTransactionModeSetting),
                                                  DUCKDB_LOCAL(IntegerDivisionSetting),
                                                  DUCKDB_LOCAL(MaximumExpressionDepthSetting),

package/src/duckdb/src/main/database_manager.cpp

@@ -27,7 +27,7 @@ optional_ptr<AttachedDatabase> DatabaseManager::GetDatabase(ClientContext &conte
 	if (StringUtil::Lower(name) == TEMP_CATALOG) {
 		return context.client_data->temporary_objects.get();
 	}
-	return (AttachedDatabase *)databases->GetEntry(context, name).get();
+	return reinterpret_cast<AttachedDatabase *>(databases->GetEntry(context, name).get());
 }
 
 void DatabaseManager::AddDatabase(ClientContext &context, unique_ptr<AttachedDatabase> db_instance) {

package/src/duckdb/src/main/error_manager.cpp

@@ -37,7 +37,7 @@ string ErrorManager::FormatExceptionRecursive(ErrorType error_type, vector<Excep
 string ErrorManager::InvalidUnicodeError(const string &input, const string &context) {
 	UnicodeInvalidReason reason;
 	size_t pos;
-	auto unicode = Utf8Proc::Analyze((const char *)input.c_str(), input.size(), &reason, &pos);
+	auto unicode = Utf8Proc::Analyze(const_char_ptr_cast(input.c_str()), input.size(), &reason, &pos);
 	if (unicode != UnicodeType::INVALID) {
 		return "Invalid unicode error thrown but no invalid unicode detected in " + context;
 	}

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

@@ -86,7 +86,7 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileSystem &fs, const str
 
 		auto signature_offset = handle->GetFileSize() - signature.size();
 
-		const idx_t maxLenChunks = 1024 * 1024;
+		const idx_t maxLenChunks = 1024ULL * 1024ULL;
 		const idx_t numChunks = (signature_offset + maxLenChunks - 1) / maxLenChunks;
 		std::vector<std::string> hash_chunks(numChunks);
 		std::vector<idx_t> splits(numChunks + 1);

package/src/duckdb/src/main/relation/create_table_relation.cpp

@@ -23,7 +23,7 @@ BoundStatement CreateTableRelation::Bind(Binder &binder) {
 	info->query = std::move(select);
 	info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
 	stmt.info = std::move(info);
-	return binder.Bind((SQLStatement &)stmt);
+	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &CreateTableRelation::Columns() {

package/src/duckdb/src/main/relation/create_view_relation.cpp

@@ -32,7 +32,7 @@ BoundStatement CreateViewRelation::Bind(Binder &binder) {
 	info->schema = schema_name;
 	info->on_conflict = replace ? OnCreateConflict::REPLACE_ON_CONFLICT : OnCreateConflict::ERROR_ON_CONFLICT;
 	stmt.info = std::move(info);
-	return binder.Bind((SQLStatement &)stmt);
+	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &CreateViewRelation::Columns() {

package/src/duckdb/src/main/relation/delete_relation.cpp

@@ -21,7 +21,7 @@ BoundStatement DeleteRelation::Bind(Binder &binder) {
 	DeleteStatement stmt;
 	stmt.condition = condition ? condition->Copy() : nullptr;
 	stmt.table = std::move(basetable);
-	return binder.Bind((SQLStatement &)stmt);
+	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &DeleteRelation::Columns() {

package/src/duckdb/src/main/relation/explain_relation.cpp

@@ -16,7 +16,7 @@ BoundStatement ExplainRelation::Bind(Binder &binder) {
 	auto select = make_uniq<SelectStatement>();
 	select->node = child->GetQueryNode();
 	ExplainStatement explain(std::move(select), type);
-	return binder.Bind((SQLStatement &)explain);
+	return binder.Bind(explain.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &ExplainRelation::Columns() {

package/src/duckdb/src/main/relation/insert_relation.cpp

@@ -21,7 +21,7 @@ BoundStatement InsertRelation::Bind(Binder &binder) {
 	stmt.schema = schema_name;
 	stmt.table = table_name;
 	stmt.select_statement = std::move(select);
-	return binder.Bind((SQLStatement &)stmt);
+	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &InsertRelation::Columns() {

package/src/duckdb/src/main/relation/update_relation.cpp

@@ -30,7 +30,7 @@ BoundStatement UpdateRelation::Bind(Binder &binder) {
 	for (auto &expr : expressions) {
 		stmt.set_info->expressions.push_back(expr->Copy());
 	}
-	return binder.Bind((SQLStatement &)stmt);
+	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &UpdateRelation::Columns() {

package/src/duckdb/src/main/relation/write_csv_relation.cpp

@@ -22,7 +22,7 @@ BoundStatement WriteCSVRelation::Bind(Binder &binder) {
 	info->format = "csv";
 	info->options = options;
 	copy.info = std::move(info);
-	return binder.Bind((SQLStatement &)copy);
+	return binder.Bind(copy.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &WriteCSVRelation::Columns() {

package/src/duckdb/src/main/relation/write_parquet_relation.cpp

@@ -22,7 +22,7 @@ BoundStatement WriteParquetRelation::Bind(Binder &binder) {
 	info->format = "parquet";
 	info->options = options;
 	copy.info = std::move(info);
-	return binder.Bind((SQLStatement &)copy);
+	return binder.Bind(copy.Cast<SQLStatement>());
 }
 
 const vector<ColumnDefinition> &WriteParquetRelation::Columns() {

package/src/duckdb/src/main/relation.cpp

@@ -209,7 +209,7 @@ unique_ptr<QueryResult> Relation::ExecuteOrThrow() {
 BoundStatement Relation::Bind(Binder &binder) {
 	SelectStatement stmt;
 	stmt.node = GetQueryNode();
-	return binder.Bind((SQLStatement &)stmt);
+	return binder.Bind(stmt.Cast<SQLStatement>());
 }
 
 shared_ptr<Relation> Relation::InsertRel(const string &schema_name, const string &table_name) {

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

@@ -151,7 +151,7 @@ void OrderedAggregateThreshold::ResetLocal(ClientContext &context) {
 
 void OrderedAggregateThreshold::SetLocal(ClientContext &context, const Value &input) {
 	const auto param = input.GetValue<uint64_t>();
-	if (!param) {
+	if (param <= 0) {
 		throw ParserException("Invalid option for PRAGMA ordered_aggregate_threshold, value must be positive");
 	}
 	ClientConfig::GetConfig(context).ordered_aggregate_threshold = param;
@@ -189,7 +189,7 @@ Value DebugWindowMode::GetSetting(ClientContext &context) {
 // Debug AsOf Join
 //===--------------------------------------------------------------------===//
 void DebugAsOfIEJoin::ResetLocal(ClientContext &context) {
-	ClientConfig::GetConfig(context).force_no_cross_product = ClientConfig().force_asof_iejoin;
+	ClientConfig::GetConfig(context).force_asof_iejoin = ClientConfig().force_asof_iejoin;
 }
 
 void DebugAsOfIEJoin::SetLocal(ClientContext &context, const Value &input) {
@@ -433,7 +433,6 @@ Value EnableHTTPMetadataCacheSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Enable Profiling
 //===--------------------------------------------------------------------===//
-
 void EnableProfilingSetting::ResetLocal(ClientContext &context) {
 	auto &config = ClientConfig::GetConfig(context);
 	config.profiler_print_format = ClientConfig().profiler_print_format;
@@ -718,10 +717,10 @@ Value IntegerDivisionSetting::GetSetting(ClientContext &context) {
 	auto &config = ClientConfig::GetConfig(context);
 	return Value(config.integer_division);
 }
+
 //===--------------------------------------------------------------------===//
 // Log Query Path
 //===--------------------------------------------------------------------===//
-
 void LogQueryPathSetting::ResetLocal(ClientContext &context) {
 	auto &client_data = ClientData::Get(context);
 	// TODO: verify that this does the right thing
@@ -745,6 +744,23 @@ Value LogQueryPathSetting::GetSetting(ClientContext &context) {
 	return client_data.log_query_writer ? Value(client_data.log_query_writer->path) : Value();
 }
 
+//===--------------------------------------------------------------------===//
+// Lock Configuration
+//===--------------------------------------------------------------------===//
+void LockConfigurationSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	auto new_value = input.GetValue<bool>();
+	config.options.lock_configuration = new_value;
+}
+
+void LockConfigurationSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.lock_configuration = DBConfig().options.lock_configuration;
+}
+
+Value LockConfigurationSetting::GetSetting(ClientContext &context) {
+	auto &config = DBConfig::GetConfig(context);
+	return Value::BOOLEAN(config.options.lock_configuration);
+}
+
 //===--------------------------------------------------------------------===//
 // Immediate Transaction Mode
 //===--------------------------------------------------------------------===//
@@ -988,7 +1004,7 @@ void SchemaSetting::ResetLocal(ClientContext &context) {
 void SchemaSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = input.ToString();
 	auto &client_data = ClientData::Get(context);
-	client_data.catalog_search_path->Set(CatalogSearchEntry::Parse(parameter), true);
+	client_data.catalog_search_path->Set(CatalogSearchEntry::Parse(parameter), CatalogSetPathType::SET_SCHEMA);
 }
 
 Value SchemaSetting::GetSetting(ClientContext &context) {
@@ -1008,7 +1024,7 @@ void SearchPathSetting::ResetLocal(ClientContext &context) {
 void SearchPathSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = input.ToString();
 	auto &client_data = ClientData::Get(context);
-	client_data.catalog_search_path->Set(CatalogSearchEntry::ParseList(parameter), false);
+	client_data.catalog_search_path->Set(CatalogSearchEntry::ParseList(parameter), CatalogSetPathType::SET_SCHEMAS);
 }
 
 Value SearchPathSetting::GetSetting(ClientContext &context) {