duckdb 0.7.2-dev333.0 → 0.7.2-dev457.0

package/binding.gyp

@@ -230,6 +230,7 @@
                 "src/duckdb/extension/icu/./icu-datefunc.cpp", 
                 "src/duckdb/extension/icu/./icu-extension.cpp", 
                 "src/duckdb/extension/icu/./icu-makedate.cpp", 
+                "src/duckdb/extension/icu/./icu-list-range.cpp", 
                 "src/duckdb/extension/icu/./icu-timezone.cpp", 
                 "src/duckdb/extension/icu/./icu-datesub.cpp", 
                 "src/duckdb/extension/icu/./icu-timebucket.cpp", 

package/lib/duckdb.d.ts

@@ -4,12 +4,54 @@
  * on Node.JS API
  */
 
+export type ExceptionType =
+    | "Invalid"          // invalid type
+    | "Out of Range"     // value out of range error
+    | "Conversion"       // conversion/casting error
+    | "Unknown Type"     // unknown type
+    | "Decimal"          // decimal related
+    | "Mismatch Type"    // type mismatch
+    | "Divide by Zero"   // divide by 0
+    | "Object Size"      // object size exceeded
+    | "Invalid type"     // incompatible for operation
+    | "Serialization"    // serialization
+    | "TransactionContext" // transaction management
+    | "Not implemented"  // method not implemented
+    | "Expression"       // expression parsing
+    | "Catalog"          // catalog related
+    | "Parser"           // parser related
+    | "Binder"           // binder related
+    | "Planner"          // planner related
+    | "Scheduler"        // scheduler related
+    | "Executor"         // executor related
+    | "Constraint"       // constraint related
+    | "Index"            // index related
+    | "Stat"             // stat related
+    | "Connection"       // connection related
+    | "Syntax"           // syntax related
+    | "Settings"         // settings related
+    | "Optimizer"        // optimizer related
+    | "NullPointer"      // nullptr exception
+    | "IO"               // IO exception
+    | "INTERRUPT"        // interrupt
+    | "FATAL"            // Fatal exceptions are non-recoverable and render the entire DB in an unusable state
+    | "INTERNAL"         // Internal exceptions indicate something went wrong internally (i.e. bug in the code base)
+    | "Invalid Input"    // Input or arguments error
+    | "Out of Memory"    // out of memory
+    | "Permission"       // insufficient permissions
+    | "Parameter Not Resolved" // parameter types could not be resolved
+    | "Parameter Not Allowed"  // parameter types not allowed
+    | "Dependency"       // dependency
+    | "Unknown"
+    ;
+
 /**
  * Standard error shape for DuckDB errors
  */
 export interface DuckDbError extends Error {
   errno: -1; // value of ERROR
   code: 'DUCKDB_NODEJS_ERROR';
+  errorType: ExceptionType;
 }
 
 type Callback<T> = (err: DuckDbError | null, res: T) => void;

package/package.json

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

package/src/connection.cpp

