duckdb 0.8.2-dev33.0 → 0.8.2-dev3300.0

package/src/duckdb/src/include/duckdb/main/client_config.hpp

@@ -75,6 +75,8 @@ struct ClientConfig {
 	bool force_no_cross_product = false;
 	//! Force use of IEJoin to implement AsOfJoin, used for testing
 	bool force_asof_iejoin = false;
+	//! Use range joins for inequalities, even if there are equality predicates
+	bool prefer_range_joins = false;
 	//! If this context should also try to use the available replacement scans
 	//! True by default
 	bool use_replacement_scans = true;
@@ -96,6 +98,9 @@ struct ClientConfig {
 	//! The maximum amount of pivot columns
 	idx_t pivot_limit = 100000;
 
+	//! The threshold at which we switch from using filtered aggregates to LIST with a dedicated pivot operator
+	idx_t pivot_filter_threshold = 10;
+
 	//! Whether or not the "/" division operator defaults to integer division or floating point division
 	bool integer_division = false;
 
@@ -110,8 +115,6 @@ public:
 	static ClientConfig &GetConfig(ClientContext &context);
 	static const ClientConfig &GetConfig(const ClientContext &context);
 
-	string ExtractTimezone() const;
-
 	bool AnyVerification() {
 		return query_verification_enabled || verify_external || verify_serializer;
 	}

package/src/duckdb/src/include/duckdb/main/client_context.hpp

@@ -24,6 +24,7 @@
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/main/external_dependencies.hpp"
 #include "duckdb/common/preserved_error.hpp"
+#include "duckdb/main/client_properties.hpp"
 
 namespace duckdb {
 class Appender;
@@ -46,7 +47,7 @@ struct ClientData;
 
 struct PendingQueryParameters {
 	//! Prepared statement parameters (if any)
-	vector<Value> *parameters = nullptr;
+	optional_ptr<case_insensitive_map_t<Value>> parameters;
 	//! Whether or not a stream result should be allowed
 	bool allow_stream_result = false;
 };
@@ -134,16 +135,17 @@ public:
 	//! Create a pending query result from a prepared statement with the given name and set of parameters
 	//! It is possible that the prepared statement will be re-bound. This will generally happen if the catalog is
 	//! modified in between the prepared statement being bound and the prepared statement being run.
-	DUCKDB_API unique_ptr<PendingQueryResult>
-	PendingQuery(const string &query, shared_ptr<PreparedStatementData> &prepared, PendingQueryParameters parameters);
+	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(const string &query,
+	                                                       shared_ptr<PreparedStatementData> &prepared,
+	                                                       const PendingQueryParameters &parameters);
 
 	//! Execute a prepared statement with the given name and set of parameters
 	//! It is possible that the prepared statement will be re-bound. This will generally happen if the catalog is
 	//! modified in between the prepared statement being bound and the prepared statement being run.
 	DUCKDB_API unique_ptr<QueryResult> Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-	                                           vector<Value> &values, bool allow_stream_result = true);
+	                                           case_insensitive_map_t<Value> &values, bool allow_stream_result = true);
 	DUCKDB_API unique_ptr<QueryResult> Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
-	                                           PendingQueryParameters parameters);
+	                                           const PendingQueryParameters &parameters);
 
 	//! Gets current percentage of the query's progress, returns 0 in case the progress bar is disabled.
 	DUCKDB_API double GetProgress();
@@ -197,7 +199,7 @@ private:
 	                     PreservedError &error);
 	//! Issues a query to the database and returns a Pending Query Result
 	unique_ptr<PendingQueryResult> PendingQueryInternal(ClientContextLock &lock, unique_ptr<SQLStatement> statement,
-	                                                    PendingQueryParameters parameters, bool verify = true);
+	                                                    const PendingQueryParameters &parameters, bool verify = true);
 	unique_ptr<QueryResult> ExecutePendingQueryInternal(ClientContextLock &lock, PendingQueryResult &query);
 
 	//! Parse statements from a query
