duckdb 0.7.2-dev0.0 → 0.7.2-dev1034.0

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

@@ -30,25 +30,20 @@ PhysicalPiecewiseMergeJoin::PhysicalPiecewiseMergeJoin(LogicalOperator &op, uniq
 		switch (cond.comparison) {
 		case ExpressionType::COMPARE_LESSTHAN:
 		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			lhs_orders.emplace_back(
-			    BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(left)));
-			rhs_orders.emplace_back(
-			    BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(right)));
+			lhs_orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(left));
+			rhs_orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, std::move(right));
 			break;
 		case ExpressionType::COMPARE_GREATERTHAN:
 		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			lhs_orders.emplace_back(
-			    BoundOrderByNode(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(left)));
-			rhs_orders.emplace_back(
-			    BoundOrderByNode(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(right)));
+			lhs_orders.emplace_back(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(left));
+			rhs_orders.emplace_back(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, std::move(right));
 			break;
 		case ExpressionType::COMPARE_NOTEQUAL:
 		case ExpressionType::COMPARE_DISTINCT_FROM:
 			// Allowed in multi-predicate joins, but can't be first/sort.
 			D_ASSERT(!lhs_orders.empty());
-			lhs_orders.emplace_back(BoundOrderByNode(OrderType::INVALID, OrderByNullType::NULLS_LAST, std::move(left)));
-			rhs_orders.emplace_back(
-			    BoundOrderByNode(OrderType::INVALID, OrderByNullType::NULLS_LAST, std::move(right)));
+			lhs_orders.emplace_back(OrderType::INVALID, OrderByNullType::NULLS_LAST, std::move(left));
+			rhs_orders.emplace_back(OrderType::INVALID, OrderByNullType::NULLS_LAST, std::move(right));
 			break;
 
 		default:

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

