duckdb 0.7.2-dev1867.0 → 0.7.2-dev1901.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev1867.0",
+  "version": "0.7.2-dev1901.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/data_chunk.cpp

@@ -145,7 +145,19 @@ Napi::Array EncodeDataChunk(Napi::Env env, duckdb::DataChunk &chunk, bool with_t
 				}
 				break;
 			}
-			case duckdb::LogicalTypeId::BLOB:
+			case duckdb::LogicalTypeId::BLOB: {
+				if (with_data) {
+					auto array = Napi::Array::New(env, chunk.size());
+					auto data = duckdb::FlatVector::GetData<duckdb::string_t>(*vec);
+
+					for (size_t i = 0; i < chunk.size(); ++i) {
+						auto buf = Napi::Buffer<char>::Copy(env, data[i].GetDataUnsafe(), data[i].GetSize());
+						array.Set(i, buf);
+					}
+					desc.Set("data", array);
+				}
+				break;
+			}
 			case duckdb::LogicalTypeId::VARCHAR: {
 				if (with_data) {
 					auto array = Napi::Array::New(env, chunk.size());

package/src/duckdb/src/catalog/default/default_functions.cpp

@@ -53,10 +53,10 @@ static DefaultMacro internal_macros[] = {
 
 	// various postgres system functions
 	{"pg_catalog", "pg_get_viewdef", {"oid", nullptr}, "(select sql from duckdb_views() v where v.view_oid=oid)"},
-	{"pg_catalog", "pg_get_constraintdef", {"constraint_oid", "pretty_bool", nullptr}, "(select constraint_text from duckdb_constraints() d_constraint where d_constraint.table_oid=constraint_oid/1000000 and d_constraint.constraint_index=constraint_oid%1000000)"},
+	{"pg_catalog", "pg_get_constraintdef", {"constraint_oid", "pretty_bool", nullptr}, "(select constraint_text from duckdb_constraints() d_constraint where d_constraint.table_oid=constraint_oid//1000000 and d_constraint.constraint_index=constraint_oid%1000000)"},
 	{"pg_catalog", "pg_get_expr", {"pg_node_tree", "relation_oid", nullptr}, "pg_node_tree"},
 	{"pg_catalog", "format_pg_type", {"type_name", nullptr}, "case when logical_type='FLOAT' then 'real' when logical_type='DOUBLE' then 'double precision' when logical_type='DECIMAL' then 'numeric' when logical_type='ENUM' then lower(type_name) when logical_type='VARCHAR' then 'character varying' when logical_type='BLOB' then 'bytea' when logical_type='TIMESTAMP' then 'timestamp without time zone' when logical_type='TIME' then 'time without time zone' else lower(logical_type) end"},
-	{"pg_catalog", "format_type", {"type_oid", "typemod", nullptr}, "(select format_pg_type(type_name) from duckdb_types() t where t.type_oid=type_oid) || case when typemod>0 then concat('(', typemod/1000, ',', typemod%1000, ')') else '' end"},
+	{"pg_catalog", "format_type", {"type_oid", "typemod", nullptr}, "(select format_pg_type(type_name) from duckdb_types() t where t.type_oid=type_oid) || case when typemod>0 then concat('(', typemod//1000, ',', typemod%1000, ')') else '' end"},
 
 	{"pg_catalog", "pg_has_role", {"user", "role", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for role
 	{"pg_catalog", "pg_has_role", {"role", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for role

package/src/duckdb/src/common/sort/sorted_block.cpp

@@ -366,11 +366,16 @@ int SBIterator::ComparisonValue(ExpressionType comparison) {
 	}
 }
 
+static idx_t GetBlockCountWithEmptyCheck(const GlobalSortState &gss) {
+	D_ASSERT(gss.sorted_blocks.size() > 0);
+	return gss.sorted_blocks[0]->radix_sorting_data.size();
+}
+
 SBIterator::SBIterator(GlobalSortState &gss, ExpressionType comparison, idx_t entry_idx_p)
-    : sort_layout(gss.sort_layout), block_count(gss.sorted_blocks[0]->radix_sorting_data.size()),
-      block_capacity(gss.block_capacity), cmp_size(sort_layout.comparison_size), entry_size(sort_layout.entry_size),
-      all_constant(sort_layout.all_constant), external(gss.external), cmp(ComparisonValue(comparison)),
-      scan(gss.buffer_manager, gss), block_ptr(nullptr), entry_ptr(nullptr) {
+    : sort_layout(gss.sort_layout), block_count(GetBlockCountWithEmptyCheck(gss)), block_capacity(gss.block_capacity),
+      cmp_size(sort_layout.comparison_size), entry_size(sort_layout.entry_size), all_constant(sort_layout.all_constant),
+      external(gss.external), cmp(ComparisonValue(comparison)), scan(gss.buffer_manager, gss), block_ptr(nullptr),
+      entry_ptr(nullptr) {
 
 	scan.sb = gss.sorted_blocks[0].get();
 	scan.block_idx = block_count;

package/src/duckdb/src/execution/operator/join/physical_iejoin.cpp

@@ -402,6 +402,10 @@ IEJoinUnion::IEJoinUnion(ClientContext &context, const PhysicalIEJoin &op, Sorte
 	r_executor.AddExpression(*op.rhs_orders[1][0].expression);
 	AppendKey(t2, r_executor, *l1, -1, -1, b2);
 
+	if (l1->global_sort_state.sorted_blocks.empty()) {
+		return;
+	}
+
 	Sort(*l1);
 
 	op1 = make_uniq<SBIterator>(l1->global_sort_state, cmp1);

package/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/parser/expression_map.hpp"
 #include "duckdb/function/aggregate/distributive_functions.hpp"
 
@@ -12,7 +13,8 @@ namespace duckdb {
 struct SortedAggregateBindData : public FunctionData {
 	SortedAggregateBindData(ClientContext &context, BoundAggregateExpression &expr)
 	    : buffer_manager(BufferManager::GetBufferManager(context)), function(expr.function),
-	      bind_info(std::move(expr.bind_info)) {
+	      bind_info(std::move(expr.bind_info)), threshold(ClientConfig::GetConfig(context).ordered_aggregate_threshold),
+	      external(ClientConfig::GetConfig(context).force_external) {
 		auto &children = expr.children;
 		arg_types.reserve(children.size());
 		for (const auto &child : children) {
@@ -32,7 +34,8 @@ struct SortedAggregateBindData : public FunctionData {
 
 	SortedAggregateBindData(const SortedAggregateBindData &other)
 	    : buffer_manager(other.buffer_manager), function(other.function), arg_types(other.arg_types),
-	      sort_types(other.sort_types), sorted_on_args(other.sorted_on_args) {
+	      sort_types(other.sort_types), sorted_on_args(other.sorted_on_args), threshold(other.threshold),
+	      external(other.external) {
 		if (other.bind_info) {
 			bind_info = other.bind_info->Copy();
 		}
@@ -76,13 +79,17 @@ struct SortedAggregateBindData : public FunctionData {
 	vector<BoundOrderByNode> orders;
 	vector<LogicalType> sort_types;
 	bool sorted_on_args;
+
+	//! The sort flush threshold
+	const idx_t threshold;
+	const bool external;
 };
 
 struct SortedAggregateState {
 	//! Default buffer size, optimised for small group to avoid blowing out memory.
 	static const idx_t BUFFER_CAPACITY = 16;
 
-	SortedAggregateState() : nsel(0), offset(0) {
+	SortedAggregateState() : count(0), nsel(0), offset(0) {
 	}
 
 	static inline void InitializeBuffer(DataChunk &chunk, const vector<LogicalType> &types) {
@@ -98,7 +105,7 @@ struct SortedAggregateState {
 		chunk.Initialize(Allocator::DefaultAllocator(), types);
 	}
 
-	void Flush(SortedAggregateBindData &order_bind) {
+	void Flush(const SortedAggregateBindData &order_bind) {
 		if (ordering) {
 			return;
 		}
@@ -116,7 +123,9 @@ struct SortedAggregateState {
 		}
 	}
 
-	void Update(SortedAggregateBindData &order_bind, DataChunk &sort_chunk, DataChunk &arg_chunk) {
+	void Update(const SortedAggregateBindData &order_bind, DataChunk &sort_chunk, DataChunk &arg_chunk) {
+		count += sort_chunk.size();
+
 		// Lazy instantiation of the buffer chunks
 		InitializeBuffer(sort_buffer, order_bind.sort_types);
 		if (!order_bind.sorted_on_args) {
@@ -139,7 +148,9 @@ struct SortedAggregateState {
 		}
 	}
 
-	void UpdateSlice(SortedAggregateBindData &order_bind, DataChunk &sort_inputs, DataChunk &arg_inputs) {
+	void UpdateSlice(const SortedAggregateBindData &order_bind, DataChunk &sort_inputs, DataChunk &arg_inputs) {
+		count += nsel;
+
 		// Lazy instantiation of the buffer chunks
 		InitializeBuffer(sort_buffer, order_bind.sort_types);
 		if (!order_bind.sorted_on_args) {
@@ -178,25 +189,35 @@ struct SortedAggregateState {
 			Flush(order_bind);
 			ordering->Combine(*other.ordering);
 			arguments->Combine(*other.arguments);
+			count += other.count;
 		} else if (other.ordering) {
 			// Force CDC if the other has it
 			Flush(order_bind);
 			ordering->Combine(*other.ordering);
+			count += other.count;
 		} else if (other.sort_buffer.size()) {
 			Update(order_bind, other.sort_buffer, other.arg_buffer);
 		}
 	}
 
-	void Finalize(SortedAggregateBindData &order_bind, LocalSortState &local_sort) {
+	void PrefixSortBuffer(DataChunk &prefixed) {
+		for (column_t col_idx = 0; col_idx < sort_buffer.ColumnCount(); ++col_idx) {
+			prefixed.data[col_idx + 1].Reference(sort_buffer.data[col_idx]);
+		}
+		prefixed.SetCardinality(sort_buffer);
+	}
+
+	void Finalize(const SortedAggregateBindData &order_bind, DataChunk &prefixed, LocalSortState &local_sort) {
 		if (arguments) {
 			ColumnDataScanState sort_state;
 			ordering->InitializeScan(sort_state);
 			ColumnDataScanState arg_state;
 			arguments->InitializeScan(arg_state);
 			for (sort_buffer.Reset(); ordering->Scan(sort_state, sort_buffer); sort_buffer.Reset()) {
+				PrefixSortBuffer(prefixed);
 				arg_buffer.Reset();
 				arguments->Scan(arg_state, arg_buffer);
-				local_sort.SinkChunk(sort_buffer, arg_buffer);
+				local_sort.SinkChunk(prefixed, arg_buffer);
 			}
 			ordering->Reset();
 			arguments->Reset();
@@ -204,16 +225,20 @@ struct SortedAggregateState {
 			ColumnDataScanState sort_state;
 			ordering->InitializeScan(sort_state);
 			for (sort_buffer.Reset(); ordering->Scan(sort_state, sort_buffer); sort_buffer.Reset()) {
-				local_sort.SinkChunk(sort_buffer, sort_buffer);
+				PrefixSortBuffer(prefixed);
+				local_sort.SinkChunk(prefixed, sort_buffer);
 			}
 			ordering->Reset();
 		} else if (order_bind.sorted_on_args) {
-			local_sort.SinkChunk(sort_buffer, sort_buffer);
+			PrefixSortBuffer(prefixed);
+			local_sort.SinkChunk(prefixed, sort_buffer);
 		} else {
-			local_sort.SinkChunk(sort_buffer, arg_buffer);
+			PrefixSortBuffer(prefixed);
+			local_sort.SinkChunk(prefixed, arg_buffer);
 		}
 	}
 
+	idx_t count;
 	unique_ptr<ColumnDataCollection> arguments;
 	unique_ptr<ColumnDataCollection> ordering;
 
@@ -237,19 +262,19 @@ struct SortedAggregateFunction {
 		state->~STATE();
 	}
 
-	static void ProjectInputs(Vector inputs[], SortedAggregateBindData *order_bind, idx_t input_count, idx_t count,
-	                          DataChunk &arg_chunk, DataChunk &sort_chunk) {
+	static void ProjectInputs(Vector inputs[], const SortedAggregateBindData &order_bind, idx_t input_count,
+	                          idx_t count, DataChunk &arg_chunk, DataChunk &sort_chunk) {
 		idx_t col = 0;
 
-		if (!order_bind->sorted_on_args) {
-			arg_chunk.InitializeEmpty(order_bind->arg_types);
+		if (!order_bind.sorted_on_args) {
+			arg_chunk.InitializeEmpty(order_bind.arg_types);
 			for (auto &dst : arg_chunk.data) {
 				dst.Reference(inputs[col++]);
 			}
 			arg_chunk.SetCardinality(count);
 		}
 
-		sort_chunk.InitializeEmpty(order_bind->sort_types);
+		sort_chunk.InitializeEmpty(order_bind.sort_types);
 		for (auto &dst : sort_chunk.data) {
 			dst.Reference(inputs[col++]);
 		}
@@ -258,13 +283,13 @@ struct SortedAggregateFunction {
 
 	static void SimpleUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, data_ptr_t state,
 	                         idx_t count) {
-		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
+		const auto order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
 		DataChunk arg_chunk;
 		DataChunk sort_chunk;
 		ProjectInputs(inputs, order_bind, input_count, count, arg_chunk, sort_chunk);
 
 		const auto order_state = (SortedAggregateState *)state;
-		order_state->Update(*order_bind, sort_chunk, arg_chunk);
+		order_state->Update(order_bind, sort_chunk, arg_chunk);
 	}
 
 	static void ScatterUpdate(Vector inputs[], AggregateInputData &aggr_input_data, idx_t input_count, Vector &states,
@@ -274,7 +299,7 @@ struct SortedAggregateFunction {
 		}
 
 		// Append the arguments to the two sub-collections
-		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
+		const auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
 		DataChunk arg_inputs;
 		DataChunk sort_inputs;
 		ProjectInputs(inputs, order_bind, input_count, count, arg_inputs, sort_inputs);
@@ -315,7 +340,7 @@ struct SortedAggregateFunction {
 				continue;
 			}
 
-			order_state->UpdateSlice(*order_bind, sort_inputs, arg_inputs);
+			order_state->UpdateSlice(order_bind, sort_inputs, arg_inputs);
 		}
 	}
 
@@ -333,78 +358,162 @@ struct SortedAggregateFunction {
 	}
 
 	static void Finalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
-	                     idx_t offset) {
-		const auto order_bind = (SortedAggregateBindData *)aggr_input_data.bind_data;
-		auto &buffer_manager = order_bind->buffer_manager;
-		auto &orders = order_bind->orders;
+	                     const idx_t offset) {
+		const auto &order_bind = aggr_input_data.bind_data->Cast<SortedAggregateBindData>();
+		auto &buffer_manager = order_bind.buffer_manager;
 		RowLayout payload_layout;
-		payload_layout.Initialize(order_bind->arg_types);
+		payload_layout.Initialize(order_bind.arg_types);
 		DataChunk chunk;
-		chunk.Initialize(Allocator::DefaultAllocator(), order_bind->arg_types);
+		chunk.Initialize(Allocator::DefaultAllocator(), order_bind.arg_types);
+		DataChunk sliced;
+		sliced.Initialize(Allocator::DefaultAllocator(), order_bind.arg_types);
 
 		//	 Reusable inner state
-		vector<data_t> agg_state(order_bind->function.state_size());
+		vector<data_t> agg_state(order_bind.function.state_size());
 		Vector agg_state_vec(Value::POINTER((idx_t)agg_state.data()));
 
 		// State variables
-		const auto input_count = order_bind->function.arguments.size();
-		auto bind_info = order_bind->bind_info.get();
+		auto bind_info = order_bind.bind_info.get();
 		AggregateInputData aggr_bind_info(bind_info, Allocator::DefaultAllocator());
 
 		// Inner aggregate APIs
-		auto initialize = order_bind->function.initialize;
-		auto destructor = order_bind->function.destructor;
-		auto simple_update = order_bind->function.simple_update;
-		auto update = order_bind->function.update;
-		auto finalize = order_bind->function.finalize;
+		auto initialize = order_bind.function.initialize;
+		auto destructor = order_bind.function.destructor;
+		auto simple_update = order_bind.function.simple_update;
+		auto update = order_bind.function.update;
+		auto finalize = order_bind.function.finalize;
 
 		auto sdata = FlatVector::GetData<SortedAggregateState *>(states);
+
+		vector<idx_t> state_unprocessed(count, 0);
 		for (idx_t i = 0; i < count; ++i) {
-			initialize(agg_state.data());
-			auto state = sdata[i];
-
-			// Apply the sort before delegating the chunks
-			auto global_sort = make_uniq<GlobalSortState>(buffer_manager, orders, payload_layout);
-			LocalSortState local_sort;
-			local_sort.Initialize(*global_sort, global_sort->buffer_manager);
-			state->Finalize(*order_bind, local_sort);
-			global_sort->AddLocalState(local_sort);
-
-			if (!global_sort->sorted_blocks.empty()) {
-				global_sort->PrepareMergePhase();
-				while (global_sort->sorted_blocks.size() > 1) {
-					global_sort->InitializeMergeRound();
-					MergeSorter merge_sorter(*global_sort, global_sort->buffer_manager);
-					merge_sorter.PerformInMergeRound();
-					global_sort->CompleteMergeRound(false);
+			state_unprocessed[i] = sdata[i]->count;
+		}
+
+		// Sort the input payloads on (state_idx ASC, orders)
+		vector<BoundOrderByNode> orders;
+		orders.emplace_back(BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST,
+		                                     make_uniq<BoundConstantExpression>(Value::USMALLINT(0))));
+		for (const auto &order : order_bind.orders) {
+			orders.emplace_back(order.Copy());
+		}
+
+		auto global_sort = make_uniq<GlobalSortState>(buffer_manager, orders, payload_layout);
+		global_sort->external = order_bind.external;
+		auto local_sort = make_uniq<LocalSortState>();
+		local_sort->Initialize(*global_sort, global_sort->buffer_manager);
+
+		DataChunk prefixed;
+		prefixed.Initialize(Allocator::DefaultAllocator(), global_sort->sort_layout.logical_types);
+
+		//	Go through the states accumulating values to sort until we hit the sort threshold
+		idx_t unsorted_count = 0;
+		idx_t sorted = 0;
+		for (idx_t finalized = 0; finalized < count;) {
+			if (unsorted_count < order_bind.threshold) {
+				auto state = sdata[finalized];
+				prefixed.Reset();
+				prefixed.data[0].Reference(Value::USMALLINT(finalized));
+				state->Finalize(order_bind, prefixed, *local_sort);
+				unsorted_count += state_unprocessed[finalized];
+
+				// Go to the next aggregate unless this is the last one
+				if (++finalized < count) {
+					continue;
 				}
+			}
+
+			//	If they were all empty (filtering) flush them
+			//	(This can only happen on the last range)
+			if (!unsorted_count) {
+				break;
+			}
+
+			//	Sort all the data
+			global_sort->AddLocalState(*local_sort);
+			global_sort->PrepareMergePhase();
+			while (global_sort->sorted_blocks.size() > 1) {
+				global_sort->InitializeMergeRound();
+				MergeSorter merge_sorter(*global_sort, global_sort->buffer_manager);
+				merge_sorter.PerformInMergeRound();
+				global_sort->CompleteMergeRound(false);
+			}
 
-				PayloadScanner scanner(*global_sort);
-				for (;;) {
-					chunk.Reset();
-					scanner.Scan(chunk);
-					if (chunk.size() == 0) {
-						break;
+			auto scanner = make_uniq<PayloadScanner>(*global_sort);
+			initialize(agg_state.data());
+			while (scanner->Remaining()) {
+				chunk.Reset();
+				scanner->Scan(chunk);
+				idx_t consumed = 0;
+
+				// Distribute the scanned chunk to the aggregates
+				while (consumed < chunk.size()) {
+					//	Find the next aggregate that needs data
+					for (; !state_unprocessed[sorted]; ++sorted) {
+						// Finalize a single value at the next offset
+						agg_state_vec.SetVectorType(states.GetVectorType());
+						finalize(agg_state_vec, aggr_bind_info, result, 1, sorted + offset);
+						if (destructor) {
+							destructor(agg_state_vec, aggr_bind_info, 1);
+						}
+
+						initialize(agg_state.data());
+					}
+					const auto input_count = MinValue(state_unprocessed[sorted], chunk.size() - consumed);
+					for (column_t col_idx = 0; col_idx < chunk.ColumnCount(); ++col_idx) {
+						sliced.data[col_idx].Slice(chunk.data[col_idx], consumed, consumed + input_count);
 					}
+					sliced.SetCardinality(input_count);
+
 					// These are all simple updates, so use it if available
 					if (simple_update) {
-						simple_update(chunk.data.data(), aggr_bind_info, input_count, agg_state.data(), chunk.size());
+						simple_update(sliced.data.data(), aggr_bind_info, 1, agg_state.data(), sliced.size());
 					} else {
 						// We are only updating a constant state
 						agg_state_vec.SetVectorType(VectorType::CONSTANT_VECTOR);
-						update(chunk.data.data(), aggr_bind_info, input_count, agg_state_vec, chunk.size());
+						update(sliced.data.data(), aggr_bind_info, 1, agg_state_vec, sliced.size());
 					}
+
+					consumed += input_count;
+					state_unprocessed[sorted] -= input_count;
 				}
 			}
 
+			//	Finalize the last state for this sort
+			agg_state_vec.SetVectorType(states.GetVectorType());
+			finalize(agg_state_vec, aggr_bind_info, result, 1, sorted + offset);
+			if (destructor) {
+				destructor(agg_state_vec, aggr_bind_info, 1);
+			}
+			++sorted;
+
+			//	Stop if we are done
+			if (finalized >= count) {
+				break;
+			}
+
+			//	Create a new sort
+			scanner.reset();
+			global_sort = make_uniq<GlobalSortState>(buffer_manager, orders, payload_layout);
+			global_sort->external = order_bind.external;
+			local_sort = make_uniq<LocalSortState>();
+			local_sort->Initialize(*global_sort, global_sort->buffer_manager);
+			unsorted_count = 0;
+		}
+
+		for (; sorted < count; ++sorted) {
+			initialize(agg_state.data());
+
 			// Finalize a single value at the next offset
 			agg_state_vec.SetVectorType(states.GetVectorType());
-			finalize(agg_state_vec, aggr_bind_info, result, 1, i + offset);
+			finalize(agg_state_vec, aggr_bind_info, result, 1, sorted + offset);
 
 			if (destructor) {
 				destructor(agg_state_vec, aggr_bind_info, 1);
 			}
 		}
+
+		result.Verify(count);
 	}
 
 	static void Serialize(FieldWriter &writer, const FunctionData *bind_data, const AggregateFunction &function) {

package/src/duckdb/src/function/scalar/operators/arithmetic.cpp

@@ -907,23 +907,29 @@ static scalar_function_t GetBinaryFunctionIgnoreZero(const LogicalType &type) {
 }
 
 void DivideFun::RegisterFunction(BuiltinFunctions &set) {
-	ScalarFunctionSet functions("/");
+	ScalarFunctionSet fp_divide("/");
+	fp_divide.AddFunction(ScalarFunction({LogicalType::FLOAT, LogicalType::FLOAT}, LogicalType::FLOAT,
+	                                     GetBinaryFunctionIgnoreZero<DivideOperator>(LogicalType::FLOAT)));
+	fp_divide.AddFunction(ScalarFunction({LogicalType::DOUBLE, LogicalType::DOUBLE}, LogicalType::DOUBLE,
+	                                     GetBinaryFunctionIgnoreZero<DivideOperator>(LogicalType::DOUBLE)));
+	fp_divide.AddFunction(
+	    ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL,
+	                   BinaryScalarFunctionIgnoreZero<interval_t, int64_t, interval_t, DivideOperator>));
+	set.AddFunction(fp_divide);
+
+	ScalarFunctionSet full_divide("//");
 	for (auto &type : LogicalType::Numeric()) {
 		if (type.id() == LogicalTypeId::DECIMAL) {
 			continue;
 		} else {
-			functions.AddFunction(
+			full_divide.AddFunction(
 			    ScalarFunction({type, type}, type, GetBinaryFunctionIgnoreZero<DivideOperator>(type)));
 		}
 	}
-	functions.AddFunction(
-	    ScalarFunction({LogicalType::INTERVAL, LogicalType::BIGINT}, LogicalType::INTERVAL,
-	                   BinaryScalarFunctionIgnoreZero<interval_t, int64_t, interval_t, DivideOperator>));
+	set.AddFunction(full_divide);
 
-	set.AddFunction(functions);
-
-	functions.name = "divide";
-	set.AddFunction(functions);
+	full_divide.name = "divide";
+	set.AddFunction(full_divide);
 }
 
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.7.2-dev1867"
+#define DUCKDB_VERSION "0.7.2-dev1901"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "084890df27"
+#define DUCKDB_SOURCE_ID "5aa369b4b1"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

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

@@ -77,6 +77,8 @@ struct ClientConfig {
 	//! Maximum bits allowed for using a perfect hash table (i.e. the perfect HT can hold up to 2^perfect_ht_threshold
 	//! elements)
 	idx_t perfect_ht_threshold = 12;
+	//! The maximum number of rows to accumulate before sorting ordered aggregates.
+	idx_t ordered_aggregate_threshold = (idx_t(1) << 18);
 
 	//! Callback to create a progress bar display
 	progress_bar_display_create_func_t display_create_func = nullptr;
@@ -90,6 +92,9 @@ struct ClientConfig {
 	//! The maximum amount of pivot columns
 	idx_t pivot_limit = 100000;
 
+	//! Whether or not the "/" division operator defaults to integer division or floating point division
+	bool integer_division = false;
+
 	//! Generic options
 	case_insensitive_map_t<Value> set_variables;
 

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

@@ -65,6 +65,15 @@ struct DebugForceNoCrossProduct {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct OrderedAggregateThreshold {
+	static constexpr const char *Name = "ordered_aggregate_threshold";
+	static constexpr const char *Description = "the number of rows to accumulate before sorting, used for tuning";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::UBIGINT;
+	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";
@@ -270,6 +279,16 @@ struct HomeDirectorySetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct IntegerDivisionSetting {
+	static constexpr const char *Name = "integer_division";
+	static constexpr const char *Description =
+	    "Whether or not the / operator defaults to integer division, or to floating point division";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct LogQueryPathSetting {
 	static constexpr const char *Name = "log_query_path";
 	static constexpr const char *Description =

package/src/duckdb/src/include/duckdb/parser/parser.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/parser/query_node.hpp"
 #include "duckdb/parser/column_list.hpp"
 #include "duckdb/parser/simplified_token.hpp"
+#include "duckdb/parser/parser_options.hpp"
 
 namespace duckdb_libpgquery {
 struct PGNode;
@@ -20,13 +21,6 @@ struct PGList;
 } // namespace duckdb_libpgquery
 
 namespace duckdb {
-class ParserExtension;
-
-struct ParserOptions {
-	bool preserve_identifier_case = true;
-	idx_t max_expression_depth = 1000;
-	const vector<ParserExtension> *extensions = nullptr;
-};
 
 //! The parser is responsible for parsing the query and converting it into a set
 //! of parsed statements. The parsed statements can then be converted into a

package/src/duckdb/src/include/duckdb/parser/parser_options.hpp

@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parser_options.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+class ParserExtension;
+
+struct ParserOptions {
+	bool preserve_identifier_case = true;
+	bool integer_division = false;
+	idx_t max_expression_depth = 1000;
+	const vector<ParserExtension> *extensions = nullptr;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -33,6 +33,7 @@ struct CommonTableExpressionInfo;
 struct GroupingExpressionMap;
 class OnConflictInfo;
 class UpdateSetInfo;
+struct ParserOptions;
 struct PivotColumn;
 
 //! The transformer class is responsible for transforming the internal Postgres
@@ -47,7 +48,7 @@ class Transformer {
 	};
 
 public:
-	explicit Transformer(idx_t max_expression_depth_p);
+	explicit Transformer(ParserOptions &options);
 	explicit Transformer(Transformer *parent);
 	~Transformer();
 
@@ -61,7 +62,8 @@ public:
 
 private:
 	Transformer *parent;
-	idx_t max_expression_depth;
+	//! Parser options
+	ParserOptions &options;
 	//! The current prepared statement parameter index
 	idx_t prepared_statement_parameter_index = 0;
 	//! Map from named parameter to parameter index;
@@ -292,7 +294,7 @@ private:
 	                                                  CommonTableExpressionInfo &info);
 
 	unique_ptr<ParsedExpression> TransformUnaryOperator(const string &op, unique_ptr<ParsedExpression> child);
-	unique_ptr<ParsedExpression> TransformBinaryOperator(const string &op, unique_ptr<ParsedExpression> left,
+	unique_ptr<ParsedExpression> TransformBinaryOperator(string op, unique_ptr<ParsedExpression> left,
 	                                                     unique_ptr<ParsedExpression> right);
 	//===--------------------------------------------------------------------===//
 	// TableRef transform