duckdb 0.3.3-dev1226.0 → 0.3.3-dev1251.0

package/src/duckdb.cpp

@@ -5307,15 +5307,19 @@ int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stre
 		out->release = nullptr;
 		return 0;
 	}
-	while (chunk_result->size() < my_stream->batch_size) {
+	unique_ptr<DataChunk> agg_chunk_result = make_unique<DataChunk>();
+	agg_chunk_result->Initialize(chunk_result->GetTypes());
+	agg_chunk_result->Append(*chunk_result, true);
+
+	while (agg_chunk_result->size() < my_stream->batch_size) {
 		auto new_chunk = result.Fetch();
 		if (!new_chunk) {
 			break;
 		} else {
-			chunk_result->Append(*new_chunk, true);
+			agg_chunk_result->Append(*new_chunk, true);
 		}
 	}
-	chunk_result->ToArrowArray(out);
+	agg_chunk_result->ToArrowArray(out);
 	return 0;
 }
 
@@ -26367,17 +26371,20 @@ template <class OP, bool NO_MATCH_SEL>
 static void TemplatedMatchNested(Vector &col, Vector &rows, const idx_t vcount, SelectionVector &sel, idx_t &count,
                                  const idx_t col_offset, const idx_t col_no, SelectionVector *no_match,
                                  idx_t &no_match_count) {
-	// Gather a scattered Vector containing the column values being matched
+	// Gather a dense Vector containing the column values being matched
 	Vector key(col.GetType());
-	RowOperations::Gather(rows, sel, key, sel, count, col_offset, col_no);
+	RowOperations::Gather(rows, sel, key, *FlatVector::IncrementalSelectionVector(), count, col_offset, col_no);
+
+	// Densify the input column
+	Vector sliced(col, sel, count);
 
 	if (NO_MATCH_SEL) {
 		SelectionVector no_match_sel_offset(no_match->data() + no_match_count);
-		auto match_count = SelectComparison<OP>(col, key, vcount, sel, count, &sel, &no_match_sel_offset);
+		auto match_count = SelectComparison<OP>(sliced, key, count, sel, count, &sel, &no_match_sel_offset);
 		no_match_count += count - match_count;
 		count = match_count;
 	} else {
-		count = SelectComparison<OP>(col, key, vcount, sel, count, &sel, nullptr);
+		count = SelectComparison<OP>(sliced, key, count, sel, count, &sel, nullptr);
 	}
 }
 
@@ -43436,9 +43443,13 @@ static idx_t DistinctSelect(Vector &left, Vector &right, idx_t vcount, const Sel
 }
 
 template <class OP>