@@ -213,18 +215,18 @@ private:
 	unique_ptr<PendingQueryResult> PendingStatementOrPreparedStatement(ClientContextLock &lock, const string &query,
 	                                                                   unique_ptr<SQLStatement> statement,
 	                                                                   shared_ptr<PreparedStatementData> &prepared,
-	                                                                   PendingQueryParameters parameters);
+	                                                                   const PendingQueryParameters &parameters);
 	unique_ptr<PendingQueryResult> PendingPreparedStatement(ClientContextLock &lock,
 	                                                        shared_ptr<PreparedStatementData> statement_p,
-	                                                        PendingQueryParameters parameters);
+	                                                        const PendingQueryParameters &parameters);
 
 	//! Internally prepare a SQL statement. Caller must hold the context_lock.
-	shared_ptr<PreparedStatementData> CreatePreparedStatement(ClientContextLock &lock, const string &query,
-	                                                          unique_ptr<SQLStatement> statement,
-	                                                          vector<Value> *values = nullptr);
+	shared_ptr<PreparedStatementData>
+	CreatePreparedStatement(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
+	                        optional_ptr<case_insensitive_map_t<Value>> values = nullptr);
 	unique_ptr<PendingQueryResult> PendingStatementInternal(ClientContextLock &lock, const string &query,
 	                                                        unique_ptr<SQLStatement> statement,
-	                                                        PendingQueryParameters parameters);
+	                                                        const PendingQueryParameters &parameters);
 	unique_ptr<QueryResult> RunStatementInternal(ClientContextLock &lock, const string &query,
 	                                             unique_ptr<SQLStatement> statement, bool allow_stream_result,
 	                                             bool verify = true);
@@ -244,11 +246,11 @@ private:
 
 	unique_ptr<PendingQueryResult> PendingStatementOrPreparedStatementInternal(
 	    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> PendingQueryPreparedInternal(ClientContextLock &lock, const string &query,
 	                                                            shared_ptr<PreparedStatementData> &prepared,
-	                                                            PendingQueryParameters parameters);
+	                                                            const PendingQueryParameters &parameters);
 
 	unique_ptr<PendingQueryResult> PendingQueryInternal(ClientContextLock &, const shared_ptr<Relation> &relation,
 	                                                    bool allow_stream_result);

