duckdb 0.3.4-dev91.0 → 0.3.5-dev116.0

package/src/duckdb.cpp

@@ -29679,6 +29679,8 @@ public:
 	//! Completes the cascaded merge sort round.
 	//! Pass true if you wish to use the radix data for further comparisons.
 	void CompleteMergeRound(bool keep_radix_data = false);
+	//! Print the sorted data to the console.
+	void Print();
 
 public:
 	//! The lock for updating the order global state
@@ -31591,6 +31593,19 @@ void GlobalSortState::CompleteMergeRound(bool keep_radix_data) {
 		sorted_blocks[0]->blob_sorting_data = nullptr;
 	}
 }
+void GlobalSortState::Print() {
+	PayloadScanner scanner(*this, false);
+	DataChunk chunk;
+	chunk.Initialize(scanner.GetPayloadTypes());
+	for (;;) {
+		scanner.Scan(chunk);
+		const auto count = chunk.size();
+		if (!count) {
+			break;
+		}
+		chunk.Print();
+	}
+}
 
 } // namespace duckdb
 
@@ -41290,7 +41305,7 @@ void Vector::Normalify(idx_t count) {
 		break;
 	case VectorType::DICTIONARY_VECTOR: {
 		// create a new flat vector of this type
-		Vector other(GetType());
+		Vector other(GetType(), count);
 		// now copy the data of this vector to the other vector, removing the selection vector in the process
 		VectorOperations::Copy(*this, other, count, 0, 0);
 		// create a reference to the data in the other vector
@@ -46757,8 +46772,8 @@ static bool ListCastSwitch(Vector &source, Vector &result, idx_t count, string *
 }
 
 template <class SRC_TYPE, class RES_TYPE>
-void FillEnum(Vector &source, Vector &result, idx_t count) {
-
+bool FillEnum(Vector &source, Vector &result, idx_t count, string *error_message) {
+	bool all_converted = true;
 	result.SetVectorType(VectorType::FLAT_VECTOR);
 
 	auto &str_vec = EnumType::GetValuesInsertOrder(source.GetType());
@@ -46786,25 +46801,29 @@ void FillEnum(Vector &source, Vector &result, idx_t count) {
 		auto key = EnumType::GetPos(res_enum_type, str);
 		if (key == -1) {
 			// key doesn't exist on result enum
-			result_mask.SetInvalid(i);
+			if (!error_message) {
+				result_data[i] = HandleVectorCastError::Operation<RES_TYPE>(
+				    CastExceptionText<SRC_TYPE, RES_TYPE>(source_data[src_idx]), result_mask, i, error_message,
+				    all_converted);
+			} else {
+				result_mask.SetInvalid(i);
+			}
 			continue;
 		}
 		result_data[i] = key;
 	}
+	return all_converted;
 }
 
 template <class SRC_TYPE>
-void FillEnumResultTemplate(Vector &source, Vector &result, idx_t count) {
+bool FillEnumResultTemplate(Vector &source, Vector &result, idx_t count, string *error_message) {
 	switch (source.GetType().InternalType()) {
 	case PhysicalType::UINT8:
-		FillEnum<SRC_TYPE, uint8_t>(source, result, count);
-		break;
+		return FillEnum<SRC_TYPE, uint8_t>(source, result, count, error_message);
 	case PhysicalType::UINT16:
-		FillEnum<SRC_TYPE, uint16_t>(source, result, count);
-		break;
+		return FillEnum<SRC_TYPE, uint16_t>(source, result, count, error_message);
 	case PhysicalType::UINT32:
-		FillEnum<SRC_TYPE, uint32_t>(source, result, count);
-		break;
+		return FillEnum<SRC_TYPE, uint32_t>(source, result, count, error_message);
 	default:
 		throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
 	}
@@ -46852,18 +46871,14 @@ static bool EnumCastSwitch(Vector &source, Vector &result, idx_t count, string *
 		// This means they are both ENUMs, but of different types.
 		switch (enum_physical_type) {
 		case PhysicalType::UINT8:
-			FillEnumResultTemplate<uint8_t>(source, result, count);
-			break;
+			return FillEnumResultTemplate<uint8_t>(source, result, count, error_message);
 		case PhysicalType::UINT16:
-			FillEnumResultTemplate<uint16_t>(source, result, count);
-			break;
+			return FillEnumResultTemplate<uint16_t>(source, result, count, error_message);
 		case PhysicalType::UINT32:
-			FillEnumResultTemplate<uint32_t>(source, result, count);
-			break;
+			return FillEnumResultTemplate<uint32_t>(source, result, count, error_message);
 		default:
 			throw InternalException("ENUM can only have unsigned integers (except UINT64) as physical types");
 		}
-		break;
 	}
 	case LogicalTypeId::JSON:
 	case LogicalTypeId::VARCHAR: {
@@ -47105,7 +47120,20 @@ void VectorOperations::Copy(const Vector &source, Vector &target, const Selectio
 		if (smask.IsMaskSet()) {
 			for (idx_t i = 0; i < copy_count; i++) {
 				auto idx = sel->get_index(source_offset + i);
-				tmask.Set(target_offset + i, smask.RowIsValid(idx));
+
+				if (smask.RowIsValid(idx)) {
+					// set valid
+					if (!tmask.AllValid()) {
+						tmask.SetValidUnsafe(target_offset + i);
+					}
+				} else {
+					// set invalid
+					if (tmask.AllValid()) {
+						auto init_size = MaxValue<idx_t>(STANDARD_VECTOR_SIZE, target_offset + copy_count);
+						tmask.Initialize(init_size);
+					}
+					tmask.SetInvalidUnsafe(target_offset + i);
+				}
 			}
 		}
 	}
@@ -59205,16 +59233,119 @@ void PhysicalHashJoin::GetData(ExecutionContext &context, DataChunk &chunk, Glob
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/join/physical_piecewise_merge_join.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
 
 
 
 namespace duckdb {
 
-class IEJoinSortedTable;
+struct GlobalSortState;
+
+//! PhysicalRangeJoin represents one or more inequality range join predicates between
+//! two tables
+class PhysicalRangeJoin : public PhysicalComparisonJoin {
+public:
+	class LocalSortedTable {
+	public:
+		LocalSortedTable(const PhysicalRangeJoin &op, const idx_t child);
+
+		void Sink(DataChunk &input, GlobalSortState &global_sort_state);
+
+		inline void Sort(GlobalSortState &global_sort_state) {
+			local_sort_state.Sort(global_sort_state, true);
+		}
+
+		//! The hosting operator
+		const PhysicalRangeJoin &op;
+		//! The local sort state
+		LocalSortState local_sort_state;
+		//! Local copy of the sorting expression executor
+		ExpressionExecutor executor;
+		//! Holds a vector of incoming sorting columns
+		DataChunk keys;
+		//! The number of NULL values
+		idx_t has_null;
+		//! The total number of rows
+		idx_t count;
+
+	private:
+		// Merge the NULLs of all non-DISTINCT predicates into the primary so they sort to the end.
+		idx_t MergeNulls(const vector<JoinCondition> &conditions);
+	};
+
+	class GlobalSortedTable {
+	public:
+		GlobalSortedTable(ClientContext &context, const vector<BoundOrderByNode> &orders, RowLayout &payload_layout);
+
+		inline idx_t Count() const {
+			return count;
+		}
+
+		inline idx_t BlockCount() const {
+			if (global_sort_state.sorted_blocks.empty()) {
+				return 0;
+			}
+			D_ASSERT(global_sort_state.sorted_blocks.size() == 1);
+			return global_sort_state.sorted_blocks[0]->radix_sorting_data.size();
+		}
+
+		inline idx_t BlockSize(idx_t i) const {
+			return global_sort_state.sorted_blocks[0]->radix_sorting_data[i].count;
+		}
+
+		void Combine(LocalSortedTable &ltable);
+		void IntializeMatches();
+		void Print();
+
+		//! Starts the sorting process.
+		void Finalize(Pipeline &pipeline, Event &event);
+		//! Schedules tasks to merge sort the current child's data during a Finalize phase
+		void ScheduleMergeTasks(Pipeline &pipeline, Event &event);
+
+		GlobalSortState global_sort_state;
+		//! Whether or not the RHS has NULL values
+		atomic<idx_t> has_null;
+		//! The total number of rows in the RHS
+		atomic<idx_t> count;
+		//! A bool indicating for each tuple in the RHS if they found a match (only used in FULL OUTER JOIN)
+		unique_ptr<bool[]> found_match;
+		//! Memory usage per thread
+		idx_t memory_per_thread;
+	};
+
+public:
+	PhysicalRangeJoin(LogicalOperator &op, PhysicalOperatorType type, unique_ptr<PhysicalOperator> left,
+	                  unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
+	                  idx_t estimated_cardinality);
+
+public:
+	// Gather the result values and slice the payload columns to those values.
+	static void SliceSortedPayload(DataChunk &payload, GlobalSortState &state, const idx_t block_idx,
+	                               const SelectionVector &result, const idx_t result_count, const idx_t left_cols = 0);
+	// Apply a tail condition to the current selection
+	static idx_t SelectJoinTail(const ExpressionType &condition, Vector &left, Vector &right,
+	                            const SelectionVector *sel, idx_t count, SelectionVector *true_sel);
+};
+
+} // namespace duckdb
+
+
+
+namespace duckdb {
 
 //! PhysicalIEJoin represents a two inequality range join between
 //! two tables
-class PhysicalIEJoin : public PhysicalComparisonJoin {
+class PhysicalIEJoin : public PhysicalRangeJoin {
 public:
 	PhysicalIEJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left, unique_ptr<PhysicalOperator> right,
 	               vector<JoinCondition> cond, JoinType join_type, idx_t estimated_cardinality);
@@ -59253,9 +59384,6 @@ public:
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
 	                          GlobalSinkState &gstate) const override;
 
-	//! Schedules tasks to merge sort the current child's data during a Finalize phase
-	static void ScheduleMergeTasks(Pipeline &pipeline, Event &event, IEJoinSortedTable &table);
-
 	bool IsSink() const override {
 		return true;
 	}
@@ -59289,35 +59417,8 @@ namespace duckdb {
 PhysicalIEJoin::PhysicalIEJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
                                unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
                                idx_t estimated_cardinality)
-    : PhysicalComparisonJoin(op, PhysicalOperatorType::IE_JOIN, move(cond), join_type, estimated_cardinality) {
-	// Reorder the conditions so that ranges are at the front.
-	// TODO: use stats to improve the choice?
-	// TODO: Prefer fixed length types?
-	auto conditions_p = std::move(conditions);
-	conditions.resize(conditions_p.size());
-	idx_t range_position = 0;
-	idx_t other_position = conditions_p.size();
-	for (idx_t i = 0; i < conditions_p.size(); ++i) {
-		switch (conditions_p[i].comparison) {
-		case ExpressionType::COMPARE_LESSTHAN:
-		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		case ExpressionType::COMPARE_GREATERTHAN:
-		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			conditions[range_position++] = std::move(conditions_p[i]);
-			break;
-		case ExpressionType::COMPARE_NOTEQUAL:
-		case ExpressionType::COMPARE_DISTINCT_FROM:
-			// Allowed in multi-predicate joins, but can't be first/sort.
-			conditions[--other_position] = std::move(conditions_p[i]);
-			break;
-		default:
-			// COMPARE EQUAL not supported with iejoin join
-			throw NotImplementedException("Unimplemented join type for IEJoin");
-		}
-	}
-
-	// IEJoin requires at least two comparisons.
-	D_ASSERT(range_position > 1);
+    : PhysicalRangeJoin(op, PhysicalOperatorType::IE_JOIN, move(left), move(right), move(cond), join_type,
+                        estimated_cardinality) {
 
 	// 1. let L1 (resp. L2) be the array of column X (resp. Y)
 	D_ASSERT(conditions.size() >= 2);
@@ -59342,9 +59443,12 @@ PhysicalIEJoin::PhysicalIEJoin(LogicalOperator &op, unique_ptr<PhysicalOperator>
 		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
 			sense = i ? OrderType::ASCENDING : OrderType::DESCENDING;
 			break;
-		default:
+		case ExpressionType::COMPARE_LESSTHAN:
+		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
 			sense = i ? OrderType::DESCENDING : OrderType::ASCENDING;
 			break;
+		default:
+			throw NotImplementedException("Unimplemented join type for IEJoin");
 		}
 		lhs_orders[i].emplace_back(BoundOrderByNode(sense, OrderByNullType::NULLS_LAST, move(left)));
 		rhs_orders[i].emplace_back(BoundOrderByNode(sense, OrderByNullType::NULLS_LAST, move(right)));
@@ -59355,9 +59459,6 @@ PhysicalIEJoin::PhysicalIEJoin(LogicalOperator &op, unique_ptr<PhysicalOperator>
 		D_ASSERT(cond.left->return_type == cond.right->return_type);
 		join_key_types.push_back(cond.left->return_type);
 	}
-
-	children.push_back(move(left));
-	children.push_back(move(right));
 }
 
 //===--------------------------------------------------------------------===//
@@ -59365,193 +59466,19 @@ PhysicalIEJoin::PhysicalIEJoin(LogicalOperator &op, unique_ptr<PhysicalOperator>
 //===--------------------------------------------------------------------===//
 class IEJoinLocalState : public LocalSinkState {
 public:
-	explicit IEJoinLocalState(const vector<JoinCondition> &conditions, const idx_t child) : has_null(0), count(0) {
-		// Initialize order clause expression executor and key DataChunk
-		vector<LogicalType> types;
-		for (const auto &cond : conditions) {
-			comparisons.emplace_back(cond.comparison);
+	using LocalSortedTable = PhysicalRangeJoin::LocalSortedTable;
 
-			const auto &expr = child ? cond.right : cond.left;
-			executor.AddExpression(*expr);
-
-			types.push_back(expr->return_type);
-		}
-		keys.Initialize(types);
+	IEJoinLocalState(const PhysicalRangeJoin &op, const idx_t child) : table(op, child) {
 	}
 
 	//! The local sort state
-	LocalSortState local_sort_state;
-	//! Local copy of the sorting expression executor
-	ExpressionExecutor executor;
-	//! Holds a vector of incoming sorting columns
-	DataChunk keys;
-	//! The comparison list (for null merging)
-	vector<ExpressionType> comparisons;
-	//! The number of NULL values
-	idx_t has_null;
-	//! The total number of rows
-	idx_t count;
-
-	idx_t MergeKeyNulls();
-
-	void Sink(DataChunk &input, GlobalSortState &global_sort_state) {
-		// Initialize local state (if necessary)
-		if (!local_sort_state.initialized) {
-			local_sort_state.Initialize(global_sort_state, global_sort_state.buffer_manager);
-		}
-
-		// Obtain sorting columns
-		keys.Reset();
-		executor.Execute(input, keys);
-
-		// Count the NULLs so we can exclude them later
-		has_null += MergeKeyNulls();
-		count += keys.size();
-
-		// Sink the data into the local sort state
-		D_ASSERT(keys.ColumnCount() > 1);
-		//	Only sort the primary key
-		DataChunk join_head;
-		join_head.data.emplace_back(Vector(keys.data[0]));
-		join_head.SetCardinality(keys.size());
-
-		local_sort_state.SinkChunk(join_head, input);
-	}
-
-	void Sort(GlobalSortState &gss) {
-		local_sort_state.Sort(gss, true);
-	}
-	void Reset() {
-		has_null = 0;
-		count = 0;
-	}
+	LocalSortedTable table;
 };
 
-idx_t IEJoinLocalState::MergeKeyNulls() {
-	// Merge the validity masks of the comparison keys into the primary
-	// Return the number of NULLs in the resulting chunk
-	D_ASSERT(keys.ColumnCount() > 0);
-	const auto count = keys.size();
-
-	size_t all_constant = 0;
-	for (auto &v : keys.data) {
-		all_constant += int(v.GetVectorType() == VectorType::CONSTANT_VECTOR);
-	}
-
-	auto &primary = keys.data[0];
-	if (all_constant == keys.data.size()) {
-		//	Either all NULL or no NULLs
-		for (auto &v : keys.data) {
-			if (ConstantVector::IsNull(v)) {
-				ConstantVector::SetNull(primary, true);
-				return count;
-			}
-		}
-		return 0;
-	} else if (keys.ColumnCount() > 1) {
-		//	Normalify the primary, as it will need to merge arbitrary validity masks
-		primary.Normalify(count);
-		auto &pvalidity = FlatVector::Validity(primary);
-		D_ASSERT(keys.ColumnCount() == comparisons.size());
-		for (size_t c = 1; c < keys.data.size(); ++c) {
-			// Skip comparisons that accept NULLs
-			if (comparisons[c] == ExpressionType::COMPARE_DISTINCT_FROM) {
-				continue;
-			}
-			//	Orrify the rest, as the sort code will do this anyway.
-			auto &v = keys.data[c];
-			VectorData vdata;
-			v.Orrify(count, vdata);
-			auto &vvalidity = vdata.validity;
-			if (vvalidity.AllValid()) {
-				continue;
-			}
-			pvalidity.EnsureWritable();
-			auto pmask = pvalidity.GetData();
-			if (v.GetVectorType() == VectorType::FLAT_VECTOR) {
-				//	Merge entire entries
-				const auto entry_count = pvalidity.EntryCount(count);
-				for (idx_t entry_idx = 0; entry_idx < entry_count; ++entry_idx) {
-					pmask[entry_idx] &= vvalidity.GetValidityEntry(entry_idx);
-				}
-			}
-		}
-		return count - pvalidity.CountValid(count);
-	} else {
-		return count - VectorOperations::CountNotNull(primary, count);
-	}
-}
-
-class IEJoinSortedTable {
+class IEJoinGlobalState : public GlobalSinkState {
 public:
-	IEJoinSortedTable(ClientContext &context, const vector<BoundOrderByNode> &orders, RowLayout &payload_layout)
-	    : global_sort_state(BufferManager::GetBufferManager(context), orders, payload_layout), has_null(0), count(0),
-	      memory_per_thread(0) {
-		D_ASSERT(orders.size() == 1);
-
-		// Set external (can be force with the PRAGMA)
-		auto &config = ClientConfig::GetConfig(context);
-		global_sort_state.external = config.force_external;
-		// Memory usage per thread should scale with max mem / num threads
-		// We take 1/4th of this, to be conservative
-		idx_t max_memory = global_sort_state.buffer_manager.GetMaxMemory();
-		idx_t num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
-		memory_per_thread = (max_memory / num_threads) / 4;
-	}
-
-	inline idx_t Count() const {
-		return count;
-	}
-
-	inline idx_t BlockCount() const {
-		if (global_sort_state.sorted_blocks.empty()) {
-			return 0;
-		}
-		D_ASSERT(global_sort_state.sorted_blocks.size() == 1);
-		return global_sort_state.sorted_blocks[0]->radix_sorting_data.size();
-	}
+	using GlobalSortedTable = PhysicalRangeJoin::GlobalSortedTable;
 
-	inline idx_t BlockSize(idx_t i) const {
-		return global_sort_state.sorted_blocks[0]->radix_sorting_data[i].count;
-	}
-
-	inline void Combine(IEJoinLocalState &lstate) {
-		global_sort_state.AddLocalState(lstate.local_sort_state);
-		has_null += lstate.has_null;
-		count += lstate.count;
-	}
-
-	inline void IntializeMatches() {
-		found_match = unique_ptr<bool[]>(new bool[Count()]);
-		memset(found_match.get(), 0, sizeof(bool) * Count());
-	}
-
-	void Print() {
-		PayloadScanner scanner(global_sort_state, false);
-		DataChunk chunk;
-		chunk.Initialize(scanner.GetPayloadTypes());
-		for (;;) {
-			scanner.Scan(chunk);
-			const auto count = chunk.size();
-			if (!count) {
-				break;
-			}
-			chunk.Print();
-		}
-	}
-
-	GlobalSortState global_sort_state;
-	//! Whether or not the RHS has NULL values
-	atomic<idx_t> has_null;
-	//! The total number of rows in the RHS
-	atomic<idx_t> count;
-	//! A bool indicating for each tuple in the RHS if they found a match (only used in FULL OUTER JOIN)
-	unique_ptr<bool[]> found_match;
-	//! Memory usage per thread
-	idx_t memory_per_thread;
-};
-
-class IEJoinGlobalState : public GlobalSinkState {
 public:
 	IEJoinGlobalState(ClientContext &context, const PhysicalIEJoin &op) : child(0) {
 		tables.resize(2);
@@ -59559,13 +59486,13 @@ public:
 		lhs_layout.Initialize(op.children[0]->types);
 		vector<BoundOrderByNode> lhs_order;
 		lhs_order.emplace_back(op.lhs_orders[0][0].Copy());
-		tables[0] = make_unique<IEJoinSortedTable>(context, lhs_order, lhs_layout);
+		tables[0] = make_unique<GlobalSortedTable>(context, lhs_order, lhs_layout);
 
 		RowLayout rhs_layout;
 		rhs_layout.Initialize(op.children[1]->types);
 		vector<BoundOrderByNode> rhs_order;
 		rhs_order.emplace_back(op.rhs_orders[0][0].Copy());
-		tables[1] = make_unique<IEJoinSortedTable>(context, rhs_order, rhs_layout);
+		tables[1] = make_unique<GlobalSortedTable>(context, rhs_order, rhs_layout);
 	}
 
 	IEJoinGlobalState(IEJoinGlobalState &prev)
@@ -59575,10 +59502,10 @@ public:
 	void Sink(DataChunk &input, IEJoinLocalState &lstate) {
 		auto &table = *tables[child];
 		auto &global_sort_state = table.global_sort_state;
-		auto &local_sort_state = lstate.local_sort_state;
+		auto &local_sort_state = lstate.table.local_sort_state;
 
 		// Sink the data into the local sort state
-		lstate.Sink(input, global_sort_state);
+		lstate.table.Sink(input, global_sort_state);
 
 		// When sorting data reaches a certain size, we sort it
 		if (local_sort_state.SizeInBytes() >= table.memory_per_thread) {
@@ -59586,7 +59513,7 @@ public:
 		}
 	}
 
-	vector<unique_ptr<IEJoinSortedTable>> tables;
+	vector<unique_ptr<GlobalSortedTable>> tables;
 	size_t child;
 };
 
@@ -59601,7 +59528,7 @@ unique_ptr<LocalSinkState> PhysicalIEJoin::GetLocalSinkState(ExecutionContext &c
 		const auto &ie_sink = (IEJoinGlobalState &)*sink_state;
 		sink_child = ie_sink.child;
 	}
-	return make_unique<IEJoinLocalState>(conditions, sink_child);
+	return make_unique<IEJoinLocalState>(*this, sink_child);
 }
 
 SinkResultType PhysicalIEJoin::Sink(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p,
@@ -59617,80 +59544,16 @@ SinkResultType PhysicalIEJoin::Sink(ExecutionContext &context, GlobalSinkState &
 void PhysicalIEJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate_p, LocalSinkState &lstate_p) const {
 	auto &gstate = (IEJoinGlobalState &)gstate_p;
 	auto &lstate = (IEJoinLocalState &)lstate_p;
-	gstate.tables[gstate.child]->Combine(lstate);
+	gstate.tables[gstate.child]->Combine(lstate.table);
 	auto &client_profiler = QueryProfiler::Get(context.client);
 
-	context.thread.profiler.Flush(this, &lstate.executor, gstate.child ? "rhs_executor" : "lhs_executor", 1);
+	context.thread.profiler.Flush(this, &lstate.table.executor, gstate.child ? "rhs_executor" : "lhs_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
 }
 
 //===--------------------------------------------------------------------===//
 // Finalize
 //===--------------------------------------------------------------------===//
-class IEJoinFinalizeTask : public ExecutorTask {
-public:
-	IEJoinFinalizeTask(shared_ptr<Event> event_p, ClientContext &context, IEJoinSortedTable &table)
-	    : ExecutorTask(context), event(move(event_p)), context(context), table(table) {
-	}
-
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		// Initialize iejoin sorted and iterate until done
-		auto &global_sort_state = table.global_sort_state;
-		MergeSorter merge_sorter(global_sort_state, BufferManager::GetBufferManager(context));
-		merge_sorter.PerformInMergeRound();
-		event->FinishTask();
-
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-
-private:
-	shared_ptr<Event> event;
-	ClientContext &context;
-	IEJoinSortedTable &table;
-};
-
-class IEJoinFinalizeEvent : public Event {
-public:
-	IEJoinFinalizeEvent(IEJoinSortedTable &table_p, Pipeline &pipeline_p)
-	    : Event(pipeline_p.executor), table(table_p), pipeline(pipeline_p) {
-	}
-
-	IEJoinSortedTable &table;
-	Pipeline &pipeline;
-
-public:
-	void Schedule() override {
-		auto &context = pipeline.GetClientContext();
-
-		// Schedule tasks equal to the number of threads, which will each iejoin multiple partitions
-		auto &ts = TaskScheduler::GetScheduler(context);
-		idx_t num_threads = ts.NumberOfThreads();
-
-		vector<unique_ptr<Task>> iejoin_tasks;
-		for (idx_t tnum = 0; tnum < num_threads; tnum++) {
-			iejoin_tasks.push_back(make_unique<IEJoinFinalizeTask>(shared_from_this(), context, table));
-		}
-		SetTasks(move(iejoin_tasks));
-	}
-
-	void FinishEvent() override {
-		auto &global_sort_state = table.global_sort_state;
-
-		global_sort_state.CompleteMergeRound(true);
-		if (global_sort_state.sorted_blocks.size() > 1) {
-			// Multiple blocks remaining: Schedule the next round
-			PhysicalIEJoin::ScheduleMergeTasks(pipeline, *this, table);
-		}
-	}
-};
-
-void PhysicalIEJoin::ScheduleMergeTasks(Pipeline &pipeline, Event &event, IEJoinSortedTable &table) {
-	// Initialize global sort state for a round of merging
-	table.global_sort_state.InitializeMergeRound();
-	auto new_event = make_shared<IEJoinFinalizeEvent>(table, pipeline);
-	event.InsertEvent(move(new_event));
-}
-
 SinkFinalizeType PhysicalIEJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                           GlobalSinkState &gstate_p) const {
 	auto &gstate = (IEJoinGlobalState &)gstate_p;
@@ -59706,14 +59569,10 @@ SinkFinalizeType PhysicalIEJoin::Finalize(Pipeline &pipeline, Event &event, Clie
 		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
 	}
 
-	// Prepare for child sort phase
-	global_sort_state.PrepareMergePhase();
-
-	// Start the iejoin phase or finish if a iejoin is not necessary
-	if (global_sort_state.sorted_blocks.size() > 1) {
-		PhysicalIEJoin::ScheduleMergeTasks(pipeline, event, table);
-	}
+	// Sort the current input child
+	table.Finalize(pipeline, event);
 
+	// Move to the next input child
 	++gstate.child;
 
 	return SinkFinalizeType::READY;
@@ -59722,6 +59581,14 @@ SinkFinalizeType PhysicalIEJoin::Finalize(Pipeline &pipeline, Event &event, Clie
 //===--------------------------------------------------------------------===//
 // Operator
 //===--------------------------------------------------------------------===//
+OperatorResultType PhysicalIEJoin::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
+                                           GlobalOperatorState &gstate, OperatorState &state) const {
+	return OperatorResultType::FINISHED;
+}
+
+//===--------------------------------------------------------------------===//
+// Source
+//===--------------------------------------------------------------------===//
 struct SBIterator {
 	static int ComparisonValue(ExpressionType comparison) {
 		switch (comparison) {
@@ -59821,7 +59688,7 @@ struct SBIterator {
 };
 
 struct IEJoinUnion {
-	using SortedTable = IEJoinSortedTable;
+	using SortedTable = PhysicalRangeJoin::GlobalSortedTable;
 
 	static idx_t AppendKey(SortedTable &table, ExpressionExecutor &executor, SortedTable &marked, int64_t increment,
 	                       int64_t base, const idx_t block_idx);
@@ -60262,61 +60129,11 @@ idx_t IEJoinUnion::JoinComplexBlocks(SelectionVector &lsel, SelectionVector &rse
 
 class IEJoinState : public OperatorState {
 public:
-	explicit IEJoinState(const PhysicalIEJoin &op) : local_left(op.conditions, 0) {};
+	explicit IEJoinState(const PhysicalIEJoin &op) : local_left(op, 0) {};
 
 	IEJoinLocalState local_left;
 };
 
-static void SliceSortedPayload(DataChunk &payload, GlobalSortState &state, const idx_t block_idx,
-                               const SelectionVector &result, const idx_t result_count, const idx_t left_cols = 0) {
-	// There should only be one sorted block if they have been sorted
-	D_ASSERT(state.sorted_blocks.size() == 1);
-	SBScanState read_state(state.buffer_manager, state);
-	read_state.sb = state.sorted_blocks[0].get();
-	auto &sorted_data = *read_state.sb->payload_data;
-
-	read_state.SetIndices(block_idx, 0);
-	read_state.PinData(sorted_data);
-	const auto data_ptr = read_state.DataPtr(sorted_data);
-
-	// Set up a batch of pointers to scan data from
-	Vector addresses(LogicalType::POINTER, result_count);
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-
-	// Set up the data pointers for the values that are actually referenced
-	const idx_t &row_width = sorted_data.layout.GetRowWidth();
-
-	auto prev_idx = result.get_index(0);
-	SelectionVector gsel(result_count);
-	idx_t addr_count = 0;
-	gsel.set_index(0, addr_count);
-	data_pointers[addr_count] = data_ptr + prev_idx * row_width;
-	for (idx_t i = 1; i < result_count; ++i) {
-		const auto row_idx = result.get_index(i);
-		if (row_idx != prev_idx) {
-			data_pointers[++addr_count] = data_ptr + row_idx * row_width;
-			prev_idx = row_idx;
-		}
-		gsel.set_index(i, addr_count);
-	}
-	++addr_count;
-
-	// Unswizzle the offsets back to pointers (if needed)
-	if (!sorted_data.layout.AllConstant() && state.external) {
-		RowOperations::UnswizzlePointers(sorted_data.layout, data_ptr, read_state.payload_heap_handle->Ptr(),
-		                                 addr_count);
-	}
-
-	// Deserialize the payload data
-	auto sel = FlatVector::IncrementalSelectionVector();
-	for (idx_t col_idx = 0; col_idx < sorted_data.layout.ColumnCount(); col_idx++) {
-		const auto col_offset = sorted_data.layout.GetOffsets()[col_idx];
-		auto &col = payload.data[left_cols + col_idx];
-		RowOperations::Gather(addresses, *sel, col, *sel, addr_count, col_offset, col_idx);
-		col.Slice(gsel, result_count);
-	}
-}
-
 class IEJoinLocalSourceState : public LocalSourceState {
 public:
 	explicit IEJoinLocalSourceState(const PhysicalIEJoin &op)
@@ -60342,9 +60159,6 @@ public:
 		right_keys.Initialize(right_types);
 	}
 
-	idx_t SelectJoinTail(const ExpressionType &condition, Vector &left, Vector &right, const SelectionVector *sel,
-	                     idx_t count);
-
 	idx_t SelectOuterRows(bool *matches) {
 		idx_t count = 0;
 		for (; outer_idx < outer_count; ++outer_idx) {
@@ -60386,30 +60200,6 @@ public:
 	bool *right_matches;
 };
 
-idx_t IEJoinLocalSourceState::SelectJoinTail(const ExpressionType &condition, Vector &left, Vector &right,
-                                             const SelectionVector *sel, idx_t count) {
-	switch (condition) {
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return VectorOperations::NotEquals(left, right, sel, count, &true_sel, nullptr);
-	case ExpressionType::COMPARE_LESSTHAN:
-		return VectorOperations::LessThan(left, right, sel, count, &true_sel, nullptr);
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return VectorOperations::GreaterThan(left, right, sel, count, &true_sel, nullptr);
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return VectorOperations::LessThanEquals(left, right, sel, count, &true_sel, nullptr);
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return VectorOperations::GreaterThanEquals(left, right, sel, count, &true_sel, nullptr);
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return VectorOperations::DistinctFrom(left, right, sel, count, &true_sel, nullptr);
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-	case ExpressionType::COMPARE_EQUAL:
-	default:
-		throw InternalException("Unsupported comparison type for PhysicalIEJoin");
-	}
-
-	return count;
-}
-
 void PhysicalIEJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &chunk, LocalSourceState &state_p) const {
 	auto &state = (IEJoinLocalSourceState &)state_p;
 	auto &ie_sink = (IEJoinGlobalState &)*sink_state;
@@ -60446,6 +60236,7 @@ void PhysicalIEJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &ch
 			state.right_executor.SetChunk(right_chunk);
 
 			auto tail_count = result_count;
+			auto true_sel = &state.true_sel;
 			for (size_t cmp_idx = 0; cmp_idx < tail_cols; ++cmp_idx) {
 				auto &left = state.left_keys.data[cmp_idx];
 				state.left_executor.ExecuteExpression(cmp_idx, left);
@@ -60457,8 +60248,8 @@ void PhysicalIEJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &ch
 					left.Slice(*sel, tail_count);
 					right.Slice(*sel, tail_count);
 				}
-				tail_count = state.SelectJoinTail(conditions[cmp_idx + 2].comparison, left, right, sel, tail_count);
-				sel = &state.true_sel;
+				tail_count = SelectJoinTail(conditions[cmp_idx + 2].comparison, left, right, sel, tail_count, true_sel);
+				sel = true_sel;
 			}
 			chunk.Fuse(right_chunk);
 
@@ -60483,14 +60274,6 @@ void PhysicalIEJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &ch
 	} while (chunk.size() == 0);
 }
 
-OperatorResultType PhysicalIEJoin::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                           GlobalOperatorState &gstate, OperatorState &state) const {
-	return OperatorResultType::FINISHED;
-}
-
-//===--------------------------------------------------------------------===//
-// Source
-//===--------------------------------------------------------------------===//
 class IEJoinGlobalSourceState : public GlobalSourceState {
 public:
 	explicit IEJoinGlobalSourceState(const PhysicalIEJoin &op)
@@ -61631,7 +61414,7 @@ class MergeJoinGlobalState;
 
 //! PhysicalPiecewiseMergeJoin represents a piecewise merge loop join between
 //! two tables
-class PhysicalPiecewiseMergeJoin : public PhysicalComparisonJoin {
+class PhysicalPiecewiseMergeJoin : public PhysicalRangeJoin {
 public:
 	PhysicalPiecewiseMergeJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
 	                           unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
@@ -61678,9 +61461,6 @@ public:
 	SinkFinalizeType Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
 	                          GlobalSinkState &gstate) const override;
 
-	//! Schedules tasks to merge sort the RHS data during the Finalize phase
-	static void ScheduleMergeTasks(Pipeline &pipeline, Event &event, MergeJoinGlobalState &state);
-
 	bool IsSink() const override {
 		return true;
 	}
@@ -61715,29 +61495,8 @@ namespace duckdb {
 PhysicalPiecewiseMergeJoin::PhysicalPiecewiseMergeJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
                                                        unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond,
                                                        JoinType join_type, idx_t estimated_cardinality)
-    : PhysicalComparisonJoin(op, PhysicalOperatorType::PIECEWISE_MERGE_JOIN, move(cond), join_type,
-                             estimated_cardinality) {
-	// Reorder the conditions so that ranges are at the front.
-	// TODO: use stats to improve the choice?
-	if (conditions.size() > 1) {
-		auto conditions_p = std::move(conditions);
-		conditions.resize(conditions_p.size());
-		idx_t range_position = 0;
-		idx_t other_position = conditions_p.size();
-		for (idx_t i = 0; i < conditions_p.size(); ++i) {
-			switch (conditions_p[i].comparison) {
-			case ExpressionType::COMPARE_LESSTHAN:
-			case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			case ExpressionType::COMPARE_GREATERTHAN:
-			case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-				conditions[range_position++] = std::move(conditions_p[i]);
-				break;
-			default:
-				conditions[--other_position] = std::move(conditions_p[i]);
-				break;
-			}
-		}
-	}
+    : PhysicalRangeJoin(op, PhysicalOperatorType::PIECEWISE_MERGE_JOIN, move(left), move(right), move(cond), join_type,
+                        estimated_cardinality) {
 
 	for (auto &cond : conditions) {
 		D_ASSERT(cond.left->return_type == cond.right->return_type);
@@ -61770,172 +61529,60 @@ PhysicalPiecewiseMergeJoin::PhysicalPiecewiseMergeJoin(LogicalOperator &op, uniq
 			throw NotImplementedException("Unimplemented join type for merge join");
 		}
 	}
-	children.push_back(move(left));
-	children.push_back(move(right));
 }
 
 //===--------------------------------------------------------------------===//
 // Sink
 //===--------------------------------------------------------------------===//
-class MergeJoinGlobalState : public GlobalSinkState {
+class MergeJoinLocalState : public LocalSinkState {
 public:
-	MergeJoinGlobalState(BufferManager &buffer_manager, const vector<BoundOrderByNode> &orders, RowLayout &rhs_layout)
-	    : rhs_global_sort_state(buffer_manager, orders, rhs_layout), rhs_has_null(0), rhs_count(0),
-	      memory_per_thread(0) {
-		D_ASSERT(orders.size() == 1);
-	}
-
-	inline idx_t Count() const {
-		return rhs_count;
+	explicit MergeJoinLocalState(const PhysicalRangeJoin &op, const idx_t child) : table(op, child) {
 	}
 
-	//! The lock for updating the global state
-	mutex lock;
-	//! Global sort state
-	GlobalSortState rhs_global_sort_state;
-	//! Whether or not the RHS has NULL values
-	idx_t rhs_has_null;
-	//! The total number of rows in the RHS
-	idx_t rhs_count;
-	//! A bool indicating for each tuple in the RHS if they found a match (only used in FULL OUTER JOIN)
-	unique_ptr<bool[]> rhs_found_match;
-	//! Memory usage per thread
-	idx_t memory_per_thread;
+	//! The local sort state
+	PhysicalRangeJoin::LocalSortedTable table;
 };
 
-unique_ptr<GlobalSinkState> PhysicalPiecewiseMergeJoin::GetGlobalSinkState(ClientContext &context) const {
-	// Get the payload layout from the rhs types and tail predicates
-	RowLayout rhs_layout;
-	rhs_layout.Initialize(children[1]->types);
-	vector<BoundOrderByNode> rhs_order;
-	rhs_order.emplace_back(rhs_orders[0].Copy());
-	auto state = make_unique<MergeJoinGlobalState>(BufferManager::GetBufferManager(context), rhs_order, rhs_layout);
-	// Set external (can be force with the PRAGMA)
-	auto &config = ClientConfig::GetConfig(context);
-	state->rhs_global_sort_state.external = config.force_external;
-	// Memory usage per thread should scale with max mem / num threads
-	// We take 1/4th of this, to be conservative
-	idx_t max_memory = BufferManager::GetBufferManager(context).GetMaxMemory();
-	idx_t num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
-	state->memory_per_thread = (max_memory / num_threads) / 4;
-	return move(state);
-}
+class MergeJoinGlobalState : public GlobalSinkState {
+public:
+	using GlobalSortedTable = PhysicalRangeJoin::GlobalSortedTable;
 
-class MergeJoinLocalState : public LocalSinkState {
 public:
-	explicit MergeJoinLocalState() : rhs_has_null(0), rhs_count(0) {
+	MergeJoinGlobalState(ClientContext &context, const PhysicalPiecewiseMergeJoin &op) {
+		RowLayout rhs_layout;
+		rhs_layout.Initialize(op.children[1]->types);
+		vector<BoundOrderByNode> rhs_order;
+		rhs_order.emplace_back(op.rhs_orders[0].Copy());
+		table = make_unique<GlobalSortedTable>(context, rhs_order, rhs_layout);
 	}
 
-	//! The local sort state
-	LocalSortState rhs_local_sort_state;
-	//! Local copy of the sorting expression executor
-	ExpressionExecutor rhs_executor;
-	//! Holds a vector of incoming sorting columns
-	DataChunk rhs_keys;
-	//! Whether or not the RHS has NULL values
-	idx_t rhs_has_null;
-	//! The total number of rows in the RHS
-	idx_t rhs_count;
-};
-
-unique_ptr<LocalSinkState> PhysicalPiecewiseMergeJoin::GetLocalSinkState(ExecutionContext &context) const {
-	auto result = make_unique<MergeJoinLocalState>();
-	// Initialize order clause expression executor and DataChunk
-	vector<LogicalType> types;
-	for (auto &order : rhs_orders) {
-		types.push_back(order.expression->return_type);
-		result->rhs_executor.AddExpression(*order.expression);
+	inline idx_t Count() const {
+		return table->count;
 	}
-	result->rhs_keys.Initialize(types);
-	return move(result);
-}
 
-static idx_t PiecewiseMergeNulls(DataChunk &keys, const vector<JoinCondition> &conditions) {
-	// Merge the validity masks of the comparison keys into the primary
-	// Return the number of NULLs in the resulting chunk
-	D_ASSERT(keys.ColumnCount() > 0);
-	const auto count = keys.size();
+	void Sink(DataChunk &input, MergeJoinLocalState &lstate) {
+		auto &global_sort_state = table->global_sort_state;
+		auto &local_sort_state = lstate.table.local_sort_state;
 
-	size_t all_constant = 0;
-	for (auto &v : keys.data) {
-		if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
-			++all_constant;
-		}
-	}
+		// Sink the data into the local sort state
+		lstate.table.Sink(input, global_sort_state);
 
-	auto &primary = keys.data[0];
-	if (all_constant == keys.data.size()) {
-		//	Either all NULL or no NULLs
-		for (auto &v : keys.data) {
-			if (ConstantVector::IsNull(v)) {
-				ConstantVector::SetNull(primary, true);
-				return count;
-			}
-		}
-		return 0;
-	} else if (keys.ColumnCount() > 1) {
-		//	Normalify the primary, as it will need to merge arbitrary validity masks
-		primary.Normalify(count);
-		auto &pvalidity = FlatVector::Validity(primary);
-		for (size_t c = 1; c < keys.data.size(); ++c) {
-			// Skip comparisons that accept NULLs
-			if (conditions[c].comparison == ExpressionType::COMPARE_DISTINCT_FROM) {
-				continue;
-			}
-			//	Orrify the rest, as the sort code will do this anyway.
-			auto &v = keys.data[c];
-			VectorData vdata;
-			v.Orrify(count, vdata);
-			auto &vvalidity = vdata.validity;
-			if (vvalidity.AllValid()) {
-				continue;
-			}
-			pvalidity.EnsureWritable();
-			switch (v.GetVectorType()) {
-			case VectorType::FLAT_VECTOR: {
-				// Merge entire entries
-				auto pmask = pvalidity.GetData();
-				const auto entry_count = pvalidity.EntryCount(count);
-				for (idx_t entry_idx = 0; entry_idx < entry_count; ++entry_idx) {
-					pmask[entry_idx] &= vvalidity.GetValidityEntry(entry_idx);
-				}
-				break;
-			}
-			case VectorType::CONSTANT_VECTOR:
-				// All or nothing
-				if (ConstantVector::IsNull(v)) {
-					pvalidity.SetAllInvalid(count);
-					return count;
-				}
-				break;
-			default:
-				// One by one
-				for (idx_t i = 0; i < count; ++i) {
-					const auto idx = vdata.sel->get_index(i);
-					if (!vvalidity.RowIsValidUnsafe(idx)) {
-						pvalidity.SetInvalidUnsafe(i);
-					}
-				}
-				break;
-			}
+		// When sorting data reaches a certain size, we sort it
+		if (local_sort_state.SizeInBytes() >= table->memory_per_thread) {
+			local_sort_state.Sort(global_sort_state, true);
 		}
-		return count - pvalidity.CountValid(count);
-	} else {
-		return count - VectorOperations::CountNotNull(primary, count);
 	}
-}
 
-static inline void SinkPiecewiseMergeChunk(LocalSortState &sort_state, DataChunk &join_keys, DataChunk &input) {
-	if (join_keys.ColumnCount() > 1) {
-		//	Only sort the first key
-		DataChunk join_head;
-		join_head.data.emplace_back(Vector(join_keys.data[0]));
-		join_head.SetCardinality(join_keys.size());
+	unique_ptr<GlobalSortedTable> table;
+};
 
-		sort_state.SinkChunk(join_head, input);
-	} else {
-		sort_state.SinkChunk(join_keys, input);
-	}
+unique_ptr<GlobalSinkState> PhysicalPiecewiseMergeJoin::GetGlobalSinkState(ClientContext &context) const {
+	return make_unique<MergeJoinGlobalState>(context, *this);
+}
+
+unique_ptr<LocalSinkState> PhysicalPiecewiseMergeJoin::GetLocalSinkState(ExecutionContext &context) const {
+	// We only sink the RHS
+	return make_unique<MergeJoinLocalState>(*this, 1);
 }
 
 SinkResultType PhysicalPiecewiseMergeJoin::Sink(ExecutionContext &context, GlobalSinkState &gstate_p,
@@ -61943,30 +61590,8 @@ SinkResultType PhysicalPiecewiseMergeJoin::Sink(ExecutionContext &context, Globa
 	auto &gstate = (MergeJoinGlobalState &)gstate_p;
 	auto &lstate = (MergeJoinLocalState &)lstate_p;
 
-	auto &global_sort_state = gstate.rhs_global_sort_state;
-	auto &local_sort_state = lstate.rhs_local_sort_state;
-
-	// Initialize local state (if necessary)
-	if (!local_sort_state.initialized) {
-		local_sort_state.Initialize(global_sort_state, BufferManager::GetBufferManager(context.client));
-	}
-
-	// Obtain sorting columns
-	auto &join_keys = lstate.rhs_keys;
-	join_keys.Reset();
-	lstate.rhs_executor.Execute(input, join_keys);
-
-	// Count the NULLs so we can exclude them later
-	lstate.rhs_has_null += PiecewiseMergeNulls(join_keys, conditions);
-	lstate.rhs_count += join_keys.size();
-
-	// Sink the data into the local sort state
-	SinkPiecewiseMergeChunk(local_sort_state, join_keys, input);
+	gstate.Sink(input, lstate);
 
-	// When sorting data reaches a certain size, we sort it
-	if (local_sort_state.SizeInBytes() >= gstate.memory_per_thread) {
-		local_sort_state.Sort(global_sort_state, true);
-	}
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -61974,105 +61599,33 @@ void PhysicalPiecewiseMergeJoin::Combine(ExecutionContext &context, GlobalSinkSt
                                          LocalSinkState &lstate_p) const {
 	auto &gstate = (MergeJoinGlobalState &)gstate_p;
 	auto &lstate = (MergeJoinLocalState &)lstate_p;
-	gstate.rhs_global_sort_state.AddLocalState(lstate.rhs_local_sort_state);
-	lock_guard<mutex> locked(gstate.lock);
-	gstate.rhs_has_null += lstate.rhs_has_null;
-	gstate.rhs_count += lstate.rhs_count;
+	gstate.table->Combine(lstate.table);
 	auto &client_profiler = QueryProfiler::Get(context.client);
 
-	context.thread.profiler.Flush(this, &lstate.rhs_executor, "rhs_executor", 1);
+	context.thread.profiler.Flush(this, &lstate.table.executor, "rhs_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
 }
 
 //===--------------------------------------------------------------------===//
 // Finalize
 //===--------------------------------------------------------------------===//
-class MergeJoinFinalizeTask : public ExecutorTask {
-public:
-	MergeJoinFinalizeTask(shared_ptr<Event> event_p, ClientContext &context, MergeJoinGlobalState &state)
-	    : ExecutorTask(context), event(move(event_p)), context(context), state(state) {
-	}
-
-	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
-		// Initialize merge sorted and iterate until done
-		auto &global_sort_state = state.rhs_global_sort_state;
-		MergeSorter merge_sorter(global_sort_state, BufferManager::GetBufferManager(context));
-		merge_sorter.PerformInMergeRound();
-		event->FinishTask();
-
-		return TaskExecutionResult::TASK_FINISHED;
-	}
-
-private:
-	shared_ptr<Event> event;
-	ClientContext &context;
-	MergeJoinGlobalState &state;
-};
-
-class MergeJoinFinalizeEvent : public Event {
-public:
-	MergeJoinFinalizeEvent(MergeJoinGlobalState &gstate_p, Pipeline &pipeline_p)
-	    : Event(pipeline_p.executor), gstate(gstate_p), pipeline(pipeline_p) {
-	}
-
-	MergeJoinGlobalState &gstate;
-	Pipeline &pipeline;
-
-public:
-	void Schedule() override {
-		auto &context = pipeline.GetClientContext();
-
-		// Schedule tasks equal to the number of threads, which will each merge multiple partitions
-		auto &ts = TaskScheduler::GetScheduler(context);
-		idx_t num_threads = ts.NumberOfThreads();
-
-		vector<unique_ptr<Task>> merge_tasks;
-		for (idx_t tnum = 0; tnum < num_threads; tnum++) {
-			merge_tasks.push_back(make_unique<MergeJoinFinalizeTask>(shared_from_this(), context, gstate));
-		}
-		SetTasks(move(merge_tasks));
-	}
-
-	void FinishEvent() override {
-		auto &global_sort_state = gstate.rhs_global_sort_state;
-
-		global_sort_state.CompleteMergeRound(true);
-		if (global_sort_state.sorted_blocks.size() > 1) {
-			// Multiple blocks remaining: Schedule the next round
-			PhysicalPiecewiseMergeJoin::ScheduleMergeTasks(pipeline, *this, gstate);
-		}
-	}
-};
-
-void PhysicalPiecewiseMergeJoin::ScheduleMergeTasks(Pipeline &pipeline, Event &event, MergeJoinGlobalState &gstate) {
-	// Initialize global sort state for a round of merging
-	gstate.rhs_global_sort_state.InitializeMergeRound();
-	auto new_event = make_shared<MergeJoinFinalizeEvent>(gstate, pipeline);
-	event.InsertEvent(move(new_event));
-}
-
 SinkFinalizeType PhysicalPiecewiseMergeJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                                       GlobalSinkState &gstate_p) const {
 	auto &gstate = (MergeJoinGlobalState &)gstate_p;
-	auto &global_sort_state = gstate.rhs_global_sort_state;
+	auto &global_sort_state = gstate.table->global_sort_state;
 
 	if (IsRightOuterJoin(join_type)) {
 		// for FULL/RIGHT OUTER JOIN, initialize found_match to false for every tuple
-		gstate.rhs_found_match = unique_ptr<bool[]>(new bool[gstate.Count()]);
-		memset(gstate.rhs_found_match.get(), 0, sizeof(bool) * gstate.Count());
+		gstate.table->IntializeMatches();
 	}
 	if (global_sort_state.sorted_blocks.empty() && EmptyResultIfRHSIsEmpty()) {
 		// Empty input!
 		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
 	}
 
-	// Prepare for merge sort phase
-	global_sort_state.PrepareMergePhase();
+	// Sort the current input child
+	gstate.table->Finalize(pipeline, event);
 
-	// Start the merge phase or finish if a merge is not necessary
-	if (global_sort_state.sorted_blocks.size() > 1) {
-		PhysicalPiecewiseMergeJoin::ScheduleMergeTasks(pipeline, event, gstate);
-	}
 	return SinkFinalizeType::READY;
 }
 
@@ -62081,16 +61634,16 @@ SinkFinalizeType PhysicalPiecewiseMergeJoin::Finalize(Pipeline &pipeline, Event
 //===--------------------------------------------------------------------===//
 class PiecewiseMergeJoinState : public OperatorState {
 public:
+	using LocalSortedTable = PhysicalRangeJoin::LocalSortedTable;
+
 	explicit PiecewiseMergeJoinState(const PhysicalPiecewiseMergeJoin &op, BufferManager &buffer_manager,
 	                                 bool force_external)
 	    : op(op), buffer_manager(buffer_manager), force_external(force_external), left_position(0), first_fetch(true),
 	      finished(true), right_position(0), right_chunk_index(0) {
 		vector<LogicalType> condition_types;
 		for (auto &order : op.lhs_orders) {
-			lhs_executor.AddExpression(*order.expression);
 			condition_types.push_back(order.expression->return_type);
 		}
-		lhs_keys.Initialize(condition_types);
 		if (IsLeftOuterJoin(op.join_type)) {
 			lhs_found_match = unique_ptr<bool[]>(new bool[STANDARD_VECTOR_SIZE]);
 			memset(lhs_found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
@@ -62115,16 +61668,12 @@ public:
 	bool force_external;
 
 	// Block sorting
-	DataChunk lhs_keys;
 	DataChunk lhs_payload;
-	ExpressionExecutor lhs_executor;
 	unique_ptr<bool[]> lhs_found_match;
 	vector<BoundOrderByNode> lhs_order;
 	RowLayout lhs_layout;
-	unique_ptr<LocalSortState> lhs_local_state;
+	unique_ptr<LocalSortedTable> lhs_local_table;
 	unique_ptr<GlobalSortState> lhs_global_state;
-	idx_t lhs_count;
-	idx_t lhs_has_null;
 
 	// Simple scans
 	idx_t left_position;
@@ -62144,23 +61693,14 @@ public:
 
 public:
 	void ResolveJoinKeys(DataChunk &input) {
-		// resolve the join keys for the input
-		lhs_keys.Reset();
-		lhs_executor.Execute(input, lhs_keys);
-
-		// Count the NULLs so we can exclude them later
-		lhs_count = lhs_keys.size();
-		lhs_has_null = PiecewiseMergeNulls(lhs_keys, op.conditions);
-
 		// sort by join key
 		lhs_global_state = make_unique<GlobalSortState>(buffer_manager, lhs_order, lhs_layout);
-		lhs_local_state = make_unique<LocalSortState>();
-		lhs_local_state->Initialize(*lhs_global_state, buffer_manager);
-		SinkPiecewiseMergeChunk(*lhs_local_state, lhs_keys, input);
+		lhs_local_table = make_unique<LocalSortedTable>(op, 0);
+		lhs_local_table->Sink(input, *lhs_global_state);
 
-		// Set external (can be force with the PRAGMA)
+		// Set external (can be forced with the PRAGMA)
 		lhs_global_state->external = force_external;
-		lhs_global_state->AddLocalState(*lhs_local_state);
+		lhs_global_state->AddLocalState(lhs_local_table->local_sort_state);
 		lhs_global_state->PrepareMergePhase();
 		while (lhs_global_state->sorted_blocks.size() > 1) {
 			MergeSorter merge_sorter(*lhs_global_state, buffer_manager);
@@ -62176,12 +61716,14 @@ public:
 		scanner.Scan(lhs_payload);
 
 		// Recompute the sorted keys from the sorted input
-		lhs_keys.Reset();
-		lhs_executor.Execute(lhs_payload, lhs_keys);
+		lhs_local_table->keys.Reset();
+		lhs_local_table->executor.Execute(lhs_payload, lhs_local_table->keys);
 	}
 
 	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
-		context.thread.profiler.Flush(op, &lhs_executor, "lhs_executor", 0);
+		if (lhs_local_table) {
+			context.thread.profiler.Flush(op, &lhs_local_table->executor, "lhs_executor", 0);
+		}
 	}
 };
 
@@ -62212,76 +61754,17 @@ struct BlockMergeInfo {
 	GlobalSortState &state;
 	//! The block being scanned
 	const idx_t block_idx;
-	//! The start position being read from the block
-	const idx_t base_idx;
 	//! The number of not-NULL values in the block (they are at the end)
 	const idx_t not_null;
 	//! The current offset in the block
 	idx_t &entry_idx;
 	SelectionVector result;
 
-	BlockMergeInfo(GlobalSortState &state, idx_t block_idx, idx_t base_idx, idx_t &entry_idx, idx_t not_null)
-	    : state(state), block_idx(block_idx), base_idx(base_idx), not_null(not_null), entry_idx(entry_idx),
-	      result(STANDARD_VECTOR_SIZE) {
+	BlockMergeInfo(GlobalSortState &state, idx_t block_idx, idx_t &entry_idx, idx_t not_null)
+	    : state(state), block_idx(block_idx), not_null(not_null), entry_idx(entry_idx), result(STANDARD_VECTOR_SIZE) {
 	}
 };
 
-static idx_t SliceSortedPayload(DataChunk &payload, BlockMergeInfo &info, const idx_t result_count,
-                                const idx_t left_cols = 0) {
-	// There should only be one sorted block if they have been sorted
-	D_ASSERT(info.state.sorted_blocks.size() == 1);
-	SBScanState read_state(info.state.buffer_manager, info.state);
-	read_state.sb = info.state.sorted_blocks[0].get();
-	auto &sorted_data = *read_state.sb->payload_data;
-
-	// We have to create pointers for the entire block
-	// because unswizzle works on ranges not selections.
-	const auto first_idx = info.result.get_index(0);
-	read_state.SetIndices(info.block_idx, info.base_idx + first_idx);
-	read_state.PinData(sorted_data);
-	const auto data_ptr = read_state.DataPtr(sorted_data);
-
-	// Set up a batch of pointers to scan data from
-	Vector addresses(LogicalType::POINTER, result_count);
-	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
-
-	// Set up the data pointers for the values that are actually referenced
-	// and normalise the selection vector to zero
-	data_ptr_t row_ptr = data_ptr;
-	const idx_t &row_width = sorted_data.layout.GetRowWidth();
-
-	auto prev_idx = first_idx;
-	info.result.set_index(0, 0);
-	idx_t addr_count = 0;
-	data_pointers[addr_count++] = row_ptr;
-	for (idx_t i = 1; i < result_count; ++i) {
-		const auto row_idx = info.result.get_index(i);
-		info.result.set_index(i, row_idx - first_idx);
-		if (row_idx == prev_idx) {
-			continue;
-		}
-		row_ptr += (row_idx - prev_idx) * row_width;
-		data_pointers[addr_count++] = row_ptr;
-		prev_idx = row_idx;
-	}
-	// Unswizzle the offsets back to pointers (if needed)
-	if (!sorted_data.layout.AllConstant() && info.state.external) {
-		const auto next = prev_idx + 1;
-		RowOperations::UnswizzlePointers(sorted_data.layout, data_ptr, read_state.payload_heap_handle->Ptr(), next);
-	}
-
-	// Deserialize the payload data
-	auto sel = FlatVector::IncrementalSelectionVector();
-	for (idx_t col_idx = 0; col_idx < sorted_data.layout.ColumnCount(); col_idx++) {
-		const auto col_offset = sorted_data.layout.GetOffsets()[col_idx];
-		auto &col = payload.data[left_cols + col_idx];
-		RowOperations::Gather(addresses, *sel, col, *sel, addr_count, col_offset, col_idx);
-		col.Slice(info.result, result_count);
-	}
-
-	return first_idx;
-}
-
 static void MergeJoinPinSortingBlock(SBScanState &scan, const idx_t block_idx) {
 	scan.SetIndices(block_idx, 0);
 	scan.PinRadix(block_idx);
@@ -62303,7 +61786,7 @@ static idx_t MergeJoinSimpleBlocks(PiecewiseMergeJoinState &lstate, MergeJoinGlo
 
 	// The sort parameters should all be the same
 	auto &lsort = *lstate.lhs_global_state;
-	auto &rsort = rstate.rhs_global_sort_state;
+	auto &rsort = rstate.table->global_sort_state;
 	D_ASSERT(lsort.sort_layout.all_constant == rsort.sort_layout.all_constant);
 	const auto all_constant = lsort.sort_layout.all_constant;
 	D_ASSERT(lsort.external == rsort.external);
@@ -62316,7 +61799,7 @@ static idx_t MergeJoinSimpleBlocks(PiecewiseMergeJoinState &lstate, MergeJoinGlo
 
 	const idx_t l_block_idx = 0;
 	idx_t l_entry_idx = 0;
-	const auto lhs_not_null = lstate.lhs_count - lstate.lhs_has_null;
+	const auto lhs_not_null = lstate.lhs_local_table->count - lstate.lhs_local_table->has_null;
 	MergeJoinPinSortingBlock(lread, l_block_idx);
 	auto l_ptr = MergeJoinRadixPtr(lread, l_entry_idx);
 
@@ -62335,7 +61818,8 @@ static idx_t MergeJoinSimpleBlocks(PiecewiseMergeJoinState &lstate, MergeJoinGlo
 		MergeJoinPinSortingBlock(rread, r_block_idx);
 
 		auto &rblock = rread.sb->radix_sorting_data[r_block_idx];
-		const auto r_not_null = SortedBlockNotNull(right_base, rblock.count, rstate.rhs_count - rstate.rhs_has_null);
+		const auto r_not_null =
+		    SortedBlockNotNull(right_base, rblock.count, rstate.table->count - rstate.table->has_null);
 		if (r_not_null == 0) {
 			break;
 		}
@@ -62381,6 +61865,7 @@ void PhysicalPiecewiseMergeJoin::ResolveSimpleJoin(ExecutionContext &context, Da
 	auto &gstate = (MergeJoinGlobalState &)*sink_state;
 
 	state.ResolveJoinKeys(input);
+	auto &lhs_table = *state.lhs_local_table;
 
 	// perform the actual join
 	bool found_match[STANDARD_VECTOR_SIZE];
@@ -62388,7 +61873,7 @@ void PhysicalPiecewiseMergeJoin::ResolveSimpleJoin(ExecutionContext &context, Da
 	MergeJoinSimpleBlocks(state, gstate, found_match, conditions[0].comparison);
 
 	// use the sorted payload
-	const auto lhs_not_null = state.lhs_count - state.lhs_has_null;
+	const auto lhs_not_null = lhs_table.count - lhs_table.has_null;
 	auto &payload = state.lhs_payload;
 
 	// now construct the result based on the join result
@@ -62396,19 +61881,19 @@ void PhysicalPiecewiseMergeJoin::ResolveSimpleJoin(ExecutionContext &context, Da
 	case JoinType::MARK: {
 		// The only part of the join keys that is actually used is the validity mask.
 		// Since the payload is sorted, we can just set the tail end of the validity masks to invalid.
-		for (auto &key : state.lhs_keys.data) {
-			key.Normalify(state.lhs_keys.size());
+		for (auto &key : lhs_table.keys.data) {
+			key.Normalify(lhs_table.keys.size());
 			auto &mask = FlatVector::Validity(key);
 			if (mask.AllValid()) {
 				continue;
 			}
 			mask.SetAllValid(lhs_not_null);
-			for (idx_t i = lhs_not_null; i < state.lhs_count; ++i) {
+			for (idx_t i = lhs_not_null; i < lhs_table.count; ++i) {
 				mask.SetInvalid(i);
 			}
 		}
 		// So we make a set of keys that have the validity mask set for the
-		PhysicalJoin::ConstructMarkJoinResult(state.lhs_keys, payload, chunk, found_match, gstate.rhs_has_null);
+		PhysicalJoin::ConstructMarkJoinResult(lhs_table.keys, payload, chunk, found_match, gstate.table->has_null);
 		break;
 	}
 	case JoinType::SEMI:
@@ -62468,8 +61953,8 @@ static idx_t MergeJoinComplexBlocks(BlockMergeInfo &l, BlockMergeInfo &r, const
 
 			if (comp_res <= cmp) {
 				// left side smaller: found match
-				l.result.set_index(result_count, sel_t(l.entry_idx - l.base_idx));
-				r.result.set_index(result_count, sel_t(r.entry_idx - r.base_idx));
+				l.result.set_index(result_count, sel_t(l.entry_idx));
+				r.result.set_index(result_count, sel_t(r.entry_idx));
 				result_count++;
 				// move left side forward
 				l.entry_idx++;
@@ -62496,35 +61981,11 @@ static idx_t MergeJoinComplexBlocks(BlockMergeInfo &l, BlockMergeInfo &r, const
 	return result_count;
 }
 
-static idx_t SelectJoinTail(const ExpressionType &condition, Vector &left, Vector &right, const SelectionVector *sel,
-                            idx_t count, SelectionVector *true_sel) {
-	switch (condition) {
-	case ExpressionType::COMPARE_NOTEQUAL:
-		return VectorOperations::NotEquals(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_LESSTHAN:
-		return VectorOperations::LessThan(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return VectorOperations::GreaterThan(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return VectorOperations::LessThanEquals(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return VectorOperations::GreaterThanEquals(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_DISTINCT_FROM:
-		return VectorOperations::DistinctFrom(left, right, sel, count, true_sel, nullptr);
-	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
-	case ExpressionType::COMPARE_EQUAL:
-	default:
-		throw InternalException("Unsupported comparison type for PhysicalPiecewiseMergeJoin");
-	}
-
-	return count;
-}
-
 OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionContext &context, DataChunk &input,
                                                                   DataChunk &chunk, OperatorState &state_p) const {
 	auto &state = (PiecewiseMergeJoinState &)state_p;
 	auto &gstate = (MergeJoinGlobalState &)*sink_state;
-	auto &rsorted = *gstate.rhs_global_sort_state.sorted_blocks[0];
+	auto &rsorted = *gstate.table->global_sort_state.sorted_blocks[0];
 	const auto left_cols = input.ColumnCount();
 	const auto tail_cols = conditions.size() - 1;
 	do {
@@ -62550,14 +62011,15 @@ OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionConte
 			return OperatorResultType::NEED_MORE_INPUT;
 		}
 
-		const auto lhs_not_null = state.lhs_count - state.lhs_has_null;
-		BlockMergeInfo left_info(*state.lhs_global_state, 0, 0, state.left_position, lhs_not_null);
+		auto &lhs_table = *state.lhs_local_table;
+		const auto lhs_not_null = lhs_table.count - lhs_table.has_null;
+		BlockMergeInfo left_info(*state.lhs_global_state, 0, state.left_position, lhs_not_null);
 
 		const auto &rblock = rsorted.radix_sorting_data[state.right_chunk_index];
 		const auto rhs_not_null =
-		    SortedBlockNotNull(state.right_base, rblock.count, gstate.rhs_count - gstate.rhs_has_null);
-		BlockMergeInfo right_info(gstate.rhs_global_sort_state, state.right_chunk_index, state.right_position,
-		                          state.right_position, rhs_not_null);
+		    SortedBlockNotNull(state.right_base, rblock.count, gstate.table->count - gstate.table->has_null);
+		BlockMergeInfo right_info(gstate.table->global_sort_state, state.right_chunk_index, state.right_position,
+		                          rhs_not_null);
 
 		idx_t result_count = MergeJoinComplexBlocks(left_info, right_info, conditions[0].comparison);
 		if (result_count == 0) {
@@ -62576,7 +62038,8 @@ OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionConte
 			for (idx_t c = 0; c < state.lhs_payload.ColumnCount(); ++c) {
 				chunk.data[c].Slice(state.lhs_payload.data[c], left_info.result, result_count);
 			}
-			const auto first_idx = SliceSortedPayload(chunk, right_info, result_count, left_cols);
+			SliceSortedPayload(chunk, right_info.state, right_info.block_idx, right_info.result, result_count,
+			                   left_cols);
 			chunk.SetCardinality(result_count);
 
 			auto sel = FlatVector::IncrementalSelectionVector();
@@ -62590,7 +62053,7 @@ OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionConte
 
 				auto tail_count = result_count;
 				for (size_t cmp_idx = 1; cmp_idx < conditions.size(); ++cmp_idx) {
-					Vector left(state.lhs_keys.data[cmp_idx]);
+					Vector left(lhs_table.keys.data[cmp_idx]);
 					left.Slice(left_info.result, result_count);
 
 					auto &right = state.rhs_keys.data[cmp_idx];
@@ -62618,11 +62081,10 @@ OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionConte
 					state.lhs_found_match[left_info.result[sel->get_index(i)]] = true;
 				}
 			}
-			if (gstate.rhs_found_match) {
+			if (gstate.table->found_match) {
 				//	Absolute position of the block + start position inside that block
-				const idx_t base_index = right_info.base_idx + first_idx;
 				for (idx_t i = 0; i < result_count; i++) {
-					gstate.rhs_found_match[base_index + right_info.result[sel->get_index(i)]] = true;
+					gstate.table->found_match[state.right_base + right_info.result[sel->get_index(i)]] = true;
 				}
 			}
 			chunk.SetCardinality(result_count);
@@ -62639,7 +62101,7 @@ OperatorResultType PhysicalPiecewiseMergeJoin::Execute(ExecutionContext &context
 	if (gstate.Count() == 0) {
 		// empty RHS
 		if (!EmptyResultIfRHSIsEmpty()) {
-			ConstructEmptyJoinResult(join_type, gstate.rhs_has_null, input, chunk);
+			ConstructEmptyJoinResult(join_type, gstate.table->has_null, input, chunk);
 			return OperatorResultType::NEED_MORE_INPUT;
 		} else {
 			return OperatorResultType::FINISHED;
@@ -62697,7 +62159,7 @@ void PhysicalPiecewiseMergeJoin::GetData(ExecutionContext &context, DataChunk &r
 	lock_guard<mutex> l(state.lock);
 	if (!state.scanner) {
 		// Initialize scanner (if not yet initialized)
-		auto &sort_state = sink.rhs_global_sort_state;
+		auto &sort_state = sink.table->global_sort_state;
 		if (sort_state.sorted_blocks.empty()) {
 			return;
 		}
@@ -62706,11 +62168,12 @@ void PhysicalPiecewiseMergeJoin::GetData(ExecutionContext &context, DataChunk &r
 
 	// if the LHS is exhausted in a FULL/RIGHT OUTER JOIN, we scan the found_match for any chunks we
 	// still need to output
-	const auto found_match = sink.rhs_found_match.get();
+	const auto found_match = sink.table->found_match.get();
 
-	// ConstructFullOuterJoinResult(sink.rhs_found_match.get(), sink.right_chunks, chunk, state.right_outer_position);
+	// ConstructFullOuterJoinResult(sink.table->found_match.get(), sink.right_chunks, chunk,
+	// state.right_outer_position);
 	DataChunk rhs_chunk;
-	rhs_chunk.Initialize(sink.rhs_global_sort_state.payload_layout.GetTypes());
+	rhs_chunk.Initialize(sink.table->global_sort_state.payload_layout.GetTypes());
 	SelectionVector rsel(STANDARD_VECTOR_SIZE);
 	for (;;) {
 		// Read the next sorted chunk
@@ -62749,6 +62212,353 @@ void PhysicalPiecewiseMergeJoin::GetData(ExecutionContext &context, DataChunk &r
 }
 
 } // namespace duckdb
+
+
+
+
+
+
+
+
+
+
+
+
+
+#include <thread>
+
+namespace duckdb {
+
+PhysicalRangeJoin::LocalSortedTable::LocalSortedTable(const PhysicalRangeJoin &op, const idx_t child)
+    : op(op), has_null(0), count(0) {
+	// Initialize order clause expression executor and key DataChunk
+	vector<LogicalType> types;
+	for (const auto &cond : op.conditions) {
+		const auto &expr = child ? cond.right : cond.left;
+		executor.AddExpression(*expr);
+
+		types.push_back(expr->return_type);
+	}
+	keys.Initialize(types);
+}
+
+void PhysicalRangeJoin::LocalSortedTable::Sink(DataChunk &input, GlobalSortState &global_sort_state) {
+	// Initialize local state (if necessary)
+	if (!local_sort_state.initialized) {
+		local_sort_state.Initialize(global_sort_state, global_sort_state.buffer_manager);
+	}
+
+	// Obtain sorting columns
+	keys.Reset();
+	executor.Execute(input, keys);
+
+	// Count the NULLs so we can exclude them later
+	has_null += MergeNulls(op.conditions);
+	count += keys.size();
+
+	//	Only sort the primary key
+	DataChunk join_head;
+	join_head.data.emplace_back(Vector(keys.data[0]));
+	join_head.SetCardinality(keys.size());
+
+	// Sink the data into the local sort state
+	local_sort_state.SinkChunk(join_head, input);
+}
+
+PhysicalRangeJoin::GlobalSortedTable::GlobalSortedTable(ClientContext &context, const vector<BoundOrderByNode> &orders,
+                                                        RowLayout &payload_layout)
+    : global_sort_state(BufferManager::GetBufferManager(context), orders, payload_layout), has_null(0), count(0),
+      memory_per_thread(0) {
+	D_ASSERT(orders.size() == 1);
+
+	// Set external (can be force with the PRAGMA)
+	auto &config = ClientConfig::GetConfig(context);
+	global_sort_state.external = config.force_external;
+	// Memory usage per thread should scale with max mem / num threads
+	// We take 1/4th of this, to be conservative
+	idx_t max_memory = global_sort_state.buffer_manager.GetMaxMemory();
+	idx_t num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
+	memory_per_thread = (max_memory / num_threads) / 4;
+}
+
+void PhysicalRangeJoin::GlobalSortedTable::Combine(LocalSortedTable &ltable) {
+	global_sort_state.AddLocalState(ltable.local_sort_state);
+	has_null += ltable.has_null;
+	count += ltable.count;
+}
+
+void PhysicalRangeJoin::GlobalSortedTable::IntializeMatches() {
+	found_match = unique_ptr<bool[]>(new bool[Count()]);
+	memset(found_match.get(), 0, sizeof(bool) * Count());
+}
+
+void PhysicalRangeJoin::GlobalSortedTable::Print() {
+	global_sort_state.Print();
+}
+
+class RangeJoinMergeTask : public ExecutorTask {
+public:
+	using GlobalSortedTable = PhysicalRangeJoin::GlobalSortedTable;
+
+public:
+	RangeJoinMergeTask(shared_ptr<Event> event_p, ClientContext &context, GlobalSortedTable &table)
+	    : ExecutorTask(context), event(move(event_p)), context(context), table(table) {
+	}
+
+	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
+		// Initialize iejoin sorted and iterate until done
+		auto &global_sort_state = table.global_sort_state;
+		MergeSorter merge_sorter(global_sort_state, BufferManager::GetBufferManager(context));
+		merge_sorter.PerformInMergeRound();
+		event->FinishTask();
+
+		return TaskExecutionResult::TASK_FINISHED;
+	}
+
+private:
+	shared_ptr<Event> event;
+	ClientContext &context;
+	GlobalSortedTable &table;
+};
+
+class RangeJoinMergeEvent : public Event {
+public:
+	using GlobalSortedTable = PhysicalRangeJoin::GlobalSortedTable;
+
+public:
+	RangeJoinMergeEvent(GlobalSortedTable &table_p, Pipeline &pipeline_p)
+	    : Event(pipeline_p.executor), table(table_p), pipeline(pipeline_p) {
+	}
+
+	GlobalSortedTable &table;
+	Pipeline &pipeline;
+
+public:
+	void Schedule() override {
+		auto &context = pipeline.GetClientContext();
+
+		// Schedule tasks equal to the number of threads, which will each merge multiple partitions
+		auto &ts = TaskScheduler::GetScheduler(context);
+		idx_t num_threads = ts.NumberOfThreads();
+
+		vector<unique_ptr<Task>> iejoin_tasks;
+		for (idx_t tnum = 0; tnum < num_threads; tnum++) {
+			iejoin_tasks.push_back(make_unique<RangeJoinMergeTask>(shared_from_this(), context, table));
+		}
+		SetTasks(move(iejoin_tasks));
+	}
+
+	void FinishEvent() override {
+		auto &global_sort_state = table.global_sort_state;
+
+		global_sort_state.CompleteMergeRound(true);
+		if (global_sort_state.sorted_blocks.size() > 1) {
+			// Multiple blocks remaining: Schedule the next round
+			table.ScheduleMergeTasks(pipeline, *this);
+		}
+	}
+};
+
+void PhysicalRangeJoin::GlobalSortedTable::ScheduleMergeTasks(Pipeline &pipeline, Event &event) {
+	// Initialize global sort state for a round of merging
+	global_sort_state.InitializeMergeRound();
+	auto new_event = make_shared<RangeJoinMergeEvent>(*this, pipeline);
+	event.InsertEvent(move(new_event));
+}
+
+void PhysicalRangeJoin::GlobalSortedTable::Finalize(Pipeline &pipeline, Event &event) {
+	// Prepare for merge sort phase
+	global_sort_state.PrepareMergePhase();
+
+	// Start the merge phase or finish if a merge is not necessary
+	if (global_sort_state.sorted_blocks.size() > 1) {
+		ScheduleMergeTasks(pipeline, event);
+	}
+}
+
+PhysicalRangeJoin::PhysicalRangeJoin(LogicalOperator &op, PhysicalOperatorType type, unique_ptr<PhysicalOperator> left,
+                                     unique_ptr<PhysicalOperator> right, vector<JoinCondition> cond, JoinType join_type,
+                                     idx_t estimated_cardinality)
+    : PhysicalComparisonJoin(op, type, move(cond), join_type, estimated_cardinality) {
+	// Reorder the conditions so that ranges are at the front.
+	// TODO: use stats to improve the choice?
+	// TODO: Prefer fixed length types?
+	if (conditions.size() > 1) {
+		auto conditions_p = std::move(conditions);
+		conditions.resize(conditions_p.size());
+		idx_t range_position = 0;
+		idx_t other_position = conditions_p.size();
+		for (idx_t i = 0; i < conditions_p.size(); ++i) {
+			switch (conditions_p[i].comparison) {
+			case ExpressionType::COMPARE_LESSTHAN:
+			case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+			case ExpressionType::COMPARE_GREATERTHAN:
+			case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+				conditions[range_position++] = std::move(conditions_p[i]);
+				break;
+			default:
+				conditions[--other_position] = std::move(conditions_p[i]);
+				break;
+			}
+		}
+	}
+
+	children.push_back(move(left));
+	children.push_back(move(right));
+}
+
+idx_t PhysicalRangeJoin::LocalSortedTable::MergeNulls(const vector<JoinCondition> &conditions) {
+	// Merge the validity masks of the comparison keys into the primary
+	// Return the number of NULLs in the resulting chunk
+	D_ASSERT(keys.ColumnCount() > 0);
+	const auto count = keys.size();
+
+	size_t all_constant = 0;
+	for (auto &v : keys.data) {
+		if (v.GetVectorType() == VectorType::CONSTANT_VECTOR) {
+			++all_constant;
+		}
+	}
+
+	auto &primary = keys.data[0];
+	if (all_constant == keys.data.size()) {
+		//	Either all NULL or no NULLs
+		for (auto &v : keys.data) {
+			if (ConstantVector::IsNull(v)) {
+				ConstantVector::SetNull(primary, true);
+				return count;
+			}
+		}
+		return 0;
+	} else if (keys.ColumnCount() > 1) {
+		//	Normalify the primary, as it will need to merge arbitrary validity masks
+		primary.Normalify(count);
+		auto &pvalidity = FlatVector::Validity(primary);
+		D_ASSERT(keys.ColumnCount() == conditions.size());
+		for (size_t c = 1; c < keys.data.size(); ++c) {
+			// Skip comparisons that accept NULLs
+			if (conditions[c].comparison == ExpressionType::COMPARE_DISTINCT_FROM) {
+				continue;
+			}
+			//	Orrify the rest, as the sort code will do this anyway.
+			auto &v = keys.data[c];
+			VectorData vdata;
+			v.Orrify(count, vdata);
+			auto &vvalidity = vdata.validity;
+			if (vvalidity.AllValid()) {
+				continue;
+			}
+			pvalidity.EnsureWritable();
+			switch (v.GetVectorType()) {
+			case VectorType::FLAT_VECTOR: {
+				// Merge entire entries
+				auto pmask = pvalidity.GetData();
+				const auto entry_count = pvalidity.EntryCount(count);
+				for (idx_t entry_idx = 0; entry_idx < entry_count; ++entry_idx) {
+					pmask[entry_idx] &= vvalidity.GetValidityEntry(entry_idx);
+				}
+				break;
+			}
+			case VectorType::CONSTANT_VECTOR:
+				// All or nothing
+				if (ConstantVector::IsNull(v)) {
+					pvalidity.SetAllInvalid(count);
+					return count;
+				}
+				break;
+			default:
+				// One by one
+				for (idx_t i = 0; i < count; ++i) {
+					const auto idx = vdata.sel->get_index(i);
+					if (!vvalidity.RowIsValidUnsafe(idx)) {
+						pvalidity.SetInvalidUnsafe(i);
+					}
+				}
+				break;
+			}
+		}
+		return count - pvalidity.CountValid(count);
+	} else {
+		return count - VectorOperations::CountNotNull(primary, count);
+	}
+}
+
+void PhysicalRangeJoin::SliceSortedPayload(DataChunk &payload, GlobalSortState &state, const idx_t block_idx,
+                                           const SelectionVector &result, const idx_t result_count,
+                                           const idx_t left_cols) {
+	// There should only be one sorted block if they have been sorted
+	D_ASSERT(state.sorted_blocks.size() == 1);
+	SBScanState read_state(state.buffer_manager, state);
+	read_state.sb = state.sorted_blocks[0].get();
+	auto &sorted_data = *read_state.sb->payload_data;
+
+	read_state.SetIndices(block_idx, 0);
+	read_state.PinData(sorted_data);
+	const auto data_ptr = read_state.DataPtr(sorted_data);
+
+	// Set up a batch of pointers to scan data from
+	Vector addresses(LogicalType::POINTER, result_count);
+	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
+
+	// Set up the data pointers for the values that are actually referenced
+	const idx_t &row_width = sorted_data.layout.GetRowWidth();
+
+	auto prev_idx = result.get_index(0);
+	SelectionVector gsel(result_count);
+	idx_t addr_count = 0;
+	gsel.set_index(0, addr_count);
+	data_pointers[addr_count] = data_ptr + prev_idx * row_width;
+	for (idx_t i = 1; i < result_count; ++i) {
+		const auto row_idx = result.get_index(i);
+		if (row_idx != prev_idx) {
+			data_pointers[++addr_count] = data_ptr + row_idx * row_width;
+			prev_idx = row_idx;
+		}
+		gsel.set_index(i, addr_count);
+	}
+	++addr_count;
+
+	// Unswizzle the offsets back to pointers (if needed)
+	if (!sorted_data.layout.AllConstant() && state.external) {
+		RowOperations::UnswizzlePointers(sorted_data.layout, data_ptr, read_state.payload_heap_handle->Ptr(),
+		                                 addr_count);
+	}
+
+	// Deserialize the payload data
+	auto sel = FlatVector::IncrementalSelectionVector();
+	for (idx_t col_idx = 0; col_idx < sorted_data.layout.ColumnCount(); col_idx++) {
+		const auto col_offset = sorted_data.layout.GetOffsets()[col_idx];
+		auto &col = payload.data[left_cols + col_idx];
+		RowOperations::Gather(addresses, *sel, col, *sel, addr_count, col_offset, col_idx);
+		col.Slice(gsel, result_count);
+	}
+}
+
+idx_t PhysicalRangeJoin::SelectJoinTail(const ExpressionType &condition, Vector &left, Vector &right,
+                                        const SelectionVector *sel, idx_t count, SelectionVector *true_sel) {
+	switch (condition) {
+	case ExpressionType::COMPARE_NOTEQUAL:
+		return VectorOperations::NotEquals(left, right, sel, count, true_sel, nullptr);
+	case ExpressionType::COMPARE_LESSTHAN:
+		return VectorOperations::LessThan(left, right, sel, count, true_sel, nullptr);
+	case ExpressionType::COMPARE_GREATERTHAN:
+		return VectorOperations::GreaterThan(left, right, sel, count, true_sel, nullptr);
+	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+		return VectorOperations::LessThanEquals(left, right, sel, count, true_sel, nullptr);
+	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+		return VectorOperations::GreaterThanEquals(left, right, sel, count, true_sel, nullptr);
+	case ExpressionType::COMPARE_DISTINCT_FROM:
+		return VectorOperations::DistinctFrom(left, right, sel, count, true_sel, nullptr);
+	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
+	case ExpressionType::COMPARE_EQUAL:
+	default:
+		throw InternalException("Unsupported comparison type for PhysicalRangeJoin");
+	}
+
+	return count;
+}
+
+} // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -63751,7 +63561,7 @@ std::string BufferedCSVReaderOptions::ToString() const {
 	       ", HEADER=" + std::to_string(header) +
 	       (has_header ? "" : (auto_detect ? " (auto detected)" : "' (default)")) +
 	       ", SAMPLE_SIZE=" + std::to_string(sample_chunk_size * sample_chunks) +
-	       ", ALL_VARCHAR=" + std::to_string(all_varchar);
+	       ", IGNORE_ERRORS=" + std::to_string(ignore_errors) + ", ALL_VARCHAR=" + std::to_string(all_varchar);
 }
 
 static string GetLineNumberStr(idx_t linenr, bool linenr_estimated) {
@@ -65214,9 +65024,14 @@ void BufferedCSVReader::AddValue(char *str_val, idx_t length, idx_t &column, vec
 		return;
 	}
 	if (column >= sql_types.size()) {
-		throw InvalidInputException("Error on line %s: expected %lld values per row, but got more. (%s)",
-		                            GetLineNumberStr(linenr, linenr_estimated).c_str(), sql_types.size(),
-		                            options.ToString());
+		if (options.ignore_errors) {
+			error_column_overflow = true;
+			return;
+		} else {
+			throw InvalidInputException("Error on line %s: expected %lld values per row, but got more. (%s)",
+			                            GetLineNumberStr(linenr, linenr_estimated).c_str(), sql_types.size(),
+			                            options.ToString());
+		}
 	}
 
 	// insert the line number into the chunk
@@ -65268,10 +65083,23 @@ bool BufferedCSVReader::AddRow(DataChunk &insert_chunk, idx_t &column) {
 		}
 	}
 
+	// Error forwarded by 'ignore_errors' - originally encountered in 'AddValue'
+	if (error_column_overflow) {
+		D_ASSERT(options.ignore_errors);
+		error_column_overflow = false;
+		column = 0;
+		return false;
+	}
+
 	if (column < sql_types.size() && mode != ParserMode::SNIFFING_DIALECT) {
-		throw InvalidInputException("Error on line %s: expected %lld values per row, but got %d. (%s)",
-		                            GetLineNumberStr(linenr, linenr_estimated).c_str(), sql_types.size(), column,
-		                            options.ToString());
+		if (options.ignore_errors) {
+			column = 0;
+			return false;
+		} else {
+			throw InvalidInputException("Error on line %s: expected %lld values per row, but got %d. (%s)",
+			                            GetLineNumberStr(linenr, linenr_estimated).c_str(), sql_types.size(), column,
+			                            options.ToString());
+		}
 	}
 
 	if (mode == ParserMode::SNIFFING_DIALECT) {
@@ -65305,6 +65133,9 @@ void BufferedCSVReader::Flush(DataChunk &insert_chunk) {
 	if (parse_chunk.size() == 0) {
 		return;
 	}
+
+	bool conversion_error_ignored = false;
+
 	// convert the columns in the parsed chunk to the types of the table
 	insert_chunk.SetCardinality(parse_chunk);
 	for (idx_t col_idx = 0; col_idx < sql_types.size(); col_idx++) {
@@ -65346,26 +65177,56 @@ void BufferedCSVReader::Flush(DataChunk &insert_chunk) {
 				success = VectorOperations::TryCast(parse_chunk.data[col_idx], insert_chunk.data[col_idx],
 				                                    parse_chunk.size(), &error_message);
 			}
-			if (!success) {
-				string col_name = to_string(col_idx);
-				if (col_idx < col_names.size()) {
-					col_name = "\"" + col_names[col_idx] + "\"";
-				}
+			if (success) {
+				continue;
+			}
+			if (options.ignore_errors) {
+				conversion_error_ignored = true;
+				continue;
+			}
+			string col_name = to_string(col_idx);
+			if (col_idx < col_names.size()) {
+				col_name = "\"" + col_names[col_idx] + "\"";
+			}
 
-				if (options.auto_detect) {
-					throw InvalidInputException("%s in column %s, between line %llu and %llu. Parser "
-					                            "options: %s. Consider either increasing the sample size "
-					                            "(SAMPLE_SIZE=X [X rows] or SAMPLE_SIZE=-1 [all rows]), "
-					                            "or skipping column conversion (ALL_VARCHAR=1)",
-					                            error_message, col_name, linenr - parse_chunk.size() + 1, linenr,
-					                            options.ToString());
-				} else {
-					throw InvalidInputException("%s between line %llu and %llu in column %s. Parser options: %s ",
-					                            error_message, linenr - parse_chunk.size(), linenr, col_name,
-					                            options.ToString());
+			if (options.auto_detect) {
+				throw InvalidInputException("%s in column %s, between line %llu and %llu. Parser "
+				                            "options: %s. Consider either increasing the sample size "
+				                            "(SAMPLE_SIZE=X [X rows] or SAMPLE_SIZE=-1 [all rows]), "
+				                            "or skipping column conversion (ALL_VARCHAR=1)",
+				                            error_message, col_name, linenr - parse_chunk.size() + 1, linenr,
+				                            options.ToString());
+			} else {
+				throw InvalidInputException("%s between line %llu and %llu in column %s. Parser options: %s ",
+				                            error_message, linenr - parse_chunk.size(), linenr, col_name,
+				                            options.ToString());
+			}
+		}
+	}
+	if (conversion_error_ignored) {
+		D_ASSERT(options.ignore_errors);
+		SelectionVector succesful_rows;
+		succesful_rows.Initialize(parse_chunk.size());
+		idx_t sel_size = 0;
+
+		for (idx_t row_idx = 0; row_idx < parse_chunk.size(); row_idx++) {
+			bool failed = false;
+			for (idx_t column_idx = 0; column_idx < sql_types.size(); column_idx++) {
+
+				auto &inserted_column = insert_chunk.data[column_idx];
+				auto &parsed_column = parse_chunk.data[column_idx];
+
+				bool was_already_null = FlatVector::IsNull(parsed_column, row_idx);
+				if (!was_already_null && FlatVector::IsNull(inserted_column, row_idx)) {
+					failed = true;
+					break;
 				}
 			}
+			if (!failed) {
+				succesful_rows.set_index(sel_size++, row_idx);
+			}
 		}
+		insert_chunk.Slice(succesful_rows, sel_size);
 	}
 	parse_chunk.Reset();
 }
@@ -79724,6 +79585,11 @@ struct ListAggregateFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct ListSortFun {
+	static ScalarFunction GetFunction();
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct CardinalityFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -84973,9 +84839,6 @@ void DateSubFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
-// TODO date_trunc function should also handle interval data type when it is implemented. See
-// https://www.postgresql.org/docs/9.1/functions-datetime.html
-
 namespace duckdb {
 
 struct DateTrunc {
@@ -85186,6 +85049,101 @@ timestamp_t DateTrunc::MicrosecondOperator::Operation(date_t input) {
 	return DayOperator::Operation<date_t, timestamp_t>(input);
 }
 
+// INTERVAL specialisations
+template <>
+interval_t DateTrunc::MillenniumOperator::Operation(interval_t input) {
+	input.days = 0;
+	input.micros = 0;
+	input.months = (input.months / Interval::MONTHS_PER_MILLENIUM) * Interval::MONTHS_PER_MILLENIUM;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::CenturyOperator::Operation(interval_t input) {
+	input.days = 0;
+	input.micros = 0;
+	input.months = (input.months / Interval::MONTHS_PER_CENTURY) * Interval::MONTHS_PER_CENTURY;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::DecadeOperator::Operation(interval_t input) {
+	input.days = 0;
+	input.micros = 0;
+	input.months = (input.months / Interval::MONTHS_PER_DECADE) * Interval::MONTHS_PER_DECADE;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::YearOperator::Operation(interval_t input) {
+	input.days = 0;
+	input.micros = 0;
+	input.months = (input.months / Interval::MONTHS_PER_YEAR) * Interval::MONTHS_PER_YEAR;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::QuarterOperator::Operation(interval_t input) {
+	input.days = 0;
+	input.micros = 0;
+	input.months = (input.months / Interval::MONTHS_PER_QUARTER) * Interval::MONTHS_PER_QUARTER;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::MonthOperator::Operation(interval_t input) {
+	input.days = 0;
+	input.micros = 0;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::WeekOperator::Operation(interval_t input) {
+	input.micros = 0;
+	input.days = (input.days / Interval::DAYS_PER_WEEK) * Interval::DAYS_PER_WEEK;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::ISOYearOperator::Operation(interval_t input) {
+	return YearOperator::Operation<interval_t, interval_t>(input);
+}
+
+template <>
+interval_t DateTrunc::DayOperator::Operation(interval_t input) {
+	input.micros = 0;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::HourOperator::Operation(interval_t input) {
+	input.micros = (input.micros / Interval::MICROS_PER_HOUR) * Interval::MICROS_PER_HOUR;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::MinuteOperator::Operation(interval_t input) {
+	input.micros = (input.micros / Interval::MICROS_PER_MINUTE) * Interval::MICROS_PER_MINUTE;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::SecondOperator::Operation(interval_t input) {
+	input.micros = (input.micros / Interval::MICROS_PER_SEC) * Interval::MICROS_PER_SEC;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::MillisecondOperator::Operation(interval_t input) {
+	input.micros = (input.micros / Interval::MICROS_PER_MSEC) * Interval::MICROS_PER_MSEC;
+	return input;
+}
+
+template <>
+interval_t DateTrunc::MicrosecondOperator::Operation(interval_t input) {
+	return input;
+}
+
 template <class TA, class TR>
 static TR TruncateElement(DatePartSpecifier type, TA element) {
 	switch (type) {
@@ -85289,7 +85247,7 @@ static void DateTruncUnaryExecutor(DatePartSpecifier type, Vector &left, Vector
 	}
 }
 
-template <typename T>
+template <typename TA, typename TR>
 static void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &result) {
 	D_ASSERT(args.ColumnCount() == 2);
 	auto &part_arg = args.data[0];
@@ -85302,20 +85260,22 @@ static void DateTruncFunction(DataChunk &args, ExpressionState &state, Vector &r
 			ConstantVector::SetNull(result, true);
 		} else {
 			const auto type = GetDatePartSpecifier(ConstantVector::GetData<string_t>(part_arg)->GetString());
-			DateTruncUnaryExecutor<T, timestamp_t>(type, date_arg, result, args.size());
+			DateTruncUnaryExecutor<TA, TR>(type, date_arg, result, args.size());
 		}
 	} else {
-		BinaryExecutor::ExecuteStandard<string_t, T, timestamp_t, DateTruncBinaryOperator>(part_arg, date_arg, result,
-		                                                                                   args.size());
+		BinaryExecutor::ExecuteStandard<string_t, TA, TR, DateTruncBinaryOperator>(part_arg, date_arg, result,
+		                                                                           args.size());
 	}
 }
 
 void DateTruncFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet date_trunc("date_trunc");
 	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::TIMESTAMP}, LogicalType::TIMESTAMP,
-	                                      DateTruncFunction<timestamp_t>));
-	date_trunc.AddFunction(
-	    ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::TIMESTAMP, DateTruncFunction<date_t>));
+	                                      DateTruncFunction<timestamp_t, timestamp_t>));
+	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::DATE}, LogicalType::TIMESTAMP,
+	                                      DateTruncFunction<date_t, timestamp_t>));
+	date_trunc.AddFunction(ScalarFunction({LogicalType::VARCHAR, LogicalType::INTERVAL}, LogicalType::INTERVAL,
+	                                      DateTruncFunction<interval_t, interval_t>));
 	set.AddFunction(date_trunc);
 	date_trunc.name = "datetrunc";
 	set.AddFunction(date_trunc);
@@ -85647,7 +85607,8 @@ void StrfTimeFormat::AddFormatSpecifier(string preceding_literal, StrTimeSpecifi
 	StrTimeFormat::AddFormatSpecifier(move(preceding_literal), specifier);
 }
 
-idx_t StrfTimeFormat::GetSpecifierLength(StrTimeSpecifier specifier, date_t date, dtime_t time) {
+idx_t StrfTimeFormat::GetSpecifierLength(StrTimeSpecifier specifier, date_t date, dtime_t time, int32_t utc_offset,
+                                         const char *tz_name) {
 	switch (specifier) {
 	case StrTimeSpecifier::FULL_WEEKDAY_NAME:
 		return Date::DAY_NAMES[Date::ExtractISODayOfTheWeek(date) % 7].GetSize();
@@ -85664,9 +85625,12 @@ idx_t StrfTimeFormat::GetSpecifierLength(StrTimeSpecifier specifier, date_t date
 		return len;
 	}
 	case StrTimeSpecifier::UTC_OFFSET:
-		// +00
-		return 3;
+		// ±HH or ±HH:MM
+		return (utc_offset % 60) ? 6 : 3;
 	case StrTimeSpecifier::TZ_NAME:
+		if (tz_name) {
+			return strlen(tz_name);
+		}
 		// empty for now
 		return 0;
 	case StrTimeSpecifier::HOUR_24_DECIMAL:
@@ -85711,11 +85675,11 @@ idx_t StrfTimeFormat::GetSpecifierLength(StrTimeSpecifier specifier, date_t date
 }
 
 //! Returns the total length of the date formatted by this format specifier
-idx_t StrfTimeFormat::GetLength(date_t date, dtime_t time) {
+idx_t StrfTimeFormat::GetLength(date_t date, dtime_t time, int32_t utc_offset, const char *tz_name) {
 	idx_t size = constant_size;
 	if (!var_length_specifiers.empty()) {
 		for (auto &specifier : var_length_specifiers) {
-			size += GetSpecifierLength(specifier, date, time);
+			size += GetSpecifierLength(specifier, date, time, utc_offset, tz_name);
 		}
 	}
 	return size;
@@ -85828,8 +85792,9 @@ char *StrfTimeFormat::WriteDateSpecifier(StrTimeSpecifier specifier, date_t date
 	return target;
 }
 
-char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], char *target) {
-	// data contains [0] year, [1] month, [2] day, [3] hour, [4] minute, [5] second, [6] msec
+char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t data[], const char *tz_name,
+                                             char *target) {
+	// data contains [0] year, [1] month, [2] day, [3] hour, [4] minute, [5] second, [6] msec, [7] utc
 	switch (specifier) {
 	case StrTimeSpecifier::DAY_OF_MONTH_PADDED:
 		target = WritePadded2(target, data[2]);
@@ -85892,13 +85857,24 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 	case StrTimeSpecifier::MILLISECOND_PADDED:
 		target = WritePadded3(target, data[6] / 1000);
 		break;
-	case StrTimeSpecifier::UTC_OFFSET:
-		*target++ = '+';
-		*target++ = '0';
-		*target++ = '0';
+	case StrTimeSpecifier::UTC_OFFSET: {
+		*target++ = (data[7] < 0) ? '-' : '+';
+
+		auto offset = abs(data[7]);
+		auto offset_hours = offset / Interval::MINS_PER_HOUR;
+		auto offset_minutes = offset % Interval::MINS_PER_HOUR;
+		target = WritePadded2(target, offset_hours);
+		if (offset_minutes) {
+			*target++ = ':';
+			target = WritePadded2(target, offset_minutes);
+		}
 		break;
+	}
 	case StrTimeSpecifier::TZ_NAME:
-		// always empty for now, FIXME when we have timestamp with tz
+		if (tz_name) {
+			strcpy(target, tz_name);
+			target += strlen(tz_name);
+		}
 		break;
 	case StrTimeSpecifier::DAY_OF_MONTH: {
 		target = Write2(target, data[2] % 100);
@@ -85938,7 +85914,7 @@ char *StrfTimeFormat::WriteStandardSpecifier(StrTimeSpecifier specifier, int32_t
 	return target;
 }
 
-void StrfTimeFormat::FormatString(date_t date, int32_t data[7], char *target) {
+void StrfTimeFormat::FormatString(date_t date, int32_t data[8], const char *tz_name, char *target) {
 	D_ASSERT(specifiers.size() + 1 == literals.size());
 	idx_t i;
 	for (i = 0; i < specifiers.size(); i++) {
@@ -85949,7 +85925,7 @@ void StrfTimeFormat::FormatString(date_t date, int32_t data[7], char *target) {
 		if (is_date_specifier[i]) {
 			target = WriteDateSpecifier(specifiers[i], date, target);
 		} else {
-			target = WriteStandardSpecifier(specifiers[i], data, target);
+			target = WriteStandardSpecifier(specifiers[i], data, tz_name, target);
 		}
 	}
 	// copy the final literal into the target
@@ -85957,11 +85933,12 @@ void StrfTimeFormat::FormatString(date_t date, int32_t data[7], char *target) {
 }
 
 void StrfTimeFormat::FormatString(date_t date, dtime_t time, char *target) {
-	int32_t data[7]; // year, month, day, hour, min, sec, msec
+	int32_t data[8]; // year, month, day, hour, min, sec, µs, offset
 	Date::Convert(date, data[0], data[1], data[2]);
 	Time::Convert(time, data[3], data[4], data[5], data[6]);
+	data[7] = 0;
 
-	FormatString(date, data, target);
+	FormatString(date, data, nullptr, target);
 }
 
 string StrfTimeFormat::Format(timestamp_t timestamp, const string &format_str) {
@@ -85971,7 +85948,7 @@ string StrfTimeFormat::Format(timestamp_t timestamp, const string &format_str) {
 	auto date = Timestamp::GetDate(timestamp);
 	auto time = Timestamp::GetTime(timestamp);
 
-	auto len = format.GetLength(date, time);
+	auto len = format.GetLength(date, time, 0, nullptr);
 	auto result = unique_ptr<char[]>(new char[len]);
 	format.FormatString(date, time, result.get());
 	return string(result.get(), len);
@@ -86187,7 +86164,7 @@ static void StrfTimeFunctionDate(DataChunk &args, ExpressionState &state, Vector
 	}
 	UnaryExecutor::Execute<date_t, string_t>(args.data[REVERSED ? 1 : 0], result, args.size(), [&](date_t input) {
 		dtime_t time(0);
-		idx_t len = info.format.GetLength(input, time);
+		idx_t len = info.format.GetLength(input, time, 0, nullptr);
 		string_t target = StringVector::EmptyString(result, len);
 		info.format.FormatString(input, time, target.GetDataWriteable());
 		target.Finalize();
@@ -86211,7 +86188,7 @@ static void StrfTimeFunctionTimestamp(DataChunk &args, ExpressionState &state, V
 		                                              date_t date;
 		                                              dtime_t time;
 		                                              Timestamp::Convert(input, date, time);
-		                                              idx_t len = info.format.GetLength(date, time);
+		                                              idx_t len = info.format.GetLength(date, time, 0, nullptr);
 		                                              string_t target = StringVector::EmptyString(result, len);
 		                                              info.format.FormatString(date, time, target.GetDataWriteable());
 		                                              target.Finalize();
@@ -86319,6 +86296,7 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
 	result_data[4] = 0;
 	result_data[5] = 0;
 	result_data[6] = 0;
+	result_data[7] = 0;
 
 	auto data = str.GetDataUnsafe();
 	idx_t size = str.GetSize();
@@ -86591,8 +86569,7 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
 					error_position = pos;
 					return false;
 				}
-				result_data[3] -= hour_offset;
-				result_data[4] -= minute_offset;
+				result_data[7] = hour_offset * Interval::MINS_PER_HOUR + minute_offset;
 				break;
 			}
 			case StrTimeSpecifier::TZ_NAME: {
@@ -86600,11 +86577,20 @@ bool StrpTimeFormat::Parse(string_t str, ParseResult &result) {
 				while (pos < size && StringUtil::CharacterIsSpace(data[pos])) {
 					pos++;
 				}
+				const auto tz_begin = data + pos;
 				// stop when we encounter a space or the end of the string
 				while (pos < size && !StringUtil::CharacterIsSpace(data[pos])) {
 					pos++;
 				}
-				// FIXME: actually use the timestamp...
+				const auto tz_end = data + pos;
+				// Can't fully validate without a list - caller's responsibility.
+				// But tz must not be empty.
+				if (tz_end == tz_begin) {
+					error_message = "Empty Time Zone name";
+					error_position = tz_begin - data;
+					return false;
+				}
+				result.tz.assign(tz_begin, tz_end);
 				break;
 			}
 			default:
@@ -86701,6 +86687,9 @@ static unique_ptr<FunctionData> StrpTimeBindFunction(ClientContext &context, Sca
 		if (!error.empty()) {
 			throw InvalidInputException("Failed to parse format specifier %s: %s", format_string, error);
 		}
+		if (format.HasFormatSpecifier(StrTimeSpecifier::UTC_OFFSET)) {
+			bound_function.return_type = LogicalType::TIMESTAMP_TZ;
+		}
 	}
 	return make_unique<StrpTimeBindData>(format);
 }
@@ -86732,7 +86721,9 @@ date_t StrpTimeFormat::ParseResult::ToDate() {
 
 timestamp_t StrpTimeFormat::ParseResult::ToTimestamp() {
 	date_t date = Date::FromDate(data[0], data[1], data[2]);
-	dtime_t time = Time::FromTime(data[3], data[4], data[5], data[6]);
+	const auto hour_offset = data[7] / Interval::MINS_PER_HOUR;
+	const auto mins_offset = data[7] % Interval::MINS_PER_HOUR;
+	dtime_t time = Time::FromTime(data[3] - hour_offset, data[4] - mins_offset, data[5], data[6]);
 	return Timestamp::FromDatetime(date, time);
 }
 
@@ -88774,6 +88765,371 @@ void ListExtractFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+namespace duckdb {
+
+struct ListSortBindData : public FunctionData {
+	ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p, LogicalType &return_type_p,
+	                 LogicalType &child_type_p, ClientContext &context_p);
+	~ListSortBindData() override;
+
+	OrderType order_type;
+	OrderByNullType null_order;
+	LogicalType return_type;
+	LogicalType child_type;
+
+	vector<LogicalType> types;
+	vector<LogicalType> payload_types;
+
+	ClientContext &context;
+	unique_ptr<GlobalSortState> global_sort_state;
+	RowLayout payload_layout;
+	vector<BoundOrderByNode> orders;
+
+	unique_ptr<FunctionData> Copy() override;
+};
+
+ListSortBindData::ListSortBindData(OrderType order_type_p, OrderByNullType null_order_p, LogicalType &return_type_p,
+                                   LogicalType &child_type_p, ClientContext &context_p)
+    : order_type(order_type_p), null_order(null_order_p), return_type(return_type_p), child_type(child_type_p),
+      context(context_p) {
+
+	// get the vector types
+	types.emplace_back(LogicalType::USMALLINT);
+	types.emplace_back(child_type);
+	D_ASSERT(types.size() == 2);
+
+	// get the payload types
+	payload_types.emplace_back(LogicalType::UINTEGER);
+	D_ASSERT(payload_types.size() == 1);
+
+	// initialize the payload layout
+	payload_layout.Initialize(payload_types);
+
+	// get the BoundOrderByNode
+	auto idx_col_expr = make_unique_base<Expression, BoundReferenceExpression>(LogicalType::USMALLINT, 0);
+	auto lists_col_expr = make_unique_base<Expression, BoundReferenceExpression>(child_type, 1);
+	orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT, move(idx_col_expr));
+	orders.emplace_back(order_type, null_order, move(lists_col_expr));
+}
+
+unique_ptr<FunctionData> ListSortBindData::Copy() {
+	return make_unique<ListSortBindData>(order_type, null_order, return_type, child_type, context);
+}
+
+ListSortBindData::~ListSortBindData() {
+}
+
+// create the key_chunk and the payload_chunk and sink them into the local_sort_state
+void SinkDataChunk(Vector *child_vector, SelectionVector &sel, idx_t offset_lists_indices, vector<LogicalType> &types,
+                   vector<LogicalType> &payload_types, Vector &payload_vector, LocalSortState &local_sort_state,
+                   bool &data_to_sort, Vector &lists_indices) {
+
+	// slice the child vector
+	Vector slice(*child_vector, sel, offset_lists_indices);
+
+	// initialize and fill key_chunk
+	DataChunk key_chunk;
+	key_chunk.InitializeEmpty(types);
+	key_chunk.data[0].Reference(lists_indices);
+	key_chunk.data[1].Reference(slice);
+	key_chunk.SetCardinality(offset_lists_indices);
+
+	// initialize and fill key_chunk and payload_chunk
+	DataChunk payload_chunk;
+	payload_chunk.InitializeEmpty(payload_types);
+	payload_chunk.data[0].Reference(payload_vector);
+	payload_chunk.SetCardinality(offset_lists_indices);
+
+	// sink
+	local_sort_state.SinkChunk(key_chunk, payload_chunk);
+	data_to_sort = true;
+}
+
+static void ListSortFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+
+	D_ASSERT(args.ColumnCount() >= 1 && args.ColumnCount() <= 3);
+	auto count = args.size();
+	Vector &lists = args.data[0];
+
+	result.SetVectorType(VectorType::FLAT_VECTOR);
+	auto &result_validity = FlatVector::Validity(result);
+
+	if (lists.GetType().id() == LogicalTypeId::SQLNULL) {
+		result_validity.SetInvalid(0);
+		return;
+	}
+
+	auto &func_expr = (BoundFunctionExpression &)state.expr;
+	auto &info = (ListSortBindData &)*func_expr.bind_info;
+
+	// initialize the global and local sorting state
+	auto &buffer_manager = BufferManager::GetBufferManager(info.context);
+	info.global_sort_state = make_unique<GlobalSortState>(buffer_manager, info.orders, info.payload_layout);
+	auto &global_sort_state = *info.global_sort_state;
+	LocalSortState local_sort_state;
+	local_sort_state.Initialize(global_sort_state, buffer_manager);
+
+	// get the child vector
+	auto lists_size = ListVector::GetListSize(lists);
+	auto &child_vector = ListVector::GetEntry(lists);
+	VectorData child_data;
+	child_vector.Orrify(lists_size, child_data);
+
+	// get the lists data
+	VectorData lists_data;
+	lists.Orrify(count, lists_data);
+	auto list_entries = (list_entry_t *)lists_data.data;
+
+	// create the lists_indices vector, this contains an element for each list's entry,
+	// the element corresponds to the list's index, e.g. for [1, 2, 4], [5, 4]
+	// lists_indices contains [0, 0, 0, 1, 1]
+	Vector lists_indices(LogicalType::USMALLINT);
+	auto lists_indices_data = FlatVector::GetData<uint16_t>(lists_indices);
+
+	// create the payload_vector, this is just a vector containing incrementing integers
+	// this will later be used as the 'new' selection vector of the child_vector, after
+	// rearranging the payload according to the sorting order
+	Vector payload_vector(LogicalType::UINTEGER);
+	auto payload_vector_data = FlatVector::GetData<uint32_t>(payload_vector);
+
+	// selection vector pointing to the data of the child vector,
+	// used for slicing the child_vector correctly
+	SelectionVector sel(STANDARD_VECTOR_SIZE);
+
+	idx_t offset_lists_indices = 0;
+	uint32_t incr_payload_count = 0;
+	bool data_to_sort = false;
+
+	for (idx_t i = 0; i < count; i++) {
+
+		auto lists_index = lists_data.sel->get_index(i);
+		const auto &list_entry = list_entries[lists_index];
+
+		// nothing to do for this list
+		if (!lists_data.validity.RowIsValid(lists_index)) {
+			result_validity.SetInvalid(i);
+			continue;
+		}
+
+		// empty list, no sorting required
+		if (list_entry.length == 0) {
+			continue;
+		}
+
+		for (idx_t child_idx = 0; child_idx < list_entry.length; child_idx++) {
+
+			// lists_indices vector is full, sink
+			if (offset_lists_indices == STANDARD_VECTOR_SIZE) {
+				SinkDataChunk(&child_vector, sel, offset_lists_indices, info.types, info.payload_types, payload_vector,
+				              local_sort_state, data_to_sort, lists_indices);
+				offset_lists_indices = 0;
+			}
+
+			auto source_idx = child_data.sel->get_index(list_entry.offset + child_idx);
+			sel.set_index(offset_lists_indices, source_idx);
+			lists_indices_data[offset_lists_indices] = (uint32_t)i;
+			payload_vector_data[offset_lists_indices] = incr_payload_count;
+			offset_lists_indices++;
+			incr_payload_count++;
+		}
+	}
+
+	if (offset_lists_indices != 0) {
+		SinkDataChunk(&child_vector, sel, offset_lists_indices, info.types, info.payload_types, payload_vector,
+		              local_sort_state, data_to_sort, lists_indices);
+	}
+
+	if (data_to_sort) {
+
+		// add local state to global state, which sorts the data
+		global_sort_state.AddLocalState(local_sort_state);
+		global_sort_state.PrepareMergePhase();
+
+		// selection vector that is to be filled with the 'sorted' payload
+		SelectionVector sel_sorted(incr_payload_count);
+		idx_t sel_sorted_idx = 0;
+
+		// scan the sorted row data
+		PayloadScanner scanner(*global_sort_state.sorted_blocks[0]->payload_data, global_sort_state);
+		for (;;) {
+			DataChunk result_chunk;
+			result_chunk.Initialize(info.payload_types);
+			result_chunk.SetCardinality(0);
+			scanner.Scan(result_chunk);
+			if (result_chunk.size() == 0) {
+				break;
+			}
+
+			// construct the selection vector with the new order from the result vectors
+			Vector result_vector(result_chunk.data[0]);
+			auto result_data = FlatVector::GetData<uint32_t>(result_vector);
+			auto row_count = result_chunk.size();
+
+			for (idx_t i = 0; i < row_count; i++) {
+				sel_sorted.set_index(sel_sorted_idx, result_data[i]);
+				sel_sorted_idx++;
+			}
+		}
+
+		D_ASSERT(sel_sorted_idx == incr_payload_count);
+		child_vector.Slice(sel_sorted, sel_sorted_idx);
+		child_vector.Normalify(sel_sorted_idx);
+	}
+
+	result.Reference(lists);
+}
+
+static unique_ptr<FunctionData> ListSortBind(ClientContext &context, ScalarFunction &bound_function,
+                                             vector<unique_ptr<Expression>> &arguments, OrderType &order,
+                                             OrderByNullType &null_order) {
+
+	if (arguments[0]->return_type.id() == LogicalTypeId::SQLNULL) {
+		bound_function.arguments[0] = LogicalType::SQLNULL;
+		bound_function.return_type = LogicalType::SQLNULL;
+		return make_unique<VariableReturnBindData>(bound_function.return_type);
+	}
+
+	bound_function.arguments[0] = arguments[0]->return_type;
+	bound_function.return_type = arguments[0]->return_type;
+	auto child_type = ListType::GetChildType(arguments[0]->return_type);
+
+	return make_unique<ListSortBindData>(order, null_order, bound_function.return_type, child_type, context);
+}
+
+OrderByNullType GetNullOrder(vector<unique_ptr<Expression>> &arguments, idx_t idx) {
+
+	if (!arguments[idx]->IsFoldable()) {
+		throw InvalidInputException("Null sorting order must be a constant");
+	}
+	Value null_order_value = ExpressionExecutor::EvaluateScalar(*arguments[idx]);
+	auto null_order_name = null_order_value.ToString();
+	std::transform(null_order_name.begin(), null_order_name.end(), null_order_name.begin(), ::toupper);
+	if (null_order_name != "NULLS FIRST" && null_order_name != "NULLS LAST") {
+		throw InvalidInputException("Null sorting order must be either NULLS FIRST or NULLS LAST");
+	}
+
+	if (null_order_name == "NULLS LAST") {
+		return OrderByNullType::NULLS_LAST;
+	}
+	return OrderByNullType::NULLS_FIRST;
+}
+
+static unique_ptr<FunctionData> ListNormalSortBind(ClientContext &context, ScalarFunction &bound_function,
+                                                   vector<unique_ptr<Expression>> &arguments) {
+
+	D_ASSERT(bound_function.arguments.size() >= 1 && bound_function.arguments.size() <= 3);
+	D_ASSERT(arguments.size() >= 1 && arguments.size() <= 3);
+
+	// set default values
+	auto &config = DBConfig::GetConfig(context);
+	auto order = config.default_order_type;
+	auto null_order = config.default_null_order;
+
+	// get the sorting order
+	if (arguments.size() >= 2) {
+
+		if (!arguments[1]->IsFoldable()) {
+			throw InvalidInputException("Sorting order must be a constant");
+		}
+		Value order_value = ExpressionExecutor::EvaluateScalar(*arguments[1]);
+		auto order_name = order_value.ToString();
+		std::transform(order_name.begin(), order_name.end(), order_name.begin(), ::toupper);
+		if (order_name != "DESC" && order_name != "ASC") {
+			throw InvalidInputException("Sorting order must be either ASC or DESC");
+		}
+		if (order_name == "DESC") {
+			order = OrderType::DESCENDING;
+		} else {
+			order = OrderType::ASCENDING;
+		}
+	}
+
+	// get the null sorting order
+	if (arguments.size() == 3) {
+		null_order = GetNullOrder(arguments, 2);
+	}
+
+	return ListSortBind(context, bound_function, arguments, order, null_order);
+}
+
+static unique_ptr<FunctionData> ListReverseSortBind(ClientContext &context, ScalarFunction &bound_function,
+                                                    vector<unique_ptr<Expression>> &arguments) {
+
+	D_ASSERT(bound_function.arguments.size() == 1 || bound_function.arguments.size() == 2);
+	D_ASSERT(arguments.size() == 1 || arguments.size() == 2);
+
+	// set (reverse) default values
+	auto &config = DBConfig::GetConfig(context);
+	auto order = (config.default_order_type == OrderType::ASCENDING) ? OrderType::DESCENDING : OrderType::ASCENDING;
+	auto null_order = config.default_null_order;
+
+	// get the null sorting order
+	if (arguments.size() == 2) {
+		null_order = GetNullOrder(arguments, 1);
+	}
+
+	return ListSortBind(context, bound_function, arguments, order, null_order);
+}
+
+void ListSortFun::RegisterFunction(BuiltinFunctions &set) {
+
+	// normal sort
+
+	// one parameter: list
+	ScalarFunction sort({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY), ListSortFunction,
+	                    false, false, ListNormalSortBind);
+
+	// two parameters: list, order
+	ScalarFunction sort_order({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR},
+	                          LogicalType::LIST(LogicalType::ANY), ListSortFunction, false, false, ListNormalSortBind);
+
+	// three parameters: list, order, null order
+	ScalarFunction sort_orders({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR, LogicalType::VARCHAR},
+	                           LogicalType::LIST(LogicalType::ANY), ListSortFunction, false, false, ListNormalSortBind);
+
+	ScalarFunctionSet list_sort("list_sort");
+	list_sort.AddFunction(sort);
+	list_sort.AddFunction(sort_order);
+	list_sort.AddFunction(sort_orders);
+	set.AddFunction(list_sort);
+
+	ScalarFunctionSet array_sort("array_sort");
+	array_sort.AddFunction(sort);
+	array_sort.AddFunction(sort_order);
+	array_sort.AddFunction(sort_orders);
+	set.AddFunction(array_sort);
+
+	// reverse sort
+
+	// one parameter: list
+	ScalarFunction sort_reverse({LogicalType::LIST(LogicalType::ANY)}, LogicalType::LIST(LogicalType::ANY),
+	                            ListSortFunction, false, false, ListReverseSortBind);
+
+	// two parameters: list, null order
+	ScalarFunction sort_reverse_null_order({LogicalType::LIST(LogicalType::ANY), LogicalType::VARCHAR},
+	                                       LogicalType::LIST(LogicalType::ANY), ListSortFunction, false, false,
+	                                       ListReverseSortBind);
+
+	ScalarFunctionSet list_reverse_sort("list_reverse_sort");
+	list_reverse_sort.AddFunction(sort_reverse);
+	list_reverse_sort.AddFunction(sort_reverse_null_order);
+	set.AddFunction(list_reverse_sort);
+
+	ScalarFunctionSet array_reverse_sort("array_reverse_sort");
+	array_reverse_sort.AddFunction(sort_reverse);
+	array_reverse_sort.AddFunction(sort_reverse_null_order);
+	set.AddFunction(array_reverse_sort);
+}
+
+} // namespace duckdb
+
+
+
+
+
+
+
+
 namespace duckdb {
 
 static void ListValueFunction(DataChunk &args, ExpressionState &state, Vector &result) {
@@ -90668,6 +91024,7 @@ void BuiltinFunctions::RegisterNestedFunctions() {
 	Register<ListAggregateFun>();
 	Register<ListValueFun>();
 	Register<ListExtractFun>();
+	Register<ListSortFun>();
 	Register<ListRangeFun>();
 	Register<ListFlattenFun>();
 	Register<MapFun>();
@@ -98561,6 +98918,8 @@ static bool ParseBaseOption(BufferedCSVReaderOptions &options, string &loption,
 		options.skip_rows = ParseInteger(set);
 	} else if (loption == "max_line_size" || loption == "maximum_line_size") {
 		options.maximum_line_size = ParseInteger(set);
+	} else if (loption == "ignore_errors") {
+		options.ignore_errors = ParseBoolean(set);
 	} else {
 		// unrecognized option in base CSV
 		return false;
@@ -103872,44 +104231,74 @@ void BaseAppender::AppendValueInternal(T input) {
 		throw InvalidInputException("Too many appends for chunk!");
 	}
 	auto &col = chunk->data[column];
-	switch (col.GetType().InternalType()) {
-	case PhysicalType::BOOL:
+	switch (col.GetType().id()) {
+	case LogicalTypeId::BOOLEAN:
 		AppendValueInternal<T, bool>(col, input);
 		break;
-	case PhysicalType::UINT8:
+	case LogicalTypeId::UTINYINT:
 		AppendValueInternal<T, uint8_t>(col, input);
 		break;
-	case PhysicalType::INT8:
+	case LogicalTypeId::TINYINT:
 		AppendValueInternal<T, int8_t>(col, input);
 		break;
-	case PhysicalType::UINT16:
+	case LogicalTypeId::USMALLINT:
 		AppendValueInternal<T, uint16_t>(col, input);
 		break;
-	case PhysicalType::INT16:
+	case LogicalTypeId::SMALLINT:
 		AppendValueInternal<T, int16_t>(col, input);
 		break;
-	case PhysicalType::UINT32:
+	case LogicalTypeId::UINTEGER:
 		AppendValueInternal<T, uint32_t>(col, input);
 		break;
-	case PhysicalType::INT32:
+	case LogicalTypeId::INTEGER:
 		AppendValueInternal<T, int32_t>(col, input);
 		break;
-	case PhysicalType::UINT64:
+	case LogicalTypeId::UBIGINT:
 		AppendValueInternal<T, uint64_t>(col, input);
 		break;
-	case PhysicalType::INT64:
+	case LogicalTypeId::BIGINT:
 		AppendValueInternal<T, int64_t>(col, input);
 		break;
-	case PhysicalType::INT128:
+	case LogicalTypeId::HUGEINT:
 		AppendValueInternal<T, hugeint_t>(col, input);
 		break;
-	case PhysicalType::FLOAT:
+	case LogicalTypeId::FLOAT:
 		AppendValueInternal<T, float>(col, input);
 		break;
-	case PhysicalType::DOUBLE:
+	case LogicalTypeId::DOUBLE:
 		AppendValueInternal<T, double>(col, input);
 		break;
-	case PhysicalType::VARCHAR:
+	case LogicalTypeId::DECIMAL:
+		switch (col.GetType().InternalType()) {
+		case PhysicalType::INT8:
+			AppendValueInternal<T, int8_t>(col, input);
+			break;
+		case PhysicalType::INT16:
+			AppendValueInternal<T, int16_t>(col, input);
+			break;
+		case PhysicalType::INT32:
+			AppendValueInternal<T, int32_t>(col, input);
+			break;
+		default:
+			AppendValueInternal<T, int64_t>(col, input);
+			break;
+		}
+		break;
+	case LogicalTypeId::DATE:
+		AppendValueInternal<T, date_t>(col, input);
+		break;
+	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
+		AppendValueInternal<T, timestamp_t>(col, input);
+		break;
+	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
+		AppendValueInternal<T, dtime_t>(col, input);
+		break;
+	case LogicalTypeId::INTERVAL:
+		AppendValueInternal<T, interval_t>(col, input);
+		break;
+	case LogicalTypeId::VARCHAR:
 		FlatVector::GetData<string_t>(col)[chunk->size()] = StringCast::Operation<T>(input, col);
 		break;
 	default:
@@ -103995,17 +104384,17 @@ void BaseAppender::Append(double value) {
 
 template <>
 void BaseAppender::Append(date_t value) {
-	AppendValueInternal<int32_t>(value.days);
+	AppendValueInternal<date_t>(value);
 }
 
 template <>
 void BaseAppender::Append(dtime_t value) {
-	AppendValueInternal<int64_t>(value.micros);
+	AppendValueInternal<dtime_t>(value);
 }
 
 template <>
 void BaseAppender::Append(timestamp_t value) {
-	AppendValueInternal<int64_t>(value.value);
+	AppendValueInternal<timestamp_t>(value);
 }
 
 template <>
@@ -105104,6 +105493,24 @@ duckdb_logical_type duckdb_create_logical_type(duckdb_type type) {
 	return new duckdb::LogicalType(duckdb::ConvertCTypeToCPP(type));
 }
 
+duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type) {
+	if (!type) {
+		return nullptr;
+	}
+	duckdb::LogicalType *ltype = new duckdb::LogicalType;
+	*ltype = duckdb::LogicalType::LIST(*(duckdb::LogicalType *)type);
+	return ltype;
+}
+
+duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type) {
+	if (!key_type || !value_type) {
+		return nullptr;
+	}
+	duckdb::LogicalType *mtype = new duckdb::LogicalType;
+	*mtype = duckdb::LogicalType::MAP(*(duckdb::LogicalType *)key_type, *(duckdb::LogicalType *)value_type);
+	return mtype;
+}
+
 duckdb_logical_type duckdb_create_decimal_type(uint8_t width, uint8_t scale) {
 	return new duckdb::LogicalType(duckdb::LogicalType::DECIMAL(width, scale));
 }
@@ -105223,6 +105630,28 @@ duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type) {
 	return new duckdb::LogicalType(duckdb::ListType::GetChildType(ltype));
 }
 
+duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type) {
+	if (!type) {
+		return nullptr;
+	}
+	auto &mtype = *((duckdb::LogicalType *)type);
+	if (mtype.id() != duckdb::LogicalTypeId::MAP) {
+		return nullptr;
+	}
+	return new duckdb::LogicalType(duckdb::MapType::KeyType(mtype));
+}
+
+duckdb_logical_type duckdb_map_type_value_type(duckdb_logical_type type) {
+	if (!type) {
+		return nullptr;
+	}
+	auto &mtype = *((duckdb::LogicalType *)type);
+	if (mtype.id() != duckdb::LogicalTypeId::MAP) {
+		return nullptr;
+	}
+	return new duckdb::LogicalType(duckdb::MapType::ValueType(mtype));
+}
+
 idx_t duckdb_struct_type_child_count(duckdb_logical_type type) {
 	if (!type) {
 		return 0;
@@ -121694,6 +122123,18 @@ string Relation::RenderWhitespace(idx_t depth) {
 	return string(depth * 2, ' ');
 }
 
+vector<shared_ptr<ExternalDependency>> Relation::GetAllDependencies() {
+	vector<shared_ptr<ExternalDependency>> all_dependencies;
+	Relation *cur = this;
+	while (cur) {
+		if (cur->extra_dependencies) {
+			all_dependencies.push_back(cur->extra_dependencies);
+		}
+		cur = ChildRelation();
+	}
+	return all_dependencies;
+}
+
 } // namespace duckdb
 
 
@@ -129244,7 +129685,7 @@ unique_ptr<Expression> EnumComparisonRule::Apply(LogicalOperator &op, vector<Exp
 	}
 
 	auto cast_left_to_right =
-	    make_unique<BoundCastExpression>(move(left_child->child), right_child->child->return_type);
+	    make_unique<BoundCastExpression>(move(left_child->child), right_child->child->return_type, true);
 
 	return make_unique<BoundComparisonExpression>(root->type, move(cast_left_to_right), move(right_child->child));
 }