-static idx_t DistinctSelectNotNull(VectorData &lvdata, VectorData &rvdata, const idx_t count, idx_t &true_count,
-                                   const SelectionVector &sel, SelectionVector &maybe_vec, OptionalSelection &true_vec,
-                                   OptionalSelection &false_vec) {
+static idx_t DistinctSelectNotNull(Vector &left, Vector &right, const idx_t count, idx_t &true_count,
+                                   const SelectionVector &sel, SelectionVector &maybe_vec, OptionalSelection &true_opt,
+                                   OptionalSelection &false_opt) {
+	VectorData lvdata, rvdata;
+	left.Orrify(count, lvdata);
+	right.Orrify(count, rvdata);
+
 	auto &lmask = lvdata.validity;
 	auto &rmask = rvdata.validity;
 
@@ -43452,39 +43463,39 @@ static idx_t DistinctSelectNotNull(VectorData &lvdata, VectorData &rvdata, const
 		return remaining;
 	}
 
+	// Slice the Vectors down to the rows that are not determined (i.e., neither is NULL)
+	SelectionVector slicer(count);
+	true_count = 0;
 	idx_t false_count = 0;
 	for (idx_t i = 0; i < count; ++i) {
-		const auto idx = sel.get_index(i);
-		const auto lidx = lvdata.sel->get_index(idx);
-		const auto ridx = rvdata.sel->get_index(idx);
+		const auto result_idx = sel.get_index(i);
+		const auto lidx = lvdata.sel->get_index(i);
+		const auto ridx = rvdata.sel->get_index(i);
 		const auto lnull = !lmask.RowIsValid(lidx);
 		const auto rnull = !rmask.RowIsValid(ridx);
 		if (lnull || rnull) {
 			// If either is NULL then we can major distinguish them
 			if (!OP::Operation(false, false, lnull, rnull)) {
-				false_vec.Append(false_count, idx);
+				false_opt.Append(false_count, result_idx);
 			} else {
-				true_vec.Append(true_count, idx);
+				true_opt.Append(true_count, result_idx);
 			}
 		} else {
 			//	Neither is NULL, distinguish values.
-			maybe_vec.set_index(remaining++, idx);
+			slicer.set_index(remaining, i);
+			maybe_vec.set_index(remaining++, result_idx);
 		}
 	}
-	true_vec.Advance(true_count);
-	false_vec.Advance(false_count);
 
-	return remaining;
-}
+	true_opt.Advance(true_count);
+	false_opt.Advance(false_count);
 
-template <bool DENSE>
-static inline void ScatterSelection(SelectionVector *target, const idx_t count, const SelectionVector &sel,
-                                    const SelectionVector &dense_vec) {
-	if (DENSE && target) {
-		for (idx_t i = 0; i < count; ++i) {
-			target->set_index(i, sel.get_index(dense_vec.get_index(i)));
-		}
+	if (remaining && remaining < count) {
+		left.Slice(slicer, remaining);
+		right.Slice(slicer, remaining);
 	}
+
+	return remaining;
 }
 
 struct PositionComparator {
@@ -43616,26 +43627,70 @@ static StructEntries &StructVectorGetSlicedEntries(Vector &parent, StructEntries
 	return children;
 }
 
+static void ExtractNestedSelection(const SelectionVector &slice_sel, const idx_t count, const SelectionVector &sel,
+                                   OptionalSelection &opt) {
+
+	for (idx_t i = 0; i < count;) {
+		const auto slice_idx = slice_sel.get_index(i);
+		const auto result_idx = sel.get_index(slice_idx);
+		opt.Append(i, result_idx);
+	}
+	opt.Advance(count);
+}
+
+static void DensifyNestedSelection(const SelectionVector &dense_sel, const idx_t count, SelectionVector &slice_sel) {
+	for (idx_t i = 0; i < count; ++i) {
+		slice_sel.set_index(i, dense_sel.get_index(i));
+	}
+}
+
 template <class OP>
-static idx_t DistinctSelectStruct(Vector &left, Vector &right, idx_t vcount, VectorData &lvdata, VectorData &rvdata,
-                                  idx_t count, SelectionVector &maybe_vec, OptionalSelection &true_opt,
-                                  OptionalSelection &false_opt) {
+static idx_t DistinctSelectStruct(Vector &left, Vector &right, idx_t count, const SelectionVector &sel,
+                                  OptionalSelection &true_opt, OptionalSelection &false_opt) {
+	if (count == 0) {
+		return 0;
+	}
+
 	// Avoid allocating in the 99% of the cases where we don't need to.
 	StructEntries lsliced, rsliced;
-	auto &lchildren = StructVectorGetSlicedEntries(left, lsliced, vcount);
-	auto &rchildren = StructVectorGetSlicedEntries(right, rsliced, vcount);
+	auto &lchildren = StructVectorGetSlicedEntries(left, lsliced, count);
+	auto &rchildren = StructVectorGetSlicedEntries(right, rsliced, count);
 	D_ASSERT(lchildren.size() == rchildren.size());
 
+	// In order to reuse the comparators, we have to track what passed and failed internally.
+	// To do that, we need local SVs that we then merge back into the real ones after every pass.
+	const auto vcount = count;
+	SelectionVector slice_sel(count);
+	for (idx_t i = 0; i < count; ++i) {
+		slice_sel.set_index(i, i);
+	}
+
+	SelectionVector true_sel(count);
+	SelectionVector false_sel(count);
+
 	idx_t match_count = 0;
 	for (idx_t col_no = 0; col_no < lchildren.size(); ++col_no) {
-		auto &lchild = *lchildren[col_no];
-		auto &rchild = *rchildren[col_no];
+		// Slice the children to maintain density
+		Vector lchild(*lchildren[col_no]);
+		lchild.Normalify(vcount);
+		lchild.Slice(slice_sel, count);
+
+		Vector rchild(*rchildren[col_no]);
+		rchild.Normalify(vcount);
+		rchild.Slice(slice_sel, count);
 
 		// Find everything that definitely matches
 		auto true_count =
-		    PositionComparator::Definite<OP>(lchild, rchild, vcount, maybe_vec, count, true_opt, maybe_vec);
+		    PositionComparator::Definite<OP>(lchild, rchild, count, slice_sel, count, &true_sel, false_sel);
 		if (true_count > 0) {
-			true_opt.Advance(true_count);
+			auto false_count = count - true_count;
+
+			// Extract the definite matches into the true result
+			ExtractNestedSelection(false_count ? true_sel : slice_sel, true_count, sel, true_opt);
+
+			// Remove the definite matches from the slicing vector
+			DensifyNestedSelection(false_sel, false_count, slice_sel);
+
 			match_count += true_count;
 			count -= true_count;
 		}
@@ -43643,12 +43698,28 @@ static idx_t DistinctSelectStruct(Vector &left, Vector &right, idx_t vcount, Vec
 		if (col_no != lchildren.size() - 1) {
 			// Find what might match on the next position
 			true_count =
-			    PositionComparator::Possible<OP>(lchild, rchild, vcount, maybe_vec, count, maybe_vec, false_opt);
+			    PositionComparator::Possible<OP>(lchild, rchild, count, slice_sel, count, true_sel, &false_sel);
 			auto false_count = count - true_count;
-			false_opt.Advance(false_count);
+
+			// Extract the definite failures into the false result
+			ExtractNestedSelection(true_count ? false_sel : slice_sel, false_count, sel, false_opt);
+
+			// Remove any definite failures from the slicing vector
+			if (false_count) {
+				DensifyNestedSelection(true_sel, true_count, slice_sel);
+			}
+
 			count = true_count;
 		} else {
-			true_count = PositionComparator::Final<OP>(lchild, rchild, vcount, maybe_vec, count, true_opt, false_opt);
+			true_count = PositionComparator::Final<OP>(lchild, rchild, count, slice_sel, count, &true_sel, &false_sel);
+			auto false_count = count - true_count;
+
+			// Extract the definite matches into the true result
+			ExtractNestedSelection(false_count ? true_sel : slice_sel, true_count, sel, true_opt);
+
+			// Extract the definite failures into the false result
+			ExtractNestedSelection(true_count ? false_sel : slice_sel, false_count, sel, false_opt);
+
 			match_count += true_count;
 		}
 	}
@@ -43657,28 +43728,27 @@ static idx_t DistinctSelectStruct(Vector &left, Vector &right, idx_t vcount, Vec
 }
 
 static void PositionListCursor(SelectionVector &cursor, VectorData &vdata, const idx_t pos,
-                               const SelectionVector &maybe_vec, const idx_t count) {
+                               const SelectionVector &slice_sel, const idx_t count) {
 	const auto data = (const list_entry_t *)vdata.data;
 	for (idx_t i = 0; i < count; ++i) {
-		const auto idx = maybe_vec.get_index(i);
+		const auto slice_idx = slice_sel.get_index(i);
 
-		const auto lidx = vdata.sel->get_index(idx);
+		const auto lidx = vdata.sel->get_index(slice_idx);
 		const auto &entry = data[lidx];
-		cursor.set_index(idx, entry.offset + pos);
+		cursor.set_index(i, entry.offset + pos);
 	}
 }
 
 template <class OP>
-static idx_t DistinctSelectList(Vector &left, Vector &right, idx_t vcount, VectorData &lvdata, VectorData &rvdata,
-                                idx_t count, SelectionVector &maybe_vec, OptionalSelection &true_opt,
-                                OptionalSelection &false_opt) {
+static idx_t DistinctSelectList(Vector &left, Vector &right, idx_t count, const SelectionVector &sel,
+                                OptionalSelection &true_opt, OptionalSelection &false_opt) {
 	if (count == 0) {
 		return count;
 	}
 
-	// We use them to create dictionary views of the children so we can vectorise the positional comparisons.
-	SelectionVector lcursor(vcount);
-	SelectionVector rcursor(vcount);
+	// Create dictionary views of the children so we can vectorise the positional comparisons.
+	SelectionVector lcursor(count);
+	SelectionVector rcursor(count);
 
 	Vector lchild(ListVector::GetEntry(left), lcursor, count);
 	Vector rchild(ListVector::GetEntry(right), rcursor, count);
@@ -43696,105 +43766,137 @@ static idx_t DistinctSelectList(Vector &left, Vector &right, idx_t vcount, Vecto
 	//	 	++left, ++right;
 	// 	}
 	// }
+
+	// Get pointers to the list entries
+	VectorData lvdata;
+	left.Orrify(count, lvdata);
 	const auto ldata = (const list_entry_t *)lvdata.data;
+
+	VectorData rvdata;
+	right.Orrify(count, rvdata);
 	const auto rdata = (const list_entry_t *)rvdata.data;
 
+	// In order to reuse the comparators, we have to track what passed and failed internally.
+	// To do that, we need local SVs that we then merge back into the real ones after every pass.
+	SelectionVector slice_sel(count);
+	for (idx_t i = 0; i < count; ++i) {
+		slice_sel.set_index(i, i);
+	}
+
+	SelectionVector true_sel(count);
+	SelectionVector false_sel(count);
+
 	idx_t match_count = 0;
 	for (idx_t pos = 0; count > 0; ++pos) {
 		// Set up the cursors for the current position
-		PositionListCursor(lcursor, lvdata, pos, maybe_vec, count);
-		PositionListCursor(rcursor, rvdata, pos, maybe_vec, count);
+		PositionListCursor(lcursor, lvdata, pos, slice_sel, count);
+		PositionListCursor(rcursor, rvdata, pos, slice_sel, count);
 
 		// Tie-break the pairs where one of the LISTs is exhausted.
 		idx_t true_count = 0;
 		idx_t false_count = 0;
 		idx_t maybe_count = 0;
 		for (idx_t i = 0; i < count; ++i) {
-			const auto idx = maybe_vec.get_index(i);
-			const auto lidx = lvdata.sel->get_index(idx);
+			const auto slice_idx = slice_sel.get_index(i);
+			const auto lidx = lvdata.sel->get_index(slice_idx);
 			const auto &lentry = ldata[lidx];
-			const auto ridx = rvdata.sel->get_index(idx);
+			const auto ridx = rvdata.sel->get_index(slice_idx);
 			const auto &rentry = rdata[ridx];
 			if (lentry.length == pos || rentry.length == pos) {
+				const auto idx = sel.get_index(slice_idx);
 				if (PositionComparator::TieBreak<OP>(lentry.length, rentry.length)) {
 					true_opt.Append(true_count, idx);
 				} else {
 					false_opt.Append(false_count, idx);
 				}
 			} else {
-				maybe_vec.set_index(maybe_count++, idx);
+				true_sel.set_index(maybe_count++, slice_idx);
 			}
 		}
 		true_opt.Advance(true_count);
 		false_opt.Advance(false_count);
-		count = maybe_count;
 		match_count += true_count;
 
+		// Redensify the list cursors
+		if (maybe_count < count) {
+			count = maybe_count;
+			DensifyNestedSelection(true_sel, count, slice_sel);
+			PositionListCursor(lcursor, lvdata, pos, slice_sel, count);
+			PositionListCursor(rcursor, rvdata, pos, slice_sel, count);
+		}
+
 		// Find everything that definitely matches
-		true_count = PositionComparator::Definite<OP>(lchild, rchild, vcount, maybe_vec, count, true_opt, maybe_vec);
-		true_opt.Advance(true_count);
-		match_count += true_count;
-		count -= true_count;
+		true_count = PositionComparator::Definite<OP>(lchild, rchild, count, slice_sel, count, &true_sel, false_sel);
+		if (true_count) {
+			false_count = count - true_count;
+			ExtractNestedSelection(false_count ? true_sel : slice_sel, true_count, sel, true_opt);
+			match_count += true_count;
+
+			// Redensify the list cursors
+			count -= true_count;
+			DensifyNestedSelection(false_sel, count, slice_sel);
+			PositionListCursor(lcursor, lvdata, pos, slice_sel, count);
+			PositionListCursor(rcursor, rvdata, pos, slice_sel, count);
+		}
 
 		// Find what might match on the next position
-		maybe_count = PositionComparator::Possible<OP>(lchild, rchild, vcount, maybe_vec, count, maybe_vec, false_opt);
-		false_count = count - maybe_count;
-		false_opt.Advance(false_count);
-		count = maybe_count;
+		true_count = PositionComparator::Possible<OP>(lchild, rchild, count, slice_sel, count, true_sel, &false_sel);
+		false_count = count - true_count;
+		ExtractNestedSelection(true_count ? false_sel : slice_sel, false_count, sel, false_opt);
+
+		if (false_count) {
+			DensifyNestedSelection(true_sel, true_count, slice_sel);
+		}
+		count = true_count;
 	}
 
 	return match_count;
 }
 
-template <class OP, bool DENSE, class OPNESTED>
-static idx_t DistinctSelectNested(Vector &left, Vector &right, idx_t vcount, const SelectionVector *sel, idx_t count,
+template <class OP, class OPNESTED>
+static idx_t DistinctSelectNested(Vector &left, Vector &right, const SelectionVector *sel, const idx_t count,
                                   SelectionVector *true_sel, SelectionVector *false_sel) {
-	// We need multiple, real selections
+	// The Select operations all use a dense pair of input vectors to partition
+	// a selection vector in a single pass. But to implement progressive comparisons,
+	// we have to make multiple passes, so we need to keep track of the original input positions
+	// and then scatter the output selections when we are done.
 	SelectionVector owned_sel;
 	if (!sel) {
 		sel = FlatVector::IncrementalSelectionVector(count, owned_sel);
 	}
 
-	SelectionVector true_vec;
-	SelectionVector false_vec;
-	if (DENSE) {
-		true_vec.Initialize(vcount);
-		false_vec.Initialize(vcount);
-	}
+	// Make buffered selections for progressive comparisons
+	// TODO: Remove unnecessary allocations
+	SelectionVector true_vec(count);
+	OptionalSelection true_opt(&true_vec);
 
-	OptionalSelection true_opt(DENSE ? &true_vec : true_sel);
-	OptionalSelection false_opt(DENSE ? &false_vec : false_sel);
+	SelectionVector false_vec(count);
+	OptionalSelection false_opt(&false_vec);
 
-	// Handle NULL STRUCTs
-	VectorData lvdata, rvdata;
-	left.Orrify(vcount, lvdata);
-	right.Orrify(vcount, rvdata);
+	SelectionVector maybe_vec(count);
+
+	// Handle NULL nested values
+	Vector l_not_null(left);
+	Vector r_not_null(right);
 
-	sel_t maybe_one;
-	SelectionVector maybe_vec(&maybe_one);
-	if (count > 1) {
-		maybe_vec.Initialize(count);
-	}
 	idx_t match_count = 0;
-	idx_t no_match_count = count;
-	count = DistinctSelectNotNull<OP>(lvdata, rvdata, count, match_count, *sel, maybe_vec, true_opt, false_opt);
-	no_match_count -= (count + match_count);
+	auto unknown =
+	    DistinctSelectNotNull<OP>(l_not_null, r_not_null, count, match_count, *sel, maybe_vec, true_opt, false_opt);
 
-	idx_t true_count = 0;
 	if (PhysicalType::LIST == left.GetType().InternalType()) {
-		true_count =
-		    DistinctSelectList<OPNESTED>(left, right, vcount, lvdata, rvdata, count, maybe_vec, true_opt, false_opt);
+		match_count += DistinctSelectList<OPNESTED>(l_not_null, r_not_null, unknown, maybe_vec, true_opt, false_opt);
 	} else {
-		true_count =
-		    DistinctSelectStruct<OPNESTED>(left, right, vcount, lvdata, rvdata, count, maybe_vec, true_opt, false_opt);
+		match_count += DistinctSelectStruct<OPNESTED>(l_not_null, r_not_null, unknown, maybe_vec, true_opt, false_opt);
 	}
 
-	auto false_count = count - true_count;
-	match_count += true_count;
-	no_match_count += false_count;
+	// Copy the buffered selections to the output selections
+	if (true_sel) {
+		DensifyNestedSelection(true_vec, match_count, *true_sel);
+	}
 
-	ScatterSelection<DENSE>(true_sel, match_count, *sel, true_vec);
-	ScatterSelection<DENSE>(false_sel, no_match_count, *sel, false_vec);
+	if (false_sel) {
+		DensifyNestedSelection(false_vec, count - match_count, *false_sel);
+	}
 
 	return match_count;
 }
@@ -43896,7 +43998,7 @@ static idx_t TemplatedDistinctSelectOperation(Vector &left, Vector &right, idx_t
 	case PhysicalType::MAP:
 	case PhysicalType::STRUCT:
 	case PhysicalType::LIST:
-		return DistinctSelectNested<OP, DENSE, OPNESTED>(left, right, vcount, sel, count, true_sel, false_sel);
+		return DistinctSelectNested<OP, OPNESTED>(left, right, sel, count, true_sel, false_sel);
 	default:
 		throw InternalException("Invalid type for distinct selection");
 	}
@@ -44004,38 +44106,38 @@ idx_t VectorOperations::DistinctLessThanEquals(Vector &left, Vector &right, cons
 // true := A != B with nulls being equal, inputs selected
 idx_t VectorOperations::NestedNotEquals(Vector &left, Vector &right, idx_t vcount, const SelectionVector &sel,
                                         idx_t count, SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctFrom, false>(left, right, vcount, &sel, count, true_sel,
-	                                                                     false_sel);
+	return TemplatedDistinctSelectOperation<duckdb::DistinctFrom, true>(left, right, vcount, &sel, count, true_sel,
+	                                                                    false_sel);
 }
 // true := A == B with nulls being equal, inputs selected
 idx_t VectorOperations::NestedEquals(Vector &left, Vector &right, idx_t vcount, const SelectionVector &sel, idx_t count,
                                      SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::NotDistinctFrom, false>(left, right, vcount, &sel, count, true_sel,
-	                                                                        false_sel);
+	return TemplatedDistinctSelectOperation<duckdb::NotDistinctFrom, true>(left, right, vcount, &sel, count, true_sel,
+	                                                                       false_sel);
 }
 // true := A > B with nulls being maximal, inputs selected
 idx_t VectorOperations::NestedGreaterThan(Vector &left, Vector &right, idx_t vcount, const SelectionVector &sel,
                                           idx_t count, SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThan, false>(left, right, vcount, &sel, count,
-	                                                                            true_sel, false_sel);
+	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThan, true>(left, right, vcount, &sel, count,
+	                                                                           true_sel, false_sel);
 }
 // true := A >= B with nulls being maximal, inputs selected
 idx_t VectorOperations::NestedGreaterThanEquals(Vector &left, Vector &right, idx_t vcount, const SelectionVector &sel,
                                                 idx_t count, SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThanEquals, false>(left, right, vcount, &sel, count,
-	                                                                                  true_sel, false_sel);
+	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThanEquals, true>(left, right, vcount, &sel, count,
+	                                                                                 true_sel, false_sel);
 }
 // true := A < B with nulls being maximal, inputs selected
 idx_t VectorOperations::NestedLessThan(Vector &left, Vector &right, idx_t vcount, const SelectionVector &sel,
                                        idx_t count, SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctLessThan, false>(left, right, vcount, &sel, count, true_sel,
-	                                                                         false_sel);
+	return TemplatedDistinctSelectOperation<duckdb::DistinctLessThan, true>(left, right, vcount, &sel, count, true_sel,
+	                                                                        false_sel);
 }
 // true := A <= B with nulls being maximal, inputs selected
 idx_t VectorOperations::NestedLessThanEquals(Vector &left, Vector &right, idx_t vcount, const SelectionVector &sel,
                                              idx_t count, SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctLessThanEquals, false>(left, right, vcount, &sel, count,
-	                                                                               true_sel, false_sel);
+	return TemplatedDistinctSelectOperation<duckdb::DistinctLessThanEquals, true>(left, right, vcount, &sel, count,
+	                                                                              true_sel, false_sel);
 }
 
 } // namespace duckdb
@@ -48171,45 +48273,63 @@ idx_t NestedSelector::Select<duckdb::GreaterThanEquals>(Vector &left, Vector &ri
 	return VectorOperations::NestedGreaterThanEquals(left, right, vcount, sel, count, true_sel, false_sel);
 }
 
-static inline idx_t SelectNotNull(VectorData &lvdata, VectorData &rvdata, const idx_t count,
-                                  OptionalSelection &false_vec, SelectionVector &maybe_vec) {
+static inline idx_t SelectNotNull(Vector &left, Vector &right, const idx_t count, const SelectionVector &sel,
+                                  SelectionVector &maybe_vec, OptionalSelection &false_opt) {
+
+	VectorData lvdata, rvdata;
+	left.Orrify(count, lvdata);
+	right.Orrify(count, rvdata);
+
+	auto &lmask = lvdata.validity;
+	auto &rmask = rvdata.validity;
 
 	// For top-level comparisons, NULL semantics are in effect,
 	// so filter out any NULLs
-	if (!lvdata.validity.AllValid() || !rvdata.validity.AllValid()) {
-		idx_t true_count = 0;
-		idx_t false_count = 0;
+	idx_t remaining = 0;
+	if (lmask.AllValid() && rmask.AllValid()) {
+		//	None are NULL, distinguish values.
 		for (idx_t i = 0; i < count; ++i) {
-			const auto lidx = lvdata.sel->get_index(i);
-			const auto ridx = rvdata.sel->get_index(i);
-			if (!lvdata.validity.RowIsValid(lidx) || !rvdata.validity.RowIsValid(ridx)) {
-				false_vec.Append(false_count, i);
-			} else {
-				maybe_vec.set_index(true_count++, i);
-			}
+			const auto idx = sel.get_index(i);
+			maybe_vec.set_index(remaining++, idx);
 		}
-		false_vec.Advance(false_count);
+		return remaining;
+	}
 
-		return true_count;
-	} else {
-		for (idx_t i = 0; i < count; ++i) {
-			maybe_vec.set_index(i, i);
+	// Slice the Vectors down to the rows that are not determined (i.e., neither is NULL)
+	SelectionVector slicer(count);
+	idx_t false_count = 0;
+	for (idx_t i = 0; i < count; ++i) {
+		const auto result_idx = sel.get_index(i);
+		const auto lidx = lvdata.sel->get_index(i);
+		const auto ridx = rvdata.sel->get_index(i);
+		if (!lmask.RowIsValid(lidx) || !rmask.RowIsValid(ridx)) {
+			false_opt.Append(false_count, result_idx);
+		} else {
+			//	Neither is NULL, distinguish values.
+			slicer.set_index(remaining, i);
+			maybe_vec.set_index(remaining++, result_idx);
 		}
-		return count;
 	}
+	false_opt.Advance(false_count);
+
+	if (remaining && remaining < count) {
+		left.Slice(slicer, remaining);
+		right.Slice(slicer, remaining);
+	}
+
+	return remaining;
 }
 
-static void ScatterSelection(SelectionVector *target, const idx_t count, const SelectionVector *sel,
-                             const SelectionVector &dense_vec) {
+static void ScatterSelection(SelectionVector *target, const idx_t count, const SelectionVector &dense_vec) {
 	if (target) {
 		for (idx_t i = 0; i < count; ++i) {
-			target->set_index(i, sel->get_index(dense_vec.get_index(i)));
+			target->set_index(i, dense_vec.get_index(i));
 		}
 	}
 }
 
 template <typename OP>
-static idx_t NestedSelectOperation(Vector &left, Vector &right, const SelectionVector *sel, idx_t vcount,
+static idx_t NestedSelectOperation(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
                                    SelectionVector *true_sel, SelectionVector *false_sel) {
 	// The Select operations all use a dense pair of input vectors to partition
 	// a selection vector in a single pass. But to implement progressive comparisons,
@@ -48217,47 +48337,34 @@ static idx_t NestedSelectOperation(Vector &left, Vector &right, const SelectionV
 	// and then scatter the output selections when we are done.
 	SelectionVector owned_sel;
 	if (!sel) {
-		sel = FlatVector::IncrementalSelectionVector(vcount, owned_sel);
+		sel = FlatVector::IncrementalSelectionVector(count, owned_sel);
 	}
 
-	VectorData lvdata, rvdata;
-	left.Orrify(vcount, lvdata);
-	right.Orrify(vcount, rvdata);
-
-	// Make real selections for progressive comparisons
-	SelectionVector true_vec(vcount);
+	// Make buffered selections for progressive comparisons
+	// TODO: Remove unnecessary allocations
+	SelectionVector true_vec(count);
 	OptionalSelection true_opt(&true_vec);
 
-	SelectionVector false_vec(vcount);
+	SelectionVector false_vec(count);
 	OptionalSelection false_opt(&false_vec);
 
-	SelectionVector maybe_vec(vcount);
-	auto count = SelectNotNull(lvdata, rvdata, vcount, false_opt, maybe_vec);
-	auto no_match_count = vcount - count;
+	SelectionVector maybe_vec(count);
 
-	// If everything was NULL, fill in false_sel with sel
-	if (count == 0) {
-		SelectionVector owned_flat_sel;
-		auto flat_sel = FlatVector::IncrementalSelectionVector(vcount, owned_sel);
-		ScatterSelection(false_sel, no_match_count, sel, *flat_sel);
-		return count;
-	}
+	// Handle NULL nested values
+	Vector l_not_null(left);
+	Vector r_not_null(right);
+
+	auto match_count = SelectNotNull(l_not_null, r_not_null, count, *sel, maybe_vec, false_opt);
+	auto no_match_count = count - match_count;
+	count = match_count;
 
 	//	Now that we have handled the NULLs, we can use the recursive nested comparator for the rest.
-	auto match_count = NestedSelector::Select<OP>(left, right, vcount, maybe_vec, count, true_opt, false_opt);
+	match_count = NestedSelector::Select<OP>(l_not_null, r_not_null, count, maybe_vec, count, true_opt, false_opt);
 	no_match_count += (count - match_count);
 
-	// Sort the optional selections if we would overwrite.
-	if (true_sel == sel) {
-		std::sort(true_vec.data(), true_vec.data() + match_count);
-	}
-	if (false_sel == sel) {
-		std::sort(false_vec.data(), false_vec.data() + no_match_count);
-	}
-
-	// Scatter the original selection to the output selections
-	ScatterSelection(true_sel, match_count, sel, true_vec);
-	ScatterSelection(false_sel, no_match_count, sel, false_vec);
+	// Copy the buffered selections to the output selections
+	ScatterSelection(true_sel, match_count, true_vec);
+	ScatterSelection(false_sel, no_match_count, false_vec);
 
 	return match_count;
 }
@@ -63944,14 +64051,15 @@ class DataTable;
 class PhysicalDelete : public PhysicalOperator {
 public:
 	PhysicalDelete(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table, idx_t row_id_index,
-	               idx_t estimated_cardinality)
+	               idx_t estimated_cardinality, bool return_chunk)
 	    : PhysicalOperator(PhysicalOperatorType::DELETE_OPERATOR, move(types), estimated_cardinality),
-	      tableref(tableref), table(table), row_id_index(row_id_index) {
+	      tableref(tableref), table(table), row_id_index(row_id_index), return_chunk(return_chunk) {
 	}
 
 	TableCatalogEntry &tableref;
 	DataTable &table;
 	idx_t row_id_index;
+	bool return_chunk;
 
 public:
 	// Source interface
@@ -63962,6 +64070,7 @@ public:
 public:
 	// Sink interface
 	unique_ptr<GlobalSinkState> GetGlobalSinkState(ClientContext &context) const override;
+	unique_ptr<LocalSinkState> GetLocalSinkState(ExecutionContext &context) const override;
 	SinkResultType Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
 	                    DataChunk &input) const override;
 
@@ -63981,6 +64090,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -63988,21 +64098,46 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 class DeleteGlobalState : public GlobalSinkState {
 public:
-	DeleteGlobalState() : deleted_count(0) {
+	DeleteGlobalState() : deleted_count(0), returned_chunk_count(0) {
 	}
 
 	mutex delete_lock;
 	idx_t deleted_count;
+	ChunkCollection return_chunk_collection;
+	idx_t returned_chunk_count;
+};
+
+class DeleteLocalState : public LocalSinkState {
+public:
+	explicit DeleteLocalState(const vector<LogicalType> &table_types) {
+		delete_chunk.Initialize(table_types);
+	}
+	DataChunk delete_chunk;
 };
 
 SinkResultType PhysicalDelete::Sink(ExecutionContext &context, GlobalSinkState &state, LocalSinkState &lstate,
                                     DataChunk &input) const {
 	auto &gstate = (DeleteGlobalState &)state;
+	auto &ustate = (DeleteLocalState &)lstate;
+
+	// get rows and
+	auto &transaction = Transaction::GetTransaction(context.client);
+	auto &row_identifiers = input.data[row_id_index];
+
+	vector<column_t> column_ids;
+	for (idx_t i = 0; i < table.column_definitions.size(); i++) {
+		column_ids.emplace_back(i);
+	};
+	auto cfs = ColumnFetchState();
 
-	// delete data in the base table
-	// the row ids are given to us as the last column of the child chunk
 	lock_guard<mutex> delete_guard(gstate.delete_lock);
-	gstate.deleted_count += table.Delete(tableref, context.client, input.data[row_id_index], input.size());
+	if (return_chunk) {
+		row_identifiers.Normalify(input.size());
+		table.Fetch(transaction, ustate.delete_chunk, column_ids, row_identifiers, input.size(), cfs);
+		gstate.return_chunk_collection.Append(ustate.delete_chunk);
+	}
+	gstate.deleted_count += table.Delete(tableref, context.client, row_identifiers, input.size());
+
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -64010,6 +64145,10 @@ unique_ptr<GlobalSinkState> PhysicalDelete::GetGlobalSinkState(ClientContext &co
 	return make_unique<DeleteGlobalState>();
 }
 
+unique_ptr<LocalSinkState> PhysicalDelete::GetLocalSinkState(ExecutionContext &context) const {
+	return make_unique<DeleteLocalState>(table.GetTypes());
+}
+
 //===--------------------------------------------------------------------===//
 // Source
 //===--------------------------------------------------------------------===//
@@ -64033,9 +64172,22 @@ void PhysicalDelete::GetData(ExecutionContext &context, DataChunk &chunk, Global
 		return;
 	}
 
-	chunk.SetCardinality(1);
-	chunk.SetValue(0, 0, Value::BIGINT(g.deleted_count));
-	state.finished = true;
+	if (!return_chunk) {
+		chunk.SetCardinality(1);
+		chunk.SetValue(0, 0, Value::BIGINT(g.deleted_count));
+		state.finished = true;
+	}
+
+	idx_t chunk_return = g.returned_chunk_count;
+	if (chunk_return >= g.return_chunk_collection.Chunks().size()) {
+		return;
+	}
+	chunk.Reference(g.return_chunk_collection.GetChunk(chunk_return));
+	chunk.SetCardinality((g.return_chunk_collection.GetChunk(chunk_return)).size());
+	g.returned_chunk_count += 1;
+	if (g.returned_chunk_count >= g.return_chunk_collection.Chunks().size()) {
+		state.finished = true;
+	}
 }
 
 } // namespace duckdb
@@ -64482,10 +64634,10 @@ class PhysicalUpdate : public PhysicalOperator {
 public:
 	PhysicalUpdate(vector<LogicalType> types, TableCatalogEntry &tableref, DataTable &table, vector<column_t> columns,
 	               vector<unique_ptr<Expression>> expressions, vector<unique_ptr<Expression>> bound_defaults,
-	               idx_t estimated_cardinality)
+	               idx_t estimated_cardinality, bool return_chunk)
 	    : PhysicalOperator(PhysicalOperatorType::UPDATE, move(types), estimated_cardinality), tableref(tableref),
 	      table(table), columns(std::move(columns)), expressions(move(expressions)),
-	      bound_defaults(move(bound_defaults)) {
+	      bound_defaults(move(bound_defaults)), return_chunk(return_chunk) {
 	}
 
 	TableCatalogEntry &tableref;
@@ -64494,6 +64646,8 @@ public:
 	vector<unique_ptr<Expression>> expressions;
 	vector<unique_ptr<Expression>> bound_defaults;
 	bool update_is_del_and_insert;
+	//! If the returning statement is present, return the whole chunk
+	bool return_chunk;
 
 public:
 	// Source interface
@@ -64527,6 +64681,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 //===--------------------------------------------------------------------===//
@@ -64534,12 +64689,14 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 class UpdateGlobalState : public GlobalSinkState {
 public:
-	UpdateGlobalState() : updated_count(0) {
+	UpdateGlobalState() : updated_count(0), returned_chunk_count(0) {
 	}
 
 	mutex lock;
 	idx_t updated_count;
 	unordered_set<row_t> updated_columns;
+	ChunkCollection return_chunk_collection;
+	idx_t returned_chunk_count;
 };
 
 class UpdateLocalState : public LocalSinkState {
@@ -64619,9 +64776,21 @@ SinkResultType PhysicalUpdate::Sink(ExecutionContext &context, GlobalSinkState &
 		}
 		table.Append(tableref, context.client, mock_chunk);
 	} else {
+		if (return_chunk) {
+			mock_chunk.SetCardinality(update_chunk);
+			for (idx_t i = 0; i < columns.size(); i++) {
+				mock_chunk.data[columns[i]].Reference(update_chunk.data[i]);
+			}
+		}
 		table.Update(tableref, context.client, row_ids, columns, update_chunk);
 	}
+
+	if (return_chunk) {
+		gstate.return_chunk_collection.Append(mock_chunk);
+	}
+
 	gstate.updated_count += chunk.size();
+
 	return SinkResultType::NEED_MORE_INPUT;
 }
 
@@ -64662,10 +64831,22 @@ void PhysicalUpdate::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	if (state.finished) {
 		return;
 	}
+	if (!return_chunk) {
+		chunk.SetCardinality(1);
+		chunk.SetValue(0, 0, Value::BIGINT(g.updated_count));
+		state.finished = true;
+	}
 
-	chunk.SetCardinality(1);
-	chunk.SetValue(0, 0, Value::BIGINT(g.updated_count));
-	state.finished = true;
+	idx_t chunk_return = g.returned_chunk_count;
+	if (chunk_return >= g.return_chunk_collection.Chunks().size()) {
+		return;
+	}
+	chunk.Reference(g.return_chunk_collection.GetChunk(chunk_return));
+	chunk.SetCardinality((g.return_chunk_collection.GetChunk(chunk_return)).size());
+	g.returned_chunk_count += 1;
+	if (g.returned_chunk_count >= g.return_chunk_collection.Chunks().size()) {
+		state.finished = true;
+	}
 }
 
 } // namespace duckdb
@@ -68288,14 +68469,27 @@ namespace duckdb {
 class LogicalDelete : public LogicalOperator {
 public:
 	explicit LogicalDelete(TableCatalogEntry *table)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE), table(table) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE), table(table), table_index(0), return_chunk(false) {
 	}
 
 	TableCatalogEntry *table;
+	idx_t table_index;
+	bool return_chunk;
 
 protected:
+	vector<ColumnBinding> GetColumnBindings() override {
+		if (return_chunk) {
+			return GenerateColumnBindings(table_index, table->columns.size());
+		}
+		return {ColumnBinding(0, 0)};
+	}
+
 	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BIGINT);
+		if (return_chunk) {
+			types = table->GetTypes();
+		} else {
+			types.emplace_back(LogicalType::BIGINT);
+		}
 	}
 };
 } // namespace duckdb
@@ -68314,8 +68508,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op
 	auto &bound_ref = (BoundReferenceExpression &)*op.expressions[0];
 
 	dependencies.insert(op.table);
-	auto del =
-	    make_unique<PhysicalDelete>(op.types, *op.table, *op.table->storage, bound_ref.index, op.estimated_cardinality);
+	auto del = make_unique<PhysicalDelete>(op.types, *op.table, *op.table->storage, bound_ref.index,
+	                                       op.estimated_cardinality, op.return_chunk);
 	del->children.push_back(move(plan));
 	return move(del);
 }
@@ -70604,17 +70798,33 @@ namespace duckdb {
 class LogicalUpdate : public LogicalOperator {
 public:
 	explicit LogicalUpdate(TableCatalogEntry *table)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_UPDATE), table(table), table_index(0), return_chunk(false) {
 	}
 
+	//! The base table to update
 	TableCatalogEntry *table;
+	//! table catalog index
+	idx_t table_index;
+	//! if returning option is used, return the update chunk
+	bool return_chunk;
 	vector<column_t> columns;
 	vector<unique_ptr<Expression>> bound_defaults;
 	bool update_is_del_and_insert;
 
 protected:
+	vector<ColumnBinding> GetColumnBindings() override {
+		if (return_chunk) {
+			return GenerateColumnBindings(table_index, table->columns.size());
+		}
+		return {ColumnBinding(0, 0)};
+	}
+
 	void ResolveTypes() override {
-		types.emplace_back(LogicalType::BIGINT);
+		if (return_chunk) {
+			types = table->GetTypes();
+		} else {
+			types.emplace_back(LogicalType::BIGINT);
+		}
 	}
 };
 } // namespace duckdb
@@ -70629,7 +70839,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op
 
 	dependencies.insert(op.table);
 	auto update = make_unique<PhysicalUpdate>(op.types, *op.table, *op.table->storage, op.columns, move(op.expressions),
-	                                          move(op.bound_defaults), op.estimated_cardinality);
+	                                          move(op.bound_defaults), op.estimated_cardinality, op.return_chunk);
+
 	update->update_is_del_and_insert = op.update_is_del_and_insert;
 	update->children.push_back(move(plan));
 	return move(update);
@@ -97377,8 +97588,7 @@ void ArrowTableFunction::ArrowToDuckDB(ArrowScanState &scan_state,
 		if (array.length != scan_state.chunk->arrow_array.length) {
 			throw InvalidInputException("arrow_scan: array length mismatch");
 		}
-		output.data[idx].GetBuffer()->SetAuxiliaryData(make_unique<ArrowAuxiliaryData>(scan_state.chunk),
-		                                               VectorAuxiliaryDataType::ARROW_AUXILIARY);
+		output.data[idx].GetBuffer()->SetAuxiliaryData(make_unique<ArrowAuxiliaryData>(scan_state.chunk));
 		if (array.dictionary) {
 			ColumnArrowToDuckDBDictionary(output.data[idx], array, scan_state, output.size(), arrow_convert_data,
 			                              col_idx, arrow_convert_idx);
@@ -118983,6 +119193,7 @@ public:
 	unique_ptr<ParsedExpression> condition;
 	unique_ptr<TableRef> table;
 	vector<unique_ptr<TableRef>> using_clauses;
+	vector<unique_ptr<ParsedExpression>> returning_list;
 
 protected:
 	DeleteStatement(const DeleteStatement &other);
@@ -120287,6 +120498,8 @@ public:
 	unique_ptr<TableRef> from_table;
 	vector<string> columns;
 	vector<unique_ptr<ParsedExpression>> expressions;
+	//! keep track of optional returningList if statement contains a RETURNING keyword
+	vector<unique_ptr<ParsedExpression>> returning_list;
 
 protected:
 	UpdateStatement(const UpdateStatement &other);
@@ -127682,10 +127895,14 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 		remove.VisitOperator(*op.children[0]);
 		return;
 	}
-	case LogicalOperatorType::LOGICAL_INSERT: {
-		//! When RETURNING is used, a PROJECTION is the top level operator
-		//! We still need to project all values from the insert so the projection
-		//! on top of the INSERT can select from only that table values being inserted
+	case LogicalOperatorType::LOGICAL_INSERT:
+	case LogicalOperatorType::LOGICAL_UPDATE:
+	case LogicalOperatorType::LOGICAL_DELETE: {
+		//! When RETURNING is used, a PROJECTION is the top level operator for INSERTS, UPDATES, and DELETES
+		//! We still need to project all values from these operators so the projection
+		//! on top of them can select from only the table values being inserted.
+		//! TODO: Push down the projections from the returning statement
+		//! TODO: Be careful because you might be adding expressions when a user returns *
 		RemoveUnusedColumns remove(binder, context, true);
 		remove.VisitOperatorExpressions(op);
 		remove.VisitOperator(*op.children[0]);
@@ -149630,6 +149847,10 @@ unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGNo
 			result->using_clauses.push_back(move(using_entry));
 		}
 	}
+
+	if (stmt->returningList) {
+		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
+	}
 	return result;
 }
 
@@ -150394,6 +150615,11 @@ unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGNo
 		result->expressions.push_back(TransformExpression(target->val));
 	}
 
+	// Grab and transform the returning columns from the parser.
+	if (stmt->returningList) {
+		Transformer::TransformExpressionList(*(stmt->returningList), result->returning_list);
+	}
+
 	result->condition = TransformExpression(stmt->whereClause);
 	return result;
 }
@@ -155594,6 +155820,32 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression_binder/returning_binder.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+
+
+namespace duckdb {
+
+//! The RETURNING binder is responsible for binding expressions within the RETURNING statement
+class ReturningBinder : public ExpressionBinder {
+public:
+	ReturningBinder(Binder &binder, ClientContext &context);
+
+protected:
+	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	                          bool root_expression = false) override;
+};
+
+} // namespace duckdb
+
 
 
 
@@ -155668,10 +155920,21 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 	    LogicalType::ROW_TYPE, ColumnBinding(get.table_index, get.column_ids.size())));
 	get.column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
 
-	result.plan = move(del);
-	result.names = {"Count"};
-	result.types = {LogicalType::BIGINT};
-	this->allow_stream_result = false;
+	if (!stmt.returning_list.empty()) {
+		del->return_chunk = true;
+
+		auto update_table_index = GenerateTableIndex();
+		del->table_index = update_table_index;
+
+		unique_ptr<LogicalOperator> del_as_logicaloperator = move(del);
+		return BindReturning(move(stmt.returning_list), table, update_table_index, move(del_as_logicaloperator),
+		                     move(result));
+	} else {
+		result.plan = move(del);
+		result.names = {"Count"};
+		result.types = {LogicalType::BIGINT};
+		this->allow_stream_result = false;
+	}
 	return result;
 }
 
@@ -155994,31 +156257,6 @@ protected:
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/planner/expression_binder/returning_binder.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-namespace duckdb {
-
-//! The RETURNING binder is responsible for binding expressions within the RETURNING statement
-class ReturningBinder : public ExpressionBinder {
-public:
-	ReturningBinder(Binder &binder, ClientContext &context);
-
-protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
-};
-
-} // namespace duckdb
 
 
 namespace duckdb {
@@ -156139,57 +156377,15 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 
 	if (!stmt.returning_list.empty()) {
 		insert->return_chunk = true;
-		// clear result type and names because returning list will update them
 		result.types.clear();
 		result.names.clear();
-
 		auto insert_table_index = GenerateTableIndex();
 		insert->table_index = insert_table_index;
+		unique_ptr<LogicalOperator> index_as_logicaloperator = move(insert);
 
-		auto binder = Binder::CreateBinder(context);
-		auto types = table->GetTypes();
-		vector<std::string> names;
-		for (auto &col : table->columns) {
-			names.push_back(col.name);
-		}
-
-		binder->bind_context.AddGenericBinding(insert->table_index, stmt.table, names, types);
-		ReturningBinder returning_binder(*binder, context);
-
-		unique_ptr<LogicalOperator> insert_as_logicaloperator = move(insert);
-
-		vector<unique_ptr<Expression>> projection_expressions;
-		LogicalType result_type;
-		for (auto &returning_expr : stmt.returning_list) {
-			auto expr_type = returning_expr->GetExpressionType();
-			if (expr_type == ExpressionType::STAR) {
-				auto generated_star_list = vector<unique_ptr<ParsedExpression>>();
-				binder->bind_context.GenerateAllColumnExpressions((StarExpression &)*returning_expr,
-				                                                  generated_star_list);
-
-				for (auto &star_column : generated_star_list) {
-					auto star_expr = returning_binder.Bind(star_column, &result_type);
-					result.types.push_back(result_type);
-					result.names.push_back(star_expr->GetName());
-					projection_expressions.push_back(move(star_expr));
-				}
-			} else {
-				auto expr = returning_binder.Bind(returning_expr, &result_type);
-				result.names.push_back(expr->GetName());
-				result.types.push_back(result_type);
-				projection_expressions.push_back(move(expr));
-			}
-		}
-
-		auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(projection_expressions));
-		projection->AddChild(move(insert_as_logicaloperator));
-		result.plan = move(projection);
-		D_ASSERT(result.types.size() == result.names.size());
-		this->allow_stream_result = true;
-		return result;
+		return BindReturning(move(stmt.returning_list), table, insert_table_index, move(index_as_logicaloperator),
+		                     move(result));
 	} else {
-		insert->table_index = 0;
-		insert->return_chunk = false;
 		D_ASSERT(result.types.size() == result.names.size());
 		result.plan = move(insert);
 		this->allow_stream_result = false;
@@ -156644,6 +156840,8 @@ static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, Log
 	}
 	// for index updates we always turn any update into an insert and a delete
 	// we thus need all the columns to be available, hence we check if the update touches any index columns
+	// If the returning keyword is used, we need access to the whole row in case the user requests it.
+	// Therefore switch the update to a delete and insert.
 	update.update_is_del_and_insert = false;
 	table.storage->info->indexes.Scan([&](Index &index) {
 		if (index.IndexIsUpdated(update.columns)) {
@@ -156661,8 +156859,9 @@ static void BindUpdateConstraints(TableCatalogEntry &table, LogicalGet &get, Log
 		}
 	}
 
-	if (update.update_is_del_and_insert) {
-		// the update updates a column required by an index, push projections for all columns
+	if (update.update_is_del_and_insert || update.return_chunk) {
+		// the update updates a column required by an index or requires returning the updated rows,
+		// push projections for all columns
 		unordered_set<column_t> all_columns;
 		for (idx_t i = 0; i < table.storage->column_definitions.size(); i++) {
 			all_columns.insert(i);
@@ -156700,6 +156899,11 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 		this->read_only = false;
 	}
 	auto update = make_unique<LogicalUpdate>(table);
+
+	// set return_chunk boolean early because it needs uses update_is_del_and_insert logic
+	if (!stmt.returning_list.empty()) {
+		update->return_chunk = true;
+	}
 	// bind the default values
 	BindDefaultValues(table->columns, update->bound_defaults);
 
@@ -156718,6 +156922,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 
 	auto proj_index = GenerateTableIndex();
 	vector<unique_ptr<Expression>> projection_expressions;
+
 	for (idx_t i = 0; i < stmt.columns.size(); i++) {
 		auto &colname = stmt.columns[i];
 		auto &expr = stmt.expressions[i];
@@ -156743,6 +156948,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 			projection_expressions.push_back(move(bound_expr));
 		}
 	}
+
 	// now create the projection
 	auto proj = make_unique<LogicalProjection>(proj_index, move(projection_expressions));
 	proj->AddChild(move(root));
@@ -156758,10 +156964,21 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	// set the projection as child of the update node and finalize the result
 	update->AddChild(move(proj));
 
-	result.names = {"Count"};
-	result.types = {LogicalType::BIGINT};
-	result.plan = move(update);
-	this->allow_stream_result = false;
+	if (!stmt.returning_list.empty()) {
+		auto update_table_index = GenerateTableIndex();
+		update->table_index = update_table_index;
+		unique_ptr<LogicalOperator> update_as_logicaloperator = move(update);
+
+		return BindReturning(move(stmt.returning_list), table, update_table_index, move(update_as_logicaloperator),
+		                     move(result));
+
+	} else {
+		update->table_index = 0;
+		result.names = {"Count"};
+		result.types = {LogicalType::BIGINT};
+		result.plan = move(update);
+		this->allow_stream_result = false;
+	}
 	return result;
 }
 
@@ -158024,6 +158241,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableFunction &ref) {
 
 
 
+
 #include <algorithm>
 
 
@@ -158392,6 +158610,53 @@ string Binder::FormatErrorRecursive(idx_t query_location, const string &message,
 	return context.FormatErrorRecursive(message, values);
 }
 
+BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
+                                     idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,
+                                     BoundStatement result) {
+
+	vector<LogicalType> types;
+	vector<std::string> names;
+
+	auto binder = Binder::CreateBinder(context);
+
+	for (auto &col : table->columns) {
+		names.push_back(col.name);
+		types.push_back(col.type);
+	}
+
+	binder->bind_context.AddGenericBinding(update_table_index, table->name, names, types);
+	ReturningBinder returning_binder(*binder, context);
+
+	vector<unique_ptr<Expression>> projection_expressions;
+	LogicalType result_type;
+	for (auto &returning_expr : returning_list) {
+		auto expr_type = returning_expr->GetExpressionType();
+		if (expr_type == ExpressionType::STAR) {
+			auto generated_star_list = vector<unique_ptr<ParsedExpression>>();
+			binder->bind_context.GenerateAllColumnExpressions((StarExpression &)*returning_expr, generated_star_list);
+
+			for (auto &star_column : generated_star_list) {
+				auto star_expr = returning_binder.Bind(star_column, &result_type);
+				result.types.push_back(result_type);
+				result.names.push_back(star_expr->GetName());
+				projection_expressions.push_back(move(star_expr));
+			}
+		} else {
+			auto expr = returning_binder.Bind(returning_expr, &result_type);
+			result.names.push_back(expr->GetName());
+			result.types.push_back(result_type);
+			projection_expressions.push_back(move(expr));
+		}
+	}
+
+	auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(projection_expressions));
+	projection->AddChild(move(child_operator));
+	D_ASSERT(result.types.size() == result.names.size());
+	result.plan = move(projection);
+	this->allow_stream_result = true;
+	return result;
+}
+
 } // namespace duckdb