package/src/duckdb/src/include/duckdb/main/client_properties.hpp

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/client_properties.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <string>
+
+namespace duckdb {
+enum ArrowOffsetSize { REGULAR, LARGE };
+
+//! A set of properties from the client context that can be used to interpret the query result
+struct ClientProperties {
+	ClientProperties(string time_zone_p, ArrowOffsetSize arrow_offset_size_p)
+	    : time_zone(std::move(time_zone_p)), arrow_offset_size(arrow_offset_size_p) {
+	}
+	ClientProperties() {};
+	string time_zone = "UTC";
+	ArrowOffsetSize arrow_offset_size = ArrowOffsetSize::REGULAR;
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/main/config.hpp

@@ -28,7 +28,7 @@
 #include "duckdb/optimizer/optimizer_extension.hpp"
 #include "duckdb/parser/parser_extension.hpp"
 #include "duckdb/planner/operator_extension.hpp"
-#include "duckdb/common/arrow/arrow_options.hpp"
+#include "duckdb/main/client_properties.hpp"
 
 namespace duckdb {
 class BufferPool;
@@ -158,6 +158,8 @@ struct DBConfigOptions {
 	bool lock_configuration = false;
 	//! Whether to print bindings when printing the plan (debug mode only)
 	static bool debug_print_bindings;
+	//! The peak allocation threshold at which to flush the allocator after completing a task (1 << 27, ~128MB)
+	idx_t allocator_flush_threshold = 134217728;
 
 	bool operator==(const DBConfigOptions &other) const;
 };

package/src/duckdb/src/include/duckdb/main/connection.hpp

@@ -169,8 +169,7 @@ public:
 	template <typename TR, typename... Args>
 	void CreateScalarFunction(const string &name, vector<LogicalType> args, LogicalType ret_type,
 	                          TR (*udf_func)(Args...)) {
-		scalar_function_t function =
-		    UDFWrapper::CreateScalarFunction<TR, Args...>(name, args, std::move(ret_type), udf_func);
+		scalar_function_t function = UDFWrapper::CreateScalarFunction<TR, Args...>(name, args, ret_type, udf_func);
 		UDFWrapper::RegisterFunction(name, args, ret_type, function, *context);
 	}
 

package/src/duckdb/src/include/duckdb/main/extension/generated_extension_loader.hpp

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/extension/generated_extension_loader.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#if defined(GENERATED_EXTENSION_HEADERS) and !defined(DUCKDB_AMALGAMATION)
+#include "generated_extension_headers.hpp"
+
+namespace duckdb {
+
+//! Looks through the CMake-generated list of extensions that are linked into DuckDB currently to try load <extension>
+bool TryLoadLinkedExtension(DuckDB &db, const std::string &extension);
+extern vector<string> linked_extensions;
+extern vector<string> loaded_extension_test_paths;
+
+} // namespace duckdb
+#endif

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -32,6 +32,9 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {{"->>", "json"},
                                                          {"from_substrait_json", "substrait"},
                                                          {"get_substrait", "substrait"},
                                                          {"get_substrait_json", "substrait"},
+                                                         {"iceberg_scan", "iceberg"},
+                                                         {"iceberg_metadata", "iceberg"},
+                                                         {"iceberg_snapshots", "iceberg"},
                                                          {"icu_calendar_names", "icu"},
                                                          {"icu_sort_key", "icu"},
                                                          {"json", "json"},
@@ -58,6 +61,7 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {{"->>", "json"},
                                                          {"json_deserialize_sql", "json"},
                                                          {"json_serialize_sql", "json"},
                                                          {"json_execute_serialized_sql", "json"},
+                                                         {"load_aws_credentials", "aws"},
                                                          {"make_timestamptz", "icu"},
                                                          {"parquet_metadata", "parquet"},
                                                          {"parquet_scan", "parquet"},
@@ -158,9 +162,13 @@ static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {{"->>", "json"},
                                                          {"st_removerepeatedpoints", "spatial"},
                                                          {"st_geomfromgeojson", "spatial"},
                                                          {"st_readosm", "spatial"},
+                                                         {"st_reduceprecision", "spatial"},
+                                                         {"st_geomfromhexwkb", "spatial"},
+                                                         {"st_geomfromhexewkb", "spatial"},
                                                          {"st_numpoints", "spatial"}};
 
 static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
+    {"azure_storage_connection_string", "azure"},
     {"binary_as_string", "parquet"},
     {"calendar", "icu"},
     {"http_retries", "httpfs"},

package/src/duckdb/src/include/duckdb/main/extension_util.hpp

@@ -23,6 +23,10 @@ public:
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunction function);
 	//! Register a new scalar function set - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunctionSet function);
+	//! Register a new aggregate function - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, AggregateFunction function);
+	//! Register a new aggregate function set - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, AggregateFunctionSet function);
 	//! Register a new table function - throw an exception if the function already exists
 	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, TableFunction function);
 	//! Register a new table function set - throw an exception if the function already exists

package/src/duckdb/src/include/duckdb/main/pending_query_result.hpp

@@ -34,6 +34,8 @@ public:
 	//! If this returns RESULT_READY, the Execute function can be called to obtain a pointer to the result.
 	//! If this returns RESULT_NOT_READY, the ExecuteTask function should be called again.
 	//! If this returns EXECUTION_ERROR, an error occurred during execution.
+	//! If this returns NO_TASKS_AVAILABLE, this means currently no meaningful work can be done by the current executor,
+	//!	    but tasks may become available in the future.
 	//! The error message can be obtained by calling GetError() on the PendingQueryResult.
 	DUCKDB_API PendingExecutionResult ExecuteTask();
 
@@ -43,6 +45,9 @@ public:
 
 	DUCKDB_API void Close();
 
+	//! Function to determine whether execution is considered finished
+	DUCKDB_API static bool IsFinished(PendingExecutionResult result);
+
 private:
 	shared_ptr<ClientContext> context;
 	bool allow_stream_result;

package/src/duckdb/src/include/duckdb/main/prepared_statement.hpp

@@ -63,7 +63,7 @@ public:
 	//! Returns the result names of the prepared statement
 	DUCKDB_API const vector<string> &GetNames();
 	//! Returns the map of parameter index to the expected type of parameter
-	DUCKDB_API vector<LogicalType> GetExpectedParameterTypes() const;
+	DUCKDB_API case_insensitive_map_t<LogicalType> GetExpectedParameterTypes() const;
 
 	//! Create a pending query result of the prepared statement with the given set of arguments
 	template <typename... Args>
@@ -72,6 +72,20 @@ public:
 		return PendingQueryRecursive(values, args...);
 	}
 
+	//! Create a pending query result of the prepared statement with the given set of arguments
+	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(vector<Value> &values, bool allow_stream_result = true);
+
+	//! Create a pending query result of the prepared statement with the given set named arguments
+	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(case_insensitive_map_t<Value> &named_values,
+	                                                       bool allow_stream_result = true);
+
+	//! Execute the prepared statement with the given set of values
+	DUCKDB_API unique_ptr<QueryResult> Execute(vector<Value> &values, bool allow_stream_result = true);
+
+	//! Execute the prepared statement with the given set of named+unnamed values
+	DUCKDB_API unique_ptr<QueryResult> Execute(case_insensitive_map_t<Value> &named_values,
+	                                           bool allow_stream_result = true);
+
 	//! Execute the prepared statement with the given set of arguments
 	template <typename... Args>
 	unique_ptr<QueryResult> Execute(Args... args) {
@@ -79,11 +93,65 @@ public:
 		return ExecuteRecursive(values, args...);
 	}
 
-	//! Create a pending query result of the prepared statement with the given set of arguments
-	DUCKDB_API unique_ptr<PendingQueryResult> PendingQuery(vector<Value> &values, bool allow_stream_result = true);
+	template <class PAYLOAD>
+	static string ExcessValuesException(const case_insensitive_map_t<idx_t> &parameters,
+	                                    case_insensitive_map_t<PAYLOAD> &values) {
+		// Too many values
+		set<string> excess_set;
+		for (auto &pair : values) {
+			auto &name = pair.first;
+			if (!parameters.count(name)) {
+				excess_set.insert(name);
+			}
+		}
+		vector<string> excess_values;
+		for (auto &val : excess_set) {
+			excess_values.push_back(val);
+		}
+		return StringUtil::Format("Parameter argument/count mismatch, identifiers of the excess parameters: %s",
+		                          StringUtil::Join(excess_values, ", "));
+	}
 
-	//! Execute the prepared statement with the given set of values
-	DUCKDB_API unique_ptr<QueryResult> Execute(vector<Value> &values, bool allow_stream_result = true);
+	template <class PAYLOAD>
+	static string MissingValuesException(const case_insensitive_map_t<idx_t> &parameters,
+	                                     case_insensitive_map_t<PAYLOAD> &values) {
+		// Missing values
+		set<string> missing_set;
+		for (auto &pair : parameters) {
+			auto &name = pair.first;
+			if (!values.count(name)) {
+				missing_set.insert(name);
+			}
+		}
+		vector<string> missing_values;
+		for (auto &val : missing_set) {
+			missing_values.push_back(val);
+		}
+		return StringUtil::Format("Values were not provided for the following prepared statement parameters: %s",
+		                          StringUtil::Join(missing_values, ", "));
+	}
+
+	template <class PAYLOAD>
+	static void VerifyParameters(case_insensitive_map_t<PAYLOAD> &provided,
+	                             const case_insensitive_map_t<idx_t> &expected) {
+		if (expected.size() == provided.size()) {
+			// Same amount of identifiers, if
+			for (auto &pair : expected) {
+				auto &identifier = pair.first;
+				if (!provided.count(identifier)) {
+					throw InvalidInputException(MissingValuesException(expected, provided));
+				}
+			}
+			return;
+		}
+		// Mismatch in expected and provided parameters/values
+		if (expected.size() > provided.size()) {
+			throw InvalidInputException(MissingValuesException(expected, provided));
+		} else {
+			D_ASSERT(provided.size() > expected.size());
+			throw InvalidInputException(ExcessValuesException(expected, provided));
+		}
+	}
 
 private:
 	unique_ptr<PendingQueryResult> PendingQueryRecursive(vector<Value> &values) {

package/src/duckdb/src/include/duckdb/main/prepared_statement_data.hpp

@@ -31,8 +31,6 @@ public:
 	unique_ptr<SQLStatement> unbound_statement;
 	//! The fully prepared physical plan of the prepared statement
 	unique_ptr<PhysicalOperator> plan;
-	//! The map of parameter index to the actual value entry
-	bound_parameter_map_t value_map;
 
 	//! The result names of the transaction
 	vector<string> names;
@@ -45,17 +43,19 @@ public:
 	//! The catalog version of when the prepared statement was bound
 	//! If this version is lower than the current catalog version, we have to rebind the prepared statement
 	idx_t catalog_version;
+	//! The map of parameter index to the actual value entry
+	bound_parameter_map_t value_map;
 
 public:
 	void CheckParameterCount(idx_t parameter_count);
 	//! Whether or not the prepared statement data requires the query to rebound for the given parameters
-	bool RequireRebind(ClientContext &context, const vector<Value> &values);
+	bool RequireRebind(ClientContext &context, optional_ptr<case_insensitive_map_t<Value>> values);
 	//! Bind a set of values to the prepared statement data
-	DUCKDB_API void Bind(vector<Value> values);
+	DUCKDB_API void Bind(case_insensitive_map_t<Value> values);
 	//! Get the expected SQL Type of the bound parameter
-	DUCKDB_API LogicalType GetType(idx_t param_index);
+	DUCKDB_API LogicalType GetType(const string &identifier);
 	//! Try to get the expected SQL Type of the bound parameter
-	DUCKDB_API bool TryGetType(idx_t param_idx, LogicalType &result);
+	DUCKDB_API bool TryGetType(const string &identifier, LogicalType &result);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/query_result.hpp

@@ -12,22 +12,13 @@
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/common/winapi.hpp"
 #include "duckdb/common/preserved_error.hpp"
-#include "duckdb/common/arrow/arrow_options.hpp"
+#include "duckdb/main/client_properties.hpp"
 
 namespace duckdb {
 struct BoxRendererConfig;
 
 enum class QueryResultType : uint8_t { MATERIALIZED_RESULT, STREAM_RESULT, PENDING_RESULT };
 
-//! A set of properties from the client context that can be used to interpret the query result
-struct ClientProperties {
-	ClientProperties(string time_zone_p, ArrowOffsetSize arrow_offset_size_p)
-	    : time_zone(std::move(time_zone_p)), arrow_offset_size(arrow_offset_size_p) {
-	}
-	string time_zone;
-	ArrowOffsetSize arrow_offset_size;
-};
-
 class BaseQueryResult {
 public:
 	//! Creates a successful query result with the specified names and types
@@ -63,16 +54,7 @@ protected:
 	//! The error (in case execution was not successful)
 	PreservedError error;
 };
-struct CurrentChunk {
-	//! The current data chunk
-	unique_ptr<DataChunk> data_chunk;
-	//! The current position in the data chunk
-	idx_t position;
-	//! If we have a current chunk we must scan for result production
-	bool Valid();
-	//! The remaining size of the current chunk
-	idx_t RemainingSize();
-};
+
 //! The QueryResult object holds the result of a query. It can either be a MaterializedQueryResult, in which case the
 //! result contains the entire result set, or a StreamQueryResult in which case the Fetch method can be called to
 //! incrementally fetch data from the database.
@@ -89,10 +71,6 @@ public:
 	ClientProperties client_properties;
 	//! The next result (if any)
 	unique_ptr<QueryResult> next;
-	//! In case we are converting the result from Native DuckDB to a different library (e.g., Arrow, Polars)
-	//! We might be producing chunks of a pre-determined size.
-	//! To comply, we use the following variable to store the current chunk, and it's position.
-	CurrentChunk current_chunk;
 
 public:
 	template <class TARGET>
@@ -146,9 +124,6 @@ public:
 		}
 	}
 
-	static ArrowOptions GetArrowOptions(QueryResult &query_result);
-	static string GetConfigTimezone(QueryResult &query_result);
-
 private:
 	class QueryResultIterator;
 	class QueryResultRow {

package/src/duckdb/src/include/duckdb/main/relation/aggregate_relation.hpp

@@ -10,17 +10,20 @@
 
 #include "duckdb/main/relation.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/parser/group_by_node.hpp"
 
 namespace duckdb {
 
 class AggregateRelation : public Relation {
 public:
 	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions);
+	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
+	                             GroupByNode groups);
 	DUCKDB_API AggregateRelation(shared_ptr<Relation> child, vector<unique_ptr<ParsedExpression>> expressions,
 	                             vector<unique_ptr<ParsedExpression>> groups);
 
 	vector<unique_ptr<ParsedExpression>> expressions;
-	vector<unique_ptr<ParsedExpression>> groups;
+	GroupByNode groups;
 	vector<ColumnDefinition> columns;
 	shared_ptr<Relation> child;
 

package/src/duckdb/src/include/duckdb/main/relation/cross_product_relation.hpp

@@ -9,15 +9,18 @@
 #pragma once
 
 #include "duckdb/main/relation.hpp"
+#include "duckdb/common/enums/joinref_type.hpp"
 
 namespace duckdb {
 
 class CrossProductRelation : public Relation {
 public:
-	DUCKDB_API CrossProductRelation(shared_ptr<Relation> left, shared_ptr<Relation> right);
+	DUCKDB_API CrossProductRelation(shared_ptr<Relation> left, shared_ptr<Relation> right,
+	                                JoinRefType join_ref_type = JoinRefType::CROSS);
 
 	shared_ptr<Relation> left;
 	shared_ptr<Relation> right;
+	JoinRefType ref_type;
 	vector<ColumnDefinition> columns;
 
 public:

package/src/duckdb/src/include/duckdb/main/relation/join_relation.hpp

@@ -9,21 +9,24 @@
 #pragma once
 
 #include "duckdb/main/relation.hpp"
+#include "duckdb/common/enums/joinref_type.hpp"
 
 namespace duckdb {
 
 class JoinRelation : public Relation {
 public:
 	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right,
-	                        unique_ptr<ParsedExpression> condition, JoinType type);
+	                        unique_ptr<ParsedExpression> condition, JoinType type,
+	                        JoinRefType join_ref_type = JoinRefType::REGULAR);
 	DUCKDB_API JoinRelation(shared_ptr<Relation> left, shared_ptr<Relation> right, vector<string> using_columns,
-	                        JoinType type);
+	                        JoinType type, JoinRefType join_ref_type = JoinRefType::REGULAR);
 
 	shared_ptr<Relation> left;
 	shared_ptr<Relation> right;
 	unique_ptr<ParsedExpression> condition;
 	vector<string> using_columns;
 	JoinType join_type;
+	JoinRefType join_ref_type;
 	vector<ColumnDefinition> columns;
 
 public:

package/src/duckdb/src/include/duckdb/main/relation.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/enums/join_type.hpp"
 #include "duckdb/common/enums/relation_type.hpp"
 #include "duckdb/common/winapi.hpp"
+#include "duckdb/common/enums/joinref_type.hpp"
 #include "duckdb/main/query_result.hpp"
 #include "duckdb/parser/column_definition.hpp"
 #include "duckdb/common/named_parameter_map.hpp"
@@ -94,10 +95,11 @@ public:
 
 	// JOIN operation
 	DUCKDB_API shared_ptr<Relation> Join(const shared_ptr<Relation> &other, const string &condition,
-	                                     JoinType type = JoinType::INNER);
+	                                     JoinType type = JoinType::INNER, JoinRefType ref_type = JoinRefType::REGULAR);
 
 	// CROSS PRODUCT operation
-	DUCKDB_API shared_ptr<Relation> CrossProduct(const shared_ptr<Relation> &other);
+	DUCKDB_API shared_ptr<Relation> CrossProduct(const shared_ptr<Relation> &other,
+	                                             JoinRefType join_ref_type = JoinRefType::CROSS);
 
 	// SET operations
 	DUCKDB_API shared_ptr<Relation> Union(const shared_ptr<Relation> &other);

package/src/duckdb/src/include/duckdb/main/settings.hpp

@@ -68,7 +68,7 @@ struct DebugForceNoCrossProduct {
 struct OrderedAggregateThreshold {
 	static constexpr const char *Name = "ordered_aggregate_threshold"; // NOLINT
 	static constexpr const char *Description =                         // NOLINT
-	    "the number of rows to accumulate before sorting, used for tuning";
+	    "The number of rows to accumulate before sorting, used for tuning";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT; // NOLINT
 	static void SetLocal(ClientContext &context, const Value &parameter);
 	static void ResetLocal(ClientContext &context);
@@ -84,6 +84,15 @@ struct DebugAsOfIEJoin {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct PreferRangeJoins {
+	static constexpr const char *Name = "prefer_range_joins";                                    // NOLINT
+	static constexpr const char *Description = "Force use of range joins with mixed predicates"; // NOLINT
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;                     // NOLINT
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct DebugWindowMode {
 	static constexpr const char *Name = "debug_window_mode";
 	static constexpr const char *Description = "DEBUG SETTING: switch window mode to use";
@@ -122,6 +131,15 @@ struct DefaultNullOrderSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct DisabledFileSystemsSetting {
+	static constexpr const char *Name = "disabled_filesystems";
+	static constexpr const char *Description = "Disable specific file systems preventing access (e.g. LocalFileSystem)";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct DisabledOptimizersSetting {
 	static constexpr const char *Name = "disabled_optimizers";
 	static constexpr const char *Description = "DEBUG SETTING: disable a specific set of optimizers (comma separated)";
@@ -207,6 +225,7 @@ struct EnableProgressBarSetting {
 	static void ResetLocal(ClientContext &context);
 	static Value GetSetting(ClientContext &context);
 };
+
 struct EnableProgressBarPrintSetting {
 	static constexpr const char *Name = "enable_progress_bar_print";
 	static constexpr const char *Description =
@@ -217,15 +236,6 @@ struct EnableProgressBarPrintSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
-struct ExperimentalParallelCSVSetting {
-	static constexpr const char *Name = "experimental_parallel_csv";
-	static constexpr const char *Description = "Whether or not to use the experimental parallel CSV reader";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(ClientContext &context);
-};
-
 struct ExplainOutputSetting {
 	static constexpr const char *Name = "explain_output";
 	static constexpr const char *Description = "Output of EXPLAIN statements (ALL, OPTIMIZED_ONLY, PHYSICAL_ONLY)";
@@ -366,10 +376,20 @@ struct PerfectHashThresholdSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct PivotFilterThreshold {
+	static constexpr const char *Name = "pivot_filter_threshold";
+	static constexpr const char *Description =
+	    "The threshold to switch from using filtered aggregates to LIST with a dedicated pivot operator";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct PivotLimitSetting {
 	static constexpr const char *Name = "pivot_limit";
 	static constexpr const char *Description =
-	    "The maximum numer of pivot columns in a pivot statement (default: 100000)";
+	    "The maximum number of pivot columns in a pivot statement (default: 100000)";
 	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
 	static void SetLocal(ClientContext &context, const Value &parameter);
 	static void ResetLocal(ClientContext &context);
@@ -492,4 +512,14 @@ struct UsernameSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct FlushAllocatorSetting {
+	static constexpr const char *Name = "allocator_flush_threshold";
+	static constexpr const char *Description =
+	    "Peak allocation threshold at which to flush the allocator after completing a task.";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::VARCHAR;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 } // namespace duckdb