duckdb 0.3.2-dev1000.0 → 0.3.2-dev1051.0

package/src/duckdb.cpp

@@ -24867,8 +24867,9 @@ public:
 	void PrepareMergePhase();
 	//! Initializes the global sort state for another round of merging
 	void InitializeMergeRound();
-	//! Completes the cascaded merge sort round
-	void CompleteMergeRound();
+	//! 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);
 
 public:
 	//! The lock for updating the order global state
@@ -26764,7 +26765,7 @@ void GlobalSortState::InitializeMergeRound() {
 	}
 }
 
-void GlobalSortState::CompleteMergeRound() {
+void GlobalSortState::CompleteMergeRound(bool keep_radix_data) {
 	sorted_blocks.clear();
 	for (auto &sorted_block_vector : sorted_blocks_temp) {
 		sorted_blocks.push_back(make_unique<SortedBlock>(buffer_manager, *this));
@@ -26776,7 +26777,7 @@ void GlobalSortState::CompleteMergeRound() {
 		odd_one_out = nullptr;
 	}
 	// Only one block left: Done!
-	if (sorted_blocks.size() == 1) {
+	if (sorted_blocks.size() == 1 && !keep_radix_data) {
 		sorted_blocks[0]->radix_sorting_data.clear();
 		sorted_blocks[0]->blob_sorting_data = nullptr;
 	}
@@ -27075,6 +27076,7 @@ void PayloadScanner::Scan(DataChunk &chunk) {
 	auto count = MinValue((idx_t)STANDARD_VECTOR_SIZE, total_count - total_scanned);
 	if (count == 0) {
 		D_ASSERT(read_state.block_idx == sorted_data.data_blocks.size());
+		chunk.SetCardinality(count);
 		return;
 	}
 	// Eagerly delete references to blocks that we've passed
@@ -47663,366 +47665,6 @@ idx_t JoinHashTable::FillWithHTOffsets(data_ptr_t *key_locations, JoinHTScanStat
 	}
 	return key_count;
 }
-} // namespace duckdb
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/merge_join.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-
-
-namespace duckdb {
-
-struct MergeOrder {
-	SelectionVector order;
-	idx_t count;
-	VectorData vdata;
-};
-
-enum MergeInfoType : uint8_t { SCALAR_MERGE_INFO = 1, CHUNK_MERGE_INFO = 2 };
-
-struct MergeInfo {
-	MergeInfo(MergeInfoType info_type, LogicalType type) : info_type(info_type), type(type) {
-	}
-	MergeInfoType info_type;
-	LogicalType type;
-};
-
-struct ScalarMergeInfo : public MergeInfo {
-	MergeOrder &order;
-	idx_t &pos;
-	SelectionVector result;
-
-	ScalarMergeInfo(MergeOrder &order, LogicalType type, idx_t &pos)
-	    : MergeInfo(MergeInfoType::SCALAR_MERGE_INFO, type), order(order), pos(pos), result(STANDARD_VECTOR_SIZE) {
-	}
-};
-
-struct ChunkMergeInfo : public MergeInfo {
-	ChunkCollection &data_chunks;
-	vector<MergeOrder> &order_info;
-	bool found_match[STANDARD_VECTOR_SIZE];
-
-	ChunkMergeInfo(ChunkCollection &data_chunks, vector<MergeOrder> &order_info)
-	    : MergeInfo(MergeInfoType::CHUNK_MERGE_INFO, data_chunks.Types()[0]), data_chunks(data_chunks),
-	      order_info(order_info) {
-		memset(found_match, 0, sizeof(found_match));
-	}
-};
-
-struct MergeJoinComplex {
-	struct LessThan {
-		template <class T>
-		static idx_t Operation(ScalarMergeInfo &l, ScalarMergeInfo &r);
-	};
-	struct LessThanEquals {
-		template <class T>
-		static idx_t Operation(ScalarMergeInfo &l, ScalarMergeInfo &r);
-	};
-	struct GreaterThan {
-		template <class T>
-		static idx_t Operation(ScalarMergeInfo &l, ScalarMergeInfo &r) {
-			return LessThan::Operation<T>(r, l);
-		}
-	};
-	struct GreaterThanEquals {
-		template <class T>
-		static idx_t Operation(ScalarMergeInfo &l, ScalarMergeInfo &r) {
-			return LessThanEquals::Operation<T>(r, l);
-		}
-	};
-
-	static idx_t Perform(MergeInfo &l, MergeInfo &r, ExpressionType comparison_type);
-};
-
-struct MergeJoinSimple {
-	struct LessThan {
-		template <class T>
-		static idx_t Operation(ScalarMergeInfo &l, ChunkMergeInfo &r);
-	};
-	struct LessThanEquals {
-		template <class T>
-		static idx_t Operation(ScalarMergeInfo &l, ChunkMergeInfo &r);
-	};
-	struct GreaterThan {
-		template <class T>
-		static idx_t Operation(ScalarMergeInfo &l, ChunkMergeInfo &r);
-	};
-	struct GreaterThanEquals {
-		template <class T>
-		static idx_t Operation(ScalarMergeInfo &l, ChunkMergeInfo &r);
-	};
-
-	static idx_t Perform(MergeInfo &l, MergeInfo &r, ExpressionType comparison);
-};
-
-#define INSTANTIATE_MERGEJOIN_TEMPLATES(MJCLASS, OPNAME, L, R)                                                         \
-	template idx_t MJCLASS::OPNAME::Operation<int8_t>(L & l, R & r);                                                   \
-	template idx_t MJCLASS::OPNAME::Operation<int16_t>(L & l, R & r);                                                  \
-	template idx_t MJCLASS::OPNAME::Operation<int32_t>(L & l, R & r);                                                  \
-	template idx_t MJCLASS::OPNAME::Operation<int64_t>(L & l, R & r);                                                  \
-	template idx_t MJCLASS::OPNAME::Operation<uint8_t>(L & l, R & r);                                                  \
-	template idx_t MJCLASS::OPNAME::Operation<uint16_t>(L & l, R & r);                                                 \
-	template idx_t MJCLASS::OPNAME::Operation<uint32_t>(L & l, R & r);                                                 \
-	template idx_t MJCLASS::OPNAME::Operation<uint64_t>(L & l, R & r);                                                 \
-	template idx_t MJCLASS::OPNAME::Operation<hugeint_t>(L & l, R & r);                                                \
-	template idx_t MJCLASS::OPNAME::Operation<float>(L & l, R & r);                                                    \
-	template idx_t MJCLASS::OPNAME::Operation<double>(L & l, R & r);                                                   \
-	template idx_t MJCLASS::OPNAME::Operation<interval_t>(L & l, R & r);                                               \
-	template idx_t MJCLASS::OPNAME::Operation<string_t>(L & l, R & r);
-
-} // namespace duckdb
-
-
-
-
-namespace duckdb {
-
-template <class MJ, class L_ARG, class R_ARG>
-static idx_t MergeJoinSwitch(L_ARG &l, R_ARG &r) {
-	switch (l.type.InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		return MJ::template Operation<int8_t>(l, r);
-	case PhysicalType::INT16:
-		return MJ::template Operation<int16_t>(l, r);
-	case PhysicalType::INT32:
-		return MJ::template Operation<int32_t>(l, r);
-	case PhysicalType::INT64:
-		return MJ::template Operation<int64_t>(l, r);
-	case PhysicalType::UINT8:
-		return MJ::template Operation<uint8_t>(l, r);
-	case PhysicalType::UINT16:
-		return MJ::template Operation<uint16_t>(l, r);
-	case PhysicalType::UINT32:
-		return MJ::template Operation<uint32_t>(l, r);
-	case PhysicalType::UINT64:
-		return MJ::template Operation<uint64_t>(l, r);
-	case PhysicalType::INT128:
-		return MJ::template Operation<hugeint_t>(l, r);
-	case PhysicalType::FLOAT:
-		return MJ::template Operation<float>(l, r);
-	case PhysicalType::DOUBLE:
-		return MJ::template Operation<double>(l, r);
-	case PhysicalType::INTERVAL:
-		return MJ::template Operation<interval_t>(l, r);
-	case PhysicalType::VARCHAR:
-		return MJ::template Operation<string_t>(l, r);
-	default:
-		throw InternalException("Type not implemented for merge join!");
-	}
-}
-
-template <class T, class L_ARG, class R_ARG>
-static idx_t MergeJoinComparisonSwitch(L_ARG &l, R_ARG &r, ExpressionType comparison_type) {
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_LESSTHAN:
-		return MergeJoinSwitch<typename T::LessThan, L_ARG, R_ARG>(l, r);
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		return MergeJoinSwitch<typename T::LessThanEquals, L_ARG, R_ARG>(l, r);
-	case ExpressionType::COMPARE_GREATERTHAN:
-		return MergeJoinSwitch<typename T::GreaterThan, L_ARG, R_ARG>(l, r);
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		return MergeJoinSwitch<typename T::GreaterThanEquals, L_ARG, R_ARG>(l, r);
-	default:
-		throw InternalException("Unimplemented comparison type for merge join!");
-	}
-}
-
-idx_t MergeJoinComplex::Perform(MergeInfo &l, MergeInfo &r, ExpressionType comparison_type) {
-	D_ASSERT(l.info_type == MergeInfoType::SCALAR_MERGE_INFO && r.info_type == MergeInfoType::SCALAR_MERGE_INFO);
-	auto &left = (ScalarMergeInfo &)l;
-	auto &right = (ScalarMergeInfo &)r;
-	D_ASSERT(left.type == right.type);
-	if (left.order.count == 0 || right.order.count == 0) {
-		return 0;
-	}
-	return MergeJoinComparisonSwitch<MergeJoinComplex, ScalarMergeInfo, ScalarMergeInfo>(left, right, comparison_type);
-}
-
-idx_t MergeJoinSimple::Perform(MergeInfo &l, MergeInfo &r, ExpressionType comparison_type) {
-	D_ASSERT(l.info_type == MergeInfoType::SCALAR_MERGE_INFO && r.info_type == MergeInfoType::CHUNK_MERGE_INFO);
-	auto &left = (ScalarMergeInfo &)l;
-	auto &right = (ChunkMergeInfo &)r;
-	D_ASSERT(left.type == right.type);
-	if (left.order.count == 0 || right.data_chunks.Count() == 0) {
-		return 0;
-	}
-	return MergeJoinComparisonSwitch<MergeJoinSimple, ScalarMergeInfo, ChunkMergeInfo>(left, right, comparison_type);
-}
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-template <class T, class OP>
-idx_t MergeJoinComplexLessThan(ScalarMergeInfo &l, ScalarMergeInfo &r) {
-	if (r.pos >= r.order.count) {
-		return 0;
-	}
-	auto ldata = (T *)l.order.vdata.data;
-	auto rdata = (T *)r.order.vdata.data;
-	auto &lorder = l.order.order;
-	auto &rorder = r.order.order;
-	idx_t result_count = 0;
-	while (true) {
-		if (l.pos < l.order.count) {
-			auto lidx = lorder.get_index(l.pos);
-			auto ridx = rorder.get_index(r.pos);
-			auto dlidx = l.order.vdata.sel->get_index(lidx);
-			auto dridx = r.order.vdata.sel->get_index(ridx);
-			if (OP::Operation(ldata[dlidx], rdata[dridx])) {
-				// left side smaller: found match
-				l.result.set_index(result_count, lidx);
-				r.result.set_index(result_count, ridx);
-				result_count++;
-				// move left side forward
-				l.pos++;
-				if (result_count == STANDARD_VECTOR_SIZE) {
-					// out of space!
-					break;
-				}
-				continue;
-			}
-		}
-		// right side smaller or equal, or left side exhausted: move
-		// right pointer forward reset left side to start
-		l.pos = 0;
-		r.pos++;
-		if (r.pos == r.order.count) {
-			break;
-		}
-	}
-	return result_count;
-}
-
-template <class T>
-idx_t MergeJoinComplex::LessThan::Operation(ScalarMergeInfo &l, ScalarMergeInfo &r) {
-	return MergeJoinComplexLessThan<T, duckdb::LessThan>(l, r);
-}
-
-template <class T>
-idx_t MergeJoinComplex::LessThanEquals::Operation(ScalarMergeInfo &l, ScalarMergeInfo &r) {
-	return MergeJoinComplexLessThan<T, duckdb::LessThanEquals>(l, r);
-}
-
-INSTANTIATE_MERGEJOIN_TEMPLATES(MergeJoinComplex, LessThan, ScalarMergeInfo, ScalarMergeInfo)
-INSTANTIATE_MERGEJOIN_TEMPLATES(MergeJoinComplex, LessThanEquals, ScalarMergeInfo, ScalarMergeInfo)
-
-} // namespace duckdb
-
-
-
-
-
-namespace duckdb {
-
-template <class T, class OP>
-static idx_t MergeJoinSimpleGreaterThan(ScalarMergeInfo &l, ChunkMergeInfo &r) {
-	auto ldata = (T *)l.order.vdata.data;
-	auto &lorder = l.order.order;
-	l.pos = l.order.count;
-	for (idx_t chunk_idx = 0; chunk_idx < r.order_info.size(); chunk_idx++) {
-		// we only care about the SMALLEST value in each of the RHS
-		// because we want to figure out if they are greater than [or equal] to ANY value
-		// get the smallest value from the RHS
-		auto &rorder = r.order_info[chunk_idx];
-		auto rdata = (T *)rorder.vdata.data;
-		auto min_r_value = rdata[rorder.vdata.sel->get_index(rorder.order.get_index(0))];
-		// now we start from the current lpos value and check if we found a new value that is [>= OR >] the min RHS
-		// value
-		while (true) {
-			auto lidx = lorder.get_index(l.pos - 1);
-			auto dlidx = l.order.vdata.sel->get_index(lidx);
-			if (OP::Operation(ldata[dlidx], min_r_value)) {
-				// found a match for lpos, set it in the found_match vector
-				r.found_match[lidx] = true;
-				l.pos--;
-				if (l.pos == 0) {
-					// early out: we exhausted the entire LHS and they all match
-					return 0;
-				}
-			} else {
-				// we found no match: any subsequent value from the LHS we scan now will be smaller and thus also not
-				// match move to the next RHS chunk
-				break;
-			}
-		}
-	}
-	return 0;
-}
-template <class T>
-idx_t MergeJoinSimple::GreaterThan::Operation(ScalarMergeInfo &l, ChunkMergeInfo &r) {
-	return MergeJoinSimpleGreaterThan<T, duckdb::GreaterThan>(l, r);
-}
-
-template <class T>
-idx_t MergeJoinSimple::GreaterThanEquals::Operation(ScalarMergeInfo &l, ChunkMergeInfo &r) {
-	return MergeJoinSimpleGreaterThan<T, duckdb::GreaterThanEquals>(l, r);
-}
-
-template <class T, class OP>
-static idx_t MergeJoinSimpleLessThan(ScalarMergeInfo &l, ChunkMergeInfo &r) {
-	auto ldata = (T *)l.order.vdata.data;
-	auto &lorder = l.order.order;
-	l.pos = 0;
-	for (idx_t chunk_idx = 0; chunk_idx < r.order_info.size(); chunk_idx++) {
-		// we only care about the BIGGEST value in each of the RHS
-		// because we want to figure out if they are less than [or equal] to ANY value
-		// get the biggest value from the RHS
-		auto &rorder = r.order_info[chunk_idx];
-		auto rdata = (T *)rorder.vdata.data;
-		auto max_r_value = rdata[rorder.vdata.sel->get_index(rorder.order.get_index(rorder.count - 1))];
-		// now we start from the current lpos value and check if we found a new value that is [<= OR <] the max RHS
-		// value
-		while (true) {
-			auto lidx = lorder.get_index(l.pos);
-			auto dlidx = l.order.vdata.sel->get_index(lidx);
-			if (OP::Operation(ldata[dlidx], max_r_value)) {
-				// found a match for lpos, set it in the found_match vector
-				r.found_match[lidx] = true;
-				l.pos++;
-				if (l.pos == l.order.count) {
-					// early out: we exhausted the entire LHS and they all match
-					return 0;
-				}
-			} else {
-				// we found no match: any subsequent value from the LHS we scan now will be bigger and thus also not
-				// match move to the next RHS chunk
-				break;
-			}
-		}
-	}
-	return 0;
-}
-
-template <class T>
-idx_t MergeJoinSimple::LessThan::Operation(ScalarMergeInfo &l, ChunkMergeInfo &r) {
-	return MergeJoinSimpleLessThan<T, duckdb::LessThan>(l, r);
-}
-
-template <class T>
-idx_t MergeJoinSimple::LessThanEquals::Operation(ScalarMergeInfo &l, ChunkMergeInfo &r) {
-	return MergeJoinSimpleLessThan<T, duckdb::LessThanEquals>(l, r);
-}
-
-INSTANTIATE_MERGEJOIN_TEMPLATES(MergeJoinSimple, LessThan, ScalarMergeInfo, ChunkMergeInfo)
-INSTANTIATE_MERGEJOIN_TEMPLATES(MergeJoinSimple, LessThanEquals, ScalarMergeInfo, ChunkMergeInfo)
-INSTANTIATE_MERGEJOIN_TEMPLATES(MergeJoinSimple, GreaterThan, ScalarMergeInfo, ChunkMergeInfo)
-INSTANTIATE_MERGEJOIN_TEMPLATES(MergeJoinSimple, GreaterThanEquals, ScalarMergeInfo, ChunkMergeInfo)
-
 } // namespace duckdb
 
 //===----------------------------------------------------------------------===//
@@ -55010,6 +54652,8 @@ void PhysicalNestedLoopJoin::GetData(ExecutionContext &context, DataChunk &chunk
 
 namespace duckdb {
 
+class MergeJoinGlobalState;
+
 //! PhysicalPiecewiseMergeJoin represents a piecewise merge loop join between
 //! two tables
 class PhysicalPiecewiseMergeJoin : public PhysicalComparisonJoin {
@@ -55019,6 +54663,8 @@ public:
 	                           idx_t estimated_cardinality);
 
 	vector<LogicalType> join_key_types;
+	vector<BoundOrderByNode> lhs_orders;
+	vector<BoundOrderByNode> rhs_orders;
 
 public:
 	// Operator Interface
@@ -55057,6 +54703,9 @@ 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;
 	}
@@ -55081,6 +54730,11 @@ private:
 
 
 
+
+
+
+
+
 namespace duckdb {
 
 PhysicalPiecewiseMergeJoin::PhysicalPiecewiseMergeJoin(LogicalOperator &op, unique_ptr<PhysicalOperator> left,
@@ -55091,10 +54745,27 @@ PhysicalPiecewiseMergeJoin::PhysicalPiecewiseMergeJoin(LogicalOperator &op, uniq
 	// for now we only support one condition!
 	D_ASSERT(conditions.size() == 1);
 	for (auto &cond : conditions) {
-		// COMPARE NOT EQUAL not supported with merge join
-		D_ASSERT(cond.comparison != ExpressionType::COMPARE_NOTEQUAL);
 		D_ASSERT(cond.left->return_type == cond.right->return_type);
 		join_key_types.push_back(cond.left->return_type);
+
+		// Convert the conditions to sort orders
+		auto left = cond.left->Copy();
+		auto right = cond.right->Copy();
+		switch (cond.comparison) {
+		case ExpressionType::COMPARE_LESSTHAN:
+		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+			lhs_orders.emplace_back(BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, move(left)));
+			rhs_orders.emplace_back(BoundOrderByNode(OrderType::ASCENDING, OrderByNullType::NULLS_LAST, move(right)));
+			break;
+		case ExpressionType::COMPARE_GREATERTHAN:
+		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+			lhs_orders.emplace_back(BoundOrderByNode(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, move(left)));
+			rhs_orders.emplace_back(BoundOrderByNode(OrderType::DESCENDING, OrderByNullType::NULLS_LAST, move(right)));
+			break;
+		default:
+			// COMPARE NOT EQUAL not supported with merge join
+			throw NotImplementedException("Unimplemented join type for merge join");
+		}
 	}
 	children.push_back(move(left));
 	children.push_back(move(right));
@@ -55103,114 +54774,242 @@ PhysicalPiecewiseMergeJoin::PhysicalPiecewiseMergeJoin(LogicalOperator &op, uniq
 //===--------------------------------------------------------------------===//
 // Sink
 //===--------------------------------------------------------------------===//
-class MergeJoinLocalState : public LocalSinkState {
+class MergeJoinGlobalState : public GlobalSinkState {
 public:
-	explicit MergeJoinLocalState(const vector<JoinCondition> &conditions) {
-		vector<LogicalType> condition_types;
-		for (auto &cond : conditions) {
-			rhs_executor.AddExpression(*cond.right);
-			condition_types.push_back(cond.right->return_type);
-		}
-		join_keys.Initialize(condition_types);
+	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) {
 	}
 
-	//! The chunk holding the right condition
-	DataChunk join_keys;
-	//! The executor of the RHS condition
-	ExpressionExecutor rhs_executor;
-};
-
-class MergeJoinGlobalState : public GlobalSinkState {
-public:
-	MergeJoinGlobalState() : has_null(false), right_outer_position(0) {
+	inline idx_t Count() const {
+		return rhs_count;
 	}
 
-	mutex mj_lock;
-	//! The materialized data of the RHS
-	ChunkCollection right_chunks;
-	//! The materialized join keys of the RHS
-	ChunkCollection right_conditions;
-	//! The join orders of the RHS
-	vector<MergeOrder> right_orders;
-	//! Whether or not the RHS of the nested loop join has NULL values
-	bool has_null;
+	//! 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[]> right_found_match;
-	//! The position in the RHS in the final scan of the FULL OUTER JOIN
-	idx_t right_outer_position;
+	unique_ptr<bool[]> rhs_found_match;
+	//! Memory usage per thread
+	idx_t memory_per_thread;
 };
 
 unique_ptr<GlobalSinkState> PhysicalPiecewiseMergeJoin::GetGlobalSinkState(ClientContext &context) const {
-	return make_unique<MergeJoinGlobalState>();
+	// Get the payload layout from the rhs types
+	RowLayout rhs_layout;
+	auto types = children[1]->types;
+	rhs_layout.Initialize(types);
+	auto state = make_unique<MergeJoinGlobalState>(BufferManager::GetBufferManager(context), rhs_orders, 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);
 }
 
+static idx_t CountValid(Vector &v, const idx_t count) {
+	idx_t valid = 0;
+
+	VectorData vdata;
+	v.Orrify(count, vdata);
+	if (vdata.validity.AllValid()) {
+		return count;
+	}
+	switch (v.GetVectorType()) {
+	case VectorType::FLAT_VECTOR:
+		valid += vdata.validity.CountValid(count);
+		break;
+	case VectorType::CONSTANT_VECTOR:
+		valid += vdata.validity.CountValid(1) * count;
+		break;
+	default:
+		for (idx_t i = 0; i < count; ++i) {
+			const auto row_idx = vdata.sel->get_index(i);
+			valid += int(vdata.validity.RowIsValid(row_idx));
+		}
+		break;
+	}
+
+	return valid;
+}
+
+class MergeJoinLocalState : public LocalSinkState {
+public:
+	explicit MergeJoinLocalState() : rhs_has_null(0), rhs_count(0) {
+	}
+
+	//! 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 {
-	return make_unique<MergeJoinLocalState>(conditions);
+	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);
+	}
+	result->rhs_keys.Initialize(types);
+	return move(result);
 }
 
-SinkResultType PhysicalPiecewiseMergeJoin::Sink(ExecutionContext &context, GlobalSinkState &state,
-                                                LocalSinkState &lstate, DataChunk &input) const {
-	auto &gstate = (MergeJoinGlobalState &)state;
-	auto &mj_state = (MergeJoinLocalState &)lstate;
+SinkResultType PhysicalPiecewiseMergeJoin::Sink(ExecutionContext &context, GlobalSinkState &gstate_p,
+                                                LocalSinkState &lstate_p, DataChunk &input) const {
+	auto &gstate = (MergeJoinGlobalState &)gstate_p;
+	auto &lstate = (MergeJoinLocalState &)lstate_p;
 
-	// resolve the join keys for this chunk
-	mj_state.rhs_executor.SetChunk(input);
+	auto &global_sort_state = gstate.rhs_global_sort_state;
+	auto &local_sort_state = lstate.rhs_local_sort_state;
 
-	mj_state.join_keys.Reset();
-	mj_state.join_keys.SetCardinality(input);
-	for (idx_t k = 0; k < conditions.size(); k++) {
-		// resolve the join key
-		mj_state.rhs_executor.ExecuteExpression(k, mj_state.join_keys.data[k]);
+	// 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
+	// TODO: Sort any comparison NULLs to the end using an initial sort column
+	const auto count = join_keys.size();
+	for (auto &key : join_keys.data) {
+		lstate.rhs_has_null += (count - CountValid(key, count));
+	}
+	lstate.rhs_count += count;
+
+	// Sink the data into the local sort state
+	local_sort_state.SinkChunk(join_keys, input);
+
+	// 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);
 	}
-	// append the join keys and the chunk to the chunk collection
-	lock_guard<mutex> mj_guard(gstate.mj_lock);
-	gstate.right_chunks.Append(input);
-	gstate.right_conditions.Append(mj_state.join_keys);
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
-void PhysicalPiecewiseMergeJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate,
-                                         LocalSinkState &lstate) const {
-	auto &state = (MergeJoinLocalState &)lstate;
+void PhysicalPiecewiseMergeJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate_p,
+                                         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;
 	auto &client_profiler = QueryProfiler::Get(context.client);
 
-	context.thread.profiler.Flush(this, &state.rhs_executor, "rhs_executor", 1);
+	context.thread.profiler.Flush(this, &lstate.rhs_executor, "rhs_executor", 1);
 	client_profiler.Flush(context.thread.profiler);
 }
 
 //===--------------------------------------------------------------------===//
 // Finalize
 //===--------------------------------------------------------------------===//
-static void OrderVector(Vector &vector, idx_t count, MergeOrder &order);
+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;
-	if (gstate.right_conditions.ChunkCount() > 0) {
-		// now order all the chunks
-		gstate.right_orders.resize(gstate.right_conditions.ChunkCount());
-		for (idx_t i = 0; i < gstate.right_conditions.ChunkCount(); i++) {
-			auto &chunk_to_order = gstate.right_conditions.GetChunk(i);
-			D_ASSERT(chunk_to_order.ColumnCount() == 1);
-			for (idx_t col_idx = 0; col_idx < chunk_to_order.ColumnCount(); col_idx++) {
-				OrderVector(chunk_to_order.data[col_idx], chunk_to_order.size(), gstate.right_orders[i]);
-				if (gstate.right_orders[i].count < chunk_to_order.size()) {
-					// the amount of entries in the order vector is smaller than the amount of entries in the vector
-					// this only happens if there are NULL values in the right-hand side
-					// hence we set the has_null to true (this is required for the MARK join)
-					gstate.has_null = true;
-				}
-			}
-		}
-	}
+	auto &global_sort_state = gstate.rhs_global_sort_state;
+
 	if (IsRightOuterJoin(join_type)) {
 		// for FULL/RIGHT OUTER JOIN, initialize found_match to false for every tuple
-		gstate.right_found_match = unique_ptr<bool[]>(new bool[gstate.right_chunks.Count()]);
-		memset(gstate.right_found_match.get(), 0, sizeof(bool) * gstate.right_chunks.Count());
+		gstate.rhs_found_match = unique_ptr<bool[]>(new bool[gstate.Count()]);
+		memset(gstate.rhs_found_match.get(), 0, sizeof(bool) * gstate.Count());
 	}
-	if (gstate.right_chunks.Count() == 0 && EmptyResultIfRHSIsEmpty()) {
+	if (global_sort_state.sorted_blocks.empty() && EmptyResultIfRHSIsEmpty()) {
+		// Empty input!
 		return SinkFinalizeType::NO_OUTPUT_POSSIBLE;
 	}
+
+	// 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) {
+		PhysicalPiecewiseMergeJoin::ScheduleMergeTasks(pipeline, event, gstate);
+	}
 	return SinkFinalizeType::READY;
 }
 
@@ -55219,43 +55018,75 @@ SinkFinalizeType PhysicalPiecewiseMergeJoin::Finalize(Pipeline &pipeline, Event
 //===--------------------------------------------------------------------===//
 class PiecewiseMergeJoinState : public OperatorState {
 public:
-	explicit PiecewiseMergeJoinState(const PhysicalPiecewiseMergeJoin &op)
-	    : op(op), first_fetch(true), finished(true), left_position(0), right_position(0), right_chunk_index(0) {
+	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 &cond : op.conditions) {
 			lhs_executor.AddExpression(*cond.left);
 			condition_types.push_back(cond.left->return_type);
 		}
-		join_keys.Initialize(condition_types);
+		lhs_keys.Initialize(condition_types);
 		if (IsLeftOuterJoin(op.join_type)) {
-			left_found_match = unique_ptr<bool[]>(new bool[STANDARD_VECTOR_SIZE]);
-			memset(left_found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
+			lhs_found_match = unique_ptr<bool[]>(new bool[STANDARD_VECTOR_SIZE]);
+			memset(lhs_found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
 		}
+		lhs_layout.Initialize(op.children[0]->types);
 	}
 
 	const PhysicalPiecewiseMergeJoin &op;
+	BufferManager &buffer_manager;
+	bool force_external;
+
+	// Block sorting
+	DataChunk lhs_keys;
+	ExpressionExecutor lhs_executor;
+	unique_ptr<bool[]> lhs_found_match;
+	RowLayout lhs_layout;
+	unique_ptr<LocalSortState> lhs_local_state;
+	unique_ptr<GlobalSortState> lhs_global_state;
+	idx_t lhs_count;
+	idx_t lhs_has_null;
+
+	// Simple scans
+	idx_t left_position;
+
+	// Complex scans
 	bool first_fetch;
 	bool finished;
-	idx_t left_position;
 	idx_t right_position;
 	idx_t right_chunk_index;
-	DataChunk left_chunk;
-	DataChunk join_keys;
-	MergeOrder left_orders;
-	//! The executor of the RHS condition
-	ExpressionExecutor lhs_executor;
-	unique_ptr<bool[]> left_found_match;
+	idx_t right_base;
 
 public:
 	void ResolveJoinKeys(DataChunk &input) {
 		// resolve the join keys for the input
-		join_keys.Reset();
-		lhs_executor.SetChunk(input);
-		join_keys.SetCardinality(input);
-		for (idx_t k = 0; k < op.conditions.size(); k++) {
-			lhs_executor.ExecuteExpression(k, join_keys.data[k]);
-			// sort by join key
-			OrderVector(join_keys.data[k], join_keys.size(), left_orders);
+		lhs_keys.Reset();
+		lhs_executor.Execute(input, lhs_keys);
+
+		// Count the NULLs so we can exclude them later
+		// TODO: Sort any multi-comparison NULLs to the end using an initial sort column
+		lhs_count = lhs_keys.size();
+		for (auto &key : lhs_keys.data) {
+			lhs_has_null = lhs_count - CountValid(key, lhs_count);
+			break;
+		}
+
+		// sort by join key
+		lhs_global_state = make_unique<GlobalSortState>(buffer_manager, op.lhs_orders, lhs_layout);
+		lhs_local_state = make_unique<LocalSortState>();
+		lhs_local_state->Initialize(*lhs_global_state, buffer_manager);
+		lhs_local_state->SinkChunk(lhs_keys, input);
+
+		// Set external (can be force with the PRAGMA)
+		lhs_global_state->external = force_external;
+		lhs_global_state->AddLocalState(*lhs_local_state);
+		lhs_global_state->PrepareMergePhase();
+		while (lhs_global_state->sorted_blocks.size() > 1) {
+			MergeSorter merge_sorter(*lhs_global_state, buffer_manager);
+			merge_sorter.PerformInMergeRound();
+			lhs_global_state->CompleteMergeRound();
 		}
 	}
 
@@ -55265,7 +55096,176 @@ public:
 };
 
 unique_ptr<OperatorState> PhysicalPiecewiseMergeJoin::GetOperatorState(ClientContext &context) const {
-	return make_unique<PiecewiseMergeJoinState>(*this);
+	auto &buffer_manager = BufferManager::GetBufferManager(context);
+	auto &config = ClientConfig::GetConfig(context);
+	return make_unique<PiecewiseMergeJoinState>(*this, buffer_manager, config.force_external);
+}
+
+static inline idx_t SortedBlockNotNull(const idx_t base, const idx_t count, const idx_t not_null) {
+	return MinValue(base + count, MaxValue(base, not_null)) - base;
+}
+
+static int MergeJoinComparisonValue(ExpressionType comparison) {
+	switch (comparison) {
+	case ExpressionType::COMPARE_LESSTHAN:
+	case ExpressionType::COMPARE_GREATERTHAN:
+		return -1;
+	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+		return 0;
+	default:
+		throw InternalException("Unimplemented comparison type for merge join!");
+	}
+}
+
+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) {
+	}
+};
+
+static void SliceSortedPayload(DataChunk &payload, BlockMergeInfo &info, const idx_t result_count, const idx_t vcount,
+                               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.
+	read_state.SetIndices(info.block_idx, info.base_idx);
+	read_state.PinData(sorted_data);
+	const auto data_ptr = read_state.DataPtr(sorted_data);
+	const auto next = vcount - info.base_idx;
+
+	// Set up a batch of pointers to scan data from
+	Vector addresses(LogicalType::POINTER, next);
+	auto data_pointers = FlatVector::GetData<data_ptr_t>(addresses);
+
+	// Set up the data pointers
+	data_ptr_t row_ptr = data_ptr;
+	const idx_t &row_width = sorted_data.layout.GetRowWidth();
+	for (idx_t i = 0; i < next; ++i) {
+		data_pointers[i] = row_ptr;
+		row_ptr += row_width;
+	}
+	// Unswizzle the offsets back to pointers (if needed)
+	if (!sorted_data.layout.AllConstant() && info.state.external) {
+		RowOperations::UnswizzlePointers(sorted_data.layout, data_ptr, read_state.payload_heap_handle->Ptr(), next);
+	}
+
+	// Deserialize the payload data
+	for (idx_t col_idx = 0; col_idx < sorted_data.layout.ColumnCount(); col_idx++) {
+		const auto col_offset = sorted_data.layout.GetOffsets()[col_idx];
+		RowOperations::Gather(addresses, info.result, payload.data[left_cols + col_idx],
+		                      *FlatVector::IncrementalSelectionVector(), result_count, col_offset, col_idx);
+	}
+}
+
+static void MergeJoinPinSortingBlock(SBScanState &scan, const idx_t block_idx) {
+	scan.SetIndices(block_idx, 0);
+	scan.PinRadix(block_idx);
+
+	auto &sd = *scan.sb->blob_sorting_data;
+	if (block_idx < sd.data_blocks.size()) {
+		scan.PinData(sd);
+	}
+}
+
+static data_ptr_t MergeJoinRadixPtr(SBScanState &scan, const idx_t entry_idx) {
+	scan.entry_idx = entry_idx;
+	return scan.RadixPtr();
+}
+
+static idx_t MergeJoinSimpleBlocks(PiecewiseMergeJoinState &lstate, MergeJoinGlobalState &rstate, bool *found_match,
+                                   const ExpressionType comparison) {
+	const auto cmp = MergeJoinComparisonValue(comparison);
+
+	// The sort parameters should all be the same
+	auto &lsort = *lstate.lhs_global_state;
+	auto &rsort = rstate.rhs_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);
+	const auto external = lsort.external;
+
+	// There should only be one sorted block if they have been sorted
+	D_ASSERT(lsort.sorted_blocks.size() == 1);
+	SBScanState lread(lsort.buffer_manager, lsort);
+	lread.sb = lsort.sorted_blocks[0].get();
+
+	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;
+	MergeJoinPinSortingBlock(lread, l_block_idx);
+	auto l_ptr = MergeJoinRadixPtr(lread, l_entry_idx);
+
+	D_ASSERT(rsort.sorted_blocks.size() == 1);
+	SBScanState rread(rsort.buffer_manager, rsort);
+	rread.sb = rsort.sorted_blocks[0].get();
+
+	const auto cmp_size = lsort.sort_layout.comparison_size;
+	const auto entry_size = lsort.sort_layout.entry_size;
+
+	idx_t right_base = 0;
+	for (idx_t r_block_idx = 0; r_block_idx < rread.sb->radix_sorting_data.size(); r_block_idx++) {
+		// we only care about the BIGGEST value in each of the RHS data blocks
+		// because we want to figure out if the LHS values are less than [or equal] to ANY value
+		// get the biggest value from the RHS chunk
+		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);
+		if (r_not_null == 0) {
+			break;
+		}
+		const auto r_entry_idx = r_not_null - 1;
+		right_base += rblock.count;
+
+		auto r_ptr = MergeJoinRadixPtr(rread, r_entry_idx);
+
+		// now we start from the current lpos value and check if we found a new value that is [<= OR <] the max RHS
+		// value
+		while (true) {
+			int comp_res;
+			if (all_constant) {
+				comp_res = FastMemcmp(l_ptr, r_ptr, cmp_size);
+			} else {
+				lread.entry_idx = l_entry_idx;
+				rread.entry_idx = r_entry_idx;
+				comp_res = Comparators::CompareTuple(lread, rread, l_ptr, r_ptr, lsort.sort_layout, external);
+			}
+
+			if (comp_res <= cmp) {
+				// found a match for lpos, set it in the found_match vector
+				found_match[l_entry_idx] = true;
+				l_entry_idx++;
+				l_ptr += entry_size;
+				if (l_entry_idx >= lhs_not_null) {
+					// early out: we exhausted the entire LHS and they all match
+					return 0;
+				}
+			} else {
+				// we found no match: any subsequent value from the LHS we scan now will be bigger and thus also not
+				// match move to the next RHS chunk
+				break;
+			}
+		}
+	}
+	return 0;
 }
 
 void PhysicalPiecewiseMergeJoin::ResolveSimpleJoin(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
@@ -55275,37 +55275,138 @@ void PhysicalPiecewiseMergeJoin::ResolveSimpleJoin(ExecutionContext &context, Da
 
 	state.ResolveJoinKeys(input);
 
-	ScalarMergeInfo left_info(state.left_orders, state.join_keys.data[0].GetType(), state.left_position);
-	ChunkMergeInfo right_info(gstate.right_conditions, gstate.right_orders);
-
 	// perform the actual join
-	MergeJoinSimple::Perform(left_info, right_info, conditions[0].comparison);
+	bool found_match[STANDARD_VECTOR_SIZE];
+	memset(found_match, 0, sizeof(found_match));
+	MergeJoinSimpleBlocks(state, gstate, found_match, conditions[0].comparison);
 
-	// now construct the result based ont he join result
+	// extract the sorted payload
+	idx_t left_position = 0;
+	const auto lhs_not_null = state.lhs_count - state.lhs_has_null;
+	BlockMergeInfo left_info(*state.lhs_global_state, 0, 0, left_position, lhs_not_null);
+	left_info.result.Initialize(nullptr);
+
+	DataChunk payload;
+	payload.Initialize(input.GetTypes());
+	SliceSortedPayload(payload, left_info, state.lhs_count, state.lhs_count);
+	payload.SetCardinality(state.lhs_count);
+
+	// now construct the result based on the join result
 	switch (join_type) {
-	case JoinType::MARK:
-		PhysicalJoin::ConstructMarkJoinResult(state.join_keys, input, chunk, right_info.found_match, gstate.has_null);
+	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());
+			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) {
+				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);
 		break;
+	}
 	case JoinType::SEMI:
-		PhysicalJoin::ConstructSemiJoinResult(input, chunk, right_info.found_match);
+		PhysicalJoin::ConstructSemiJoinResult(payload, chunk, found_match);
 		break;
 	case JoinType::ANTI:
-		PhysicalJoin::ConstructAntiJoinResult(input, chunk, right_info.found_match);
+		PhysicalJoin::ConstructAntiJoinResult(payload, chunk, found_match);
 		break;
 	default:
 		throw NotImplementedException("Unimplemented join type for merge join");
 	}
 }
 
+static idx_t MergeJoinComplexBlocks(BlockMergeInfo &l, BlockMergeInfo &r, const ExpressionType comparison) {
+	const auto cmp = MergeJoinComparisonValue(comparison);
+
+	// The sort parameters should all be the same
+	D_ASSERT(l.state.sort_layout.all_constant == r.state.sort_layout.all_constant);
+	const auto all_constant = r.state.sort_layout.all_constant;
+	D_ASSERT(l.state.external == r.state.external);
+	const auto external = l.state.external;
+
+	// There should only be one sorted block if they have been sorted
+	D_ASSERT(l.state.sorted_blocks.size() == 1);
+	SBScanState lread(l.state.buffer_manager, l.state);
+	lread.sb = l.state.sorted_blocks[0].get();
+	D_ASSERT(lread.sb->radix_sorting_data.size() == 1);
+	MergeJoinPinSortingBlock(lread, l.block_idx);
+	auto l_start = MergeJoinRadixPtr(lread, 0);
+	auto l_ptr = MergeJoinRadixPtr(lread, l.entry_idx);
+
+	D_ASSERT(r.state.sorted_blocks.size() == 1);
+	SBScanState rread(r.state.buffer_manager, r.state);
+	rread.sb = r.state.sorted_blocks[0].get();
+
+	if (r.entry_idx >= r.not_null) {
+		return 0;
+	}
+
+	MergeJoinPinSortingBlock(rread, r.block_idx);
+	auto r_ptr = MergeJoinRadixPtr(rread, r.entry_idx);
+
+	const auto cmp_size = l.state.sort_layout.comparison_size;
+	const auto entry_size = l.state.sort_layout.entry_size;
+
+	idx_t result_count = 0;
+	while (true) {
+		if (l.entry_idx < l.not_null) {
+			int comp_res;
+			if (all_constant) {
+				comp_res = FastMemcmp(l_ptr, r_ptr, cmp_size);
+			} else {
+				lread.entry_idx = l.entry_idx;
+				rread.entry_idx = r.entry_idx;
+				comp_res = Comparators::CompareTuple(lread, rread, l_ptr, r_ptr, l.state.sort_layout, external);
+			}
+
+			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));
+				result_count++;
+				// move left side forward
+				l.entry_idx++;
+				l_ptr += entry_size;
+				if (result_count == STANDARD_VECTOR_SIZE) {
+					// out of space!
+					break;
+				}
+				continue;
+			}
+		}
+		// right side smaller or equal, or left side exhausted: move
+		// right pointer forward reset left side to start
+		r.entry_idx++;
+		if (r.entry_idx >= r.not_null) {
+			break;
+		}
+		r_ptr += entry_size;
+
+		l_ptr = l_start;
+		l.entry_idx = 0;
+	}
+
+	return result_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];
 	do {
 		if (state.first_fetch) {
 			state.ResolveJoinKeys(input);
 
 			state.right_chunk_index = 0;
+			state.right_base = 0;
 			state.left_position = 0;
 			state.right_position = 0;
 			state.first_fetch = false;
@@ -55315,47 +55416,53 @@ OperatorResultType PhysicalPiecewiseMergeJoin::ResolveComplexJoin(ExecutionConte
 			if (IsLeftOuterJoin(join_type)) {
 				// left join: before we move to the next chunk, see if we need to output any vectors that didn't
 				// have a match found
-				PhysicalJoin::ConstructLeftJoinResult(input, chunk, state.left_found_match.get());
-				memset(state.left_found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
+				PhysicalJoin::ConstructLeftJoinResult(input, chunk, state.lhs_found_match.get());
+				memset(state.lhs_found_match.get(), 0, sizeof(bool) * STANDARD_VECTOR_SIZE);
 			}
 			state.first_fetch = true;
 			state.finished = false;
 			return OperatorResultType::NEED_MORE_INPUT;
 		}
 
-		auto &right_chunk = gstate.right_chunks.GetChunk(state.right_chunk_index);
-		auto &right_condition_chunk = gstate.right_conditions.GetChunk(state.right_chunk_index);
-		auto &right_orders = gstate.right_orders[state.right_chunk_index];
+		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);
 
-		ScalarMergeInfo left_info(state.left_orders, state.join_keys.data[0].GetType(), state.left_position);
-		ScalarMergeInfo right_info(right_orders, right_condition_chunk.data[0].GetType(), state.right_position);
+		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);
 
-		idx_t result_count = MergeJoinComplex::Perform(left_info, right_info, conditions[0].comparison);
+		idx_t result_count = MergeJoinComplexBlocks(left_info, right_info, conditions[0].comparison);
 		if (result_count == 0) {
 			// exhausted this chunk on the right side
 			// move to the next right chunk
 			state.left_position = 0;
 			state.right_position = 0;
+			state.right_base += rsorted.radix_sorting_data[state.right_chunk_index].count;
 			state.right_chunk_index++;
-			if (state.right_chunk_index >= gstate.right_chunks.ChunkCount()) {
+			if (state.right_chunk_index >= rsorted.radix_sorting_data.size()) {
 				state.finished = true;
 			}
 		} else {
 			// found matches: mark the found matches if required
-			if (state.left_found_match) {
+			if (state.lhs_found_match) {
 				for (idx_t i = 0; i < result_count; i++) {
-					state.left_found_match[left_info.result.get_index(i)] = true;
+					state.lhs_found_match[left_info.result[i]] = true;
 				}
 			}
-			if (gstate.right_found_match) {
-				idx_t base_index = state.right_chunk_index * STANDARD_VECTOR_SIZE;
+			if (gstate.rhs_found_match) {
+				//	Absolute position of the block + start position inside that block
+				const idx_t base_index = state.right_base + right_info.base_idx;
 				for (idx_t i = 0; i < result_count; i++) {
-					gstate.right_found_match[base_index + right_info.result.get_index(i)] = true;
+					gstate.rhs_found_match[base_index + right_info.result[i]] = true;
 				}
 			}
 			// found matches: output them
-			chunk.Slice(input, left_info.result, result_count);
-			chunk.Slice(right_chunk, right_info.result, result_count, input.ColumnCount());
+			SliceSortedPayload(chunk, left_info, result_count, input.size());
+			SliceSortedPayload(chunk, right_info, result_count, right_info.entry_idx + 1, input.ColumnCount());
+			chunk.SetCardinality(result_count);
+			chunk.Verify();
 		}
 	} while (chunk.size() == 0);
 	return OperatorResultType::HAVE_MORE_OUTPUT;
@@ -55365,10 +55472,10 @@ OperatorResultType PhysicalPiecewiseMergeJoin::Execute(ExecutionContext &context
                                                        OperatorState &state) const {
 	auto &gstate = (MergeJoinGlobalState &)*sink_state;
 
-	if (gstate.right_chunks.Count() == 0) {
+	if (gstate.Count() == 0) {
 		// empty RHS
 		if (!EmptyResultIfRHSIsEmpty()) {
-			ConstructEmptyJoinResult(join_type, gstate.has_null, input, chunk);
+			ConstructEmptyJoinResult(join_type, gstate.rhs_has_null, input, chunk);
 			return OperatorResultType::NEED_MORE_INPUT;
 		} else {
 			return OperatorResultType::FINISHED;
@@ -55392,169 +55499,6 @@ OperatorResultType PhysicalPiecewiseMergeJoin::Execute(ExecutionContext &context
 	}
 }
 
-//===--------------------------------------------------------------------===//
-// OrderVector
-//===--------------------------------------------------------------------===//
-template <class T, class OP>
-static sel_t TemplatedQuicksortInitial(T *data, const SelectionVector &sel, const SelectionVector &not_null_sel,
-                                       idx_t count, SelectionVector &result) {
-	// select pivot
-	auto pivot_idx = not_null_sel.get_index(0);
-	auto dpivot_idx = sel.get_index(pivot_idx);
-	sel_t low = 0, high = count - 1;
-	// now insert elements
-	for (idx_t i = 1; i < count; i++) {
-		auto idx = not_null_sel.get_index(i);
-		auto didx = sel.get_index(idx);
-		if (OP::Operation(data[didx], data[dpivot_idx])) {
-			result.set_index(low++, idx);
-		} else {
-			result.set_index(high--, idx);
-		}
-	}
-	D_ASSERT(low == high);
-	result.set_index(low, pivot_idx);
-	return low;
-}
-
-struct QuickSortPivot {
-	QuickSortPivot(sel_t left_p, sel_t right_p) : left(left_p), right(right_p) {
-	}
-
-	sel_t left;
-	sel_t right;
-};
-
-template <class T, class OP>
-static void TemplatedQuicksortRefine(T *data, const SelectionVector &sel, idx_t count, SelectionVector &result,
-                                     sel_t left, sel_t right, vector<QuickSortPivot> &pivots) {
-	if (left >= right) {
-		return;
-	}
-
-	sel_t middle = left + (right - left) / 2;
-	sel_t dpivot_idx = sel.get_index(result.get_index(middle));
-
-	// move the mid point value to the front.
-	sel_t i = left + 1;
-	sel_t j = right;
-
-	result.swap(middle, left);
-	while (i <= j) {
-		while (i <= j && (OP::Operation(data[sel.get_index(result.get_index(i))], data[dpivot_idx]))) {
-			i++;
-		}
-
-		while (i <= j && !OP::Operation(data[sel.get_index(result.get_index(j))], data[dpivot_idx])) {
-			j--;
-		}
-
-		if (i < j) {
-			result.swap(i, j);
-		}
-	}
-	result.swap(i - 1, left);
-	sel_t part = i - 1;
-
-	if (part > 0) {
-		pivots.emplace_back(left, part - 1);
-	}
-	if (part + 1 < right) {
-		pivots.emplace_back(part + 1, right);
-	}
-}
-
-template <class T, class OP>
-void TemplatedQuicksort(T *__restrict data, const SelectionVector &sel, const SelectionVector &not_null_sel,
-                        idx_t count, SelectionVector &result) {
-	auto part = TemplatedQuicksortInitial<T, OP>(data, sel, not_null_sel, count, result);
-	if (part > count) {
-		return;
-	}
-	vector<QuickSortPivot> pivots;
-	pivots.emplace_back(0, part);
-	pivots.emplace_back(part + 1, count - 1);
-	for (idx_t i = 0; i < pivots.size(); i++) {
-		auto pivot = pivots[i];
-		TemplatedQuicksortRefine<T, OP>(data, sel, count, result, pivot.left, pivot.right, pivots);
-	}
-}
-
-template <class T>
-static void TemplatedQuicksort(VectorData &vdata, const SelectionVector &not_null_sel, idx_t not_null_count,
-                               SelectionVector &result) {
-	if (not_null_count == 0) {
-		return;
-	}
-	TemplatedQuicksort<T, duckdb::LessThanEquals>((T *)vdata.data, *vdata.sel, not_null_sel, not_null_count, result);
-}
-
-void OrderVector(Vector &vector, idx_t count, MergeOrder &order) {
-	if (count == 0) {
-		order.count = 0;
-		return;
-	}
-	vector.Orrify(count, order.vdata);
-	auto &vdata = order.vdata;
-
-	// first filter out all the non-null values
-	SelectionVector not_null(STANDARD_VECTOR_SIZE);
-	idx_t not_null_count = 0;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = vdata.sel->get_index(i);
-		if (vdata.validity.RowIsValid(idx)) {
-			not_null.set_index(not_null_count++, i);
-		}
-	}
-
-	order.count = not_null_count;
-	order.order.Initialize(STANDARD_VECTOR_SIZE);
-	switch (vector.GetType().InternalType()) {
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-		TemplatedQuicksort<int8_t>(vdata, not_null, not_null_count, order.order);
-		break;
-	case PhysicalType::INT16:
-		TemplatedQuicksort<int16_t>(vdata, not_null, not_null_count, order.order);
-		break;
-	case PhysicalType::INT32:
-		TemplatedQuicksort<int32_t>(vdata, not_null, not_null_count, order.order);
-		break;
-	case PhysicalType::INT64:
-		TemplatedQuicksort<int64_t>(vdata, not_null, not_null_count, order.order);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedQuicksort<uint8_t>(vdata, not_null, not_null_count, order.order);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedQuicksort<uint16_t>(vdata, not_null, not_null_count, order.order);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedQuicksort<uint32_t>(vdata, not_null, not_null_count, order.order);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedQuicksort<uint64_t>(vdata, not_null, not_null_count, order.order);
-		break;
-	case PhysicalType::INT128:
-		TemplatedQuicksort<hugeint_t>(vdata, not_null, not_null_count, order.order);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedQuicksort<float>(vdata, not_null, not_null_count, order.order);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedQuicksort<double>(vdata, not_null, not_null_count, order.order);
-		break;
-	case PhysicalType::INTERVAL:
-		TemplatedQuicksort<interval_t>(vdata, not_null, not_null_count, order.order);
-		break;
-	case PhysicalType::VARCHAR:
-		TemplatedQuicksort<string_t>(vdata, not_null, not_null_count, order.order);
-		break;
-	default:
-		throw NotImplementedException("Unimplemented type for sort");
-	}
-}
-
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
@@ -55565,12 +55509,13 @@ public:
 
 	mutex lock;
 	const PhysicalPiecewiseMergeJoin &op;
+	unique_ptr<PayloadScanner> scanner;
 	idx_t right_outer_position;
 
 public:
 	idx_t MaxThreads() override {
 		auto &sink = (MergeJoinGlobalState &)*op.sink_state;
-		return sink.right_chunks.Count() / (STANDARD_VECTOR_SIZE * 10);
+		return sink.Count() / (STANDARD_VECTOR_SIZE * idx_t(10));
 	}
 };
 
@@ -55578,17 +55523,63 @@ unique_ptr<GlobalSourceState> PhysicalPiecewiseMergeJoin::GetGlobalSourceState(C
 	return make_unique<PiecewiseJoinScanState>(*this);
 }
 
-void PhysicalPiecewiseMergeJoin::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
+void PhysicalPiecewiseMergeJoin::GetData(ExecutionContext &context, DataChunk &result, GlobalSourceState &gstate,
                                          LocalSourceState &lstate) const {
 	D_ASSERT(IsRightOuterJoin(join_type));
 	// check if we need to scan any unmatched tuples from the RHS for the full/right outer join
 	auto &sink = (MergeJoinGlobalState &)*sink_state;
 	auto &state = (PiecewiseJoinScanState &)gstate;
 
+	lock_guard<mutex> l(state.lock);
+	if (!state.scanner) {
+		// Initialize scanner (if not yet initialized)
+		auto &sort_state = sink.rhs_global_sort_state;
+		if (sort_state.sorted_blocks.empty()) {
+			return;
+		}
+		state.scanner = make_unique<PayloadScanner>(*sort_state.sorted_blocks[0]->payload_data, sort_state);
+	}
+
 	// if the LHS is exhausted in a FULL/RIGHT OUTER JOIN, we scan the found_match for any chunks we
 	// still need to output
-	lock_guard<mutex> l(state.lock);
-	ConstructFullOuterJoinResult(sink.right_found_match.get(), sink.right_chunks, chunk, state.right_outer_position);
+	const auto found_match = sink.rhs_found_match.get();
+
+	// ConstructFullOuterJoinResult(sink.rhs_found_match.get(), sink.right_chunks, chunk, state.right_outer_position);
+	DataChunk rhs_chunk;
+	rhs_chunk.Initialize(children[1]->types);
+	SelectionVector rsel(STANDARD_VECTOR_SIZE);
+	for (;;) {
+		// Read the next sorted chunk
+		state.scanner->Scan(rhs_chunk);
+
+		const auto count = rhs_chunk.size();
+		if (count == 0) {
+			return;
+		}
+
+		idx_t result_count = 0;
+		// figure out which tuples didn't find a match in the RHS
+		for (idx_t i = 0; i < count; i++) {
+			if (!found_match[state.right_outer_position + i]) {
+				rsel.set_index(result_count++, i);
+			}
+		}
+		state.right_outer_position += count;
+
+		if (result_count > 0) {
+			// if there were any tuples that didn't find a match, output them
+			const idx_t left_column_count = result.ColumnCount() - rhs_chunk.ColumnCount();
+			for (idx_t col_idx = 0; col_idx < left_column_count; ++col_idx) {
+				result.data[col_idx].SetVectorType(VectorType::CONSTANT_VECTOR);
+				ConstantVector::SetNull(result.data[col_idx], true);
+			}
+			for (idx_t col_idx = 0; col_idx < rhs_chunk.ColumnCount(); ++col_idx) {
+				result.data[left_column_count + col_idx].Slice(rhs_chunk.data[col_idx], rsel, result_count);
+			}
+			result.SetCardinality(result_count);
+			return;
+		}
+	}
 }
 
 } // namespace duckdb
@@ -57358,7 +57349,7 @@ void BufferedCSVReader::DetectHeader(const vector<vector<LogicalType>> &best_sql
 	// update parser info, and read, generate & set col_names based on previous findings
 	if (((!first_row_consistent || first_row_nulls) && !options.has_header) || (options.has_header && options.header)) {
 		options.header = true;
-		unordered_map<string, idx_t> name_collision_count;
+		case_insensitive_map_t<idx_t> name_collision_count;
 		// get header names from CSV
 		for (idx_t col = 0; col < options.num_cols; col++) {
 			const auto &val = best_header_row.GetValue(col, 0);
@@ -74230,7 +74221,7 @@ string Function::CallToString(const string &name, const vector<LogicalType> &arg
 }
 
 string Function::CallToString(const string &name, const vector<LogicalType> &arguments,
-                              const unordered_map<string, LogicalType> &named_parameters) {
+                              const named_parameter_type_map_t &named_parameters) {
 	vector<string> input_arguments;
 	input_arguments.reserve(arguments.size() + named_parameters.size());
 	for (auto &arg : arguments) {
@@ -79996,7 +79987,7 @@ bool ClampIndex(INDEX_TYPE &index, const INPUT_TYPE &value) {
 		}
 		index = length + index;
 	} else if (index > length) {
-		return false;
+		index = length;
 	}
 	return true;
 }
@@ -89613,7 +89604,7 @@ public:
 private:
 	//! Binds an arrow table
 	static unique_ptr<FunctionData> ArrowScanBind(ClientContext &context, vector<Value> &inputs,
-	                                              unordered_map<string, Value> &named_parameters,
+	                                              named_parameter_map_t &named_parameters,
 	                                              vector<LogicalType> &input_table_types,
 	                                              vector<string> &input_table_names, vector<LogicalType> &return_types,
 	                                              vector<string> &names);
@@ -89813,7 +89804,7 @@ LogicalType GetArrowLogicalType(ArrowSchema &schema,
 }
 
 unique_ptr<FunctionData> ArrowTableFunction::ArrowScanBind(ClientContext &context, vector<Value> &inputs,
-                                                           unordered_map<string, Value> &named_parameters,
+                                                           named_parameter_map_t &named_parameters,
                                                            vector<LogicalType> &input_table_types,
                                                            vector<string> &input_table_names,
                                                            vector<LogicalType> &return_types, vector<string> &names) {
@@ -90817,7 +90808,7 @@ struct UnnestTableFunction {
 namespace duckdb {
 
 static unique_ptr<FunctionData> CheckpointBind(ClientContext &context, vector<Value> &inputs,
-                                               unordered_map<string, Value> &named_parameters,
+                                               named_parameter_map_t &named_parameters,
                                                vector<LogicalType> &input_table_types,
                                                vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                vector<string> &names) {
@@ -91469,7 +91460,7 @@ struct GlobFunctionBindData : public TableFunctionData {
 };
 
 static unique_ptr<FunctionData> GlobFunctionBind(ClientContext &context, vector<Value> &inputs,
-                                                 unordered_map<string, Value> &named_parameters,
+                                                 named_parameter_map_t &named_parameters,
                                                  vector<LogicalType> &input_table_types,
                                                  vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                  vector<string> &names) {
@@ -91646,7 +91637,7 @@ struct PragmaDetailedProfilingOutputData : public TableFunctionData {
 };
 
 static unique_ptr<FunctionData> PragmaDetailedProfilingOutputBind(ClientContext &context, vector<Value> &inputs,
-                                                                  unordered_map<string, Value> &named_parameters,
+                                                                  named_parameter_map_t &named_parameters,
                                                                   vector<LogicalType> &input_table_types,
                                                                   vector<string> &input_table_names,
                                                                   vector<LogicalType> &return_types,
@@ -91822,12 +91813,10 @@ struct PragmaLastProfilingOutputData : public TableFunctionData {
 	vector<LogicalType> types;
 };
 
-static unique_ptr<FunctionData> PragmaLastProfilingOutputBind(ClientContext &context, vector<Value> &inputs,
-                                                              unordered_map<string, Value> &named_parameters,
-                                                              vector<LogicalType> &input_table_types,
-                                                              vector<string> &input_table_names,
-                                                              vector<LogicalType> &return_types,
-                                                              vector<string> &names) {
+static unique_ptr<FunctionData>
+PragmaLastProfilingOutputBind(ClientContext &context, vector<Value> &inputs, named_parameter_map_t &named_parameters,
+                              vector<LogicalType> &input_table_types, vector<string> &input_table_names,
+                              vector<LogicalType> &return_types, vector<string> &names) {
 	names.emplace_back("OPERATOR_ID");
 	return_types.emplace_back(LogicalType::INTEGER);
 
@@ -91941,7 +91930,7 @@ struct RangeFunctionBindData : public TableFunctionData {
 
 template <bool GENERATE_SERIES>
 static unique_ptr<FunctionData>
-RangeFunctionBind(ClientContext &context, vector<Value> &inputs, unordered_map<string, Value> &named_parameters,
+RangeFunctionBind(ClientContext &context, vector<Value> &inputs, named_parameter_map_t &named_parameters,
                   vector<LogicalType> &input_table_types, vector<string> &input_table_names,
                   vector<LogicalType> &return_types, vector<string> &names) {
 	auto result = make_unique<RangeFunctionBindData>();
@@ -92052,7 +92041,7 @@ struct RangeDateTimeBindData : public TableFunctionData {
 
 template <bool GENERATE_SERIES>
 static unique_ptr<FunctionData>
-RangeDateTimeBind(ClientContext &context, vector<Value> &inputs, unordered_map<string, Value> &named_parameters,
+RangeDateTimeBind(ClientContext &context, vector<Value> &inputs, named_parameter_map_t &named_parameters,
                   vector<LogicalType> &input_table_types, vector<string> &input_table_names,
                   vector<LogicalType> &return_types, vector<string> &names) {
 	auto result = make_unique<RangeDateTimeBindData>();
@@ -92191,7 +92180,7 @@ void BuiltinFunctions::RegisterTableFunctions() {
 namespace duckdb {
 
 static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value> &inputs,
-                                            unordered_map<string, Value> &named_parameters,
+                                            named_parameter_map_t &named_parameters,
                                             vector<LogicalType> &input_table_types, vector<string> &input_table_names,
                                             vector<LogicalType> &return_types, vector<string> &names) {
 	auto &config = DBConfig::GetConfig(context);
@@ -92210,22 +92199,23 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 	}
 
 	for (auto &kv : named_parameters) {
-		if (kv.first == "auto_detect") {
+		auto loption = StringUtil::Lower(kv.first);
+		if (loption == "auto_detect") {
 			options.auto_detect = BooleanValue::Get(kv.second);
-		} else if (kv.first == "sep" || kv.first == "delim") {
+		} else if (loption == "sep" || loption == "delim") {
 			options.SetDelimiter(StringValue::Get(kv.second));
-		} else if (kv.first == "header") {
+		} else if (loption == "header") {
 			options.header = BooleanValue::Get(kv.second);
 			options.has_header = true;
-		} else if (kv.first == "quote") {
+		} else if (loption == "quote") {
 			options.quote = StringValue::Get(kv.second);
 			options.has_quote = true;
-		} else if (kv.first == "escape") {
+		} else if (loption == "escape") {
 			options.escape = StringValue::Get(kv.second);
 			options.has_escape = true;
-		} else if (kv.first == "nullstr") {
+		} else if (loption == "nullstr") {
 			options.null_str = StringValue::Get(kv.second);
-		} else if (kv.first == "sample_size") {
+		} else if (loption == "sample_size") {
 			int64_t sample_size = kv.second.GetValue<int64_t>();
 			if (sample_size < 1 && sample_size != -1) {
 				throw BinderException("Unsupported parameter for SAMPLE_SIZE: cannot be smaller than 1");
@@ -92240,7 +92230,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 				options.sample_chunk_size = STANDARD_VECTOR_SIZE;
 				options.sample_chunks = sample_size / STANDARD_VECTOR_SIZE;
 			}
-		} else if (kv.first == "sample_chunk_size") {
+		} else if (loption == "sample_chunk_size") {
 			options.sample_chunk_size = kv.second.GetValue<int64_t>();
 			if (options.sample_chunk_size > STANDARD_VECTOR_SIZE) {
 				throw BinderException(
@@ -92249,14 +92239,14 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 			} else if (options.sample_chunk_size < 1) {
 				throw BinderException("Unsupported parameter for SAMPLE_CHUNK_SIZE: cannot be smaller than 1");
 			}
-		} else if (kv.first == "sample_chunks") {
+		} else if (loption == "sample_chunks") {
 			options.sample_chunks = kv.second.GetValue<int64_t>();
 			if (options.sample_chunks < 1) {
 				throw BinderException("Unsupported parameter for SAMPLE_CHUNKS: cannot be smaller than 1");
 			}
-		} else if (kv.first == "all_varchar") {
+		} else if (loption == "all_varchar") {
 			options.all_varchar = BooleanValue::Get(kv.second);
-		} else if (kv.first == "dateformat") {
+		} else if (loption == "dateformat") {
 			options.has_format[LogicalTypeId::DATE] = true;
 			auto &date_format = options.date_format[LogicalTypeId::DATE];
 			date_format.format_specifier = StringValue::Get(kv.second);
@@ -92264,7 +92254,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 			if (!error.empty()) {
 				throw InvalidInputException("Could not parse DATEFORMAT: %s", error.c_str());
 			}
-		} else if (kv.first == "timestampformat") {
+		} else if (loption == "timestampformat") {
 			options.has_format[LogicalTypeId::TIMESTAMP] = true;
 			auto &timestamp_format = options.date_format[LogicalTypeId::TIMESTAMP];
 			timestamp_format.format_specifier = StringValue::Get(kv.second);
@@ -92272,9 +92262,9 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 			if (!error.empty()) {
 				throw InvalidInputException("Could not parse TIMESTAMPFORMAT: %s", error.c_str());
 			}
-		} else if (kv.first == "normalize_names") {
+		} else if (loption == "normalize_names") {
 			options.normalize_names = BooleanValue::Get(kv.second);
-		} else if (kv.first == "columns") {
+		} else if (loption == "columns") {
 			auto &child_type = kv.second.type();
 			if (child_type.id() != LogicalTypeId::STRUCT) {
 				throw BinderException("read_csv columns requires a a struct as input");
@@ -92293,12 +92283,14 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, vector<Value
 			if (names.empty()) {
 				throw BinderException("read_csv requires at least a single column as input!");
 			}
-		} else if (kv.first == "compression") {
+		} else if (loption == "compression") {
 			options.compression = FileCompressionTypeFromString(StringValue::Get(kv.second));
-		} else if (kv.first == "filename") {
+		} else if (loption == "filename") {
 			result->include_file_name = BooleanValue::Get(kv.second);
-		} else if (kv.first == "skip") {
+		} else if (loption == "skip") {
 			options.skip_rows = kv.second.GetValue<int64_t>();
+		} else {
+			throw InternalException("Unrecognized parameter %s", kv.first);
 		}
 	}
 	if (!options.auto_detect && return_types.empty()) {
@@ -92352,7 +92344,7 @@ static unique_ptr<FunctionOperatorData> ReadCSVInit(ClientContext &context, cons
 }
 
 static unique_ptr<FunctionData> ReadCSVAutoBind(ClientContext &context, vector<Value> &inputs,
-                                                unordered_map<string, Value> &named_parameters,
+                                                named_parameter_map_t &named_parameters,
                                                 vector<LogicalType> &input_table_types,
                                                 vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                 vector<string> &names) {
@@ -92477,7 +92469,7 @@ struct RepeatOperatorData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> RepeatBind(ClientContext &context, vector<Value> &inputs,
-                                           unordered_map<string, Value> &named_parameters,
+                                           named_parameter_map_t &named_parameters,
                                            vector<LogicalType> &input_table_types, vector<string> &input_table_names,
                                            vector<LogicalType> &return_types, vector<string> &names) {
 	// the repeat function returns the type of the first argument
@@ -92524,7 +92516,7 @@ void RepeatTableFunction::RegisterFunction(BuiltinFunctions &set) {
 namespace duckdb {
 
 static unique_ptr<FunctionData> SummaryFunctionBind(ClientContext &context, vector<Value> &inputs,
-                                                    unordered_map<string, Value> &named_parameters,
+                                                    named_parameter_map_t &named_parameters,
                                                     vector<LogicalType> &input_table_types,
                                                     vector<string> &input_table_names,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
@@ -92592,7 +92584,7 @@ struct DuckDBColumnsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBColumnsBind(ClientContext &context, vector<Value> &inputs,
-                                                  unordered_map<string, Value> &named_parameters,
+                                                  named_parameter_map_t &named_parameters,
                                                   vector<LogicalType> &input_table_types,
                                                   vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                   vector<string> &names) {
@@ -92927,7 +92919,7 @@ struct DuckDBConstraintsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBConstraintsBind(ClientContext &context, vector<Value> &inputs,
-                                                      unordered_map<string, Value> &named_parameters,
+                                                      named_parameter_map_t &named_parameters,
                                                       vector<LogicalType> &input_table_types,
                                                       vector<string> &input_table_names,
                                                       vector<LogicalType> &return_types, vector<string> &names) {
@@ -93131,7 +93123,7 @@ struct DuckDBDependenciesData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBDependenciesBind(ClientContext &context, vector<Value> &inputs,
-                                                       unordered_map<string, Value> &named_parameters,
+                                                       named_parameter_map_t &named_parameters,
                                                        vector<LogicalType> &input_table_types,
                                                        vector<string> &input_table_names,
                                                        vector<LogicalType> &return_types, vector<string> &names) {
@@ -93254,7 +93246,7 @@ struct DuckDBFunctionsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBFunctionsBind(ClientContext &context, vector<Value> &inputs,
-                                                    unordered_map<string, Value> &named_parameters,
+                                                    named_parameter_map_t &named_parameters,
                                                     vector<LogicalType> &input_table_types,
                                                     vector<string> &input_table_names,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
@@ -93665,7 +93657,7 @@ struct DuckDBIndexesData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBIndexesBind(ClientContext &context, vector<Value> &inputs,
-                                                  unordered_map<string, Value> &named_parameters,
+                                                  named_parameter_map_t &named_parameters,
                                                   vector<LogicalType> &input_table_types,
                                                   vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                   vector<string> &names) {
@@ -93785,7 +93777,7 @@ struct DuckDBKeywordsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBKeywordsBind(ClientContext &context, vector<Value> &inputs,
-                                                   unordered_map<string, Value> &named_parameters,
+                                                   named_parameter_map_t &named_parameters,
                                                    vector<LogicalType> &input_table_types,
                                                    vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                    vector<string> &names) {
@@ -93870,7 +93862,7 @@ struct DuckDBSchemasData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBSchemasBind(ClientContext &context, vector<Value> &inputs,
-                                                  unordered_map<string, Value> &named_parameters,
+                                                  named_parameter_map_t &named_parameters,
                                                   vector<LogicalType> &input_table_types,
                                                   vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                   vector<string> &names) {
@@ -93955,7 +93947,7 @@ struct DuckDBSequencesData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBSequencesBind(ClientContext &context, vector<Value> &inputs,
-                                                    unordered_map<string, Value> &named_parameters,
+                                                    named_parameter_map_t &named_parameters,
                                                     vector<LogicalType> &input_table_types,
                                                     vector<string> &input_table_names,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
@@ -94090,7 +94082,7 @@ struct DuckDBSettingsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBSettingsBind(ClientContext &context, vector<Value> &inputs,
-                                                   unordered_map<string, Value> &named_parameters,
+                                                   named_parameter_map_t &named_parameters,
                                                    vector<LogicalType> &input_table_types,
                                                    vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                    vector<string> &names) {
@@ -94199,7 +94191,7 @@ struct DuckDBTablesData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBTablesBind(ClientContext &context, vector<Value> &inputs,
-                                                 unordered_map<string, Value> &named_parameters,
+                                                 named_parameter_map_t &named_parameters,
                                                  vector<LogicalType> &input_table_types,
                                                  vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                  vector<string> &names) {
@@ -94352,7 +94344,7 @@ struct DuckDBTypesData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, vector<Value> &inputs,
-                                                unordered_map<string, Value> &named_parameters,
+                                                named_parameter_map_t &named_parameters,
                                                 vector<LogicalType> &input_table_types,
                                                 vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                 vector<string> &names) {
@@ -94491,7 +94483,7 @@ struct DuckDBViewsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> DuckDBViewsBind(ClientContext &context, vector<Value> &inputs,
-                                                unordered_map<string, Value> &named_parameters,
+                                                named_parameter_map_t &named_parameters,
                                                 vector<LogicalType> &input_table_types,
                                                 vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                 vector<string> &names) {
@@ -94602,7 +94594,7 @@ struct PragmaCollateData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaCollateBind(ClientContext &context, vector<Value> &inputs,
-                                                  unordered_map<string, Value> &named_parameters,
+                                                  named_parameter_map_t &named_parameters,
                                                   vector<LogicalType> &input_table_types,
                                                   vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                   vector<string> &names) {
@@ -94662,7 +94654,7 @@ struct PragmaDatabaseListData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaDatabaseListBind(ClientContext &context, vector<Value> &inputs,
-                                                       unordered_map<string, Value> &named_parameters,
+                                                       named_parameter_map_t &named_parameters,
                                                        vector<LogicalType> &input_table_types,
                                                        vector<string> &input_table_names,
                                                        vector<LogicalType> &return_types, vector<string> &names) {
@@ -94723,7 +94715,7 @@ struct PragmaDatabaseSizeData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaDatabaseSizeBind(ClientContext &context, vector<Value> &inputs,
-                                                       unordered_map<string, Value> &named_parameters,
+                                                       named_parameter_map_t &named_parameters,
                                                        vector<LogicalType> &input_table_types,
                                                        vector<string> &input_table_names,
                                                        vector<LogicalType> &return_types, vector<string> &names) {
@@ -94827,7 +94819,7 @@ struct PragmaFunctionsData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaFunctionsBind(ClientContext &context, vector<Value> &inputs,
-                                                    unordered_map<string, Value> &named_parameters,
+                                                    named_parameter_map_t &named_parameters,
                                                     vector<LogicalType> &input_table_types,
                                                     vector<string> &input_table_names,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
@@ -94963,7 +94955,7 @@ struct PragmaStorageOperatorData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaStorageInfoBind(ClientContext &context, vector<Value> &inputs,
-                                                      unordered_map<string, Value> &named_parameters,
+                                                      named_parameter_map_t &named_parameters,
                                                       vector<LogicalType> &input_table_types,
                                                       vector<string> &input_table_names,
                                                       vector<LogicalType> &return_types, vector<string> &names) {
@@ -95090,7 +95082,7 @@ struct PragmaTableOperatorData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaTableInfoBind(ClientContext &context, vector<Value> &inputs,
-                                                    unordered_map<string, Value> &named_parameters,
+                                                    named_parameter_map_t &named_parameters,
                                                     vector<LogicalType> &input_table_types,
                                                     vector<string> &input_table_names,
                                                     vector<LogicalType> &return_types, vector<string> &names) {
@@ -95410,7 +95402,7 @@ static vector<TestType> GetTestTypes() {
 }
 
 static unique_ptr<FunctionData> TestAllTypesBind(ClientContext &context, vector<Value> &inputs,
-                                                 unordered_map<string, Value> &named_parameters,
+                                                 named_parameter_map_t &named_parameters,
                                                  vector<LogicalType> &input_table_types,
                                                  vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                  vector<string> &names) {
@@ -95970,7 +95962,7 @@ struct UnnestOperatorData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> UnnestBind(ClientContext &context, vector<Value> &inputs,
-                                           unordered_map<string, Value> &named_parameters,
+                                           named_parameter_map_t &named_parameters,
                                            vector<LogicalType> &input_table_types, vector<string> &input_table_names,
                                            vector<LogicalType> &return_types, vector<string> &names) {
 	return_types.push_back(ListType::GetChildType(inputs[0].type()));
@@ -96015,7 +96007,7 @@ struct PragmaVersionData : public FunctionOperatorData {
 };
 
 static unique_ptr<FunctionData> PragmaVersionBind(ClientContext &context, vector<Value> &inputs,
-                                                  unordered_map<string, Value> &named_parameters,
+                                                  named_parameter_map_t &named_parameters,
                                                   vector<LogicalType> &input_table_types,
                                                   vector<string> &input_table_names, vector<LogicalType> &return_types,
                                                   vector<string> &names) {
@@ -98757,7 +98749,7 @@ vector<unique_ptr<SQLStatement>> ClientContext::ParseStatements(const string &qu
 }
 
 vector<unique_ptr<SQLStatement>> ClientContext::ParseStatementsInternal(ClientContextLock &lock, const string &query) {
-	Parser parser;
+	Parser parser(GetParserOptions());
 	parser.ParseQuery(query);
 
 	PragmaHandler handler(*this);
@@ -99494,6 +99486,12 @@ bool ClientContext::TryGetCurrentSetting(const std::string &key, Value &result)
 	return true;
 }
 
+ParserOptions ClientContext::GetParserOptions() {
+	ParserOptions options;
+	options.preserve_identifier_case = ClientConfig::GetConfig(*this).preserve_identifier_case;
+	return options;
+}
+
 } // namespace duckdb
 
 
@@ -99687,6 +99685,15 @@ struct PerfectHashThresholdSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct PreserveIdentifierCase {
+	static constexpr const char *Name = "preserve_identifier_case";
+	static constexpr const char *Description =
+	    "Whether or not to preserve the identifier case, instead of always lowercasing all non-quoted identifiers";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct ProfilerHistorySize {
 	static constexpr const char *Name = "profiler_history_size";
 	static constexpr const char *Description = "Sets the profiler history size";
@@ -99798,6 +99805,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL_ALIAS("memory_limit", MaximumMemorySetting),
                                                  DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting),
                                                  DUCKDB_LOCAL(PerfectHashThresholdSetting),
+                                                 DUCKDB_LOCAL(PreserveIdentifierCase),
                                                  DUCKDB_LOCAL(ProfilerHistorySize),
                                                  DUCKDB_LOCAL(ProfileOutputSetting),
                                                  DUCKDB_LOCAL(ProfilingModeSetting),
@@ -99837,8 +99845,10 @@ ConfigurationOption *DBConfig::GetOptionByIndex(idx_t target_index) {
 }
 
 ConfigurationOption *DBConfig::GetOptionByName(const string &name) {
+	auto lname = StringUtil::Lower(name);
 	for (idx_t index = 0; internal_options[index].name; index++) {
-		if (internal_options[index].name == name) {
+		D_ASSERT(StringUtil::Lower(internal_options[index].name) == string(internal_options[index].name));
+		if (internal_options[index].name == lname) {
 			return internal_options + index;
 		}
 	}
@@ -100041,15 +100051,14 @@ namespace duckdb {
 class TableFunctionRelation : public Relation {
 public:
 	TableFunctionRelation(ClientContext &context, string name, vector<Value> parameters,
-	                      unordered_map<string, Value> named_parameters,
-	                      shared_ptr<Relation> input_relation_p = nullptr);
+	                      named_parameter_map_t named_parameters, shared_ptr<Relation> input_relation_p = nullptr);
 
 	TableFunctionRelation(ClientContext &context, string name, vector<Value> parameters,
 	                      shared_ptr<Relation> input_relation_p = nullptr);
 
 	string name;
 	vector<Value> parameters;
-	unordered_map<string, Value> named_parameters;
+	named_parameter_map_t named_parameters;
 	vector<ColumnDefinition> columns;
 	shared_ptr<Relation> input_relation;
 
@@ -100326,12 +100335,12 @@ shared_ptr<Relation> Connection::View(const string &schema_name, const string &t
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname) {
 	vector<Value> values;
-	unordered_map<string, Value> named_parameters;
+	named_parameter_map_t named_parameters;
 	return TableFunction(fname, values, named_parameters);
 }
 
 shared_ptr<Relation> Connection::TableFunction(const string &fname, const vector<Value> &values,
-                                               const unordered_map<string, Value> &named_parameters) {
+                                               const named_parameter_map_t &named_parameters) {
 	return make_shared<TableFunctionRelation>(*context, fname, values, named_parameters);
 }
 
@@ -100374,7 +100383,7 @@ shared_ptr<Relation> Connection::ReadCSV(const string &csv_file, const vector<st
 	// parse columns
 	vector<ColumnDefinition> column_list;
 	for (auto &column : columns) {
-		auto col_list = Parser::ParseColumnList(column);
+		auto col_list = Parser::ParseColumnList(column, context->GetParserOptions());
 		if (col_list.size() != 1) {
 			throw ParserException("Expected a single column definition");
 		}
@@ -110918,7 +110927,7 @@ QueryRelation::QueryRelation(ClientContext &context, string query, string alias)
 }
 
 unique_ptr<SelectStatement> QueryRelation::GetSelectStatement() {
-	Parser parser;
+	Parser parser(context.GetParserOptions());
 	parser.ParseQuery(query);
 	if (parser.statements.size() != 1) {
 		throw ParserException("Expected a single SELECT statement");
@@ -111183,7 +111192,7 @@ string SubqueryRelation::ToString(idx_t depth) {
 namespace duckdb {
 
 TableFunctionRelation::TableFunctionRelation(ClientContext &context, string name_p, vector<Value> parameters_p,
-                                             unordered_map<string, Value> named_parameters,
+                                             named_parameter_map_t named_parameters,
                                              shared_ptr<Relation> input_relation_p)
     : Relation(context, RelationType::TABLE_FUNCTION_RELATION), name(move(name_p)), parameters(move(parameters_p)),
       named_parameters(move(named_parameters)), input_relation(move(input_relation_p)) {
@@ -111300,6 +111309,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 TableRelation::TableRelation(ClientContext &context, unique_ptr<TableDescription> description)
@@ -111332,9 +111342,9 @@ string TableRelation::ToString(idx_t depth) {
 	return RenderWhitespace(depth) + "Scan Table [" + description->table + "]";
 }
 
-static unique_ptr<ParsedExpression> ParseCondition(const string &condition) {
+static unique_ptr<ParsedExpression> ParseCondition(ClientContext &context, const string &condition) {
 	if (!condition.empty()) {
-		auto expression_list = Parser::ParseExpressionList(condition);
+		auto expression_list = Parser::ParseExpressionList(condition, context.GetParserOptions());
 		if (expression_list.size() != 1) {
 			throw ParserException("Expected a single expression as filter condition");
 		}
@@ -111347,15 +111357,15 @@ static unique_ptr<ParsedExpression> ParseCondition(const string &condition) {
 void TableRelation::Update(const string &update_list, const string &condition) {
 	vector<string> update_columns;
 	vector<unique_ptr<ParsedExpression>> expressions;
-	auto cond = ParseCondition(condition);
-	Parser::ParseUpdateList(update_list, update_columns, expressions);
+	auto cond = ParseCondition(context, condition);
+	Parser::ParseUpdateList(update_list, update_columns, expressions, context.GetParserOptions());
 	auto update = make_shared<UpdateRelation>(context, move(cond), description->schema, description->table,
 	                                          move(update_columns), move(expressions));
 	update->Execute();
 }
 
 void TableRelation::Delete(const string &condition) {
-	auto cond = ParseCondition(condition);
+	auto cond = ParseCondition(context, condition);
 	auto del = make_shared<DeleteRelation>(context, move(cond), description->schema, description->table);
 	del->Execute();
 }
@@ -111468,7 +111478,7 @@ ValueRelation::ValueRelation(ClientContext &context, const vector<vector<Value>>
 
 ValueRelation::ValueRelation(ClientContext &context, const string &values_list, vector<string> names_p, string alias_p)
     : Relation(context, RelationType::VALUE_LIST_RELATION), names(move(names_p)), alias(move(alias_p)) {
-	this->expressions = Parser::ParseValuesList(values_list);
+	this->expressions = Parser::ParseValuesList(values_list, context.GetParserOptions());
 	context.TryBindRelation(*this, this->columns);
 }
 
@@ -111703,7 +111713,7 @@ shared_ptr<Relation> Relation::Project(const string &expression, const string &a
 }
 
 shared_ptr<Relation> Relation::Project(const string &select_list, const vector<string> &aliases) {
-	auto expressions = Parser::ParseExpressionList(select_list);
+	auto expressions = Parser::ParseExpressionList(select_list, context.GetParserOptions());
 	return make_shared<ProjectionRelation>(shared_from_this(), move(expressions), aliases);
 }
 
@@ -111712,13 +111722,14 @@ shared_ptr<Relation> Relation::Project(const vector<string> &expressions) {
 	return Project(expressions, aliases);
 }
 
-static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(const vector<string> &expressions) {
+static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(ClientContext &context,
+                                                                       const vector<string> &expressions) {
 	if (expressions.empty()) {
 		throw ParserException("Zero expressions provided");
 	}
 	vector<unique_ptr<ParsedExpression>> result_list;
 	for (auto &expr : expressions) {
-		auto expression_list = Parser::ParseExpressionList(expr);
+		auto expression_list = Parser::ParseExpressionList(expr, context.GetParserOptions());
 		if (expression_list.size() != 1) {
 			throw ParserException("Expected a single expression in the expression list");
 		}
@@ -111728,12 +111739,12 @@ static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(const vec
 }
 
 shared_ptr<Relation> Relation::Project(const vector<string> &expressions, const vector<string> &aliases) {
-	auto result_list = StringListToExpressionList(expressions);
+	auto result_list = StringListToExpressionList(context, expressions);
 	return make_shared<ProjectionRelation>(shared_from_this(), move(result_list), aliases);
 }
 
 shared_ptr<Relation> Relation::Filter(const string &expression) {
-	auto expression_list = Parser::ParseExpressionList(expression);
+	auto expression_list = Parser::ParseExpressionList(expression, context.GetParserOptions());
 	if (expression_list.size() != 1) {
 		throw ParserException("Expected a single expression as filter condition");
 	}
@@ -111742,7 +111753,7 @@ shared_ptr<Relation> Relation::Filter(const string &expression) {
 
 shared_ptr<Relation> Relation::Filter(const vector<string> &expressions) {
 	// if there are multiple expressions, we AND them together
-	auto expression_list = StringListToExpressionList(expressions);
+	auto expression_list = StringListToExpressionList(context, expressions);
 	D_ASSERT(!expression_list.empty());
 
 	auto expr = move(expression_list[0]);
@@ -111758,7 +111769,7 @@ shared_ptr<Relation> Relation::Limit(int64_t limit, int64_t offset) {
 }
 
 shared_ptr<Relation> Relation::Order(const string &expression) {
-	auto order_list = Parser::ParseOrderList(expression);
+	auto order_list = Parser::ParseOrderList(expression, context.GetParserOptions());
 	return make_shared<OrderRelation>(shared_from_this(), move(order_list));
 }
 
@@ -111768,7 +111779,7 @@ shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
 	}
 	vector<OrderByNode> order_list;
 	for (auto &expression : expressions) {
-		auto inner_list = Parser::ParseOrderList(expression);
+		auto inner_list = Parser::ParseOrderList(expression, context.GetParserOptions());
 		if (inner_list.size() != 1) {
 			throw ParserException("Expected a single ORDER BY expression in the expression list");
 		}
@@ -111778,7 +111789,7 @@ shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
 }
 
 shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const string &condition, JoinType type) {
-	auto expression_list = Parser::ParseExpressionList(condition);
+	auto expression_list = Parser::ParseExpressionList(condition, context.GetParserOptions());
 	D_ASSERT(!expression_list.empty());
 
 	if (expression_list.size() > 1 || expression_list[0]->type == ExpressionType::COLUMN_REF) {
@@ -111822,24 +111833,24 @@ shared_ptr<Relation> Relation::Alias(const string &alias) {
 }
 
 shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list) {
-	auto expression_list = Parser::ParseExpressionList(aggregate_list);
+	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetParserOptions());
 	return make_shared<AggregateRelation>(shared_from_this(), move(expression_list));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list, const string &group_list) {
-	auto expression_list = Parser::ParseExpressionList(aggregate_list);
-	auto groups = Parser::ParseExpressionList(group_list);
+	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetParserOptions());
+	auto groups = Parser::ParseExpressionList(group_list, context.GetParserOptions());
 	return make_shared<AggregateRelation>(shared_from_this(), move(expression_list), move(groups));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates) {
-	auto aggregate_list = StringListToExpressionList(aggregates);
+	auto aggregate_list = StringListToExpressionList(context, aggregates);
 	return make_shared<AggregateRelation>(shared_from_this(), move(aggregate_list));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates, const vector<string> &groups) {
-	auto aggregate_list = StringListToExpressionList(aggregates);
-	auto group_list = StringListToExpressionList(groups);
+	auto aggregate_list = StringListToExpressionList(context, aggregates);
+	auto group_list = StringListToExpressionList(context, groups);
 	return make_shared<AggregateRelation>(shared_from_this(), move(aggregate_list), move(group_list));
 }
 
@@ -111933,7 +111944,7 @@ void Relation::Delete(const string &condition) {
 }
 
 shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values,
-                                             const unordered_map<string, Value> &named_parameters) {
+                                             const named_parameter_map_t &named_parameters) {
 	return make_shared<TableFunctionRelation>(context, fname, values, named_parameters, shared_from_this());
 }
 
@@ -111989,6 +112000,7 @@ string Relation::RenderWhitespace(idx_t depth) {
 
 
 
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -112386,6 +112398,17 @@ Value PerfectHashThresholdSetting::GetSetting(ClientContext &context) {
 	return Value::BIGINT(ClientConfig::GetConfig(context).perfect_ht_threshold);
 }
 
+//===--------------------------------------------------------------------===//
+// PreserveIdentifierCase
+//===--------------------------------------------------------------------===//
+void PreserveIdentifierCase::SetLocal(ClientContext &context, const Value &input) {
+	ClientConfig::GetConfig(context).preserve_identifier_case = input.GetValue<bool>();
+}
+
+Value PreserveIdentifierCase::GetSetting(ClientContext &context) {
+	return Value::BOOLEAN(ClientConfig::GetConfig(context).preserve_identifier_case);
+}
+
 //===--------------------------------------------------------------------===//
 // Profiler History Size
 //===--------------------------------------------------------------------===//
@@ -127785,6 +127808,7 @@ unique_ptr<ParsedExpression> CollateExpression::Deserialize(ExpressionType type,
 
 
 
+
 namespace duckdb {
 
 ColumnRefExpression::ColumnRefExpression(string column_name, string table_name)
@@ -127834,13 +127858,24 @@ string ColumnRefExpression::ToString() const {
 }
 
 bool ColumnRefExpression::Equals(const ColumnRefExpression *a, const ColumnRefExpression *b) {
-	return a->column_names == b->column_names;
+	if (a->column_names.size() != b->column_names.size()) {
+		return false;
+	}
+	for (idx_t i = 0; i < a->column_names.size(); i++) {
+		auto lcase_a = StringUtil::Lower(a->column_names[i]);
+		auto lcase_b = StringUtil::Lower(b->column_names[i]);
+		if (lcase_a != lcase_b) {
+			return false;
+		}
+	}
+	return true;
 }
 
 hash_t ColumnRefExpression::Hash() const {
 	hash_t result = ParsedExpression::Hash();
 	for (auto &column_name : column_names) {
-		result = CombineHash(result, duckdb::Hash<const char *>(column_name.c_str()));
+		auto lcase = StringUtil::Lower(column_name);
+		result = CombineHash(result, duckdb::Hash<const char *>(lcase.c_str()));
 	}
 	return result;
 }
@@ -135063,7 +135098,10 @@ public:
 
 	static bool IsKeyword(const std::string &text);
 	static std::vector<duckdb_libpgquery::PGKeyword> KeywordList();
+
+	static void SetPreserveIdentifierCase(bool downcase);
 };
+
 }
 
 
@@ -135124,12 +135162,13 @@ PGTypeName *SystemTypeName(const char *name);
 
 namespace duckdb {
 
-Parser::Parser() {
+Parser::Parser(ParserOptions options_p) : options(options_p) {
 }
 
 void Parser::ParseQuery(const string &query) {
 	Transformer transformer;
 	{
+		PostgresParser::SetPreserveIdentifierCase(options.preserve_identifier_case);
 		PostgresParser parser;
 		parser.Parse(query);
 
@@ -135225,11 +135264,11 @@ vector<ParserKeyword> Parser::KeywordList() {
 	return result;
 }
 
-vector<unique_ptr<ParsedExpression>> Parser::ParseExpressionList(const string &select_list) {
+vector<unique_ptr<ParsedExpression>> Parser::ParseExpressionList(const string &select_list, ParserOptions options) {
 	// construct a mock query prefixed with SELECT
 	string mock_query = "SELECT " + select_list;
 	// parse the query
-	Parser parser;
+	Parser parser(options);
 	parser.ParseQuery(mock_query);
 	// check the statements
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
@@ -135243,11 +135282,11 @@ vector<unique_ptr<ParsedExpression>> Parser::ParseExpressionList(const string &s
 	return move(select_node.select_list);
 }
 
-vector<OrderByNode> Parser::ParseOrderList(const string &select_list) {
+vector<OrderByNode> Parser::ParseOrderList(const string &select_list, ParserOptions options) {
 	// construct a mock query
 	string mock_query = "SELECT * FROM tbl ORDER BY " + select_list;
 	// parse the query
-	Parser parser;
+	Parser parser(options);
 	parser.ParseQuery(mock_query);
 	// check the statements
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
@@ -135267,11 +135306,11 @@ vector<OrderByNode> Parser::ParseOrderList(const string &select_list) {
 }
 
 void Parser::ParseUpdateList(const string &update_list, vector<string> &update_columns,
-                             vector<unique_ptr<ParsedExpression>> &expressions) {
+                             vector<unique_ptr<ParsedExpression>> &expressions, ParserOptions options) {
 	// construct a mock query
 	string mock_query = "UPDATE tbl SET " + update_list;
 	// parse the query
-	Parser parser;
+	Parser parser(options);
 	parser.ParseQuery(mock_query);
 	// check the statements
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::UPDATE_STATEMENT) {
@@ -135282,11 +135321,11 @@ void Parser::ParseUpdateList(const string &update_list, vector<string> &update_c
 	expressions = move(update.expressions);
 }
 
-vector<vector<unique_ptr<ParsedExpression>>> Parser::ParseValuesList(const string &value_list) {
+vector<vector<unique_ptr<ParsedExpression>>> Parser::ParseValuesList(const string &value_list, ParserOptions options) {
 	// construct a mock query
 	string mock_query = "VALUES " + value_list;
 	// parse the query
-	Parser parser;
+	Parser parser(options);
 	parser.ParseQuery(mock_query);
 	// check the statements
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::SELECT_STATEMENT) {
@@ -135304,9 +135343,9 @@ vector<vector<unique_ptr<ParsedExpression>>> Parser::ParseValuesList(const strin
 	return move(values_list.values);
 }
 
-vector<ColumnDefinition> Parser::ParseColumnList(const string &column_list) {
+vector<ColumnDefinition> Parser::ParseColumnList(const string &column_list, ParserOptions options) {
 	string mock_query = "CREATE TABLE blabla (" + column_list + ")";
-	Parser parser;
+	Parser parser(options);
 	parser.ParseQuery(mock_query);
 	if (parser.statements.size() != 1 || parser.statements[0]->type != StatementType::CREATE_STATEMENT) {
 		throw ParserException("Expected a single CREATE statement");
@@ -142142,7 +142181,7 @@ class BoundSelectNode;
 
 struct BoundGroupInformation {
 	expression_map_t<idx_t> map;
-	unordered_map<string, idx_t> alias_map;
+	case_insensitive_map_t<idx_t> alias_map;
 };
 
 //! The SELECT binder is responsible for binding an expression within the SELECT clause of a SQL statement
@@ -142928,6 +142967,7 @@ unique_ptr<Expression> ExpressionBinder::PushCollation(ClientContext &context, u
 	} else {
 		collation = collation_p;
 	}
+	collation = StringUtil::Lower(collation);
 	// bind the collation
 	if (collation.empty() || collation == "binary" || collation == "c" || collation == "posix") {
 		// binary collation: just skip
@@ -144006,14 +144046,14 @@ class ColumnRefExpression;
 //! A helper binder for WhereBinder and HavingBinder which support alias as a columnref.
 class ColumnAliasBinder {
 public:
-	ColumnAliasBinder(BoundSelectNode &node, const unordered_map<string, idx_t> &alias_map);
+	ColumnAliasBinder(BoundSelectNode &node, const case_insensitive_map_t<idx_t> &alias_map);
 
 	BindResult BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth,
 	                     bool root_expression);
 
 private:
 	BoundSelectNode &node;
-	const unordered_map<string, idx_t> &alias_map;
+	const case_insensitive_map_t<idx_t> &alias_map;
 	bool in_alias;
 };
 
@@ -144062,7 +144102,6 @@ protected:
 
 
 
-
 namespace duckdb {
 class ConstantExpression;
 class ColumnRefExpression;
@@ -144071,7 +144110,7 @@ class ColumnRefExpression;
 class GroupBinder : public ExpressionBinder {
 public:
 	GroupBinder(Binder &binder, ClientContext &context, SelectNode &node, idx_t group_index,
-	            unordered_map<string, idx_t> &alias_map, unordered_map<string, idx_t> &group_alias_map);
+	            case_insensitive_map_t<idx_t> &alias_map, case_insensitive_map_t<idx_t> &group_alias_map);
 
 	//! The unbound root expression
 	unique_ptr<ParsedExpression> unbound_expression;
@@ -144088,8 +144127,8 @@ protected:
 	BindResult BindConstant(ConstantExpression &expr);
 
 	SelectNode &node;
-	unordered_map<string, idx_t> &alias_map;
-	unordered_map<string, idx_t> &group_alias_map;
+	case_insensitive_map_t<idx_t> &alias_map;
+	case_insensitive_map_t<idx_t> &group_alias_map;
 	unordered_set<idx_t> used_aliases;
 
 	idx_t group_index;
@@ -144116,7 +144155,7 @@ namespace duckdb {
 class HavingBinder : public SelectBinder {
 public:
 	HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-	             unordered_map<string, idx_t> &alias_map);
+	             case_insensitive_map_t<idx_t> &alias_map);
 
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
@@ -144149,7 +144188,7 @@ namespace duckdb {
 class QualifyBinder : public SelectBinder {
 public:
 	QualifyBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-	              unordered_map<string, idx_t> &alias_map);
+	              case_insensitive_map_t<idx_t> &alias_map);
 
 protected:
 	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
@@ -144186,10 +144225,10 @@ class SelectNode;
 //! The ORDER binder is responsible for binding an expression within the ORDER BY clause of a SQL statement
 class OrderBinder {
 public:
-	OrderBinder(vector<Binder *> binders, idx_t projection_index, unordered_map<string, idx_t> &alias_map,
+	OrderBinder(vector<Binder *> binders, idx_t projection_index, case_insensitive_map_t<idx_t> &alias_map,
 	            expression_map_t<idx_t> &projection_map, idx_t max_count);
 	OrderBinder(vector<Binder *> binders, idx_t projection_index, SelectNode &node,
-	            unordered_map<string, idx_t> &alias_map, expression_map_t<idx_t> &projection_map);
+	            case_insensitive_map_t<idx_t> &alias_map, expression_map_t<idx_t> &projection_map);
 
 public:
 	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> expr);
@@ -144206,7 +144245,7 @@ private:
 	idx_t projection_index;
 	idx_t max_count;
 	vector<unique_ptr<ParsedExpression>> *extra_list;
-	unordered_map<string, idx_t> &alias_map;
+	case_insensitive_map_t<idx_t> &alias_map;
 	expression_map_t<idx_t> &projection_map;
 };
 
@@ -144450,7 +144489,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	statement.select_list = move(new_select_list);
 
 	// create a mapping of (alias -> index) and a mapping of (Expression -> index) for the SELECT list
-	unordered_map<string, idx_t> alias_map;
+	case_insensitive_map_t<idx_t> alias_map;
 	expression_map_t<idx_t> projection_map;
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		auto &expr = statement.select_list[i];
@@ -144644,7 +144683,7 @@ public:
 
 namespace duckdb {
 
-static void GatherAliases(BoundQueryNode &node, unordered_map<string, idx_t> &aliases,
+static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &aliases,
                           expression_map_t<idx_t> &expressions) {
 	if (node.type == QueryNodeType::SET_OPERATION_NODE) {
 		// setop, recurse
@@ -144714,7 +144753,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
 
 		// we recursively visit the children of this node to extract aliases and expressions that can be referenced in
 		// the ORDER BY
-		unordered_map<string, idx_t> alias_map;
+		case_insensitive_map_t<idx_t> alias_map;
 		expression_map_t<idx_t> expression_map;
 		GatherAliases(*result, alias_map, expression_map);
 
@@ -146594,7 +146633,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 		// insertion statement specifies column list
 
 		// create a mapping of (list index) -> (column index)
-		unordered_map<string, idx_t> column_name_map;
+		case_insensitive_map_t<idx_t> column_name_map;
 		for (idx_t i = 0; i < stmt.columns.size(); i++) {
 			column_name_map[stmt.columns[i]] = i;
 			auto entry = table->name_map.find(stmt.columns[i]);
@@ -147905,7 +147944,7 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 
 namespace duckdb {
 
-void Binder::BindNamedParameters(unordered_map<string, LogicalType> &types, unordered_map<string, Value> &values,
+void Binder::BindNamedParameters(named_parameter_type_map_t &types, named_parameter_map_t &values,
                                  QueryErrorContext &error_context, string &func_name) {
 	for (auto &kv : values) {
 		auto entry = types.find(kv.first);
@@ -147982,7 +148021,7 @@ unique_ptr<BoundTableRef> Binder::Bind(SubqueryRef &ref, CommonTableExpressionIn
 namespace duckdb {
 
 bool Binder::BindFunctionParameters(vector<unique_ptr<ParsedExpression>> &expressions, vector<LogicalType> &arguments,
-                                    vector<Value> &parameters, unordered_map<string, Value> &named_parameters,
+                                    vector<Value> &parameters, named_parameter_map_t &named_parameters,
                                     unique_ptr<BoundSubqueryRef> &subquery, string &error) {
 	bool seen_subquery = false;
 	for (auto &child : expressions) {
@@ -148046,7 +148085,7 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	// evaluate the input parameters to the function
 	vector<LogicalType> arguments;
 	vector<Value> parameters;
-	unordered_map<string, Value> named_parameters;
+	named_parameter_map_t named_parameters;
 	unique_ptr<BoundSubqueryRef> subquery;
 	string error;
 	if (!BindFunctionParameters(fexpr->children, arguments, parameters, named_parameters, subquery, error)) {
@@ -150013,7 +150052,7 @@ BindResult CheckBinder::BindCheckColumn(ColumnRefExpression &colref) {
 
 namespace duckdb {
 
-ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const unordered_map<string, idx_t> &alias_map)
+ColumnAliasBinder::ColumnAliasBinder(BoundSelectNode &node, const case_insensitive_map_t<idx_t> &alias_map)
     : node(node), alias_map(alias_map), in_alias(false) {
 }
 
@@ -150077,7 +150116,7 @@ string ConstantBinder::UnsupportedAggregateMessage() {
 namespace duckdb {
 
 GroupBinder::GroupBinder(Binder &binder, ClientContext &context, SelectNode &node, idx_t group_index,
-                         unordered_map<string, idx_t> &alias_map, unordered_map<string, idx_t> &group_alias_map)
+                         case_insensitive_map_t<idx_t> &alias_map, case_insensitive_map_t<idx_t> &group_alias_map)
     : ExpressionBinder(binder, context), node(node), alias_map(alias_map), group_alias_map(group_alias_map),
       group_index(group_index) {
 }
@@ -150185,7 +150224,7 @@ BindResult GroupBinder::BindColumnRef(ColumnRefExpression &colref) {
 namespace duckdb {
 
 HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-                           unordered_map<string, idx_t> &alias_map)
+                           case_insensitive_map_t<idx_t> &alias_map)
     : SelectBinder(binder, context, node, info), column_alias_binder(node, alias_map) {
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
@@ -150280,13 +150319,13 @@ string InsertBinder::UnsupportedAggregateMessage() {
 
 namespace duckdb {
 
-OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, unordered_map<string, idx_t> &alias_map,
+OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, case_insensitive_map_t<idx_t> &alias_map,
                          expression_map_t<idx_t> &projection_map, idx_t max_count)
     : binders(move(binders)), projection_index(projection_index), max_count(max_count), extra_list(nullptr),
       alias_map(alias_map), projection_map(projection_map) {
 }
 OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, SelectNode &node,
-                         unordered_map<string, idx_t> &alias_map, expression_map_t<idx_t> &projection_map)
+                         case_insensitive_map_t<idx_t> &alias_map, expression_map_t<idx_t> &projection_map)
     : binders(move(binders)), projection_index(projection_index), alias_map(alias_map), projection_map(projection_map) {
 	this->max_count = node.select_list.size();
 	this->extra_list = &node.select_list;
@@ -150384,7 +150423,7 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 namespace duckdb {
 
 QualifyBinder::QualifyBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-                             unordered_map<string, idx_t> &alias_map)
+                             case_insensitive_map_t<idx_t> &alias_map)
     : SelectBinder(binder, context, node, info), column_alias_binder(node, alias_map) {
 	target_type = LogicalType(LogicalTypeId::BOOLEAN);
 }
@@ -152421,7 +152460,7 @@ void PragmaHandler::HandlePragmaStatementsInternal(vector<unique_ptr<SQLStatemen
 			if (!new_query.empty()) {
 				// this PRAGMA statement gets replaced by a new query string
 				// push the new query string through the parser again and add it to the transformer
-				Parser parser;
+				Parser parser(context.GetParserOptions());
 				parser.ParseQuery(new_query);
 				// insert the new statements and remove the old statement
 				// FIXME: off by one here maybe?
@@ -222210,6 +222249,45 @@ PGNode *newNode(size_t size, PGNodeTag type) {
 
 
 
+// LICENSE_CHANGE_BEGIN
+// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #9
+// See the end of this file for a list
+
+/*-------------------------------------------------------------------------
+ *
+ * scansup.h
+ *	  scanner support routines.  used by both the bootstrap lexer
+ * as well as the normal lexer
+ *
+ * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/scansup.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+
+
+namespace duckdb_libpgquery {
+
+char *scanstr(const char *s);
+
+char *downcase_truncate_identifier(const char *ident, int len, bool warn);
+
+char *downcase_identifier(const char *ident, int len, bool warn, bool truncate);
+
+bool scanner_isspace(char ch);
+
+void set_preserve_identifier_case(bool downcase);
+bool get_preserve_identifier_case();
+
+}
+
+// LICENSE_CHANGE_END
+
+
+
 // LICENSE_CHANGE_BEGIN
 // The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #9
 // See the end of this file for a list
@@ -222290,6 +222368,10 @@ vector<duckdb_libpgquery::PGKeyword> PostgresParser::KeywordList() {
 	return duckdb_libpgquery::keyword_list();
 }
 
+void PostgresParser::SetPreserveIdentifierCase(bool preserve) {
+	duckdb_libpgquery::set_preserve_identifier_case(preserve);
+}
+
 }
 
 
@@ -251634,41 +251716,6 @@ int base_yylex(YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner) {
 		/* only needed for GUC variables */
 
 
-// LICENSE_CHANGE_BEGIN
-// The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #9
-// See the end of this file for a list
-
-/*-------------------------------------------------------------------------
- *
- * scansup.h
- *	  scanner support routines.  used by both the bootstrap lexer
- * as well as the normal lexer
- *
- * Portions Copyright (c) 1996-2017, PostgreSQL Global Development PGGroup
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/include/parser/scansup.h
- *
- *-------------------------------------------------------------------------
- */
-
-
-
-namespace duckdb_libpgquery {
-
-char *scanstr(const char *s);
-
-char *downcase_truncate_identifier(const char *ident, int len, bool warn);
-
-char *downcase_identifier(const char *ident, int len, bool warn, bool truncate);
-
-bool scanner_isspace(char ch);
-
-}
-
-// LICENSE_CHANGE_END
-
-
 
 // LICENSE_CHANGE_BEGIN
 // The following code up to LICENSE_CHANGE_END is subject to THIRD PARTY LICENSE #9
@@ -255828,6 +255875,16 @@ char *downcase_truncate_identifier(const char *ident, int len, bool warn) {
 	return downcase_identifier(ident, len, warn, true);
 }
 
+static __thread bool pg_preserve_identifier_case = false;
+
+void set_preserve_identifier_case(bool preserve) {
+	pg_preserve_identifier_case = preserve;
+}
+
+bool get_preserve_identifier_case() {
+	return pg_preserve_identifier_case;
+}
+
 /*
  * a workhorse for downcase_truncate_identifier
  */
@@ -255851,10 +255908,12 @@ char *downcase_identifier(const char *ident, int len, bool warn, bool truncate)
 	for (i = 0; i < len; i++) {
 		unsigned char ch = (unsigned char)ident[i];
 
-		if (ch >= 'A' && ch <= 'Z')
-			ch += 'a' - 'A';
-		else if (enc_is_single_byte && IS_HIGHBIT_SET(ch) && isupper(ch))
-			ch = tolower(ch);
+		if (!get_preserve_identifier_case()) {
+			if (ch >= 'A' && ch <= 'Z')
+				ch += 'a' - 'A';
+			else if (enc_is_single_byte && IS_HIGHBIT_SET(ch) && isupper(ch))
+				ch = tolower(ch);
+		}
 		result[i] = (char)ch;
 	}
 	result[i] = '\0';