duckdb 0.7.2-dev314.0 → 0.7.2-dev3154.0

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

@@ -4,6 +4,14 @@
 #include "duckdb/main/error_manager.hpp"
 #include "mbedtls_wrapper.hpp"
 
+#ifndef DUCKDB_NO_THREADS
+#include <thread>
+#endif // DUCKDB_NO_THREADS
+
+#ifdef WASM_LOADABLE_EXTENSIONS
+#include <emscripten.h>
+#endif
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -11,7 +19,7 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 typedef void (*ext_init_fun_t)(DatabaseInstance &);
 typedef const char *(*ext_version_fun_t)(void);
-typedef void (*ext_storage_init_t)(DBConfig &);
+typedef bool (*ext_is_storage_t)(void);
 
 template <class T>
 static T LoadFunctionFromDLL(void *dll, const string &function_name, const string &filename) {
@@ -22,6 +30,20 @@ static T LoadFunctionFromDLL(void *dll, const string &function_name, const strin
 	return (T)function;
 }
 
+static void ComputeSHA256String(const std::string &to_hash, std::string *res) {
+	// Invoke MbedTls function to actually compute sha256
+	*res = duckdb_mbedtls::MbedTlsWrapper::ComputeSha256Hash(to_hash);
+}
+
+static void ComputeSHA256FileSegment(FileHandle *handle, const idx_t start, const idx_t end, std::string *res) {
+	const idx_t len = end - start;
+	string file_content;
+	file_content.resize(len);
+	handle->Read((void *)file_content.data(), len, start);
+
+	ComputeSHA256String(file_content, res);
+}
+
 bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileOpener *opener, const string &extension,
                                      ExtensionInitResult &result, string &error) {
 	if (!config.options.enable_external_access) {
@@ -59,25 +81,55 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileOpener *opener, const
 	if (!config.options.allow_unsigned_extensions) {
 		auto handle = fs.OpenFile(filename, FileFlags::FILE_FLAGS_READ);
 
-		// signature is the last 265 bytes of the file
+		// signature is the last 256 bytes of the file
 
 		string signature;
 		signature.resize(256);
 
 		auto signature_offset = handle->GetFileSize() - signature.size();
 
-		string file_content;
-		file_content.resize(signature_offset);
-		handle->Read((void *)file_content.data(), signature_offset, 0);
+		const idx_t maxLenChunks = 1024 * 1024;
+		const idx_t numChunks = (signature_offset + maxLenChunks - 1) / maxLenChunks;
+		std::vector<std::string> hash_chunks(numChunks);
+		std::vector<idx_t> splits(numChunks + 1);
+
+		for (idx_t i = 0; i < numChunks; i++) {
+			splits[i] = maxLenChunks * i;
+		}
+		splits.back() = signature_offset;
+
+#ifndef DUCKDB_NO_THREADS
+		std::vector<std::thread> threads;
+		threads.reserve(numChunks);
+		for (idx_t i = 0; i < numChunks; i++) {
+			threads.emplace_back(ComputeSHA256FileSegment, handle.get(), splits[i], splits[i + 1], &hash_chunks[i]);
+		}
+
+		for (auto &thread : threads) {
+			thread.join();
+		}
+#else
+		for (idx_t i = 0; i < numChunks; i++) {
+			ComputeSHA256FileSegment(handle.get(), splits[i], splits[i + 1], &hash_chunks[i]);
+		}
+#endif // DUCKDB_NO_THREADS
+
+		string hash_concatenation;
+		hash_concatenation.reserve(32 * numChunks); // 256 bits -> 32 bytes per chunk
+
+		for (auto &hash_chunk : hash_chunks) {
+			hash_concatenation += hash_chunk;
+		}
+
+		string two_level_hash;
+		ComputeSHA256String(hash_concatenation, &two_level_hash);
 
 		// TODO maybe we should do a stream read / hash update here
 		handle->Read((void *)signature.data(), signature.size(), signature_offset);
 
-		auto hash = duckdb_mbedtls::MbedTlsWrapper::ComputeSha256Hash(file_content);
-
 		bool any_valid = false;
 		for (auto &key : ExtensionHelper::GetPublicKeys()) {
-			if (duckdb_mbedtls::MbedTlsWrapper::IsValidSha256Signature(key, signature, hash)) {
+			if (duckdb_mbedtls::MbedTlsWrapper::IsValidSha256Signature(key, signature, two_level_hash)) {
 				any_valid = true;
 				break;
 			}
@@ -86,13 +138,35 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileOpener *opener, const
 			throw IOException(config.error_manager->FormatException(ErrorType::UNSIGNED_EXTENSION, filename));
 		}
 	}
-	auto lib_hdl = dlopen(filename.c_str(), RTLD_NOW | RTLD_LOCAL);
+	auto basename = fs.ExtractBaseName(filename);
+
+#ifdef WASM_LOADABLE_EXTENSIONS
+	EM_ASM(
+	    {
+		    // Next few lines should argubly in separate JavaScript-land function call
+		    // TODO: move them out / have them configurable
+		    const xhr = new XMLHttpRequest();
+		    xhr.open("GET", UTF8ToString($0), false);
+		    xhr.responseType = "arraybuffer";
+		    xhr.send(null);
+		    var uInt8Array = xhr.response;
+		    WebAssembly.validate(uInt8Array);
+		    console.log('Loading extension ', UTF8ToString($1));
+
+		    // Here we add the uInt8Array to Emscripten's filesystem, for it to be found by dlopen
+		    FS.writeFile(UTF8ToString($1), new Uint8Array(uInt8Array));
+	    },
+	    filename.c_str(), basename.c_str());
+	auto dopen_from = basename;
+#else
+	auto dopen_from = filename;
+#endif
+
+	auto lib_hdl = dlopen(dopen_from.c_str(), RTLD_NOW | RTLD_LOCAL);
 	if (!lib_hdl) {
 		throw IOException("Extension \"%s\" could not be loaded: %s", filename, GetDLError());
 	}
 
-	auto basename = fs.ExtractBaseName(filename);
-
 	ext_version_fun_t version_fun;
 	auto version_fun_name = basename + "_version";
 
@@ -131,7 +205,18 @@ ExtensionInitResult ExtensionHelper::InitialLoad(DBConfig &config, FileOpener *o
 	string error;
 	ExtensionInitResult result;
 	if (!TryInitialLoad(config, opener, extension, result, error)) {
-		throw IOException(error);
+		if (!ExtensionHelper::AllowAutoInstall(extension)) {
+			throw IOException(error);
+		}
+		// the extension load failed - try installing the extension
+		if (!config.file_system) {
+			throw InternalException("Attempting to install an extension without a file system");
+		}
+		ExtensionHelper::InstallExtension(config, *config.file_system, extension, false);
+		// try loading again
+		if (!TryInitialLoad(config, nullptr, extension, result, error)) {
+			throw IOException(error);
+		}
 	}
 	return result;
 }
@@ -181,38 +266,6 @@ void ExtensionHelper::LoadExternalExtension(ClientContext &context, const string
 	LoadExternalExtension(DatabaseInstance::GetDatabase(context), FileSystem::GetFileOpener(context), extension);
 }
 
-void ExtensionHelper::StorageInit(string &extension, DBConfig &config) {
-	extension = ExtensionHelper::ApplyExtensionAlias(extension);
-	ExtensionInitResult res;
-	string error;
-	if (!TryInitialLoad(config, nullptr, extension, res, error)) {
-		if (!ExtensionHelper::AllowAutoInstall(extension)) {
-			throw IOException(error);
-		}
-		// the extension load failed - try installing the extension
-		if (!config.file_system) {
-			throw InternalException("Attempting to install an extension without a file system");
-		}
-		ExtensionHelper::InstallExtension(config, *config.file_system, extension, false);
-		// try loading again
-		if (!TryInitialLoad(config, nullptr, extension, res, error)) {
-			throw IOException(error);
-		}
-	}
-	auto storage_fun_name = res.basename + "_storage_init";
-
-	ext_storage_init_t storage_init_fun;
-	storage_init_fun = LoadFunctionFromDLL<ext_storage_init_t>(res.lib_hdl, storage_fun_name, res.filename);
-
-	try {
-		(*storage_init_fun)(config);
-	} catch (std::exception &e) {
-		throw InvalidInputException(
-		    "Storage initialization function \"%s\" from file \"%s\" threw an exception: \"%s\"", storage_fun_name,
-		    res.filename, e.what());
-	}
-}
-
 string ExtensionHelper::ExtractExtensionPrefixFromPath(const string &path) {
 	auto first_colon = path.find(':');
 	if (first_colon == string::npos || first_colon < 2) { // needs to be at least two characters because windows c: ...

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

@@ -0,0 +1,90 @@
+#include "duckdb/main/extension_util.hpp"
+#include "duckdb/function/scalar_function.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_macro_info.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/main/config.hpp"
+
+namespace duckdb {
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunctionSet set) {
+	D_ASSERT(!set.name.empty());
+	CreateScalarFunctionInfo info(std::move(set));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, info);
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunction function) {
+	D_ASSERT(!function.name.empty());
+	ScalarFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(db, std::move(set));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, TableFunction function) {
+	D_ASSERT(!function.name.empty());
+	TableFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(db, std::move(set));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, TableFunctionSet function) {
+	D_ASSERT(!function.name.empty());
+	CreateTableFunctionInfo info(std::move(function));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, info);
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, PragmaFunction function) {
+	D_ASSERT(!function.name.empty());
+	PragmaFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(db, std::move(set));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, PragmaFunctionSet function) {
+	D_ASSERT(!function.name.empty());
+	auto function_name = function.name;
+	CreatePragmaFunctionInfo info(std::move(function_name), std::move(function));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreatePragmaFunction(data, info);
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CopyFunction function) {
+	CreateCopyFunctionInfo info(std::move(function));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateCopyFunction(data, info);
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateMacroInfo &info) {
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, info);
+}
+
+void ExtensionUtil::RegisterType(DatabaseInstance &db, string type_name, LogicalType type) {
+	D_ASSERT(!type_name.empty());
+	CreateTypeInfo info(std::move(type_name), std::move(type));
+	info.temporary = true;
+	info.internal = true;
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateType(data, info);
+}
+
+void ExtensionUtil::RegisterCastFunction(DatabaseInstance &db, const LogicalType &source, const LogicalType &target,
+                                         BoundCastInfo function, int64_t implicit_cast_cost) {
+	auto &config = DBConfig::GetConfig(db);
+	auto &casts = config.GetCastFunctions();
+	casts.RegisterCastFunction(source, target, std::move(function), implicit_cast_cost);
+}
+
+} // namespace duckdb

package/src/duckdb/src/main/materialized_query_result.cpp

@@ -53,7 +53,7 @@ string MaterializedQueryResult::ToBox(ClientContext &context, const BoxRendererC
 
 Value MaterializedQueryResult::GetValue(idx_t column, idx_t index) {
 	if (!row_collection) {
-		row_collection = make_unique<ColumnDataRowCollection>(collection->GetRows());
+		row_collection = make_uniq<ColumnDataRowCollection>(collection->GetRows());
 	}
 	return row_collection->GetValue(column, index);
 }
@@ -81,7 +81,7 @@ unique_ptr<DataChunk> MaterializedQueryResult::FetchRaw() {
 	if (HasError()) {
 		throw InvalidInputException("Attempting to fetch from an unsuccessful query result\nError: %s", GetError());
 	}
-	auto result = make_unique<DataChunk>();
+	auto result = make_uniq<DataChunk>();
 	collection->InitializeScanChunk(*result);
 	if (!scan_initialized) {
 		// we disallow zero copy so the chunk is independently usable even after the result is destroyed

package/src/duckdb/src/main/pending_query_result.cpp

@@ -58,7 +58,7 @@ unique_ptr<QueryResult> PendingQueryResult::ExecuteInternal(ClientContextLock &l
 	while (ExecuteTaskInternal(lock) == PendingExecutionResult::RESULT_NOT_READY) {
 	}
 	if (HasError()) {
-		return make_unique<MaterializedQueryResult>(error);
+		return make_uniq<MaterializedQueryResult>(error);
 	}
 	auto result = context->FetchResultInternal(lock, *this);
 	Close();

package/src/duckdb/src/main/prepared_statement.cpp

@@ -23,6 +23,10 @@ const string &PreparedStatement::GetError() {
 	return error.Message();
 }
 
+PreservedError &PreparedStatement::GetErrorObject() {
+	return error;
+}
+
 bool PreparedStatement::HasError() const {
 	return !success;
 }
@@ -68,7 +72,7 @@ vector<LogicalType> PreparedStatement::GetExpectedParameterTypes() const {
 unique_ptr<QueryResult> PreparedStatement::Execute(vector<Value> &values, bool allow_stream_result) {
 	auto pending = PendingQuery(values, allow_stream_result);
 	if (pending->HasError()) {
-		return make_unique<MaterializedQueryResult>(pending->GetErrorObject());
+		return make_uniq<MaterializedQueryResult>(pending->GetErrorObject());
 	}
 	return pending->Execute();
 }

package/src/duckdb/src/main/query_profiler.cpp

@@ -1,21 +1,23 @@
 #include "duckdb/main/query_profiler.hpp"
-#include "duckdb/common/to_string.hpp"
+
 #include "duckdb/common/fstream.hpp"
+#include "duckdb/common/http_state.hpp"
+#include "duckdb/common/limits.hpp"
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/execution/operator/join/physical_delim_join.hpp"
-#include "duckdb/execution/operator/helper/physical_execute.hpp"
-#include "duckdb/common/http_stats.hpp"
+#include "duckdb/common/to_string.hpp"
 #include "duckdb/common/tree_renderer.hpp"
-#include "duckdb/common/limits.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/execution/operator/helper/physical_execute.hpp"
+#include "duckdb/execution/operator/join/physical_delim_join.hpp"
+#include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
-#include <utility>
+#include "duckdb/planner/expression/bound_function_expression.hpp"
+
 #include <algorithm>
+#include <utility>
 
 namespace duckdb {
 
@@ -206,7 +208,7 @@ void QueryProfiler::EndPhase() {
 	}
 }
 
-void QueryProfiler::Initialize(PhysicalOperator *root_op) {
+void QueryProfiler::Initialize(const PhysicalOperator &root_op) {
 	if (!IsEnabled() || !running) {
 		return;
 	}
@@ -225,7 +227,7 @@ void QueryProfiler::Initialize(PhysicalOperator *root_op) {
 OperatorProfiler::OperatorProfiler(bool enabled_p) : enabled(enabled_p), active_operator(nullptr) {
 }
 
-void OperatorProfiler::StartOperator(const PhysicalOperator *phys_op) {
+void OperatorProfiler::StartOperator(optional_ptr<const PhysicalOperator> phys_op) {
 	if (!enabled) {
 		return;
 	}
@@ -240,7 +242,7 @@ void OperatorProfiler::StartOperator(const PhysicalOperator *phys_op) {
 	op.Start();
 }
 
-void OperatorProfiler::EndOperator(DataChunk *chunk) {
+void OperatorProfiler::EndOperator(optional_ptr<DataChunk> chunk) {
 	if (!enabled) {
 		return;
 	}
@@ -252,11 +254,11 @@ void OperatorProfiler::EndOperator(DataChunk *chunk) {
 	// finish timing for the current element
 	op.End();
 
-	AddTiming(active_operator, op.Elapsed(), chunk ? chunk->size() : 0);
+	AddTiming(*active_operator, op.Elapsed(), chunk ? chunk->size() : 0);
 	active_operator = nullptr;
 }
 
-void OperatorProfiler::AddTiming(const PhysicalOperator *op, double time, idx_t elements) {
+void OperatorProfiler::AddTiming(const PhysicalOperator &op, double time, idx_t elements) {
 	if (!enabled) {
 		return;
 	}
@@ -273,7 +275,7 @@ void OperatorProfiler::AddTiming(const PhysicalOperator *op, double time, idx_t
 		entry->second.elements += elements;
 	}
 }
-void OperatorProfiler::Flush(const PhysicalOperator *phys_op, ExpressionExecutor *expression_executor,
+void OperatorProfiler::Flush(const PhysicalOperator &phys_op, ExpressionExecutor &expression_executor,
                              const string &name, int id) {
 	auto entry = timings.find(phys_op);
 	if (entry == timings.end()) {
@@ -283,8 +285,8 @@ void OperatorProfiler::Flush(const PhysicalOperator *phys_op, ExpressionExecutor
 	if (int(operator_timing.executors_info.size()) <= id) {
 		operator_timing.executors_info.resize(id + 1);
 	}
-	operator_timing.executors_info[id] = make_unique<ExpressionExecutorInfo>(*expression_executor, name, id);
-	operator_timing.name = phys_op->GetName();
+	operator_timing.executors_info[id] = make_uniq<ExpressionExecutorInfo>(expression_executor, name, id);
+	operator_timing.name = phys_op.GetName();
 }
 
 void QueryProfiler::Flush(OperatorProfiler &profiler) {
@@ -293,11 +295,13 @@ void QueryProfiler::Flush(OperatorProfiler &profiler) {
 		return;
 	}
 	for (auto &node : profiler.timings) {
-		auto entry = tree_map.find(node.first);
+		auto &op = node.first.get();
+		auto entry = tree_map.find(op);
 		D_ASSERT(entry != tree_map.end());
+		auto &tree_node = entry->second.get();
 
-		entry->second->info.time += node.second.time;
-		entry->second->info.elements += node.second.elements;
+		tree_node.info.time += node.second.time;
+		tree_node.info.elements += node.second.elements;
 		if (!IsDetailedEnabled()) {
 			continue;
 		}
@@ -306,10 +310,10 @@ void QueryProfiler::Flush(OperatorProfiler &profiler) {
 				continue;
 			}
 			auto info_id = info->id;
-			if (int(entry->second->info.executors_info.size()) <= info_id) {
-				entry->second->info.executors_info.resize(info_id + 1);
+			if (int32_t(tree_node.info.executors_info.size()) <= info_id) {
+				tree_node.info.executors_info.resize(info_id + 1);
 			}
-			entry->second->info.executors_info[info_id] = std::move(info);
+			tree_node.info.executors_info[info_id] = std::move(info);
 		}
 	}
 	profiler.timings.clear();
@@ -377,15 +381,15 @@ void QueryProfiler::QueryTreeToStream(std::ostream &ss) const {
 		return;
 	}
 
-	if (context.client_data->http_stats && !context.client_data->http_stats->IsEmpty()) {
+	if (context.client_data->http_state && !context.client_data->http_state->IsEmpty()) {
 		string read =
-		    "in: " + StringUtil::BytesToHumanReadableString(context.client_data->http_stats->total_bytes_received);
+		    "in: " + StringUtil::BytesToHumanReadableString(context.client_data->http_state->total_bytes_received);
 		string written =
-		    "out: " + StringUtil::BytesToHumanReadableString(context.client_data->http_stats->total_bytes_sent);
-		string head = "#HEAD: " + to_string(context.client_data->http_stats->head_count);
-		string get = "#GET: " + to_string(context.client_data->http_stats->get_count);
-		string put = "#PUT: " + to_string(context.client_data->http_stats->put_count);
-		string post = "#POST: " + to_string(context.client_data->http_stats->post_count);
+		    "out: " + StringUtil::BytesToHumanReadableString(context.client_data->http_state->total_bytes_sent);
+		string head = "#HEAD: " + to_string(context.client_data->http_state->head_count);
+		string get = "#GET: " + to_string(context.client_data->http_state->get_count);
+		string put = "#PUT: " + to_string(context.client_data->http_state->put_count);
+		string post = "#POST: " + to_string(context.client_data->http_state->post_count);
 
 		constexpr idx_t TOTAL_BOX_WIDTH = 39;
 		ss << "┌─────────────────────────────────────┐\n";
@@ -608,19 +612,19 @@ void QueryProfiler::WriteToFile(const char *path, string &info) const {
 	}
 }
 
-unique_ptr<QueryProfiler::TreeNode> QueryProfiler::CreateTree(PhysicalOperator *root, idx_t depth) {
-	if (OperatorRequiresProfiling(root->type)) {
+unique_ptr<QueryProfiler::TreeNode> QueryProfiler::CreateTree(const PhysicalOperator &root, idx_t depth) {
+	if (OperatorRequiresProfiling(root.type)) {
 		this->query_requires_profiling = true;
 	}
-	auto node = make_unique<QueryProfiler::TreeNode>();
-	node->type = root->type;
-	node->name = root->GetName();
-	node->extra_info = root->ParamsToString();
+	auto node = make_uniq<QueryProfiler::TreeNode>();
+	node->type = root.type;
+	node->name = root.GetName();
+	node->extra_info = root.ParamsToString();
 	node->depth = depth;
-	tree_map[root] = node.get();
-	auto children = root->GetChildren();
+	tree_map.insert(make_pair(reference<const PhysicalOperator>(root), reference<QueryProfiler::TreeNode>(*node)));
+	auto children = root.GetChildren();
 	for (auto &child : children) {
-		auto child_node = CreateTree(child, depth + 1);
+		auto child_node = CreateTree(child.get(), depth + 1);
 		node->children.push_back(std::move(child_node));
 	}
 	return node;
@@ -664,10 +668,10 @@ void ExpressionInfo::ExtractExpressionsRecursive(unique_ptr<ExpressionState> &st
 	}
 	// extract the children of this node
 	for (auto &child : state->child_states) {
-		auto expr_info = make_unique<ExpressionInfo>();
+		auto expr_info = make_uniq<ExpressionInfo>();
 		if (child->expr.expression_class == ExpressionClass::BOUND_FUNCTION) {
 			expr_info->hasfunction = true;
-			expr_info->function_name = ((BoundFunctionExpression &)child->expr).function.ToString();
+			expr_info->function_name = child->expr.Cast<BoundFunctionExpression>().function.ToString();
 			expr_info->function_time = child->profiler.time;
 			expr_info->sample_tuples_count = child->profiler.sample_tuples_count;
 			expr_info->tuples_count = child->profiler.tuples_count;
@@ -681,21 +685,21 @@ void ExpressionInfo::ExtractExpressionsRecursive(unique_ptr<ExpressionState> &st
 ExpressionExecutorInfo::ExpressionExecutorInfo(ExpressionExecutor &executor, const string &name, int id) : id(id) {
 	// Extract Expression Root Information from ExpressionExecutorStats
 	for (auto &state : executor.GetStates()) {
-		roots.push_back(make_unique<ExpressionRootInfo>(*state, name));
+		roots.push_back(make_uniq<ExpressionRootInfo>(*state, name));
 	}
 }
 
 ExpressionRootInfo::ExpressionRootInfo(ExpressionExecutorState &state, string name)
     : current_count(state.profiler.current_count), sample_count(state.profiler.sample_count),
       sample_tuples_count(state.profiler.sample_tuples_count), tuples_count(state.profiler.tuples_count),
-      name(state.name), time(state.profiler.time) {
+      name("expression"), time(state.profiler.time) {
 	// Use the name of expression-tree as extra-info
 	extra_info = std::move(name);
-	auto expression_info_p = make_unique<ExpressionInfo>();
+	auto expression_info_p = make_uniq<ExpressionInfo>();
 	// Maybe root has a function
 	if (state.root_state->expr.expression_class == ExpressionClass::BOUND_FUNCTION) {
 		expression_info_p->hasfunction = true;
-		expression_info_p->function_name = ((BoundFunctionExpression &)state.root_state->expr).function.name;
+		expression_info_p->function_name = (state.root_state->expr.Cast<BoundFunctionExpression>()).function.name;
 		expression_info_p->function_time = state.root_state->profiler.time;
 		expression_info_p->sample_tuples_count = state.root_state->profiler.sample_tuples_count;
 		expression_info_p->tuples_count = state.root_state->profiler.tuples_count;

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

@@ -58,6 +58,19 @@ QueryResult::QueryResult(QueryResultType type, StatementType statement_type, Sta
       client_properties(std::move(client_properties_p)) {
 }
 
+bool CurrentChunk::Valid() {
+	if (data_chunk) {
+		if (position < data_chunk->size()) {
+			return true;
+		}
+	}
+	return false;
+}
+
+idx_t CurrentChunk::RemainingSize() {
+	return data_chunk->size() - position;
+}
+
 QueryResult::QueryResult(QueryResultType type, PreservedError error) : BaseQueryResult(type, std::move(error)) {
 }
 
@@ -152,7 +165,7 @@ string QueryResult::HeaderToString() {
 }
 
 string QueryResult::GetConfigTimezone(QueryResult &query_result) {
-	return query_result.client_properties.timezone;
+	return query_result.client_properties.time_zone;
 }
 
 } // namespace duckdb

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

@@ -33,12 +33,12 @@ unique_ptr<QueryNode> AggregateRelation::GetQueryNode() {
 		result = child->GetQueryNode();
 	} else {
 		// child node is not a join: create a new select node and push the child as a table reference
-		auto select = make_unique<SelectNode>();
+		auto select = make_uniq<SelectNode>();
 		select->from_table = child->GetTableRef();
 		result = std::move(select);
 	}
 	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
-	auto &select_node = (SelectNode &)*result;
+	auto &select_node = result->Cast<SelectNode>();
 	if (!groups.empty()) {
 		// explicit groups provided: use standard handling
 		select_node.aggregate_handling = AggregateHandling::STANDARD_HANDLING;

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

@@ -13,11 +13,11 @@ CreateTableRelation::CreateTableRelation(shared_ptr<Relation> child_p, string sc
 }
 
 BoundStatement CreateTableRelation::Bind(Binder &binder) {
-	auto select = make_unique<SelectStatement>();
+	auto select = make_uniq<SelectStatement>();
 	select->node = child->GetQueryNode();
 
 	CreateStatement stmt;
-	auto info = make_unique<CreateTableInfo>();
+	auto info = make_uniq<CreateTableInfo>();
 	info->schema = schema_name;
 	info->table = table_name;
 	info->query = std::move(select);

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

@@ -21,11 +21,11 @@ CreateViewRelation::CreateViewRelation(shared_ptr<Relation> child_p, string sche
 }
 
 BoundStatement CreateViewRelation::Bind(Binder &binder) {
-	auto select = make_unique<SelectStatement>();
+	auto select = make_uniq<SelectStatement>();
 	select->node = child->GetQueryNode();
 
 	CreateStatement stmt;
-	auto info = make_unique<CreateViewInfo>();
+	auto info = make_uniq<CreateViewInfo>();
 	info->query = std::move(select);
 	info->view_name = view_name;
 	info->temporary = temporary;

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

@@ -16,14 +16,14 @@ CrossProductRelation::CrossProductRelation(shared_ptr<Relation> left_p, shared_p
 }
 
 unique_ptr<QueryNode> CrossProductRelation::GetQueryNode() {
-	auto result = make_unique<SelectNode>();
-	result->select_list.push_back(make_unique<StarExpression>());
+	auto result = make_uniq<SelectNode>();
+	result->select_list.push_back(make_uniq<StarExpression>());
 	result->from_table = GetTableRef();
 	return std::move(result);
 }
 
 unique_ptr<TableRef> CrossProductRelation::GetTableRef() {
-	auto cross_product_ref = make_unique<JoinRef>(JoinRefType::CROSS);
+	auto cross_product_ref = make_uniq<JoinRef>(JoinRefType::CROSS);
 	cross_product_ref->left = left->GetTableRef();
 	cross_product_ref->right = right->GetTableRef();
 	return std::move(cross_product_ref);

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

@@ -14,7 +14,7 @@ DeleteRelation::DeleteRelation(ClientContextWrapper &context, unique_ptr<ParsedE
 }
 
 BoundStatement DeleteRelation::Bind(Binder &binder) {
-	auto basetable = make_unique<BaseTableRef>();
+	auto basetable = make_uniq<BaseTableRef>();
 	basetable->schema_name = schema_name;
 	basetable->table_name = table_name;