@@ -46,7 +46,7 @@ void PhysicalRangeJoin::LocalSortedTable::Sink(DataChunk &input, GlobalSortState
 
 	//	Only sort the primary key
 	DataChunk join_head;
-	join_head.data.emplace_back(Vector(keys.data[0]));
+	join_head.data.emplace_back(keys.data[0]);
 	join_head.SetCardinality(keys.size());
 
 	// Sink the data into the local sort state
@@ -334,7 +334,9 @@ idx_t PhysicalRangeJoin::SelectJoinTail(const ExpressionType &condition, Vector
 	case ExpressionType::COMPARE_DISTINCT_FROM:
 		return VectorOperations::DistinctFrom(left, right, sel, count, true_sel, nullptr);
 	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+		return VectorOperations::NotDistinctFrom(left, right, sel, count, true_sel, nullptr);
 	case ExpressionType::COMPARE_EQUAL:
+		return VectorOperations::Equals(left, right, sel, count, true_sel, nullptr);
 	default:
 		throw InternalException("Unsupported comparison type for PhysicalRangeJoin");
 	}

package/src/duckdb/src/execution/operator/persistent/base_csv_reader.cpp

@@ -121,6 +121,9 @@ bool TryCastFloatingValueCommaSeparated(const string_t &value_str, const Logical
 }
 
 bool BaseCSVReader::TryCastValue(const Value &value, const LogicalType &sql_type) {
+	if (value.IsNull()) {
+		return true;
+	}
 	if (options.has_format[LogicalTypeId::DATE] && sql_type.id() == LogicalTypeId::DATE) {
 		date_t result;
 		string error_message;
@@ -495,12 +498,12 @@ bool BaseCSVReader::Flush(DataChunk &insert_chunk, bool try_add_line) {
 			}
 
 			// figure out the exact line number
+			UnifiedVectorFormat inserted_column_data;
+			insert_chunk.data[col_idx].ToUnifiedFormat(parse_chunk.size(), inserted_column_data);
 			idx_t row_idx;
 			for (row_idx = 0; row_idx < parse_chunk.size(); row_idx++) {
-				auto &inserted_column = insert_chunk.data[col_idx];
 				auto &parsed_column = parse_chunk.data[col_idx];
-
-				if (FlatVector::IsNull(inserted_column, row_idx) && !FlatVector::IsNull(parsed_column, row_idx)) {
+				if (!inserted_column_data.validity.RowIsValid(row_idx) && !FlatVector::IsNull(parsed_column, row_idx)) {
 					break;
 				}
 			}

package/src/duckdb/src/execution/operator/persistent/buffered_csv_reader.cpp

@@ -555,7 +555,7 @@ void BufferedCSVReader::DetectCandidateTypes(const vector<LogicalType> &type_can
 					// try formatting for date types if the user did not specify one and it starts with numeric values.
 					string separator;
 					if (has_format_candidates.count(sql_type.id()) && !original_options.has_format[sql_type.id()] &&
-					    StartsWithNumericDate(separator, StringValue::Get(dummy_val))) {
+					    !dummy_val.IsNull() && StartsWithNumericDate(separator, StringValue::Get(dummy_val))) {
 						// generate date format candidates the first time through
 						auto &type_format_candidates = format_candidates[sql_type.id()];
 						const auto had_format_candidates = has_format_candidates[sql_type.id()];
@@ -870,16 +870,7 @@ vector<LogicalType> BufferedCSVReader::SniffCSV(const vector<LogicalType> &reque
 	// #######
 	// ### type detection (initial)
 	// #######
-	// type candidates, ordered by descending specificity (~ from high to low)
-	vector<LogicalType> type_candidates = {
-	    LogicalType::VARCHAR,
-	    LogicalType::TIMESTAMP,
-	    LogicalType::DATE,
-	    LogicalType::TIME,
-	    LogicalType::DOUBLE,
-	    /* LogicalType::FLOAT,*/ LogicalType::BIGINT,
-	    /*LogicalType::INTEGER,*/ /*LogicalType::SMALLINT, LogicalType::TINYINT,*/ LogicalType::BOOLEAN,
-	    LogicalType::SQLNULL};
+
 	// format template candidates, ordered by descending specificity (~ from high to low)
 	std::map<LogicalTypeId, vector<const char *>> format_template_candidates = {
 	    {LogicalTypeId::DATE, {"%m-%d-%Y", "%m-%d-%y", "%d-%m-%Y", "%d-%m-%y", "%Y-%m-%d", "%y-%m-%d"}},
@@ -890,8 +881,8 @@ vector<LogicalType> BufferedCSVReader::SniffCSV(const vector<LogicalType> &reque
 	vector<vector<LogicalType>> best_sql_types_candidates;
 	map<LogicalTypeId, vector<string>> best_format_candidates;
 	DataChunk best_header_row;
-	DetectCandidateTypes(type_candidates, format_template_candidates, info_candidates, original_options, best_num_cols,
-	                     best_sql_types_candidates, best_format_candidates, best_header_row);
+	DetectCandidateTypes(options.auto_type_candidates, format_template_candidates, info_candidates, original_options,
+	                     best_num_cols, best_sql_types_candidates, best_format_candidates, best_header_row);
 
 	if (best_format_candidates.empty() || best_header_row.size() == 0) {
 		throw InvalidInputException(
@@ -939,7 +930,8 @@ vector<LogicalType> BufferedCSVReader::SniffCSV(const vector<LogicalType> &reque
 	// #######
 	// ### type detection (refining)
 	// #######
-	return RefineTypeDetection(type_candidates, requested_types, best_sql_types_candidates, best_format_candidates);
+	return RefineTypeDetection(options.auto_type_candidates, requested_types, best_sql_types_candidates,
+	                           best_format_candidates);
 }
 
 bool BufferedCSVReader::TryParseComplexCSV(DataChunk &insert_chunk, string &error_message) {

package/src/duckdb/src/execution/operator/persistent/physical_copy_to_file.cpp

@@ -85,8 +85,8 @@ static string CreateDirRecursive(const vector<idx_t> &cols, const vector<string>
 	CreateDir(path, fs);
 
 	for (idx_t i = 0; i < cols.size(); i++) {
-		auto partition_col_name = names[cols[i]];
-		auto partition_value = values[i];
+		const auto &partition_col_name = names[cols[i]];
+		const auto &partition_value = values[i];
 		string p_dir = partition_col_name + "=" + partition_value.ToString();
 		path = fs.JoinPath(path, p_dir);
 		CreateDir(path, fs);

package/src/duckdb/src/execution/operator/projection/physical_projection.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/execution/operator/projection/physical_projection.hpp"
 #include "duckdb/parallel/thread_context.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
 
 namespace duckdb {
 
@@ -35,6 +36,39 @@ unique_ptr<OperatorState> PhysicalProjection::GetOperatorState(ExecutionContext
 	return make_unique<ProjectionState>(context, select_list);
 }
 
+unique_ptr<PhysicalOperator>
+PhysicalProjection::CreateJoinProjection(vector<LogicalType> proj_types, const vector<LogicalType> &lhs_types,
+                                         const vector<LogicalType> &rhs_types, const vector<idx_t> &left_projection_map,
+                                         const vector<idx_t> &right_projection_map, const idx_t estimated_cardinality) {
+
+	vector<unique_ptr<Expression>> proj_selects;
+	proj_selects.reserve(proj_types.size());
+
+	if (left_projection_map.empty()) {
+		for (storage_t i = 0; i < lhs_types.size(); ++i) {
+			proj_selects.emplace_back(make_unique<BoundReferenceExpression>(lhs_types[i], i));
+		}
+	} else {
+		for (auto i : left_projection_map) {
+			proj_selects.emplace_back(make_unique<BoundReferenceExpression>(lhs_types[i], i));
+		}
+	}
+	const auto left_cols = lhs_types.size();
+
+	if (right_projection_map.empty()) {
+		for (storage_t i = 0; i < rhs_types.size(); ++i) {
+			proj_selects.emplace_back(make_unique<BoundReferenceExpression>(rhs_types[i], left_cols + i));
+		}
+
+	} else {
+		for (auto i : right_projection_map) {
+			proj_selects.emplace_back(make_unique<BoundReferenceExpression>(rhs_types[i], left_cols + i));
+		}
+	}
+
+	return make_unique<PhysicalProjection>(std::move(proj_types), std::move(proj_selects), estimated_cardinality);
+}
+
 string PhysicalProjection::ParamsToString() const {
 	string extra_info;
 	for (auto &expr : select_list) {

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/operator/schema/physical_create_type.cpp

@@ -15,10 +15,11 @@ PhysicalCreateType::PhysicalCreateType(unique_ptr<CreateTypeInfo> info, idx_t es
 //===--------------------------------------------------------------------===//
 class CreateTypeGlobalState : public GlobalSinkState {
 public:
-	explicit CreateTypeGlobalState(ClientContext &context) : collection(context, {LogicalType::VARCHAR}) {
+	explicit CreateTypeGlobalState(ClientContext &context) : result(LogicalType::VARCHAR) {
 	}
-
-	ColumnDataCollection collection;
+	Vector result;
+	idx_t size = 0;
+	idx_t capacity = STANDARD_VECTOR_SIZE;
 };
 
 unique_ptr<GlobalSinkState> PhysicalCreateType::GetGlobalSinkState(ClientContext &context) const {
@@ -28,7 +29,7 @@ unique_ptr<GlobalSinkState> PhysicalCreateType::GetGlobalSinkState(ClientContext
 SinkResultType PhysicalCreateType::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
                                         DataChunk &input) const {
 	auto &gstate = (CreateTypeGlobalState &)gstate_p;
-	idx_t total_row_count = gstate.collection.Count() + input.size();
+	idx_t total_row_count = gstate.size + input.size();
 	if (total_row_count > NumericLimits<uint32_t>::Maximum()) {
 		throw InvalidInputException("Attempted to create ENUM of size %llu, which exceeds the maximum size of %llu",
 		                            total_row_count, NumericLimits<uint32_t>::Maximum());
@@ -36,15 +37,23 @@ SinkResultType PhysicalCreateType::Sink(ExecutionContext &context, GlobalSinkSta
 	UnifiedVectorFormat sdata;
 	input.data[0].ToUnifiedFormat(input.size(), sdata);
 
+	if (total_row_count > gstate.capacity) {
+		// We must resize our result vector
+		gstate.result.Resize(gstate.capacity, gstate.capacity * 2);
+		gstate.capacity *= 2;
+	}
+
+	auto src_ptr = (string_t *)sdata.data;
+	auto result_ptr = FlatVector::GetData<string_t>(gstate.result);
 	// Input vector has NULL value, we just throw an exception
 	for (idx_t i = 0; i < input.size(); i++) {
 		idx_t idx = sdata.sel->get_index(i);
 		if (!sdata.validity.RowIsValid(idx)) {
 			throw InvalidInputException("Attempted to create ENUM type with NULL value!");
 		}
+		result_ptr[gstate.size++] =
+		    StringVector::AddStringOrBlob(gstate.result, src_ptr[idx].GetDataUnsafe(), src_ptr[idx].GetSize());
 	}
-
-	gstate.collection.Append(input);
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -72,44 +81,15 @@ void PhysicalCreateType::GetData(ExecutionContext &context, DataChunk &chunk, Gl
 
 	if (IsSink()) {
 		D_ASSERT(info->type == LogicalType::INVALID);
-
 		auto &g_sink_state = (CreateTypeGlobalState &)*sink_state;
-		auto &collection = g_sink_state.collection;
-
-		idx_t total_row_count = collection.Count();
-
-		ColumnDataScanState scan_state;
-		collection.InitializeScan(scan_state);
-
-		DataChunk scan_chunk;
-		collection.InitializeScanChunk(scan_chunk);
-
-		Vector result(LogicalType::VARCHAR, total_row_count);
-		auto result_ptr = FlatVector::GetData<string_t>(result);
-
-		idx_t offset = 0;
-		while (collection.Scan(scan_state, scan_chunk)) {
-			idx_t src_row_count = scan_chunk.size();
-			auto &src_vec = scan_chunk.data[0];
-			D_ASSERT(src_vec.GetVectorType() == VectorType::FLAT_VECTOR);
-			D_ASSERT(src_vec.GetType().id() == LogicalType::VARCHAR);
-
-			auto src_ptr = FlatVector::GetData<string_t>(src_vec);
-
-			for (idx_t i = 0; i < src_row_count; i++) {
-				idx_t target_index = offset + i;
-				result_ptr[target_index] =
-				    StringVector::AddStringOrBlob(result, src_ptr[i].GetDataUnsafe(), src_ptr[i].GetSize());
-			}
-
-			offset += src_row_count;
-		}
-
-		info->type = LogicalType::ENUM(info->name, result, total_row_count);
+		info->type = LogicalType::ENUM(info->name, g_sink_state.result, g_sink_state.size);
 	}
 
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.CreateType(context.client, info.get());
+	auto catalog_entry = catalog.CreateType(context.client, info.get());
+	D_ASSERT(catalog_entry->type == CatalogType::TYPE_ENTRY);
+	auto catalog_type = (TypeCatalogEntry *)catalog_entry;
+	LogicalType::SetCatalog(info->type, catalog_type);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/partitionable_hashtable.cpp

@@ -62,6 +62,18 @@ PartitionableHashTable::PartitionableHashTable(ClientContext &context, Allocator
 	for (hash_t r = 0; r < partition_info.n_partitions; r++) {
 		sel_vectors[r].Initialize();
 	}
+
+	RowLayout layout;
+	layout.Initialize(group_types, AggregateObject::CreateAggregateObjects(bindings));
+	tuple_size = layout.GetRowWidth();
+}
+
+HtEntryType PartitionableHashTable::GetHTEntrySize() {
+	// we need at least STANDARD_VECTOR_SIZE entries to fit in the hash table
+	if (GroupedAggregateHashTable::GetMaxCapacity(HtEntryType::HT_WIDTH_32, tuple_size) < STANDARD_VECTOR_SIZE) {
+		return HtEntryType::HT_WIDTH_64;
+	}
+	return HtEntryType::HT_WIDTH_32;
 }
 
 idx_t PartitionableHashTable::ListAddChunk(HashTableList &list, DataChunk &groups, Vector &group_hashes,
@@ -74,7 +86,7 @@ idx_t PartitionableHashTable::ListAddChunk(HashTableList &list, DataChunk &group
 			list.back()->Finalize();
 		}
 		list.push_back(make_unique<GroupedAggregateHashTable>(context, allocator, group_types, payload_types, bindings,
-		                                                      HtEntryType::HT_WIDTH_32));
+		                                                      GetHTEntrySize()));
 	}
 	return list.back()->AddChunk(groups, group_hashes, payload, filter);
 }
@@ -141,7 +153,7 @@ void PartitionableHashTable::Partition() {
 	for (auto &unpartitioned_ht : unpartitioned_hts) {
 		for (idx_t r = 0; r < partition_info.n_partitions; r++) {
 			radix_partitioned_hts[r].push_back(make_unique<GroupedAggregateHashTable>(
-			    context, allocator, group_types, payload_types, bindings, HtEntryType::HT_WIDTH_32));
+			    context, allocator, group_types, payload_types, bindings, GetHTEntrySize()));
 			partition_hts[r] = radix_partitioned_hts[r].back().get();
 		}
 		unpartitioned_ht->Partition(partition_hts, partition_info.radix_mask, partition_info.RADIX_SHIFT);

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

@@ -9,7 +9,8 @@
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
+#include "duckdb/function/function_binder.hpp"
+
 namespace duckdb {
 
 static uint32_t RequiredBitsForValue(uint32_t n) {
@@ -50,23 +51,20 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 			// for small types we can just set the stats to [type_min, type_max]
 			switch (group_type.InternalType()) {
 			case PhysicalType::INT8:
-				stats = make_unique<NumericStatistics>(group_type, Value::MinimumValue(group_type),
-				                                       Value::MaximumValue(group_type), StatisticsType::LOCAL_STATS);
-				break;
 			case PhysicalType::INT16:
-				stats = make_unique<NumericStatistics>(group_type, Value::MinimumValue(group_type),
-				                                       Value::MaximumValue(group_type), StatisticsType::LOCAL_STATS);
 				break;
 			default:
 				// type is too large and there are no stats: skip perfect hashing
 				return false;
 			}
-			// we had no stats before, so we have no clue if there are null values or not
-			stats->validity_stats = make_unique<ValidityStatistics>(true);
+			// construct stats with the min and max value of the type
+			stats = NumericStats::CreateUnknown(group_type).ToUnique();
+			NumericStats::SetMin(*stats, Value::MinimumValue(group_type));
+			NumericStats::SetMax(*stats, Value::MaximumValue(group_type));
 		}
-		auto &nstats = (NumericStatistics &)*stats;
+		auto &nstats = *stats;
 
-		if (nstats.min.IsNull() || nstats.max.IsNull()) {
+		if (!NumericStats::HasMinMax(nstats)) {
 			return false;
 		}
 		// we have a min and a max value for the stats: use that to figure out how many bits we have
@@ -75,17 +73,17 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 		int64_t range;
 		switch (group_type.InternalType()) {
 		case PhysicalType::INT8:
-			range = int64_t(nstats.max.GetValueUnsafe<int8_t>()) - int64_t(nstats.min.GetValueUnsafe<int8_t>());
+			range = int64_t(NumericStats::GetMax<int8_t>(nstats)) - int64_t(NumericStats::GetMin<int8_t>(nstats));
 			break;
 		case PhysicalType::INT16:
-			range = int64_t(nstats.max.GetValueUnsafe<int16_t>()) - int64_t(nstats.min.GetValueUnsafe<int16_t>());
+			range = int64_t(NumericStats::GetMax<int16_t>(nstats)) - int64_t(NumericStats::GetMin<int16_t>(nstats));
 			break;
 		case PhysicalType::INT32:
-			range = int64_t(nstats.max.GetValueUnsafe<int32_t>()) - int64_t(nstats.min.GetValueUnsafe<int32_t>());
+			range = int64_t(NumericStats::GetMax<int32_t>(nstats)) - int64_t(NumericStats::GetMin<int32_t>(nstats));
 			break;
 		case PhysicalType::INT64:
-			if (!TrySubtractOperator::Operation(nstats.max.GetValueUnsafe<int64_t>(),
-			                                    nstats.min.GetValueUnsafe<int64_t>(), range)) {
+			if (!TrySubtractOperator::Operation(NumericStats::GetMax<int64_t>(nstats),
+			                                    NumericStats::GetMin<int64_t>(nstats), range)) {
 				return false;
 			}
 			break;
@@ -169,13 +167,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_asof_join.cpp

@@ -0,0 +1,97 @@
+#include "duckdb/execution/operator/aggregate/physical_window.hpp"
+#include "duckdb/execution/operator/join/physical_iejoin.hpp"
+#include "duckdb/execution/operator/projection/physical_projection.hpp"
+#include "duckdb/execution/physical_plan_generator.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
+#include "duckdb/planner/expression/bound_window_expression.hpp"
+#include "duckdb/planner/operator/logical_asof_join.hpp"
+
+namespace duckdb {
+
+unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAsOfJoin &op) {
+	// now visit the children
+	D_ASSERT(op.children.size() == 2);
+	idx_t lhs_cardinality = op.children[0]->EstimateCardinality(context);
+	idx_t rhs_cardinality = op.children[1]->EstimateCardinality(context);
+	auto left = CreatePlan(*op.children[0]);
+	auto right = CreatePlan(*op.children[1]);
+	D_ASSERT(left && right);
+
+	//	Validate
+	vector<idx_t> equi_indexes;
+	auto asof_idx = op.conditions.size();
+	for (size_t c = 0; c < op.conditions.size(); ++c) {
+		auto &cond = op.conditions[c];
+		switch (cond.comparison) {
+		case ExpressionType::COMPARE_EQUAL:
+		case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+			equi_indexes.emplace_back(c);
+			break;
+		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+			D_ASSERT(asof_idx == op.conditions.size());
+			asof_idx = c;
+			break;
+		default:
+			throw InternalException("Invalid ASOF JOIN comparison");
+		}
+	}
+	D_ASSERT(asof_idx < op.conditions.size());
+
+	//	Temporary implementation: IEJoin of Window
+	//	LEAD(asof_column, 1, infinity) OVER (PARTITION BY equi_column... ORDER BY asof_column) AS asof_temp
+	auto &asof_comp = op.conditions[asof_idx];
+	auto &asof_column = asof_comp.right;
+	auto asof_type = asof_column->return_type;
+	auto asof_temp = make_unique<BoundWindowExpression>(ExpressionType::WINDOW_LEAD, asof_type, nullptr, nullptr);
+	asof_temp->children.emplace_back(asof_column->Copy());
+	asof_temp->offset_expr = make_unique<BoundConstantExpression>(Value::BIGINT(1));
+	asof_temp->default_expr = make_unique<BoundConstantExpression>(Value::Infinity(asof_type));
+	for (auto equi_idx : equi_indexes) {
+		asof_temp->partitions.emplace_back(op.conditions[equi_idx].right->Copy());
+	}
+	asof_temp->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, asof_column->Copy());
+	asof_temp->start = WindowBoundary::UNBOUNDED_PRECEDING;
+	asof_temp->end = WindowBoundary::CURRENT_ROW_ROWS;
+
+	vector<unique_ptr<Expression>> window_select;
+	window_select.emplace_back(std::move(asof_temp));
+
+	auto window_types = right->types;
+	window_types.emplace_back(asof_type);
+
+	auto window = make_unique<PhysicalWindow>(window_types, std::move(window_select), rhs_cardinality);
+	window->children.emplace_back(std::move(right));
+
+	// IEJoin(left, window, conditions || asof_column < asof_temp)
+	JoinCondition asof_upper;
+	asof_upper.left = asof_comp.left->Copy();
+	asof_upper.right = make_unique<BoundReferenceExpression>(asof_type, window_types.size() - 1);
+	asof_upper.comparison = ExpressionType::COMPARE_LESSTHAN;
+
+	// We have an equality condition, so we may have to deal with projection maps.
+	// IEJoin does not (currently) support them, so we have to do it manually
+	auto proj_types = op.types;
+	op.types.clear();
+
+	auto lhs_types = op.children[0]->types;
+	op.types = lhs_types;
+
+	auto rhs_types = op.children[1]->types;
+	op.types.insert(op.types.end(), rhs_types.begin(), rhs_types.end());
+
+	op.types.emplace_back(asof_type);
+	op.conditions.emplace_back(std::move(asof_upper));
+	auto iejoin = make_unique<PhysicalIEJoin>(op, std::move(left), std::move(window), std::move(op.conditions),
+	                                          op.join_type, op.estimated_cardinality);
+
+	//	Project away asof_temp and anything from the projection maps
+	auto proj = PhysicalProjection::CreateJoinProjection(proj_types, lhs_types, rhs_types, op.left_projection_map,
+	                                                     op.right_projection_map, lhs_cardinality);
+	proj->children.push_back(std::move(iejoin));
+
+	return proj;
+}
+
+} // namespace duckdb