@@ -388,8 +388,7 @@ struct ExecTask : public Task {
 	void Callback() override {
 		auto env = object.Env();
 		Napi::HandleScope scope(env);
-		callback.Value().MakeCallback(object.Value(),
-		                              {success ? env.Null() : Utils::CreateError(env, error.Message())});
+		callback.Value().MakeCallback(object.Value(), {success ? env.Null() : Utils::CreateError(env, error)});
 	};
 
 	std::string sql;

package/src/database.cpp

@@ -73,7 +73,7 @@ struct OpenTask : public Task {
 
 		std::vector<napi_value> args;
 		if (!success) {
-			args.push_back(Utils::CreateError(env, error.Message()));
+			args.push_back(Utils::CreateError(env, error));
 		} else {
 			args.push_back(env.Null());
 		}

package/src/duckdb/extension/icu/icu-extension.cpp

@@ -13,6 +13,7 @@
 #include "include/icu-datesub.hpp"
 #include "include/icu-datetrunc.hpp"
 #include "include/icu-makedate.hpp"
+#include "include/icu-list-range.hpp"
 #include "include/icu-table-range.hpp"
 #include "include/icu-strptime.hpp"
 #include "include/icu-timebucket.hpp"
@@ -268,6 +269,7 @@ void ICUExtension::Load(DuckDB &db) {
 	RegisterICUDateTruncFunctions(*con.context);
 	RegisterICUMakeDateFunctions(*con.context);
 	RegisterICUTableRangeFunctions(*con.context);
+	RegisterICUListRangeFunctions(*con.context);
 	RegisterICUStrptimeFunctions(*con.context);
 	RegisterICUTimeBucketFunctions(*con.context);
 	RegisterICUTimeZoneFunctions(*con.context);

package/src/duckdb/extension/icu/icu-list-range.cpp

@@ -0,0 +1,207 @@
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/interval.hpp"
+#include "duckdb/common/types/timestamp.hpp"
+#include "duckdb/common/types/vector.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/function/scalar_function.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "include/icu-datefunc.hpp"
+
+namespace duckdb {
+
+struct ICUListRange : public ICUDateFunc {
+	template <bool INCLUSIVE_BOUND>
+	class RangeInfoStruct {
+	public:
+		explicit RangeInfoStruct(DataChunk &args_p) : args(args_p) {
+			if (args.ColumnCount() == 3) {
+				args.data[0].ToUnifiedFormat(args.size(), vdata[0]);
+				args.data[1].ToUnifiedFormat(args.size(), vdata[1]);
+				args.data[2].ToUnifiedFormat(args.size(), vdata[2]);
+			} else {
+				throw InternalException("Unsupported number of parameters for range");
+			}
+		}
+
+		bool RowIsValid(idx_t row_idx) {
+			for (idx_t i = 0; i < args.ColumnCount(); i++) {
+				auto idx = vdata[i].sel->get_index(row_idx);
+				if (!vdata[i].validity.RowIsValid(idx)) {
+					return false;
+				}
+			}
+			return true;
+		}
+
+		timestamp_t StartListValue(idx_t row_idx) {
+			auto data = (timestamp_t *)vdata[0].data;
+			auto idx = vdata[0].sel->get_index(row_idx);
+			return data[idx];
+		}
+
+		timestamp_t EndListValue(idx_t row_idx) {
+			auto data = (timestamp_t *)vdata[1].data;
+			auto idx = vdata[1].sel->get_index(row_idx);
+			return data[idx];
+		}
+
+		interval_t ListIncrementValue(idx_t row_idx) {
+			auto data = (interval_t *)vdata[2].data;
+			auto idx = vdata[2].sel->get_index(row_idx);
+			return data[idx];
+		}
+
+		void GetListValues(idx_t row_idx, timestamp_t &start_value, timestamp_t &end_value,
+		                   interval_t &increment_value) {
+			start_value = StartListValue(row_idx);
+			end_value = EndListValue(row_idx);
+			increment_value = ListIncrementValue(row_idx);
+		}
+
+		uint64_t ListLength(idx_t row_idx, icu::Calendar *calendar) {
+			timestamp_t start_value;
+			timestamp_t end_value;
+			interval_t increment_value;
+			GetListValues(row_idx, start_value, end_value, increment_value);
+			return ListLength(start_value, end_value, increment_value, INCLUSIVE_BOUND, calendar);
+		}
+
+		void Increment(timestamp_t &input, interval_t increment, icu::Calendar *calendar) {
+			input = Add(calendar, input, increment);
+		}
+
+	private:
+		DataChunk &args;
+		UnifiedVectorFormat vdata[3];
+
+		uint64_t ListLength(timestamp_t start_value, timestamp_t end_value, interval_t increment_value,
+		                    bool inclusive_bound, icu::Calendar *calendar) {
+			bool is_positive = increment_value.months > 0 || increment_value.days > 0 || increment_value.micros > 0;
+			bool is_negative = increment_value.months < 0 || increment_value.days < 0 || increment_value.micros < 0;
+			if (!is_negative && !is_positive) {
+				// interval is 0: no result
+				return 0;
+			}
+			// We don't allow infinite bounds because they generate errors or infinite loops
+			if (!Timestamp::IsFinite(start_value) || !Timestamp::IsFinite(end_value)) {
+				throw InvalidInputException("Interval infinite bounds not supported");
+			}
+
+			if (is_negative && is_positive) {
+				// we don't allow a mix of
+				throw InvalidInputException("Interval with mix of negative/positive entries not supported");
+			}
+			if (start_value > end_value && is_positive) {
+				return 0;
+			}
+			if (start_value < end_value && is_negative) {
+				return 0;
+			}
+			int64_t total_values = 0;
+			if (is_negative) {
+				// negative interval, start_value is going down
+				while (inclusive_bound ? start_value >= end_value : start_value > end_value) {
+					start_value = Add(calendar, start_value, increment_value);
+					total_values++;
+					if (total_values > NumericLimits<uint32_t>::Maximum()) {
+						throw InvalidInputException("Lists larger than 2^32 elements are not supported");
+					}
+				}
+			} else {
+				// positive interval, start_value is going up
+				while (inclusive_bound ? start_value <= end_value : start_value < end_value) {
+					start_value = Add(calendar, start_value, increment_value);
+					total_values++;
+					if (total_values > NumericLimits<uint32_t>::Maximum()) {
+						throw InvalidInputException("Lists larger than 2^32 elements are not supported");
+					}
+				}
+			}
+			return total_values;
+		}
+	};
+
+	template <bool INCLUSIVE_BOUND>
+	static void ICUListRangeFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+		D_ASSERT(result.GetType().id() == LogicalTypeId::LIST);
+		D_ASSERT(args.ColumnCount() == 3);
+
+		auto &func_expr = (BoundFunctionExpression &)state.expr;
+		auto &bind_info = (BindData &)*func_expr.bind_info;
+		CalendarPtr calendar_ptr(bind_info.calendar->clone());
+		auto calendar = calendar_ptr.get();
+
+		RangeInfoStruct<INCLUSIVE_BOUND> info(args);
+		idx_t args_size = 1;
+		auto result_type = VectorType::CONSTANT_VECTOR;
+		for (idx_t i = 0; i < args.ColumnCount(); i++) {
+			if (args.data[i].GetVectorType() != VectorType::CONSTANT_VECTOR) {
+				args_size = args.size();
+				result_type = VectorType::FLAT_VECTOR;
+				break;
+			}
+		}
+		auto list_data = FlatVector::GetData<list_entry_t>(result);
+		auto &result_validity = FlatVector::Validity(result);
+		int64_t total_size = 0;
+		for (idx_t i = 0; i < args_size; i++) {
+			if (!info.RowIsValid(i)) {
+				result_validity.SetInvalid(i);
+				list_data[i].offset = total_size;
+				list_data[i].length = 0;
+			} else {
+				list_data[i].offset = total_size;
+				list_data[i].length = info.ListLength(i, calendar);
+				total_size += list_data[i].length;
+			}
+		}
+
+		// now construct the child vector of the list
+		ListVector::Reserve(result, total_size);
+		auto range_data = FlatVector::GetData<timestamp_t>(ListVector::GetEntry(result));
+		idx_t total_idx = 0;
+		for (idx_t i = 0; i < args_size; i++) {
+			timestamp_t start_value = info.StartListValue(i);
+			interval_t increment = info.ListIncrementValue(i);
+
+			timestamp_t range_value = start_value;
+			for (idx_t range_idx = 0; range_idx < list_data[i].length; range_idx++) {
+				if (range_idx > 0) {
+					info.Increment(range_value, increment, calendar);
+				}
+				range_data[total_idx++] = range_value;
+			}
+		}
+
+		ListVector::SetListSize(result, total_size);
+		result.SetVectorType(result_type);
+
+		result.Verify(args.size());
+	}
+
+	static void AddICUListRangeFunction(ClientContext &context) {
+		auto &catalog = Catalog::GetSystemCatalog(context);
+
+		ScalarFunctionSet range("range");
+		range.AddFunction(ScalarFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                                 LogicalType::LIST(LogicalType::TIMESTAMP_TZ), ICUListRangeFunction<false>,
+		                                 Bind));
+		CreateScalarFunctionInfo range_func_info(range);
+		catalog.AddFunction(context, &range_func_info);
+
+		// generate_series: similar to range, but inclusive instead of exclusive bounds on the RHS
+		ScalarFunctionSet generate_series("generate_series");
+		generate_series.AddFunction(
+		    ScalarFunction({LogicalType::TIMESTAMP_TZ, LogicalType::TIMESTAMP_TZ, LogicalType::INTERVAL},
+		                   LogicalType::LIST(LogicalType::TIMESTAMP_TZ), ICUListRangeFunction<true>, Bind));
+		CreateScalarFunctionInfo generate_series_func_info(generate_series);
+		catalog.AddFunction(context, &generate_series_func_info);
+	}
+};
+
+void RegisterICUListRangeFunctions(ClientContext &context) {
+	ICUListRange::AddICUListRangeFunction(context);
+}
+
+} // namespace duckdb

package/src/duckdb/extension/icu/include/icu-list-range.hpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// icu-list-range.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb.hpp"
+
+namespace duckdb {
+
+void RegisterICUListRangeFunctions(ClientContext &context);
+
+} // namespace duckdb

package/src/duckdb/extension/json/json_functions/read_json.cpp

@@ -20,6 +20,12 @@ void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vecto
 	idx_t remaining = bind_data.sample_size;
 	while (remaining != 0) {
 		allocator.Reset();
+
+		if (gstate.file_index >= 10) {
+			// We really shouldn't open more than 10 files when sampling
+			break;
+		}
+
 		auto read_count = lstate.ReadNext(gstate);
 		if (lstate.scan_count > 1) {
 			more_than_one = true;
@@ -46,11 +52,6 @@ void JSONScan::AutoDetect(ClientContext &context, JSONScanData &bind_data, vecto
 		node.InitializeCandidateTypes(bind_data.max_depth);
 		node.RefineCandidateTypes(values, next, string_vector, allocator, bind_data.date_format_map);
 		remaining -= next;
-
-		if (gstate.file_index == 10) {
-			// We really shouldn't open more than 10 files when sampling
-			break;
-		}
 	}
 	bind_data.type = original_scan_type;
 

package/src/duckdb/extension/parquet/include/parquet_timestamp.hpp

@@ -16,7 +16,6 @@ struct Int96 {
 	uint32_t value[3];
 };
 
-int64_t ImpalaTimestampToNanoseconds(const Int96 &impala_timestamp);
 timestamp_t ImpalaTimestampToTimestamp(const Int96 &raw_ts);
 Int96 TimestampToImpalaTimestamp(timestamp_t &ts);
 timestamp_t ParquetTimestampMicrosToTimestamp(const int64_t &raw_ts);

package/src/duckdb/extension/parquet/parquet_timestamp.cpp

@@ -12,24 +12,26 @@ namespace duckdb {
 // surely they are joking
 static constexpr int64_t JULIAN_TO_UNIX_EPOCH_DAYS = 2440588LL;
 static constexpr int64_t MILLISECONDS_PER_DAY = 86400000LL;
-static constexpr int64_t NANOSECONDS_PER_DAY = MILLISECONDS_PER_DAY * 1000LL * 1000LL;
+static constexpr int64_t MICROSECONDS_PER_DAY = MILLISECONDS_PER_DAY * 1000LL;
+static constexpr int64_t NANOSECONDS_PER_MICRO = 1000LL;
 
-int64_t ImpalaTimestampToNanoseconds(const Int96 &impala_timestamp) {
+static int64_t ImpalaTimestampToMicroseconds(const Int96 &impala_timestamp) {
 	int64_t days_since_epoch = impala_timestamp.value[2] - JULIAN_TO_UNIX_EPOCH_DAYS;
 	auto nanoseconds = Load<int64_t>((data_ptr_t)impala_timestamp.value);
-	return days_since_epoch * NANOSECONDS_PER_DAY + nanoseconds;
+	auto microseconds = nanoseconds / NANOSECONDS_PER_MICRO;
+	return days_since_epoch * MICROSECONDS_PER_DAY + microseconds;
 }
 
 timestamp_t ImpalaTimestampToTimestamp(const Int96 &raw_ts) {
-	auto impala_ns = ImpalaTimestampToNanoseconds(raw_ts);
-	return Timestamp::FromEpochNanoSeconds(impala_ns);
+	auto impala_us = ImpalaTimestampToMicroseconds(raw_ts);
+	return Timestamp::FromEpochMicroSeconds(impala_us);
 }
 
 Int96 TimestampToImpalaTimestamp(timestamp_t &ts) {
 	int32_t hour, min, sec, msec;
 	Time::Convert(Timestamp::GetTime(ts), hour, min, sec, msec);
 	uint64_t ms_since_midnight = hour * 60 * 60 * 1000 + min * 60 * 1000 + sec * 1000 + msec;
-	auto days_since_epoch = Date::Epoch(Timestamp::GetDate(ts)) / (24 * 60 * 60);
+	auto days_since_epoch = Date::Epoch(Timestamp::GetDate(ts)) / int64_t(24 * 60 * 60);
 	// first two uint32 in Int96 are nanoseconds since midnights
 	// last uint32 is number of days since year 4713 BC ("Julian date")
 	Int96 impala_ts;

package/src/duckdb/src/common/exception.cpp

@@ -138,12 +138,22 @@ string Exception::ExceptionTypeToString(ExceptionType type) {
 		return "Parameter Not Allowed";
 	case ExceptionType::DEPENDENCY:
 		return "Dependency";
+	case ExceptionType::HTTP:
+		return "HTTP";
 	default:
 		return "Unknown";
 	}
 }
 
-void Exception::ThrowAsTypeWithMessage(ExceptionType type, const string &message) {
+const HTTPException &Exception::AsHTTPException() const {
+	D_ASSERT(type == ExceptionType::HTTP);
+	const auto &e = static_cast<const HTTPException *>(this);
+	D_ASSERT(e->GetStatusCode() != 0);
+	return *e;
+}
+
+void Exception::ThrowAsTypeWithMessage(ExceptionType type, const string &message,
+                                       const std::shared_ptr<Exception> &original) {
 	switch (type) {
 	case ExceptionType::OUT_OF_RANGE:
 		throw OutOfRangeException(message);
@@ -191,6 +201,10 @@ void Exception::ThrowAsTypeWithMessage(ExceptionType type, const string &message
 		throw FatalException(message);
 	case ExceptionType::DEPENDENCY:
 		throw DependencyException(message);
+	case ExceptionType::HTTP: {
+		auto exc = original->AsHTTPException();
+		throw HTTPException(exc.GetStatusCode(), exc.GetResponse(), exc.what());
+	}
 	default:
 		throw Exception(type, message);
 	}

package/src/duckdb/src/common/preserved_error.cpp

@@ -7,15 +7,17 @@
 
 namespace duckdb {
 
-PreservedError::PreservedError() : initialized(false) {
+PreservedError::PreservedError() : initialized(false), exception_instance(nullptr) {
 }
 
 PreservedError::PreservedError(const Exception &exception)
-    : initialized(true), type(exception.type), raw_message(SanitizeErrorMessage(exception.RawMessage())) {
+    : initialized(true), type(exception.type), raw_message(SanitizeErrorMessage(exception.RawMessage())),
+      exception_instance(exception.Copy()) {
 }
 
 PreservedError::PreservedError(const string &message)
-    : initialized(true), type(ExceptionType::INVALID), raw_message(SanitizeErrorMessage(message)) {
+    : initialized(true), type(ExceptionType::INVALID), raw_message(SanitizeErrorMessage(message)),
+      exception_instance(nullptr) {
 }
 
 const string &PreservedError::Message() {
@@ -33,9 +35,9 @@ void PreservedError::Throw(const string &prepended_message) const {
 	D_ASSERT(initialized);
 	if (!prepended_message.empty()) {
 		string new_message = prepended_message + raw_message;
-		Exception::ThrowAsTypeWithMessage(type, new_message);
+		Exception::ThrowAsTypeWithMessage(type, new_message, exception_instance);
 	}
-	Exception::ThrowAsTypeWithMessage(type, raw_message);
+	Exception::ThrowAsTypeWithMessage(type, raw_message, exception_instance);
 }
 
 const ExceptionType &PreservedError::Type() const {

package/src/duckdb/src/execution/operator/scan/physical_positional_scan.cpp

@@ -12,13 +12,28 @@ namespace duckdb {
 PhysicalPositionalScan::PhysicalPositionalScan(vector<LogicalType> types, unique_ptr<PhysicalOperator> left,
                                                unique_ptr<PhysicalOperator> right)
     : PhysicalOperator(PhysicalOperatorType::POSITIONAL_SCAN, std::move(types),
-                       MinValue(left->estimated_cardinality, right->estimated_cardinality)) {
+                       MaxValue(left->estimated_cardinality, right->estimated_cardinality)) {
 
 	// Manage the children ourselves
-	D_ASSERT(left->type == PhysicalOperatorType::TABLE_SCAN);
-	D_ASSERT(right->type == PhysicalOperatorType::TABLE_SCAN);
-	child_tables.emplace_back(std::move(left));
-	child_tables.emplace_back(std::move(right));
+	if (left->type == PhysicalOperatorType::TABLE_SCAN) {
+		child_tables.emplace_back(std::move(left));
+	} else if (left->type == PhysicalOperatorType::POSITIONAL_SCAN) {
+		auto &left_scan = (PhysicalPositionalScan &)*left;
+		child_tables = std::move(left_scan.child_tables);
+	} else {
+		throw InternalException("Invalid left input for PhysicalPositionalScan");
+	}
+
+	if (right->type == PhysicalOperatorType::TABLE_SCAN) {
+		child_tables.emplace_back(std::move(right));
+	} else if (right->type == PhysicalOperatorType::POSITIONAL_SCAN) {
+		auto &right_scan = (PhysicalPositionalScan &)*right;
+		auto &right_tables = right_scan.child_tables;
+		child_tables.reserve(child_tables.size() + right_tables.size());
+		std::move(right_tables.begin(), right_tables.end(), std::back_inserter(child_tables));
+	} else {
+		throw InternalException("Invalid right input for PhysicalPositionalScan");
+	}
 }
 
 class PositionalScanGlobalSourceState : public GlobalSourceState {

package/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp

@@ -9,6 +9,7 @@
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/operator/logical_aggregate.hpp"
+#include "duckdb/function/function_binder.hpp"
 
 namespace duckdb {
 
@@ -169,13 +170,20 @@ PhysicalPlanGenerator::ExtractAggregateExpressions(unique_ptr<PhysicalOperator>
 	vector<unique_ptr<Expression>> expressions;
 	vector<LogicalType> types;
 
+	// bind sorted aggregates
+	for (auto &aggr : aggregates) {
+		auto &bound_aggr = (BoundAggregateExpression &)*aggr;
+		if (bound_aggr.order_bys) {
+			// sorted aggregate!
+			FunctionBinder::BindSortedAggregate(context, bound_aggr, groups);
+		}
+	}
 	for (auto &group : groups) {
 		auto ref = make_unique<BoundReferenceExpression>(group->return_type, expressions.size());
 		types.push_back(group->return_type);
 		expressions.push_back(std::move(group));
 		group = std::move(ref);
 	}
-
 	for (auto &aggr : aggregates) {
 		auto &bound_aggr = (BoundAggregateExpression &)*aggr;
 		for (auto &child : bound_aggr.children) {

package/src/duckdb/src/execution/physical_plan/plan_distinct.cpp

@@ -9,8 +9,10 @@
 
 namespace duckdb {
 
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreateDistinctOn(unique_ptr<PhysicalOperator> child,
-                                                                     vector<unique_ptr<Expression>> distinct_targets) {
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDistinct &op) {
+	D_ASSERT(op.children.size() == 1);
+	auto child = CreatePlan(*op.children[0]);
+	auto &distinct_targets = op.distinct_targets;
 	D_ASSERT(child);
 	D_ASSERT(!distinct_targets.empty());
 
@@ -55,6 +57,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreateDistinctOn(unique_ptr<
 			FunctionBinder function_binder(context);
 			auto first_aggregate = function_binder.BindAggregateFunction(
 			    FirstFun::GetFunction(logical_type), std::move(first_children), nullptr, AggregateType::NON_DISTINCT);
+			first_aggregate->order_bys = op.order_by ? op.order_by->Copy() : nullptr;
 			// add the projection
 			projections.push_back(make_unique<BoundReferenceExpression>(logical_type, group_count + aggregates.size()));
 			// push it to the list of aggregates
@@ -81,10 +84,4 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreateDistinctOn(unique_ptr<
 	return std::move(aggr_projection);
 }
 
-unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDistinct &op) {
-	D_ASSERT(op.children.size() == 1);
-	auto plan = CreatePlan(*op.children[0]);
-	return CreateDistinctOn(std::move(plan), std::move(op.distinct_targets));
-}
-
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_positional_join.cpp

@@ -10,12 +10,21 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalPositional
 
 	auto left = CreatePlan(*op.children[0]);
 	auto right = CreatePlan(*op.children[1]);
-	if (left->type == PhysicalOperatorType::TABLE_SCAN && right->type == PhysicalOperatorType::TABLE_SCAN) {
-		return make_unique<PhysicalPositionalScan>(op.types, std::move(left), std::move(right));
-	} else {
-		return make_unique<PhysicalPositionalJoin>(op.types, std::move(left), std::move(right),
-		                                           op.estimated_cardinality);
+	switch (left->type) {
+	case PhysicalOperatorType::TABLE_SCAN:
+	case PhysicalOperatorType::POSITIONAL_SCAN:
+		switch (right->type) {
+		case PhysicalOperatorType::TABLE_SCAN:
+		case PhysicalOperatorType::POSITIONAL_SCAN:
+			return make_unique<PhysicalPositionalScan>(op.types, std::move(left), std::move(right));
+		default:
+			break;
+		}
+	default:
+		break;
 	}
+
+	return make_unique<PhysicalPositionalJoin>(op.types, std::move(left), std::move(right), op.estimated_cardinality);
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/aggregate/distributive/bool.cpp

@@ -95,6 +95,7 @@ AggregateFunction BoolOrFun::GetFunction() {
 	auto fun = AggregateFunction::UnaryAggregate<BoolState, bool, bool, BoolOrFunFunction>(
 	    LogicalType(LogicalTypeId::BOOLEAN), LogicalType::BOOLEAN);
 	fun.name = "bool_or";
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 
@@ -102,6 +103,7 @@ AggregateFunction BoolAndFun::GetFunction() {
 	auto fun = AggregateFunction::UnaryAggregate<BoolState, bool, bool, BoolAndFunFunction>(
 	    LogicalType(LogicalTypeId::BOOLEAN), LogicalType::BOOLEAN);
 	fun.name = "bool_and";
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 

package/src/duckdb/src/function/aggregate/distributive/count.cpp

@@ -76,6 +76,7 @@ AggregateFunction CountFun::GetFunction() {
 	    LogicalType(LogicalTypeId::ANY), LogicalType::BIGINT);
 	fun.name = "count";
 	fun.null_handling = FunctionNullHandling::SPECIAL_HANDLING;
+	fun.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return fun;
 }
 

package/src/duckdb/src/function/aggregate/distributive/minmax.cpp

@@ -514,6 +514,7 @@ unique_ptr<FunctionData> BindDecimalMinMax(ClientContext &context, AggregateFunc
 	function.name = std::move(name);
 	function.arguments[0] = decimal_type;
 	function.return_type = decimal_type;
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	return nullptr;
 }
 
@@ -545,6 +546,7 @@ unique_ptr<FunctionData> BindMinMax(ClientContext &context, AggregateFunction &f
 	auto name = std::move(function.name);
 	function = GetMinMaxOperator<OP, OP_STRING, OP_VECTOR>(input_type);
 	function.name = std::move(name);
+	function.order_dependent = AggregateOrderDependent::NOT_ORDER_DEPENDENT;
 	if (function.bind) {
 		return function.bind(context, function, arguments);
 	} else {