duckdb 0.8.2-dev37.0 → 0.8.2-dev3949.0

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

@@ -4,8 +4,10 @@
 #include "duckdb/common/string_util.hpp"
 
 #ifndef DISABLE_DUCKDB_REMOTE_INSTALL
+#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
 #include "httplib.hpp"
 #endif
+#endif
 #include "duckdb/common/windows_undefs.hpp"
 
 #include <fstream>
@@ -27,6 +29,9 @@ bool ExtensionHelper::IsRelease(const string &version_tag) {
 }
 
 const string ExtensionHelper::GetVersionDirectoryName() {
+#ifdef DUCKDB_WASM_VERSION
+	return DUCKDB_QUOTE_DEFINE(DUCKDB_WASM_VERSION);
+#endif
 	if (IsRelease(DuckDB::LibraryVersion())) {
 		return NormalizeVersionTag(DuckDB::LibraryVersion());
 	} else {
@@ -51,7 +56,7 @@ string ExtensionHelper::ExtensionDirectory(DBConfig &config, FileSystem &fs) {
 		// expand ~ in extension directory
 		extension_directory = fs.ExpandPath(extension_directory);
 		if (!fs.DirectoryExists(extension_directory)) {
-			auto sep = fs.PathSeparator();
+			auto sep = fs.PathSeparator(extension_directory);
 			auto splits = StringUtil::Split(extension_directory, sep);
 			D_ASSERT(!splits.empty());
 			string extension_directory_prefix;
@@ -112,16 +117,18 @@ bool ExtensionHelper::CreateSuggestions(const string &extension_name, string &me
 	return false;
 }
 
-void ExtensionHelper::InstallExtension(DBConfig &config, FileSystem &fs, const string &extension, bool force_install) {
+void ExtensionHelper::InstallExtension(DBConfig &config, FileSystem &fs, const string &extension, bool force_install,
+                                       const string &repository) {
 #ifdef WASM_LOADABLE_EXTENSIONS
 	// Install is currently a no-op
 	return;
 #endif
 	string local_path = ExtensionDirectory(config, fs);
-	InstallExtensionInternal(config, nullptr, fs, local_path, extension, force_install);
+	InstallExtensionInternal(config, nullptr, fs, local_path, extension, force_install, repository);
 }
 
-void ExtensionHelper::InstallExtension(ClientContext &context, const string &extension, bool force_install) {
+void ExtensionHelper::InstallExtension(ClientContext &context, const string &extension, bool force_install,
+                                       const string &repository) {
 #ifdef WASM_LOADABLE_EXTENSIONS
 	// Install is currently a no-op
 	return;
@@ -130,7 +137,7 @@ void ExtensionHelper::InstallExtension(ClientContext &context, const string &ext
 	auto &fs = FileSystem::GetFileSystem(context);
 	string local_path = ExtensionDirectory(context);
 	auto &client_config = ClientConfig::GetConfig(context);
-	InstallExtensionInternal(config, &client_config, fs, local_path, extension, force_install);
+	InstallExtensionInternal(config, &client_config, fs, local_path, extension, force_install, repository);
 }
 
 unsafe_unique_array<data_t> ReadExtensionFileFromDisk(FileSystem &fs, const string &path, idx_t &file_size) {
@@ -151,7 +158,11 @@ void WriteExtensionFileToDisk(FileSystem &fs, const string &path, void *data, id
 }
 
 void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *client_config, FileSystem &fs,
-                                               const string &local_path, const string &extension, bool force_install) {
+                                               const string &local_path, const string &extension, bool force_install,
+                                               const string &repository) {
+#ifdef DUCKDB_DISABLE_EXTENSION_LOAD
+	throw PermissionException("Installing external extensions is disabled through a compile time flag");
+#else
 	if (!config.options.enable_external_access) {
 		throw PermissionException("Installing extensions is disabled through configuration");
 	}
@@ -173,6 +184,9 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 		auto in_buffer = ReadExtensionFileFromDisk(fs, extension, file_size);
 		WriteExtensionFileToDisk(fs, temp_path, in_buffer.get(), file_size);
 
+		if (fs.FileExists(local_extension_path) && force_install) {
+			fs.RemoveFile(local_extension_path);
+		}
 		fs.MoveFile(temp_path, local_extension_path);
 		return;
 	} else if (StringUtil::Contains(extension, "/") && !is_http_url) {
@@ -183,10 +197,17 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 	throw BinderException("Remote extension installation is disabled through configuration");
 #else
 
-	string default_endpoint = "http://extensions.duckdb.org";
 	string versioned_path = "/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension.gz";
 	string custom_endpoint = client_config ? client_config->custom_extension_repo : string();
-	string &endpoint = !custom_endpoint.empty() ? custom_endpoint : default_endpoint;
+	string endpoint;
+	if (!repository.empty()) {
+		endpoint = repository;
+	} else if (!custom_endpoint.empty()) {
+		endpoint = custom_endpoint;
+	} else {
+		endpoint = "http://extensions.duckdb.org";
+	}
+
 	string url_template = endpoint + versioned_path;
 
 	if (is_http_url) {
@@ -205,6 +226,28 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 		throw IOException("No slash in URL template");
 	}
 
+	// Special case to install extension from a local file, useful for testing
+	if (!StringUtil::Contains(endpoint, "http://")) {
+		string file = fs.ConvertSeparators(url);
+		if (!fs.FileExists(file)) {
+			// check for non-gzipped variant
+			file = file.substr(0, file.size() - 3);
+			if (!fs.FileExists(file)) {
+				throw IOException("Failed to copy local extension \"%s\" at PATH \"%s\"\n", extension_name, file);
+			}
+		}
+		auto read_handle = fs.OpenFile(file, FileFlags::FILE_FLAGS_READ);
+		auto test_data = std::unique_ptr<unsigned char[]> {new unsigned char[read_handle->GetFileSize()]};
+		read_handle->Read(test_data.get(), read_handle->GetFileSize());
+		WriteExtensionFileToDisk(fs, temp_path, (void *)test_data.get(), read_handle->GetFileSize());
+
+		if (fs.FileExists(local_extension_path) && force_install) {
+			fs.RemoveFile(local_extension_path);
+		}
+		fs.MoveFile(temp_path, local_extension_path);
+		return;
+	}
+
 	// Push the substring [last, next) on to splits
 	auto hostname_without_http = no_http.substr(0, next);
 	auto url_local_part = no_http.substr(next);
@@ -235,8 +278,13 @@ void ExtensionHelper::InstallExtensionInternal(DBConfig &config, ClientConfig *c
 	auto decompressed_body = GZipFileSystem::UncompressGZIPString(res->body);
 
 	WriteExtensionFileToDisk(fs, temp_path, (void *)decompressed_body.data(), decompressed_body.size());
+
+	if (fs.FileExists(local_extension_path) && force_install) {
+		fs.RemoveFile(local_extension_path);
+	}
 	fs.MoveFile(temp_path, local_extension_path);
 #endif
+#endif
 }
 
 } // namespace duckdb

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

@@ -17,6 +17,7 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // Load External Extension
 //===--------------------------------------------------------------------===//
+#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
 typedef void (*ext_init_fun_t)(DatabaseInstance &);
 typedef const char *(*ext_version_fun_t)(void);
 typedef bool (*ext_is_storage_t)(void);
@@ -36,16 +37,31 @@ static void ComputeSHA256String(const std::string &to_hash, std::string *res) {
 }
 
 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);
+	idx_t iter = start;
+	const idx_t segment_size = 1024 * 8;
 
-	ComputeSHA256String(file_content, res);
+	duckdb_mbedtls::MbedTlsWrapper::SHA256State state;
+
+	std::string to_hash;
+	while (iter < end) {
+		idx_t len = std::min(end - iter, segment_size);
+		to_hash.resize(len);
+		handle->Read((void *)to_hash.data(), len, iter);
+
+		state.AddString(to_hash);
+
+		iter += segment_size;
+	}
+
+	*res = state.Finalize();
 }
+#endif
 
 bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileSystem &fs, const string &extension,
                                      ExtensionInitResult &result, string &error) {
+#ifdef DUCKDB_DISABLE_EXTENSION_LOAD
+	throw PermissionException("Loading external extensions is disabled through a compile time flag");
+#else
 	if (!config.options.enable_external_access) {
 		throw PermissionException("Loading external extensions is disabled through configuration");
 	}
@@ -197,6 +213,7 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileSystem &fs, const str
 	result.filename = filename;
 	result.lib_hdl = lib_hdl;
 	return true;
+#endif
 }
 
 ExtensionInitResult ExtensionHelper::InitialLoad(DBConfig &config, FileSystem &fs, const string &extension) {
@@ -241,7 +258,9 @@ void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs
 	if (db.ExtensionIsLoaded(extension)) {
 		return;
 	}
-
+#ifdef DUCKDB_DISABLE_EXTENSION_LOAD
+	throw PermissionException("Loading external extensions is disabled through a compile time flag");
+#else
 	auto res = InitialLoad(DBConfig::GetConfig(db), fs, extension);
 	auto init_fun_name = res.basename + "_init";
 
@@ -256,6 +275,7 @@ void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, FileSystem &fs
 	}
 
 	db.SetExtensionLoaded(extension);
+#endif
 }
 
 void ExtensionHelper::LoadExternalExtension(ClientContext &context, const string &extension) {

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

@@ -1,5 +1,6 @@
 #include "duckdb/main/extension_util.hpp"
 #include "duckdb/function/scalar_function.hpp"
+#include "duckdb/parser/parsed_data/create_aggregate_function_info.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"
@@ -26,6 +27,21 @@ void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunction functi
 	RegisterFunction(db, std::move(set));
 }
 
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, AggregateFunction function) {
+	D_ASSERT(!function.name.empty());
+	AggregateFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(db, std::move(set));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, AggregateFunctionSet set) {
+	D_ASSERT(!set.name.empty());
+	CreateAggregateFunctionInfo 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, TableFunction function) {
 	D_ASSERT(!function.name.empty());
 	TableFunctionSet set(function.name);

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

@@ -55,7 +55,8 @@ PendingExecutionResult PendingQueryResult::ExecuteTaskInternal(ClientContextLock
 
 unique_ptr<QueryResult> PendingQueryResult::ExecuteInternal(ClientContextLock &lock) {
 	CheckExecutableInternal(lock);
-	while (ExecuteTaskInternal(lock) == PendingExecutionResult::RESULT_NOT_READY) {
+	// Busy wait while execution is not finished
+	while (!IsFinished(ExecuteTaskInternal(lock))) {
 	}
 	if (HasError()) {
 		return make_uniq<MaterializedQueryResult>(error);
@@ -74,4 +75,11 @@ void PendingQueryResult::Close() {
 	context.reset();
 }
 
+bool PendingQueryResult::IsFinished(PendingExecutionResult result) {
+	if (result == PendingExecutionResult::RESULT_READY || result == PendingExecutionResult::EXECUTION_ERROR) {
+		return true;
+	}
+	return false;
+}
+
 } // namespace duckdb

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

@@ -6,9 +6,9 @@
 namespace duckdb {
 
 PreparedStatement::PreparedStatement(shared_ptr<ClientContext> context, shared_ptr<PreparedStatementData> data_p,
-                                     string query, idx_t n_param, case_insensitive_map_t<idx_t> named_param_pam_p)
+                                     string query, idx_t n_param, case_insensitive_map_t<idx_t> named_param_map_p)
     : context(std::move(context)), data(std::move(data_p)), query(std::move(query)), success(true), n_param(n_param),
-      named_param_map(std::move(named_param_pam_p)) {
+      named_param_map(std::move(named_param_map_p)) {
 	D_ASSERT(data || !success);
 }
 
@@ -56,19 +56,27 @@ const vector<string> &PreparedStatement::GetNames() {
 	return data->names;
 }
 
-vector<LogicalType> PreparedStatement::GetExpectedParameterTypes() const {
+case_insensitive_map_t<LogicalType> PreparedStatement::GetExpectedParameterTypes() const {
 	D_ASSERT(data);
-	vector<LogicalType> expected_types(data->value_map.size());
+	case_insensitive_map_t<LogicalType> expected_types(data->value_map.size());
 	for (auto &it : data->value_map) {
-		D_ASSERT(it.first >= 1);
-		idx_t param_index = it.first - 1;
-		D_ASSERT(param_index < expected_types.size());
+		auto &identifier = it.first;
+		D_ASSERT(data->value_map.count(identifier));
 		D_ASSERT(it.second);
-		expected_types[param_index] = it.second->value.type();
+		expected_types[identifier] = it.second->GetValue().type();
 	}
 	return expected_types;
 }
 
+unique_ptr<QueryResult> PreparedStatement::Execute(case_insensitive_map_t<Value> &named_values,
+                                                   bool allow_stream_result) {
+	auto pending = PendingQuery(named_values, allow_stream_result);
+	if (pending->HasError()) {
+		return make_uniq<MaterializedQueryResult>(pending->GetErrorObject());
+	}
+	return pending->Execute();
+}
+
 unique_ptr<QueryResult> PreparedStatement::Execute(vector<Value> &values, bool allow_stream_result) {
 	auto pending = PendingQuery(values, allow_stream_result);
 	if (pending->HasError()) {
@@ -78,14 +86,33 @@ unique_ptr<QueryResult> PreparedStatement::Execute(vector<Value> &values, bool a
 }
 
 unique_ptr<PendingQueryResult> PreparedStatement::PendingQuery(vector<Value> &values, bool allow_stream_result) {
+	case_insensitive_map_t<Value> named_values;
+	for (idx_t i = 0; i < values.size(); i++) {
+		auto &val = values[i];
+		named_values[std::to_string(i + 1)] = val;
+	}
+	return PendingQuery(named_values, allow_stream_result);
+}
+
+unique_ptr<PendingQueryResult> PreparedStatement::PendingQuery(case_insensitive_map_t<Value> &named_values,
+                                                               bool allow_stream_result) {
 	if (!success) {
-		throw InvalidInputException("Attempting to execute an unsuccessfully prepared statement!");
+		auto exception = InvalidInputException("Attempting to execute an unsuccessfully prepared statement!");
+		return make_uniq<PendingQueryResult>(PreservedError(exception));
 	}
-	D_ASSERT(data);
 	PendingQueryParameters parameters;
-	parameters.parameters = &values;
+	parameters.parameters = &named_values;
+
+	try {
+		VerifyParameters(named_values, named_param_map);
+	} catch (const Exception &ex) {
+		return make_uniq<PendingQueryResult>(PreservedError(ex));
+	}
+
+	D_ASSERT(data);
 	parameters.allow_stream_result = allow_stream_result && data->properties.allow_stream_result;
 	auto result = context->PendingQuery(query, data, parameters);
+	// The result should not contain any reference to the 'vector<Value> parameters.parameters'
 	return result;
 }
 

package/src/duckdb/src/main/prepared_statement_data.cpp

@@ -18,8 +18,9 @@ void PreparedStatementData::CheckParameterCount(idx_t parameter_count) {
 	}
 }
 
-bool PreparedStatementData::RequireRebind(ClientContext &context, const vector<Value> &values) {
-	CheckParameterCount(values.size());
+bool PreparedStatementData::RequireRebind(ClientContext &context, optional_ptr<case_insensitive_map_t<Value>> values) {
+	idx_t count = values ? values->size() : 0;
+	CheckParameterCount(count);
 	if (!unbound_statement) {
 		// no unbound statement!? cannot rebind?
 		return false;
@@ -33,52 +34,56 @@ bool PreparedStatementData::RequireRebind(ClientContext &context, const vector<V
 		return true;
 	}
 	for (auto &it : value_map) {
-		const idx_t i = it.first - 1;
-		if (values[i].type() != it.second->return_type) {
+		auto &identifier = it.first;
+		auto lookup = values->find(identifier);
+		D_ASSERT(lookup != values->end());
+		if (lookup->second.type() != it.second->return_type) {
 			return true;
 		}
 	}
 	return false;
 }
 
-void PreparedStatementData::Bind(vector<Value> values) {
+void PreparedStatementData::Bind(case_insensitive_map_t<Value> values) {
 	// set parameters
 	D_ASSERT(!unbound_statement || unbound_statement->n_param == properties.parameter_count);
 	CheckParameterCount(values.size());
 
 	// bind the required values
 	for (auto &it : value_map) {
-		const idx_t i = it.first - 1;
-		if (i >= values.size()) {
-			throw BinderException("Could not find parameter with index %llu", i + 1);
+		const string &identifier = it.first;
+		auto lookup = values.find(identifier);
+		if (lookup == values.end()) {
+			throw BinderException("Could not find parameter with identifier %s", identifier);
 		}
 		D_ASSERT(it.second);
-		if (!values[i].DefaultTryCastAs(it.second->return_type)) {
+		auto &value = lookup->second;
+		if (!value.DefaultTryCastAs(it.second->return_type)) {
 			throw BinderException(
-			    "Type mismatch for binding parameter with index %llu, expected type %s but got type %s", i + 1,
-			    it.second->return_type.ToString().c_str(), values[i].type().ToString().c_str());
+			    "Type mismatch for binding parameter with identifier %s, expected type %s but got type %s", identifier,
+			    it.second->return_type.ToString().c_str(), value.type().ToString().c_str());
 		}
-		it.second->value = values[i];
+		it.second->SetValue(value);
 	}
 }
 
-bool PreparedStatementData::TryGetType(idx_t param_idx, LogicalType &result) {
-	auto it = value_map.find(param_idx);
+bool PreparedStatementData::TryGetType(const string &identifier, LogicalType &result) {
+	auto it = value_map.find(identifier);
 	if (it == value_map.end()) {
 		return false;
 	}
 	if (it->second->return_type.id() != LogicalTypeId::INVALID) {
 		result = it->second->return_type;
 	} else {
-		result = it->second->value.type();
+		result = it->second->GetValue().type();
 	}
 	return true;
 }
 
-LogicalType PreparedStatementData::GetType(idx_t param_idx) {
+LogicalType PreparedStatementData::GetType(const string &identifier) {
 	LogicalType result;
-	if (!TryGetType(param_idx, result)) {
-		throw BinderException("Could not find parameter with index %llu", param_idx);
+	if (!TryGetType(identifier, result)) {
+		throw BinderException("Could not find parameter identified with: %s", identifier);
 	}
 	return result;
 }

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

@@ -57,19 +57,6 @@ 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)), client_properties("UTC", ArrowOffsetSize::REGULAR) {
 }
@@ -164,12 +151,4 @@ string QueryResult::HeaderToString() {
 	return result;
 }
 
-ArrowOptions QueryResult::GetArrowOptions(QueryResult &query_result) {
-	return {query_result.client_properties.arrow_offset_size, query_result.client_properties.time_zone};
-}
-
-string QueryResult::GetConfigTimezone(QueryResult &query_result) {
-	return query_result.client_properties.time_zone;
-}
-
 } // namespace duckdb

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

@@ -13,11 +13,28 @@ AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
+AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
+                                     vector<unique_ptr<ParsedExpression>> parsed_expressions, GroupByNode groups_p)
+    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
+      groups(std::move(groups_p)), child(std::move(child_p)) {
+	// bind the expressions
+	context.GetContext()->TryBindRelation(*this, this->columns);
+}
+
 AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
                                      vector<unique_ptr<ParsedExpression>> parsed_expressions,
                                      vector<unique_ptr<ParsedExpression>> groups_p)
     : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
-      groups(std::move(groups_p)), child(std::move(child_p)) {
+      child(std::move(child_p)) {
+	if (!groups_p.empty()) {
+		// explicit groups provided: use standard handling
+		GroupingSet grouping_set;
+		for (idx_t i = 0; i < groups_p.size(); i++) {
+			groups.group_expressions.push_back(std::move(groups_p[i]));
+			grouping_set.insert(i);
+		}
+		groups.grouping_sets.push_back(std::move(grouping_set));
+	}
 	// bind the expressions
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
@@ -39,16 +56,9 @@ unique_ptr<QueryNode> AggregateRelation::GetQueryNode() {
 	}
 	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
 	auto &select_node = result->Cast<SelectNode>();
-	if (!groups.empty()) {
-		// explicit groups provided: use standard handling
+	if (!groups.group_expressions.empty()) {
 		select_node.aggregate_handling = AggregateHandling::STANDARD_HANDLING;
-		select_node.groups.group_expressions.clear();
-		GroupingSet grouping_set;
-		for (idx_t i = 0; i < groups.size(); i++) {
-			select_node.groups.group_expressions.push_back(groups[i]->Copy());
-			grouping_set.insert(i);
-		}
-		select_node.groups.grouping_sets.push_back(std::move(grouping_set));
+		select_node.groups = groups.Copy();
 	} else {
 		// no groups provided: automatically figure out groups (if any)
 		select_node.aggregate_handling = AggregateHandling::FORCE_AGGREGATES;

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

@@ -6,9 +6,10 @@
 
 namespace duckdb {
 
-CrossProductRelation::CrossProductRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p)
+CrossProductRelation::CrossProductRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p,
+                                           JoinRefType ref_type)
     : Relation(left_p->context, RelationType::CROSS_PRODUCT_RELATION), left(std::move(left_p)),
-      right(std::move(right_p)) {
+      right(std::move(right_p)), ref_type(ref_type) {
 	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
@@ -23,7 +24,7 @@ unique_ptr<QueryNode> CrossProductRelation::GetQueryNode() {
 }
 
 unique_ptr<TableRef> CrossProductRelation::GetTableRef() {
-	auto cross_product_ref = make_uniq<JoinRef>(JoinRefType::CROSS);
+	auto cross_product_ref = make_uniq<JoinRef>(ref_type);
 	cross_product_ref->left = left->GetTableRef();
 	cross_product_ref->right = right->GetTableRef();
 	return std::move(cross_product_ref);

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

@@ -8,9 +8,9 @@
 namespace duckdb {
 
 JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p,
-                           unique_ptr<ParsedExpression> condition_p, JoinType type)
+                           unique_ptr<ParsedExpression> condition_p, JoinType type, JoinRefType join_ref_type)
     : Relation(left_p->context, RelationType::JOIN_RELATION), left(std::move(left_p)), right(std::move(right_p)),
-      condition(std::move(condition_p)), join_type(type) {
+      condition(std::move(condition_p)), join_type(type), join_ref_type(join_ref_type) {
 	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
@@ -18,9 +18,9 @@ JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> rig
 }
 
 JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p, vector<string> using_columns_p,
-                           JoinType type)
+                           JoinType type, JoinRefType join_ref_type)
     : Relation(left_p->context, RelationType::JOIN_RELATION), left(std::move(left_p)), right(std::move(right_p)),
-      using_columns(std::move(using_columns_p)), join_type(type) {
+      using_columns(std::move(using_columns_p)), join_type(type), join_ref_type(join_ref_type) {
 	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
@@ -35,7 +35,7 @@ unique_ptr<QueryNode> JoinRelation::GetQueryNode() {
 }
 
 unique_ptr<TableRef> JoinRelation::GetTableRef() {
-	auto join_ref = make_uniq<JoinRef>(JoinRefType::REGULAR);
+	auto join_ref = make_uniq<JoinRef>(join_ref_type);
 	join_ref->left = left->GetTableRef();
 	join_ref->right = right->GetTableRef();
 	if (condition) {
@@ -52,7 +52,7 @@ const vector<ColumnDefinition> &JoinRelation::Columns() {
 
 string JoinRelation::ToString(idx_t depth) {
 	string str = RenderWhitespace(depth);
-	str += "Join " + EnumUtil::ToString(join_type);
+	str += "Join " + EnumUtil::ToString(join_ref_type) + " " + EnumUtil::ToString(join_type);
 	if (condition) {
 		str += " " + condition->GetName();
 	}

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

@@ -1,18 +1,21 @@
 #include "duckdb/main/relation/read_csv_relation.hpp"
-#include "duckdb/parser/tableref/table_function_ref.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
+
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/execution/operator/scan/csv/buffered_csv_reader.hpp"
+#include "duckdb/execution/operator/scan/csv/csv_buffer_manager.hpp"
+#include "duckdb/execution/operator/scan/csv/csv_sniffer.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/operator/persistent/buffered_csv_reader.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/parser/tableref/table_function_ref.hpp"
 
 namespace duckdb {
 
-ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const string &csv_file,
+ReadCSVRelation::ReadCSVRelation(const shared_ptr<ClientContext> &context, const string &csv_file,
                                  vector<ColumnDefinition> columns_p, string alias_p)
     : TableFunctionRelation(context, "read_csv", {Value(csv_file)}, nullptr, false), alias(std::move(alias_p)),
       auto_detect(false) {
@@ -31,8 +34,8 @@ ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context,
 	AddNamedParameter("columns", Value::STRUCT(std::move(column_names)));
 }
 
-ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const string &csv_file,
-                                 BufferedCSVReaderOptions options, string alias_p)
+ReadCSVRelation::ReadCSVRelation(const shared_ptr<ClientContext> &context, const string &csv_file,
+                                 CSVReaderOptions options, string alias_p)
     : TableFunctionRelation(context, "read_csv_auto", {Value(csv_file)}, nullptr, false), alias(std::move(alias_p)),
       auto_detect(true) {
 
@@ -42,10 +45,13 @@ ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context,
 
 	// Force auto_detect for this constructor
 	options.auto_detect = true;
-	BufferedCSVReader reader(*context, std::move(options));
-
-	auto &types = reader.GetTypes();
-	auto &names = reader.GetNames();
+	auto bm_file_handle = BaseCSVReader::OpenCSV(*context, options);
+	auto buffer_manager = make_shared<CSVBufferManager>(*context, std::move(bm_file_handle), options);
+	CSVStateMachineCache state_machine_cache;
+	CSVSniffer sniffer(options, buffer_manager, state_machine_cache);
+	auto sniffer_result = sniffer.SniffCSV();
+	auto &types = sniffer_result.return_types;
+	auto &names = sniffer_result.names;
 	for (idx_t i = 0; i < types.size(); i++) {
 		columns.emplace_back(names[i], types[i]);
 	}