duckdb 0.3.2-dev599.0 → 0.3.2-dev656.0

package/src/duckdb.cpp

@@ -7200,7 +7200,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetSchema(struct ArrowArrayStream *st
 	}
 	if (result.type == QueryResultType::STREAM_RESULT) {
 		auto &stream_result = (StreamQueryResult &)result;
-		if (!stream_result.is_open) {
+		if (!stream_result.IsOpen()) {
 			my_stream->last_error = "Query Stream is closed";
 			return -1;
 		}
@@ -7221,7 +7221,7 @@ int ResultArrowArrayStreamWrapper::MyStreamGetNext(struct ArrowArrayStream *stre
 	}
 	if (result.type == QueryResultType::STREAM_RESULT) {
 		auto &stream_result = (StreamQueryResult &)result;
-		if (!stream_result.is_open) {
+		if (!stream_result.IsOpen()) {
 			my_stream->last_error = "Query Stream is closed";
 			return -1;
 		}
@@ -24080,51 +24080,43 @@ bool Printer::IsTerminal() {
 
 namespace duckdb {
 
-void ProgressBar::ProgressBarThread() {
-#ifndef DUCKDB_NO_THREADS
-	WaitFor(std::chrono::milliseconds(show_progress_after));
-	while (!stop) {
-		int new_percentage;
-		supported = executor->GetPipelinesProgress(new_percentage);
-		current_percentage = new_percentage;
-		if (supported && current_percentage > -1 && ClientConfig::GetConfig(executor->context).print_progress_bar) {
-			Printer::PrintProgress(current_percentage, PROGRESS_BAR_STRING.c_str(), PROGRESS_BAR_WIDTH);
-		}
-		WaitFor(std::chrono::milliseconds(time_update_bar));
-	}
-#endif
+ProgressBar::ProgressBar(Executor &executor, idx_t show_progress_after)
+    : executor(executor), show_progress_after(show_progress_after), current_percentage(-1) {
 }
 
-int ProgressBar::GetCurrentPercentage() {
+double ProgressBar::GetCurrentPercentage() {
 	return current_percentage;
 }
 
 void ProgressBar::Start() {
-#ifndef DUCKDB_NO_THREADS
-	Stop(false);
-	stop = false;
+	profiler.Start();
 	current_percentage = 0;
-	progress_bar_thread = thread(&ProgressBar::ProgressBarThread, this);
-#endif
+	supported = true;
 }
 
-ProgressBar::~ProgressBar() {
-	Stop();
-}
-
-void ProgressBar::Stop(bool success) {
-#ifndef DUCKDB_NO_THREADS
-	if (progress_bar_thread.joinable()) {
-		stop = true;
-		c.notify_one();
-		progress_bar_thread.join();
-		if (success && supported && current_percentage > 0 &&
-		    ClientConfig::GetConfig(executor->context).print_progress_bar) {
+void ProgressBar::Update(bool final) {
+	if (!supported) {
+		return;
+	}
+	double new_percentage;
+	supported = executor.GetPipelinesProgress(new_percentage);
+	if (!supported) {
+		return;
+	}
+	auto sufficient_time_elapsed = profiler.Elapsed() > show_progress_after / 1000.0;
+	auto print_progress = ClientConfig::GetConfig(executor.context).print_progress_bar;
+	if (new_percentage > current_percentage) {
+		current_percentage = new_percentage;
+	}
+	if (supported && print_progress && sufficient_time_elapsed && current_percentage > -1 && print_progress) {
+		if (final) {
 			Printer::FinishProgressBarPrint(PROGRESS_BAR_STRING.c_str(), PROGRESS_BAR_WIDTH);
+		} else {
+			Printer::PrintProgress(current_percentage, PROGRESS_BAR_STRING.c_str(), PROGRESS_BAR_WIDTH);
 		}
 	}
-#endif
 }
+
 } // namespace duckdb
 
 
@@ -24857,7 +24849,7 @@ public:
 	idx_t AppendToBlock(RowDataBlock &block, BufferHandle &handle, vector<BlockAppendEntry> &append_entries,
 	                    idx_t remaining, idx_t entry_sizes[]);
 	vector<unique_ptr<BufferHandle>> Build(idx_t added_count, data_ptr_t key_locations[], idx_t entry_sizes[],
-	                                       const SelectionVector *sel = &FlatVector::INCREMENTAL_SELECTION_VECTOR);
+	                                       const SelectionVector *sel = FlatVector::IncrementalSelectionVector());
 
 	void Merge(RowDataCollection &other);
 
@@ -25172,7 +25164,7 @@ static void HeapGatherListVector(Vector &v, const idx_t vcount, const SelectionV
 			}
 
 			// now deserialize and add to listvector
-			RowOperations::HeapGather(list_vec_to_append, next, FlatVector::INCREMENTAL_SELECTION_VECTOR, 0,
+			RowOperations::HeapGather(list_vec_to_append, next, *FlatVector::IncrementalSelectionVector(), 0,
 			                          list_entry_locations, nullptr);
 			ListVector::Append(v, list_vec_to_append, next);
 
@@ -25339,7 +25331,7 @@ static void ComputeListEntrySizes(Vector &v, VectorData &vdata, idx_t entry_size
 				// compute and add to the total
 				std::fill_n(list_entry_sizes, next, 0);
 				RowOperations::ComputeEntrySizes(child_vector, list_entry_sizes, next, next,
-				                                 FlatVector::INCREMENTAL_SELECTION_VECTOR, entry_offset);
+				                                 *FlatVector::IncrementalSelectionVector(), entry_offset);
 				for (idx_t list_idx = 0; list_idx < next; list_idx++) {
 					entry_sizes[i] += list_entry_sizes[list_idx];
 				}
@@ -25601,7 +25593,7 @@ static void HeapScatterListVector(Vector &v, idx_t vcount, const SelectionVector
 				// variable size list entries: compute entry sizes and set list entry locations
 				std::fill_n(list_entry_sizes, next, 0);
 				RowOperations::ComputeEntrySizes(child_vector, list_entry_sizes, next, next,
-				                                 FlatVector::INCREMENTAL_SELECTION_VECTOR, entry_offset);
+				                                 *FlatVector::IncrementalSelectionVector(), entry_offset);
 				for (idx_t entry_idx = 0; entry_idx < next; entry_idx++) {
 					list_entry_locations[entry_idx] = key_locations[i];
 					key_locations[i] += list_entry_sizes[entry_idx];
@@ -25612,8 +25604,8 @@ static void HeapScatterListVector(Vector &v, idx_t vcount, const SelectionVector
 
 			// now serialize to the locations
 			RowOperations::HeapScatter(child_vector, ListVector::GetListSize(v),
-			                           FlatVector::INCREMENTAL_SELECTION_VECTOR, next, 0, list_entry_locations, nullptr,
-			                           entry_offset);
+			                           *FlatVector::IncrementalSelectionVector(), next, 0, list_entry_locations,
+			                           nullptr, entry_offset);
 
 			// update for next iteration
 			entry_remaining -= next;
@@ -26084,7 +26076,7 @@ void RadixScatterListVector(Vector &v, VectorData &vdata, const SelectionVector
 					// denote that the list is not empty with a 1
 					key_locations[i][0] = 1;
 					key_locations[i]++;
-					RowOperations::RadixScatter(child_vector, list_size, FlatVector::INCREMENTAL_SELECTION_VECTOR, 1,
+					RowOperations::RadixScatter(child_vector, list_size, *FlatVector::IncrementalSelectionVector(), 1,
 					                            key_locations + i, false, true, false, prefix_len, width - 1,
 					                            list_entry.offset);
 				} else {
@@ -26115,7 +26107,7 @@ void RadixScatterListVector(Vector &v, VectorData &vdata, const SelectionVector
 				// denote that the list is not empty with a 1
 				key_locations[i][0] = 1;
 				key_locations[i]++;
-				RowOperations::RadixScatter(child_vector, list_size, FlatVector::INCREMENTAL_SELECTION_VECTOR, 1,
+				RowOperations::RadixScatter(child_vector, list_size, *FlatVector::IncrementalSelectionVector(), 1,
 				                            key_locations + i, false, true, false, prefix_len, width - 1,
 				                            list_entry.offset);
 			} else {
@@ -26158,7 +26150,7 @@ void RadixScatterStructVector(Vector &v, VectorData &vdata, idx_t vcount, const
 	}
 	// serialize the struct
 	auto &child_vector = *StructVector::GetEntries(v)[0];
-	RowOperations::RadixScatter(child_vector, vcount, FlatVector::INCREMENTAL_SELECTION_VECTOR, add_count,
+	RowOperations::RadixScatter(child_vector, vcount, *FlatVector::IncrementalSelectionVector(), add_count,
 	                            key_locations, false, true, false, prefix_len, width, offset);
 	// invert bits if desc
 	if (desc) {
@@ -27779,7 +27771,7 @@ public:
 
 private:
 	//! Selection vector and addresses for scattering the data to rows
-	const SelectionVector &sel_ptr = FlatVector::INCREMENTAL_SELECTION_VECTOR;
+	const SelectionVector &sel_ptr = *FlatVector::IncrementalSelectionVector();
 	Vector addresses = Vector(LogicalType::POINTER);
 };
 
@@ -30060,8 +30052,8 @@ void PayloadScanner::Scan(DataChunk &chunk) {
 	// 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, FlatVector::INCREMENTAL_SELECTION_VECTOR, chunk.data[col_idx],
-		                      FlatVector::INCREMENTAL_SELECTION_VECTOR, count, col_offset, col_idx);
+		RowOperations::Gather(addresses, *FlatVector::IncrementalSelectionVector(), chunk.data[col_idx],
+		                      *FlatVector::IncrementalSelectionVector(), count, col_offset, col_idx);
 	}
 	chunk.SetCardinality(count);
 	chunk.Verify();
@@ -30394,54 +30386,6 @@ string StringUtil::CandidatesErrorMessage(const vector<string> &strings, const s
 
 
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/common/profiler.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-//! The profiler can be used to measure elapsed time
-template <typename T>
-class Profiler {
-public:
-	//! Starts the timer
-	void Start() {
-		finished = false;
-		start = Tick();
-	}
-	//! Finishes timing
-	void End() {
-		end = Tick();
-		finished = true;
-	}
-
-	//! Returns the elapsed time in seconds. If End() has been called, returns
-	//! the total elapsed time. Otherwise returns how far along the timer is
-	//! right now.
-	double Elapsed() const {
-		auto _end = finished ? end : Tick();
-		return std::chrono::duration_cast<std::chrono::duration<double>>(_end - start).count();
-	}
-
-private:
-	time_point<T> Tick() const {
-		return T::now();
-	}
-	time_point<T> start;
-	time_point<T> end;
-	bool finished = false;
-};
-
-} // namespace duckdb
 
 
 
@@ -30454,6 +30398,7 @@ private:
 
 
 namespace duckdb {
+class ClientContext;
 class ExpressionExecutor;
 class PhysicalOperator;
 class SQLStatement;
@@ -30545,7 +30490,7 @@ private:
 	//! Whether or not the profiler is enabled
 	bool enabled;
 	//! The timer used to time the execution time of the individual Physical Operators
-	Profiler<system_clock> op;
+	Profiler op;
 	//! The stack of Physical Operators that are currently active
 	const PhysicalOperator *active_operator;
 	//! A mapping of physical operators to recorded timings
@@ -30555,17 +30500,7 @@ private:
 //! The QueryProfiler can be used to measure timings of queries
 class QueryProfiler {
 public:
-	DUCKDB_API QueryProfiler()
-	    : automatic_print_format(ProfilerPrintFormat::NONE), enabled(false), detailed_enabled(false), running(false),
-	      query_requires_profiling(false), is_explain_analyze(false), stored_enabled(false),
-	      stored_automatic_print_format(ProfilerPrintFormat::NONE) {
-	}
-
-	//! The format to automatically print query profiling information in (default: disabled)
-	ProfilerPrintFormat automatic_print_format;
-	//! The file to save query profiling information to, instead of printing it to the console (empty = print to
-	//! console)
-	string save_location;
+	DUCKDB_API QueryProfiler(ClientContext &context);
 
 public:
 	struct TreeNode {
@@ -30589,26 +30524,12 @@ private:
 	mutex flush_lock;
 
 public:
-	DUCKDB_API void Enable() {
-		enabled = true;
-		detailed_enabled = false;
-	}
+	DUCKDB_API bool IsEnabled() const;
+	DUCKDB_API bool IsDetailedEnabled() const;
+	DUCKDB_API ProfilerPrintFormat GetPrintFormat() const;
+	DUCKDB_API string GetSaveLocation() const;
 
-	DUCKDB_API void DetailedEnable() {
-		detailed_enabled = true;
-	}
-
-	DUCKDB_API void Disable() {
-		enabled = false;
-	}
-
-	DUCKDB_API bool IsEnabled() {
-		return enabled;
-	}
-
-	bool IsDetailedEnabled() const {
-		return detailed_enabled;
-	}
+	DUCKDB_API static QueryProfiler &Get(ClientContext &context);
 
 	DUCKDB_API void StartQuery(string query, bool is_explain_analyze = false);
 	DUCKDB_API void EndQuery();
@@ -30637,13 +30558,12 @@ public:
 	void Finalize(TreeNode &node);
 
 private:
-	//! Whether or not query profiling is enabled
-	bool enabled;
-	//! Whether or not detailed query profiling is enabled
-	bool detailed_enabled;
+	ClientContext &context;
+
 	//! Whether or not the query profiler is running
 	bool running;
 
+	//! Whether or not the query requires profiling
 	bool query_requires_profiling;
 
 	//! The root of the query tree
@@ -30651,14 +30571,11 @@ private:
 	//! The query string
 	string query;
 	//! The timer used to time the execution time of the entire query
-	Profiler<system_clock> main_query;
+	Profiler main_query;
 	//! A map of a Physical Operator pointer to a tree node
 	TreeMap tree_map;
 
 	bool is_explain_analyze;
-	bool stored_enabled;
-	ProfilerPrintFormat stored_automatic_print_format;
-	string stored_save_location;
 
 public:
 	const TreeMap &GetTreeMap() const {
@@ -30667,7 +30584,7 @@ public:
 
 private:
 	//! The timer used to time the individual phases of the planning process
-	Profiler<system_clock> phase_profiler;
+	Profiler phase_profiler;
 	//! A mapping of the phase names to the timings
 	using PhaseTimingStorage = unordered_map<string, double>;
 	PhaseTimingStorage phase_timings;
@@ -39228,7 +39145,7 @@ void Vector::Orrify(idx_t count, VectorData &data) {
 		break;
 	default:
 		Normalify(count);
-		data.sel = &FlatVector::INCREMENTAL_SELECTION_VECTOR;
+		data.sel = FlatVector::IncrementalSelectionVector(count, data.owned_sel);
 		data.data = FlatVector::GetData(*this);
 		data.validity = FlatVector::Validity(*this);
 		break;
@@ -39419,7 +39336,10 @@ void Vector::UTFVerify(const SelectionVector &sel, idx_t count) {
 }
 
 void Vector::UTFVerify(idx_t count) {
-	UTFVerify(FlatVector::INCREMENTAL_SELECTION_VECTOR, count);
+	SelectionVector owned_sel;
+	auto flat_sel = FlatVector::IncrementalSelectionVector(count, owned_sel);
+
+	UTFVerify(*flat_sel, count);
 }
 
 void Vector::Verify(const SelectionVector &sel, idx_t count) {
@@ -39559,15 +39479,9 @@ void Vector::Verify(const SelectionVector &sel, idx_t count) {
 }
 
 void Vector::Verify(idx_t count) {
-	if (count > STANDARD_VECTOR_SIZE) {
-		SelectionVector selection_vector(count);
-		for (size_t i = 0; i < count; i++) {
-			selection_vector.set_index(i, i);
-		}
-		Verify(selection_vector, count);
-	} else {
-		Verify(FlatVector::INCREMENTAL_SELECTION_VECTOR, count);
-	}
+	SelectionVector owned_sel;
+	auto flat_sel = FlatVector::IncrementalSelectionVector(count, owned_sel);
+	Verify(*flat_sel, count);
 }
 
 void FlatVector::SetNull(Vector &vector, idx_t idx, bool is_null) {
@@ -39595,9 +39509,20 @@ void ConstantVector::SetNull(Vector &vector, bool is_null) {
 	}
 }
 
+const SelectionVector *FlatVector::IncrementalSelectionVector(idx_t count, SelectionVector &owned_sel) {
+	if (count <= STANDARD_VECTOR_SIZE) {
+		return FlatVector::IncrementalSelectionVector();
+	}
+	owned_sel.Initialize(count);
+	for (idx_t i = 0; i < count; i++) {
+		owned_sel.set_index(i, i);
+	}
+	return &owned_sel;
+}
+
 const SelectionVector *ConstantVector::ZeroSelectionVector(idx_t count, SelectionVector &owned_sel) {
 	if (count <= STANDARD_VECTOR_SIZE) {
-		return &ConstantVector::ZERO_SELECTION_VECTOR;
+		return ConstantVector::ZeroSelectionVector();
 	}
 	owned_sel.Initialize(count);
 	for (idx_t i = 0; i < count; i++) {
@@ -40210,459 +40135,31 @@ const LogicalType &VectorCache::GetType() const {
 
 namespace duckdb {
 
-const SelectionVector ConstantVector::ZERO_SELECTION_VECTOR = SelectionVector((sel_t *)ConstantVector::ZERO_VECTOR);
-const SelectionVector FlatVector::INCREMENTAL_SELECTION_VECTOR;
+// We disable Wexit-time-destructors here
+// Otherwise we get a warning about the two selection vectors (ZERO/INCREMENTAL_SELECTION_VECTOR)
+// While the SelectionVector does have a non-trivial destructor
+// This only does a memory de-allocation if the selection vectors own their data (i.e. selection_data is not null)
+// In the case of the FlatVector/ConstantVector, they point towards static regions of memory
+// Hence in this case these cause no problems, as the destructors are non-trivial but effectively nops
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+const SelectionVector *ConstantVector::ZeroSelectionVector() {
+	static const SelectionVector ZERO_SELECTION_VECTOR = SelectionVector((sel_t *)ConstantVector::ZERO_VECTOR);
+	return &ZERO_SELECTION_VECTOR;
+}
+
+const SelectionVector *FlatVector::IncrementalSelectionVector() {
+	static const SelectionVector INCREMENTAL_SELECTION_VECTOR;
+	return &INCREMENTAL_SELECTION_VECTOR;
+}
+
 const sel_t ConstantVector::ZERO_VECTOR[STANDARD_VECTOR_SIZE] = {0};
 
-#if STANDARD_VECTOR_SIZE == 2
-const sel_t FlatVector::INCREMENTAL_VECTOR[] = {0, 1};
-#elif STANDARD_VECTOR_SIZE == 4
-const sel_t FlatVector::INCREMENTAL_VECTOR[] = {0, 1, 2, 3};
-#elif STANDARD_VECTOR_SIZE == 8
-const sel_t FlatVector::INCREMENTAL_VECTOR[] = {0, 1, 2, 3, 4, 5, 6, 7};
-#elif STANDARD_VECTOR_SIZE == 16
-const sel_t FlatVector::INCREMENTAL_VECTOR[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
-#elif STANDARD_VECTOR_SIZE == 32
-const sel_t FlatVector::INCREMENTAL_VECTOR[] = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
-                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
-#elif STANDARD_VECTOR_SIZE == 64
-const sel_t FlatVector::INCREMENTAL_VECTOR[] = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15,
-                                                16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-                                                32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-                                                48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63};
-#elif STANDARD_VECTOR_SIZE == 128
-const sel_t FlatVector::INCREMENTAL_VECTOR[] = {
-    0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,
-    22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,
-    44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,
-    66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,
-    88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
-    110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127};
-#elif STANDARD_VECTOR_SIZE == 256
-const sel_t FlatVector::INCREMENTAL_VECTOR[] = {
-    0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,
-    22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,
-    44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,
-    66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,
-    88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
-    110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
-    132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
-    154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
-    176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
-    198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
-    220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
-    242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255};
-#elif STANDARD_VECTOR_SIZE == 512
-const sel_t FlatVector::INCREMENTAL_VECTOR[] = {
-    0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,
-    23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,
-    46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,
-    69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,
-    92,  93,  94,  95,  96,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
-    115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
-    138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160,
-    161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
-    184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
-    207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229,
-    230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
-    253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
-    276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,
-    299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321,
-    322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
-    345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367,
-    368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390,
-    391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413,
-    414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436,
-    437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459,
-    460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482,
-    483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505,
-    506, 507, 508, 509, 510, 511};
-#elif STANDARD_VECTOR_SIZE == 1024
-const sel_t FlatVector::INCREMENTAL_VECTOR[] = {
-    0,    1,    2,    3,    4,    5,    6,    7,    8,    9,    10,   11,   12,   13,   14,   15,   16,   17,   18,
-    19,   20,   21,   22,   23,   24,   25,   26,   27,   28,   29,   30,   31,   32,   33,   34,   35,   36,   37,
-    38,   39,   40,   41,   42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
-    57,   58,   59,   60,   61,   62,   63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,
-    76,   77,   78,   79,   80,   81,   82,   83,   84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,
-    95,   96,   97,   98,   99,   100,  101,  102,  103,  104,  105,  106,  107,  108,  109,  110,  111,  112,  113,
-    114,  115,  116,  117,  118,  119,  120,  121,  122,  123,  124,  125,  126,  127,  128,  129,  130,  131,  132,
-    133,  134,  135,  136,  137,  138,  139,  140,  141,  142,  143,  144,  145,  146,  147,  148,  149,  150,  151,
-    152,  153,  154,  155,  156,  157,  158,  159,  160,  161,  162,  163,  164,  165,  166,  167,  168,  169,  170,
-    171,  172,  173,  174,  175,  176,  177,  178,  179,  180,  181,  182,  183,  184,  185,  186,  187,  188,  189,
-    190,  191,  192,  193,  194,  195,  196,  197,  198,  199,  200,  201,  202,  203,  204,  205,  206,  207,  208,
-    209,  210,  211,  212,  213,  214,  215,  216,  217,  218,  219,  220,  221,  222,  223,  224,  225,  226,  227,
-    228,  229,  230,  231,  232,  233,  234,  235,  236,  237,  238,  239,  240,  241,  242,  243,  244,  245,  246,
-    247,  248,  249,  250,  251,  252,  253,  254,  255,  256,  257,  258,  259,  260,  261,  262,  263,  264,  265,
-    266,  267,  268,  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,  279,  280,  281,  282,  283,  284,
-    285,  286,  287,  288,  289,  290,  291,  292,  293,  294,  295,  296,  297,  298,  299,  300,  301,  302,  303,
-    304,  305,  306,  307,  308,  309,  310,  311,  312,  313,  314,  315,  316,  317,  318,  319,  320,  321,  322,
-    323,  324,  325,  326,  327,  328,  329,  330,  331,  332,  333,  334,  335,  336,  337,  338,  339,  340,  341,
-    342,  343,  344,  345,  346,  347,  348,  349,  350,  351,  352,  353,  354,  355,  356,  357,  358,  359,  360,
-    361,  362,  363,  364,  365,  366,  367,  368,  369,  370,  371,  372,  373,  374,  375,  376,  377,  378,  379,
-    380,  381,  382,  383,  384,  385,  386,  387,  388,  389,  390,  391,  392,  393,  394,  395,  396,  397,  398,
-    399,  400,  401,  402,  403,  404,  405,  406,  407,  408,  409,  410,  411,  412,  413,  414,  415,  416,  417,
-    418,  419,  420,  421,  422,  423,  424,  425,  426,  427,  428,  429,  430,  431,  432,  433,  434,  435,  436,
-    437,  438,  439,  440,  441,  442,  443,  444,  445,  446,  447,  448,  449,  450,  451,  452,  453,  454,  455,
-    456,  457,  458,  459,  460,  461,  462,  463,  464,  465,  466,  467,  468,  469,  470,  471,  472,  473,  474,
-    475,  476,  477,  478,  479,  480,  481,  482,  483,  484,  485,  486,  487,  488,  489,  490,  491,  492,  493,
-    494,  495,  496,  497,  498,  499,  500,  501,  502,  503,  504,  505,  506,  507,  508,  509,  510,  511,  512,
-    513,  514,  515,  516,  517,  518,  519,  520,  521,  522,  523,  524,  525,  526,  527,  528,  529,  530,  531,
-    532,  533,  534,  535,  536,  537,  538,  539,  540,  541,  542,  543,  544,  545,  546,  547,  548,  549,  550,
-    551,  552,  553,  554,  555,  556,  557,  558,  559,  560,  561,  562,  563,  564,  565,  566,  567,  568,  569,
-    570,  571,  572,  573,  574,  575,  576,  577,  578,  579,  580,  581,  582,  583,  584,  585,  586,  587,  588,
-    589,  590,  591,  592,  593,  594,  595,  596,  597,  598,  599,  600,  601,  602,  603,  604,  605,  606,  607,
-    608,  609,  610,  611,  612,  613,  614,  615,  616,  617,  618,  619,  620,  621,  622,  623,  624,  625,  626,
-    627,  628,  629,  630,  631,  632,  633,  634,  635,  636,  637,  638,  639,  640,  641,  642,  643,  644,  645,
-    646,  647,  648,  649,  650,  651,  652,  653,  654,  655,  656,  657,  658,  659,  660,  661,  662,  663,  664,
-    665,  666,  667,  668,  669,  670,  671,  672,  673,  674,  675,  676,  677,  678,  679,  680,  681,  682,  683,
-    684,  685,  686,  687,  688,  689,  690,  691,  692,  693,  694,  695,  696,  697,  698,  699,  700,  701,  702,
-    703,  704,  705,  706,  707,  708,  709,  710,  711,  712,  713,  714,  715,  716,  717,  718,  719,  720,  721,
-    722,  723,  724,  725,  726,  727,  728,  729,  730,  731,  732,  733,  734,  735,  736,  737,  738,  739,  740,
-    741,  742,  743,  744,  745,  746,  747,  748,  749,  750,  751,  752,  753,  754,  755,  756,  757,  758,  759,
-    760,  761,  762,  763,  764,  765,  766,  767,  768,  769,  770,  771,  772,  773,  774,  775,  776,  777,  778,
-    779,  780,  781,  782,  783,  784,  785,  786,  787,  788,  789,  790,  791,  792,  793,  794,  795,  796,  797,
-    798,  799,  800,  801,  802,  803,  804,  805,  806,  807,  808,  809,  810,  811,  812,  813,  814,  815,  816,
-    817,  818,  819,  820,  821,  822,  823,  824,  825,  826,  827,  828,  829,  830,  831,  832,  833,  834,  835,
-    836,  837,  838,  839,  840,  841,  842,  843,  844,  845,  846,  847,  848,  849,  850,  851,  852,  853,  854,
-    855,  856,  857,  858,  859,  860,  861,  862,  863,  864,  865,  866,  867,  868,  869,  870,  871,  872,  873,
-    874,  875,  876,  877,  878,  879,  880,  881,  882,  883,  884,  885,  886,  887,  888,  889,  890,  891,  892,
-    893,  894,  895,  896,  897,  898,  899,  900,  901,  902,  903,  904,  905,  906,  907,  908,  909,  910,  911,
-    912,  913,  914,  915,  916,  917,  918,  919,  920,  921,  922,  923,  924,  925,  926,  927,  928,  929,  930,
-    931,  932,  933,  934,  935,  936,  937,  938,  939,  940,  941,  942,  943,  944,  945,  946,  947,  948,  949,
-    950,  951,  952,  953,  954,  955,  956,  957,  958,  959,  960,  961,  962,  963,  964,  965,  966,  967,  968,
-    969,  970,  971,  972,  973,  974,  975,  976,  977,  978,  979,  980,  981,  982,  983,  984,  985,  986,  987,
-    988,  989,  990,  991,  992,  993,  994,  995,  996,  997,  998,  999,  1000, 1001, 1002, 1003, 1004, 1005, 1006,
-    1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023};
-#elif STANDARD_VECTOR_SIZE == 2048
-const sel_t FlatVector::INCREMENTAL_VECTOR[] = {
-    0,    1,    2,    3,    4,    5,    6,    7,    8,    9,    10,   11,   12,   13,   14,   15,   16,   17,   18,
-    19,   20,   21,   22,   23,   24,   25,   26,   27,   28,   29,   30,   31,   32,   33,   34,   35,   36,   37,
-    38,   39,   40,   41,   42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
-    57,   58,   59,   60,   61,   62,   63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,
-    76,   77,   78,   79,   80,   81,   82,   83,   84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,
-    95,   96,   97,   98,   99,   100,  101,  102,  103,  104,  105,  106,  107,  108,  109,  110,  111,  112,  113,
-    114,  115,  116,  117,  118,  119,  120,  121,  122,  123,  124,  125,  126,  127,  128,  129,  130,  131,  132,
-    133,  134,  135,  136,  137,  138,  139,  140,  141,  142,  143,  144,  145,  146,  147,  148,  149,  150,  151,
-    152,  153,  154,  155,  156,  157,  158,  159,  160,  161,  162,  163,  164,  165,  166,  167,  168,  169,  170,
-    171,  172,  173,  174,  175,  176,  177,  178,  179,  180,  181,  182,  183,  184,  185,  186,  187,  188,  189,
-    190,  191,  192,  193,  194,  195,  196,  197,  198,  199,  200,  201,  202,  203,  204,  205,  206,  207,  208,
-    209,  210,  211,  212,  213,  214,  215,  216,  217,  218,  219,  220,  221,  222,  223,  224,  225,  226,  227,
-    228,  229,  230,  231,  232,  233,  234,  235,  236,  237,  238,  239,  240,  241,  242,  243,  244,  245,  246,
-    247,  248,  249,  250,  251,  252,  253,  254,  255,  256,  257,  258,  259,  260,  261,  262,  263,  264,  265,
-    266,  267,  268,  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,  279,  280,  281,  282,  283,  284,
-    285,  286,  287,  288,  289,  290,  291,  292,  293,  294,  295,  296,  297,  298,  299,  300,  301,  302,  303,
-    304,  305,  306,  307,  308,  309,  310,  311,  312,  313,  314,  315,  316,  317,  318,  319,  320,  321,  322,
-    323,  324,  325,  326,  327,  328,  329,  330,  331,  332,  333,  334,  335,  336,  337,  338,  339,  340,  341,
-    342,  343,  344,  345,  346,  347,  348,  349,  350,  351,  352,  353,  354,  355,  356,  357,  358,  359,  360,
-    361,  362,  363,  364,  365,  366,  367,  368,  369,  370,  371,  372,  373,  374,  375,  376,  377,  378,  379,
-    380,  381,  382,  383,  384,  385,  386,  387,  388,  389,  390,  391,  392,  393,  394,  395,  396,  397,  398,
-    399,  400,  401,  402,  403,  404,  405,  406,  407,  408,  409,  410,  411,  412,  413,  414,  415,  416,  417,
-    418,  419,  420,  421,  422,  423,  424,  425,  426,  427,  428,  429,  430,  431,  432,  433,  434,  435,  436,
-    437,  438,  439,  440,  441,  442,  443,  444,  445,  446,  447,  448,  449,  450,  451,  452,  453,  454,  455,
-    456,  457,  458,  459,  460,  461,  462,  463,  464,  465,  466,  467,  468,  469,  470,  471,  472,  473,  474,
-    475,  476,  477,  478,  479,  480,  481,  482,  483,  484,  485,  486,  487,  488,  489,  490,  491,  492,  493,
-    494,  495,  496,  497,  498,  499,  500,  501,  502,  503,  504,  505,  506,  507,  508,  509,  510,  511,  512,
-    513,  514,  515,  516,  517,  518,  519,  520,  521,  522,  523,  524,  525,  526,  527,  528,  529,  530,  531,
-    532,  533,  534,  535,  536,  537,  538,  539,  540,  541,  542,  543,  544,  545,  546,  547,  548,  549,  550,
-    551,  552,  553,  554,  555,  556,  557,  558,  559,  560,  561,  562,  563,  564,  565,  566,  567,  568,  569,
-    570,  571,  572,  573,  574,  575,  576,  577,  578,  579,  580,  581,  582,  583,  584,  585,  586,  587,  588,
-    589,  590,  591,  592,  593,  594,  595,  596,  597,  598,  599,  600,  601,  602,  603,  604,  605,  606,  607,
-    608,  609,  610,  611,  612,  613,  614,  615,  616,  617,  618,  619,  620,  621,  622,  623,  624,  625,  626,
-    627,  628,  629,  630,  631,  632,  633,  634,  635,  636,  637,  638,  639,  640,  641,  642,  643,  644,  645,
-    646,  647,  648,  649,  650,  651,  652,  653,  654,  655,  656,  657,  658,  659,  660,  661,  662,  663,  664,
-    665,  666,  667,  668,  669,  670,  671,  672,  673,  674,  675,  676,  677,  678,  679,  680,  681,  682,  683,
-    684,  685,  686,  687,  688,  689,  690,  691,  692,  693,  694,  695,  696,  697,  698,  699,  700,  701,  702,
-    703,  704,  705,  706,  707,  708,  709,  710,  711,  712,  713,  714,  715,  716,  717,  718,  719,  720,  721,
-    722,  723,  724,  725,  726,  727,  728,  729,  730,  731,  732,  733,  734,  735,  736,  737,  738,  739,  740,
-    741,  742,  743,  744,  745,  746,  747,  748,  749,  750,  751,  752,  753,  754,  755,  756,  757,  758,  759,
-    760,  761,  762,  763,  764,  765,  766,  767,  768,  769,  770,  771,  772,  773,  774,  775,  776,  777,  778,
-    779,  780,  781,  782,  783,  784,  785,  786,  787,  788,  789,  790,  791,  792,  793,  794,  795,  796,  797,
-    798,  799,  800,  801,  802,  803,  804,  805,  806,  807,  808,  809,  810,  811,  812,  813,  814,  815,  816,
-    817,  818,  819,  820,  821,  822,  823,  824,  825,  826,  827,  828,  829,  830,  831,  832,  833,  834,  835,
-    836,  837,  838,  839,  840,  841,  842,  843,  844,  845,  846,  847,  848,  849,  850,  851,  852,  853,  854,
-    855,  856,  857,  858,  859,  860,  861,  862,  863,  864,  865,  866,  867,  868,  869,  870,  871,  872,  873,
-    874,  875,  876,  877,  878,  879,  880,  881,  882,  883,  884,  885,  886,  887,  888,  889,  890,  891,  892,
-    893,  894,  895,  896,  897,  898,  899,  900,  901,  902,  903,  904,  905,  906,  907,  908,  909,  910,  911,
-    912,  913,  914,  915,  916,  917,  918,  919,  920,  921,  922,  923,  924,  925,  926,  927,  928,  929,  930,
-    931,  932,  933,  934,  935,  936,  937,  938,  939,  940,  941,  942,  943,  944,  945,  946,  947,  948,  949,
-    950,  951,  952,  953,  954,  955,  956,  957,  958,  959,  960,  961,  962,  963,  964,  965,  966,  967,  968,
-    969,  970,  971,  972,  973,  974,  975,  976,  977,  978,  979,  980,  981,  982,  983,  984,  985,  986,  987,
-    988,  989,  990,  991,  992,  993,  994,  995,  996,  997,  998,  999,  1000, 1001, 1002, 1003, 1004, 1005, 1006,
-    1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025,
-    1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044,
-    1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063,
-    1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082,
-    1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101,
-    1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119, 1120,
-    1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139,
-    1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158,
-    1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177,
-    1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196,
-    1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215,
-    1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234,
-    1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253,
-    1254, 1255, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272,
-    1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291,
-    1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309, 1310,
-    1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329,
-    1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348,
-    1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367,
-    1368, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386,
-    1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405,
-    1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424,
-    1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443,
-    1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462,
-    1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481,
-    1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500,
-    1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519,
-    1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538,
-    1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557,
-    1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576,
-    1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595,
-    1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614,
-    1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633,
-    1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652,
-    1653, 1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671,
-    1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 1690,
-    1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709,
-    1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728,
-    1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747,
-    1748, 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766,
-    1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785,
-    1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 1801, 1802, 1803, 1804,
-    1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823,
-    1824, 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842,
-    1843, 1844, 1845, 1846, 1847, 1848, 1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, 1860, 1861,
-    1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880,
-    1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897, 1898, 1899,
-    1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918,
-    1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937,
-    1938, 1939, 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956,
-    1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975,
-    1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
-    1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013,
-    2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032,
-    2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047};
-#elif STANDARD_VECTOR_SIZE == 4096
-const sel_t FlatVector::INCREMENTAL_VECTOR[] = {
-    0,    1,    2,    3,    4,    5,    6,    7,    8,    9,    10,   11,   12,   13,   14,   15,   16,   17,   18,
-    19,   20,   21,   22,   23,   24,   25,   26,   27,   28,   29,   30,   31,   32,   33,   34,   35,   36,   37,
-    38,   39,   40,   41,   42,   43,   44,   45,   46,   47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
-    57,   58,   59,   60,   61,   62,   63,   64,   65,   66,   67,   68,   69,   70,   71,   72,   73,   74,   75,
-    76,   77,   78,   79,   80,   81,   82,   83,   84,   85,   86,   87,   88,   89,   90,   91,   92,   93,   94,
-    95,   96,   97,   98,   99,   100,  101,  102,  103,  104,  105,  106,  107,  108,  109,  110,  111,  112,  113,
-    114,  115,  116,  117,  118,  119,  120,  121,  122,  123,  124,  125,  126,  127,  128,  129,  130,  131,  132,
-    133,  134,  135,  136,  137,  138,  139,  140,  141,  142,  143,  144,  145,  146,  147,  148,  149,  150,  151,
-    152,  153,  154,  155,  156,  157,  158,  159,  160,  161,  162,  163,  164,  165,  166,  167,  168,  169,  170,
-    171,  172,  173,  174,  175,  176,  177,  178,  179,  180,  181,  182,  183,  184,  185,  186,  187,  188,  189,
-    190,  191,  192,  193,  194,  195,  196,  197,  198,  199,  200,  201,  202,  203,  204,  205,  206,  207,  208,
-    209,  210,  211,  212,  213,  214,  215,  216,  217,  218,  219,  220,  221,  222,  223,  224,  225,  226,  227,
-    228,  229,  230,  231,  232,  233,  234,  235,  236,  237,  238,  239,  240,  241,  242,  243,  244,  245,  246,
-    247,  248,  249,  250,  251,  252,  253,  254,  255,  256,  257,  258,  259,  260,  261,  262,  263,  264,  265,
-    266,  267,  268,  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,  279,  280,  281,  282,  283,  284,
-    285,  286,  287,  288,  289,  290,  291,  292,  293,  294,  295,  296,  297,  298,  299,  300,  301,  302,  303,
-    304,  305,  306,  307,  308,  309,  310,  311,  312,  313,  314,  315,  316,  317,  318,  319,  320,  321,  322,
-    323,  324,  325,  326,  327,  328,  329,  330,  331,  332,  333,  334,  335,  336,  337,  338,  339,  340,  341,
-    342,  343,  344,  345,  346,  347,  348,  349,  350,  351,  352,  353,  354,  355,  356,  357,  358,  359,  360,
-    361,  362,  363,  364,  365,  366,  367,  368,  369,  370,  371,  372,  373,  374,  375,  376,  377,  378,  379,
-    380,  381,  382,  383,  384,  385,  386,  387,  388,  389,  390,  391,  392,  393,  394,  395,  396,  397,  398,
-    399,  400,  401,  402,  403,  404,  405,  406,  407,  408,  409,  410,  411,  412,  413,  414,  415,  416,  417,
-    418,  419,  420,  421,  422,  423,  424,  425,  426,  427,  428,  429,  430,  431,  432,  433,  434,  435,  436,
-    437,  438,  439,  440,  441,  442,  443,  444,  445,  446,  447,  448,  449,  450,  451,  452,  453,  454,  455,
-    456,  457,  458,  459,  460,  461,  462,  463,  464,  465,  466,  467,  468,  469,  470,  471,  472,  473,  474,
-    475,  476,  477,  478,  479,  480,  481,  482,  483,  484,  485,  486,  487,  488,  489,  490,  491,  492,  493,
-    494,  495,  496,  497,  498,  499,  500,  501,  502,  503,  504,  505,  506,  507,  508,  509,  510,  511,  512,
-    513,  514,  515,  516,  517,  518,  519,  520,  521,  522,  523,  524,  525,  526,  527,  528,  529,  530,  531,
-    532,  533,  534,  535,  536,  537,  538,  539,  540,  541,  542,  543,  544,  545,  546,  547,  548,  549,  550,
-    551,  552,  553,  554,  555,  556,  557,  558,  559,  560,  561,  562,  563,  564,  565,  566,  567,  568,  569,
-    570,  571,  572,  573,  574,  575,  576,  577,  578,  579,  580,  581,  582,  583,  584,  585,  586,  587,  588,
-    589,  590,  591,  592,  593,  594,  595,  596,  597,  598,  599,  600,  601,  602,  603,  604,  605,  606,  607,
-    608,  609,  610,  611,  612,  613,  614,  615,  616,  617,  618,  619,  620,  621,  622,  623,  624,  625,  626,
-    627,  628,  629,  630,  631,  632,  633,  634,  635,  636,  637,  638,  639,  640,  641,  642,  643,  644,  645,
-    646,  647,  648,  649,  650,  651,  652,  653,  654,  655,  656,  657,  658,  659,  660,  661,  662,  663,  664,
-    665,  666,  667,  668,  669,  670,  671,  672,  673,  674,  675,  676,  677,  678,  679,  680,  681,  682,  683,
-    684,  685,  686,  687,  688,  689,  690,  691,  692,  693,  694,  695,  696,  697,  698,  699,  700,  701,  702,
-    703,  704,  705,  706,  707,  708,  709,  710,  711,  712,  713,  714,  715,  716,  717,  718,  719,  720,  721,
-    722,  723,  724,  725,  726,  727,  728,  729,  730,  731,  732,  733,  734,  735,  736,  737,  738,  739,  740,
-    741,  742,  743,  744,  745,  746,  747,  748,  749,  750,  751,  752,  753,  754,  755,  756,  757,  758,  759,
-    760,  761,  762,  763,  764,  765,  766,  767,  768,  769,  770,  771,  772,  773,  774,  775,  776,  777,  778,
-    779,  780,  781,  782,  783,  784,  785,  786,  787,  788,  789,  790,  791,  792,  793,  794,  795,  796,  797,
-    798,  799,  800,  801,  802,  803,  804,  805,  806,  807,  808,  809,  810,  811,  812,  813,  814,  815,  816,
-    817,  818,  819,  820,  821,  822,  823,  824,  825,  826,  827,  828,  829,  830,  831,  832,  833,  834,  835,
-    836,  837,  838,  839,  840,  841,  842,  843,  844,  845,  846,  847,  848,  849,  850,  851,  852,  853,  854,
-    855,  856,  857,  858,  859,  860,  861,  862,  863,  864,  865,  866,  867,  868,  869,  870,  871,  872,  873,
-    874,  875,  876,  877,  878,  879,  880,  881,  882,  883,  884,  885,  886,  887,  888,  889,  890,  891,  892,
-    893,  894,  895,  896,  897,  898,  899,  900,  901,  902,  903,  904,  905,  906,  907,  908,  909,  910,  911,
-    912,  913,  914,  915,  916,  917,  918,  919,  920,  921,  922,  923,  924,  925,  926,  927,  928,  929,  930,
-    931,  932,  933,  934,  935,  936,  937,  938,  939,  940,  941,  942,  943,  944,  945,  946,  947,  948,  949,
-    950,  951,  952,  953,  954,  955,  956,  957,  958,  959,  960,  961,  962,  963,  964,  965,  966,  967,  968,
-    969,  970,  971,  972,  973,  974,  975,  976,  977,  978,  979,  980,  981,  982,  983,  984,  985,  986,  987,
-    988,  989,  990,  991,  992,  993,  994,  995,  996,  997,  998,  999,  1000, 1001, 1002, 1003, 1004, 1005, 1006,
-    1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025,
-    1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044,
-    1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063,
-    1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082,
-    1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101,
-    1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119, 1120,
-    1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139,
-    1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158,
-    1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177,
-    1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196,
-    1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215,
-    1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234,
-    1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253,
-    1254, 1255, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272,
-    1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291,
-    1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309, 1310,
-    1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329,
-    1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348,
-    1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367,
-    1368, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386,
-    1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405,
-    1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424,
-    1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443,
-    1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462,
-    1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481,
-    1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 1500,
-    1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513, 1514, 1515, 1516, 1517, 1518, 1519,
-    1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538,
-    1539, 1540, 1541, 1542, 1543, 1544, 1545, 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557,
-    1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576,
-    1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595,
-    1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614,
-    1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633,
-    1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652,
-    1653, 1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671,
-    1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 1690,
-    1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, 1706, 1707, 1708, 1709,
-    1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 1722, 1723, 1724, 1725, 1726, 1727, 1728,
-    1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747,
-    1748, 1749, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766,
-    1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785,
-    1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 1801, 1802, 1803, 1804,
-    1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823,
-    1824, 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842,
-    1843, 1844, 1845, 1846, 1847, 1848, 1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, 1860, 1861,
-    1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880,
-    1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897, 1898, 1899,
-    1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918,
-    1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937,
-    1938, 1939, 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956,
-    1957, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975,
-    1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
-    1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013,
-    2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032,
-    2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051,
-    2052, 2053, 2054, 2055, 2056, 2057, 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070,
-    2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089,
-    2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 2104, 2105, 2106, 2107, 2108,
-    2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121, 2122, 2123, 2124, 2125, 2126, 2127,
-    2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146,
-    2147, 2148, 2149, 2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163, 2164, 2165,
-    2166, 2167, 2168, 2169, 2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, 2184,
-    2185, 2186, 2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, 2200, 2201, 2202, 2203,
-    2204, 2205, 2206, 2207, 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, 2219, 2220, 2221, 2222,
-    2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, 2232, 2233, 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241,
-    2242, 2243, 2244, 2245, 2246, 2247, 2248, 2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2259, 2260,
-    2261, 2262, 2263, 2264, 2265, 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, 2278, 2279,
-    2280, 2281, 2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 2295, 2296, 2297, 2298,
-    2299, 2300, 2301, 2302, 2303, 2304, 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, 2315, 2316, 2317,
-    2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329, 2330, 2331, 2332, 2333, 2334, 2335, 2336,
-    2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345, 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355,
-    2356, 2357, 2358, 2359, 2360, 2361, 2362, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374,
-    2375, 2376, 2377, 2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389, 2390, 2391, 2392, 2393,
-    2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 2411, 2412,
-    2413, 2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, 2425, 2426, 2427, 2428, 2429, 2430, 2431,
-    2432, 2433, 2434, 2435, 2436, 2437, 2438, 2439, 2440, 2441, 2442, 2443, 2444, 2445, 2446, 2447, 2448, 2449, 2450,
-    2451, 2452, 2453, 2454, 2455, 2456, 2457, 2458, 2459, 2460, 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469,
-    2470, 2471, 2472, 2473, 2474, 2475, 2476, 2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, 2485, 2486, 2487, 2488,
-    2489, 2490, 2491, 2492, 2493, 2494, 2495, 2496, 2497, 2498, 2499, 2500, 2501, 2502, 2503, 2504, 2505, 2506, 2507,
-    2508, 2509, 2510, 2511, 2512, 2513, 2514, 2515, 2516, 2517, 2518, 2519, 2520, 2521, 2522, 2523, 2524, 2525, 2526,
-    2527, 2528, 2529, 2530, 2531, 2532, 2533, 2534, 2535, 2536, 2537, 2538, 2539, 2540, 2541, 2542, 2543, 2544, 2545,
-    2546, 2547, 2548, 2549, 2550, 2551, 2552, 2553, 2554, 2555, 2556, 2557, 2558, 2559, 2560, 2561, 2562, 2563, 2564,
-    2565, 2566, 2567, 2568, 2569, 2570, 2571, 2572, 2573, 2574, 2575, 2576, 2577, 2578, 2579, 2580, 2581, 2582, 2583,
-    2584, 2585, 2586, 2587, 2588, 2589, 2590, 2591, 2592, 2593, 2594, 2595, 2596, 2597, 2598, 2599, 2600, 2601, 2602,
-    2603, 2604, 2605, 2606, 2607, 2608, 2609, 2610, 2611, 2612, 2613, 2614, 2615, 2616, 2617, 2618, 2619, 2620, 2621,
-    2622, 2623, 2624, 2625, 2626, 2627, 2628, 2629, 2630, 2631, 2632, 2633, 2634, 2635, 2636, 2637, 2638, 2639, 2640,
-    2641, 2642, 2643, 2644, 2645, 2646, 2647, 2648, 2649, 2650, 2651, 2652, 2653, 2654, 2655, 2656, 2657, 2658, 2659,
-    2660, 2661, 2662, 2663, 2664, 2665, 2666, 2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676, 2677, 2678,
-    2679, 2680, 2681, 2682, 2683, 2684, 2685, 2686, 2687, 2688, 2689, 2690, 2691, 2692, 2693, 2694, 2695, 2696, 2697,
-    2698, 2699, 2700, 2701, 2702, 2703, 2704, 2705, 2706, 2707, 2708, 2709, 2710, 2711, 2712, 2713, 2714, 2715, 2716,
-    2717, 2718, 2719, 2720, 2721, 2722, 2723, 2724, 2725, 2726, 2727, 2728, 2729, 2730, 2731, 2732, 2733, 2734, 2735,
-    2736, 2737, 2738, 2739, 2740, 2741, 2742, 2743, 2744, 2745, 2746, 2747, 2748, 2749, 2750, 2751, 2752, 2753, 2754,
-    2755, 2756, 2757, 2758, 2759, 2760, 2761, 2762, 2763, 2764, 2765, 2766, 2767, 2768, 2769, 2770, 2771, 2772, 2773,
-    2774, 2775, 2776, 2777, 2778, 2779, 2780, 2781, 2782, 2783, 2784, 2785, 2786, 2787, 2788, 2789, 2790, 2791, 2792,
-    2793, 2794, 2795, 2796, 2797, 2798, 2799, 2800, 2801, 2802, 2803, 2804, 2805, 2806, 2807, 2808, 2809, 2810, 2811,
-    2812, 2813, 2814, 2815, 2816, 2817, 2818, 2819, 2820, 2821, 2822, 2823, 2824, 2825, 2826, 2827, 2828, 2829, 2830,
-    2831, 2832, 2833, 2834, 2835, 2836, 2837, 2838, 2839, 2840, 2841, 2842, 2843, 2844, 2845, 2846, 2847, 2848, 2849,
-    2850, 2851, 2852, 2853, 2854, 2855, 2856, 2857, 2858, 2859, 2860, 2861, 2862, 2863, 2864, 2865, 2866, 2867, 2868,
-    2869, 2870, 2871, 2872, 2873, 2874, 2875, 2876, 2877, 2878, 2879, 2880, 2881, 2882, 2883, 2884, 2885, 2886, 2887,
-    2888, 2889, 2890, 2891, 2892, 2893, 2894, 2895, 2896, 2897, 2898, 2899, 2900, 2901, 2902, 2903, 2904, 2905, 2906,
-    2907, 2908, 2909, 2910, 2911, 2912, 2913, 2914, 2915, 2916, 2917, 2918, 2919, 2920, 2921, 2922, 2923, 2924, 2925,
-    2926, 2927, 2928, 2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937, 2938, 2939, 2940, 2941, 2942, 2943, 2944,
-    2945, 2946, 2947, 2948, 2949, 2950, 2951, 2952, 2953, 2954, 2955, 2956, 2957, 2958, 2959, 2960, 2961, 2962, 2963,
-    2964, 2965, 2966, 2967, 2968, 2969, 2970, 2971, 2972, 2973, 2974, 2975, 2976, 2977, 2978, 2979, 2980, 2981, 2982,
-    2983, 2984, 2985, 2986, 2987, 2988, 2989, 2990, 2991, 2992, 2993, 2994, 2995, 2996, 2997, 2998, 2999, 3000, 3001,
-    3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017, 3018, 3019, 3020,
-    3021, 3022, 3023, 3024, 3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, 3033, 3034, 3035, 3036, 3037, 3038, 3039,
-    3040, 3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048, 3049, 3050, 3051, 3052, 3053, 3054, 3055, 3056, 3057, 3058,
-    3059, 3060, 3061, 3062, 3063, 3064, 3065, 3066, 3067, 3068, 3069, 3070, 3071, 3072, 3073, 3074, 3075, 3076, 3077,
-    3078, 3079, 3080, 3081, 3082, 3083, 3084, 3085, 3086, 3087, 3088, 3089, 3090, 3091, 3092, 3093, 3094, 3095, 3096,
-    3097, 3098, 3099, 3100, 3101, 3102, 3103, 3104, 3105, 3106, 3107, 3108, 3109, 3110, 3111, 3112, 3113, 3114, 3115,
-    3116, 3117, 3118, 3119, 3120, 3121, 3122, 3123, 3124, 3125, 3126, 3127, 3128, 3129, 3130, 3131, 3132, 3133, 3134,
-    3135, 3136, 3137, 3138, 3139, 3140, 3141, 3142, 3143, 3144, 3145, 3146, 3147, 3148, 3149, 3150, 3151, 3152, 3153,
-    3154, 3155, 3156, 3157, 3158, 3159, 3160, 3161, 3162, 3163, 3164, 3165, 3166, 3167, 3168, 3169, 3170, 3171, 3172,
-    3173, 3174, 3175, 3176, 3177, 3178, 3179, 3180, 3181, 3182, 3183, 3184, 3185, 3186, 3187, 3188, 3189, 3190, 3191,
-    3192, 3193, 3194, 3195, 3196, 3197, 3198, 3199, 3200, 3201, 3202, 3203, 3204, 3205, 3206, 3207, 3208, 3209, 3210,
-    3211, 3212, 3213, 3214, 3215, 3216, 3217, 3218, 3219, 3220, 3221, 3222, 3223, 3224, 3225, 3226, 3227, 3228, 3229,
-    3230, 3231, 3232, 3233, 3234, 3235, 3236, 3237, 3238, 3239, 3240, 3241, 3242, 3243, 3244, 3245, 3246, 3247, 3248,
-    3249, 3250, 3251, 3252, 3253, 3254, 3255, 3256, 3257, 3258, 3259, 3260, 3261, 3262, 3263, 3264, 3265, 3266, 3267,
-    3268, 3269, 3270, 3271, 3272, 3273, 3274, 3275, 3276, 3277, 3278, 3279, 3280, 3281, 3282, 3283, 3284, 3285, 3286,
-    3287, 3288, 3289, 3290, 3291, 3292, 3293, 3294, 3295, 3296, 3297, 3298, 3299, 3300, 3301, 3302, 3303, 3304, 3305,
-    3306, 3307, 3308, 3309, 3310, 3311, 3312, 3313, 3314, 3315, 3316, 3317, 3318, 3319, 3320, 3321, 3322, 3323, 3324,
-    3325, 3326, 3327, 3328, 3329, 3330, 3331, 3332, 3333, 3334, 3335, 3336, 3337, 3338, 3339, 3340, 3341, 3342, 3343,
-    3344, 3345, 3346, 3347, 3348, 3349, 3350, 3351, 3352, 3353, 3354, 3355, 3356, 3357, 3358, 3359, 3360, 3361, 3362,
-    3363, 3364, 3365, 3366, 3367, 3368, 3369, 3370, 3371, 3372, 3373, 3374, 3375, 3376, 3377, 3378, 3379, 3380, 3381,
-    3382, 3383, 3384, 3385, 3386, 3387, 3388, 3389, 3390, 3391, 3392, 3393, 3394, 3395, 3396, 3397, 3398, 3399, 3400,
-    3401, 3402, 3403, 3404, 3405, 3406, 3407, 3408, 3409, 3410, 3411, 3412, 3413, 3414, 3415, 3416, 3417, 3418, 3419,
-    3420, 3421, 3422, 3423, 3424, 3425, 3426, 3427, 3428, 3429, 3430, 3431, 3432, 3433, 3434, 3435, 3436, 3437, 3438,
-    3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448, 3449, 3450, 3451, 3452, 3453, 3454, 3455, 3456, 3457,
-    3458, 3459, 3460, 3461, 3462, 3463, 3464, 3465, 3466, 3467, 3468, 3469, 3470, 3471, 3472, 3473, 3474, 3475, 3476,
-    3477, 3478, 3479, 3480, 3481, 3482, 3483, 3484, 3485, 3486, 3487, 3488, 3489, 3490, 3491, 3492, 3493, 3494, 3495,
-    3496, 3497, 3498, 3499, 3500, 3501, 3502, 3503, 3504, 3505, 3506, 3507, 3508, 3509, 3510, 3511, 3512, 3513, 3514,
-    3515, 3516, 3517, 3518, 3519, 3520, 3521, 3522, 3523, 3524, 3525, 3526, 3527, 3528, 3529, 3530, 3531, 3532, 3533,
-    3534, 3535, 3536, 3537, 3538, 3539, 3540, 3541, 3542, 3543, 3544, 3545, 3546, 3547, 3548, 3549, 3550, 3551, 3552,
-    3553, 3554, 3555, 3556, 3557, 3558, 3559, 3560, 3561, 3562, 3563, 3564, 3565, 3566, 3567, 3568, 3569, 3570, 3571,
-    3572, 3573, 3574, 3575, 3576, 3577, 3578, 3579, 3580, 3581, 3582, 3583, 3584, 3585, 3586, 3587, 3588, 3589, 3590,
-    3591, 3592, 3593, 3594, 3595, 3596, 3597, 3598, 3599, 3600, 3601, 3602, 3603, 3604, 3605, 3606, 3607, 3608, 3609,
-    3610, 3611, 3612, 3613, 3614, 3615, 3616, 3617, 3618, 3619, 3620, 3621, 3622, 3623, 3624, 3625, 3626, 3627, 3628,
-    3629, 3630, 3631, 3632, 3633, 3634, 3635, 3636, 3637, 3638, 3639, 3640, 3641, 3642, 3643, 3644, 3645, 3646, 3647,
-    3648, 3649, 3650, 3651, 3652, 3653, 3654, 3655, 3656, 3657, 3658, 3659, 3660, 3661, 3662, 3663, 3664, 3665, 3666,
-    3667, 3668, 3669, 3670, 3671, 3672, 3673, 3674, 3675, 3676, 3677, 3678, 3679, 3680, 3681, 3682, 3683, 3684, 3685,
-    3686, 3687, 3688, 3689, 3690, 3691, 3692, 3693, 3694, 3695, 3696, 3697, 3698, 3699, 3700, 3701, 3702, 3703, 3704,
-    3705, 3706, 3707, 3708, 3709, 3710, 3711, 3712, 3713, 3714, 3715, 3716, 3717, 3718, 3719, 3720, 3721, 3722, 3723,
-    3724, 3725, 3726, 3727, 3728, 3729, 3730, 3731, 3732, 3733, 3734, 3735, 3736, 3737, 3738, 3739, 3740, 3741, 3742,
-    3743, 3744, 3745, 3746, 3747, 3748, 3749, 3750, 3751, 3752, 3753, 3754, 3755, 3756, 3757, 3758, 3759, 3760, 3761,
-    3762, 3763, 3764, 3765, 3766, 3767, 3768, 3769, 3770, 3771, 3772, 3773, 3774, 3775, 3776, 3777, 3778, 3779, 3780,
-    3781, 3782, 3783, 3784, 3785, 3786, 3787, 3788, 3789, 3790, 3791, 3792, 3793, 3794, 3795, 3796, 3797, 3798, 3799,
-    3800, 3801, 3802, 3803, 3804, 3805, 3806, 3807, 3808, 3809, 3810, 3811, 3812, 3813, 3814, 3815, 3816, 3817, 3818,
-    3819, 3820, 3821, 3822, 3823, 3824, 3825, 3826, 3827, 3828, 3829, 3830, 3831, 3832, 3833, 3834, 3835, 3836, 3837,
-    3838, 3839, 3840, 3841, 3842, 3843, 3844, 3845, 3846, 3847, 3848, 3849, 3850, 3851, 3852, 3853, 3854, 3855, 3856,
-    3857, 3858, 3859, 3860, 3861, 3862, 3863, 3864, 3865, 3866, 3867, 3868, 3869, 3870, 3871, 3872, 3873, 3874, 3875,
-    3876, 3877, 3878, 3879, 3880, 3881, 3882, 3883, 3884, 3885, 3886, 3887, 3888, 3889, 3890, 3891, 3892, 3893, 3894,
-    3895, 3896, 3897, 3898, 3899, 3900, 3901, 3902, 3903, 3904, 3905, 3906, 3907, 3908, 3909, 3910, 3911, 3912, 3913,
-    3914, 3915, 3916, 3917, 3918, 3919, 3920, 3921, 3922, 3923, 3924, 3925, 3926, 3927, 3928, 3929, 3930, 3931, 3932,
-    3933, 3934, 3935, 3936, 3937, 3938, 3939, 3940, 3941, 3942, 3943, 3944, 3945, 3946, 3947, 3948, 3949, 3950, 3951,
-    3952, 3953, 3954, 3955, 3956, 3957, 3958, 3959, 3960, 3961, 3962, 3963, 3964, 3965, 3966, 3967, 3968, 3969, 3970,
-    3971, 3972, 3973, 3974, 3975, 3976, 3977, 3978, 3979, 3980, 3981, 3982, 3983, 3984, 3985, 3986, 3987, 3988, 3989,
-    3990, 3991, 3992, 3993, 3994, 3995, 3996, 3997, 3998, 3999, 4000, 4001, 4002, 4003, 4004, 4005, 4006, 4007, 4008,
-    4009, 4010, 4011, 4012, 4013, 4014, 4015, 4016, 4017, 4018, 4019, 4020, 4021, 4022, 4023, 4024, 4025, 4026, 4027,
-    4028, 4029, 4030, 4031, 4032, 4033, 4034, 4035, 4036, 4037, 4038, 4039, 4040, 4041, 4042, 4043, 4044, 4045, 4046,
-    4047, 4048, 4049, 4050, 4051, 4052, 4053, 4054, 4055, 4056, 4057, 4058, 4059, 4060, 4061, 4062, 4063, 4064, 4065,
-    4066, 4067, 4068, 4069, 4070, 4071, 4072, 4073, 4074, 4075, 4076, 4077, 4078, 4079, 4080, 4081, 4082, 4083, 4084,
-    4085, 4086, 4087, 4088, 4089, 4090, 4091, 4092, 4093, 4094, 4095};
-#else
-#error Unsupported VECTOR_SIZE!
+#ifdef __clang__
+#pragma clang diagnostic pop
 #endif
 
 } // namespace duckdb
@@ -40841,31 +40338,40 @@ constexpr const LogicalTypeId LogicalType::VARCHAR;
 
 constexpr const LogicalTypeId LogicalType::BLOB;
 constexpr const LogicalTypeId LogicalType::INTERVAL;
+constexpr const LogicalTypeId LogicalType::ROW_TYPE;
 
 // TODO these are incomplete and should maybe not exist as such
 constexpr const LogicalTypeId LogicalType::TABLE;
 
 constexpr const LogicalTypeId LogicalType::ANY;
 
-const vector<LogicalType> LogicalType::NUMERIC = {LogicalType::TINYINT,   LogicalType::SMALLINT,  LogicalType::INTEGER,
-                                                  LogicalType::BIGINT,    LogicalType::HUGEINT,   LogicalType::FLOAT,
-                                                  LogicalType::DOUBLE,    LogicalTypeId::DECIMAL, LogicalType::UTINYINT,
-                                                  LogicalType::USMALLINT, LogicalType::UINTEGER,  LogicalType::UBIGINT};
-
-const vector<LogicalType> LogicalType::INTEGRAL = {LogicalType::TINYINT,   LogicalType::SMALLINT, LogicalType::INTEGER,
-                                                   LogicalType::BIGINT,    LogicalType::HUGEINT,  LogicalType::UTINYINT,
-                                                   LogicalType::USMALLINT, LogicalType::UINTEGER, LogicalType::UBIGINT};
-
-const vector<LogicalType> LogicalType::ALL_TYPES = {
-    LogicalType::BOOLEAN,  LogicalType::TINYINT,   LogicalType::SMALLINT,  LogicalType::INTEGER,
-    LogicalType::BIGINT,   LogicalType::DATE,      LogicalType::TIMESTAMP, LogicalType::DOUBLE,
-    LogicalType::FLOAT,    LogicalType::VARCHAR,   LogicalType::BLOB,      LogicalType::INTERVAL,
-    LogicalType::HUGEINT,  LogicalTypeId::DECIMAL, LogicalType::UTINYINT,  LogicalType::USMALLINT,
-    LogicalType::UINTEGER, LogicalType::UBIGINT,   LogicalType::TIME,      LogicalTypeId::LIST,
-    LogicalTypeId::STRUCT, LogicalType::DATE_TZ,   LogicalType::TIME_TZ,   LogicalType::TIMESTAMP_TZ,
-    LogicalTypeId::MAP,    LogicalType::UUID};
-
-const LogicalType LOGICAL_ROW_TYPE = LogicalType::BIGINT;
+const vector<LogicalType> LogicalType::Numeric() {
+	vector<LogicalType> types = {LogicalType::TINYINT,   LogicalType::SMALLINT,  LogicalType::INTEGER,
+	                             LogicalType::BIGINT,    LogicalType::HUGEINT,   LogicalType::FLOAT,
+	                             LogicalType::DOUBLE,    LogicalTypeId::DECIMAL, LogicalType::UTINYINT,
+	                             LogicalType::USMALLINT, LogicalType::UINTEGER,  LogicalType::UBIGINT};
+	return types;
+}
+
+const vector<LogicalType> LogicalType::Integral() {
+	vector<LogicalType> types = {LogicalType::TINYINT,   LogicalType::SMALLINT, LogicalType::INTEGER,
+	                             LogicalType::BIGINT,    LogicalType::HUGEINT,  LogicalType::UTINYINT,
+	                             LogicalType::USMALLINT, LogicalType::UINTEGER, LogicalType::UBIGINT};
+	return types;
+}
+
+const vector<LogicalType> LogicalType::AllTypes() {
+	vector<LogicalType> types = {
+	    LogicalType::BOOLEAN,  LogicalType::TINYINT,   LogicalType::SMALLINT,  LogicalType::INTEGER,
+	    LogicalType::BIGINT,   LogicalType::DATE,      LogicalType::TIMESTAMP, LogicalType::DOUBLE,
+	    LogicalType::FLOAT,    LogicalType::VARCHAR,   LogicalType::BLOB,      LogicalType::INTERVAL,
+	    LogicalType::HUGEINT,  LogicalTypeId::DECIMAL, LogicalType::UTINYINT,  LogicalType::USMALLINT,
+	    LogicalType::UINTEGER, LogicalType::UBIGINT,   LogicalType::TIME,      LogicalTypeId::LIST,
+	    LogicalTypeId::STRUCT, LogicalType::DATE_TZ,   LogicalType::TIME_TZ,   LogicalType::TIMESTAMP_TZ,
+	    LogicalTypeId::MAP,    LogicalType::UUID};
+	return types;
+}
+
 const PhysicalType ROW_TYPE = PhysicalType::INT64;
 
 // LCOV_EXCL_START
@@ -42038,12 +41544,15 @@ static bool TemplatedBooleanOperation(const Value &left, const Value &right) {
 	const auto &left_type = left.type();
 	const auto &right_type = right.type();
 	if (left_type != right_type) {
-		try {
-			LogicalType comparison_type = BoundComparisonExpression::BindComparison(left_type, right_type);
-			return TemplatedBooleanOperation<OP>(left.CastAs(comparison_type), right.CastAs(comparison_type));
-		} catch (...) {
+		Value left_copy = left;
+		Value right_copy = right;
+
+		LogicalType comparison_type = BoundComparisonExpression::BindComparison(left_type, right_type);
+		if (!left_copy.TryCastAs(comparison_type) || !right_copy.TryCastAs(comparison_type)) {
 			return false;
 		}
+		D_ASSERT(left_copy.type() == right_copy.type());
+		return TemplatedBooleanOperation<OP>(left_copy, right_copy);
 	}
 	switch (left_type.InternalType()) {
 	case PhysicalType::BOOL:
@@ -43234,8 +42743,9 @@ static idx_t DistinctSelectConstant(Vector &left, Vector &right, const Selection
 template <class LEFT_TYPE, class RIGHT_TYPE, class OP, bool DENSE>
 static idx_t DistinctSelect(Vector &left, Vector &right, idx_t vcount, const SelectionVector *sel, idx_t count,
                             SelectionVector *true_sel, SelectionVector *false_sel) {
+	SelectionVector owned_sel;
 	if (!sel) {
-		sel = &FlatVector::INCREMENTAL_SELECTION_VECTOR;
+		sel = FlatVector::IncrementalSelectionVector(count, owned_sel);
 	}
 	if (left.GetVectorType() == VectorType::CONSTANT_VECTOR && right.GetVectorType() == VectorType::CONSTANT_VECTOR) {
 		return DistinctSelectConstant<LEFT_TYPE, RIGHT_TYPE, OP>(left, right, sel, count, true_sel, false_sel);
@@ -43571,8 +43081,9 @@ template <class OP, bool DENSE, class OPNESTED>
 static idx_t DistinctSelectNested(Vector &left, Vector &right, idx_t vcount, const SelectionVector *sel, idx_t count,
                                   SelectionVector *true_sel, SelectionVector *false_sel) {
 	// We need multiple, real selections
+	SelectionVector owned_sel;
 	if (!sel) {
-		sel = &FlatVector::INCREMENTAL_SELECTION_VECTOR;
+		sel = FlatVector::IncrementalSelectionVector(count, owned_sel);
 	}
 
 	SelectionVector true_vec;
@@ -45499,8 +45010,9 @@ void VectorOperations::Copy(const Vector &source, Vector &target, idx_t source_c
 		break;
 	}
 	case VectorType::FLAT_VECTOR: {
-		VectorOperations::Copy(source, target, FlatVector::INCREMENTAL_SELECTION_VECTOR, source_count, source_offset,
-		                       target_offset);
+		SelectionVector owned_sel;
+		auto sel = FlatVector::IncrementalSelectionVector(source_count, owned_sel);
+		VectorOperations::Copy(source, target, *sel, source_count, source_offset, target_offset);
 		break;
 	}
 	case VectorType::SEQUENCE_VECTOR: {
@@ -45509,8 +45021,9 @@ void VectorOperations::Copy(const Vector &source, Vector &target, idx_t source_c
 		Vector flattened(source.GetType());
 		VectorOperations::GenerateSequence(flattened, source_count, start, increment);
 
-		VectorOperations::Copy(flattened, target, FlatVector::INCREMENTAL_SELECTION_VECTOR, source_count, source_offset,
-		                       target_offset);
+		SelectionVector owned_sel;
+		auto sel = FlatVector::IncrementalSelectionVector(source_count, owned_sel);
+		VectorOperations::Copy(flattened, target, *sel, source_count, source_offset, target_offset);
 		break;
 	}
 	default:
@@ -46739,7 +46252,7 @@ idx_t GroupedAggregateHashTable::FindOrCreateGroupsInternal(DataChunk &groups, V
 	auto hash_salts_ptr = FlatVector::GetData<uint16_t>(hash_salts);
 
 	// we start out with all entries [0, 1, 2, ..., groups.size()]
-	const SelectionVector *sel_vector = &FlatVector::INCREMENTAL_SELECTION_VECTOR;
+	const SelectionVector *sel_vector = FlatVector::IncrementalSelectionVector();
 
 	idx_t remaining_entries = groups.size();
 
@@ -46870,8 +46383,8 @@ void GroupedAggregateHashTable::FlushMove(Vector &source_addresses, Vector &sour
 	for (idx_t i = 0; i < groups.ColumnCount(); i++) {
 		auto &column = groups.data[i];
 		const auto col_offset = layout.GetOffsets()[i];
-		RowOperations::Gather(source_addresses, FlatVector::INCREMENTAL_SELECTION_VECTOR, column,
-		                      FlatVector::INCREMENTAL_SELECTION_VECTOR, count, col_offset, i);
+		RowOperations::Gather(source_addresses, *FlatVector::IncrementalSelectionVector(), column,
+		                      *FlatVector::IncrementalSelectionVector(), count, col_offset, i);
 	}
 
 	SelectionVector new_groups(STANDARD_VECTOR_SIZE);
@@ -46998,8 +46511,8 @@ idx_t GroupedAggregateHashTable::Scan(idx_t &scan_position, DataChunk &result) {
 	for (idx_t i = 0; i < group_cols; i++) {
 		auto &column = result.data[i];
 		const auto col_offset = layout.GetOffsets()[i];
-		RowOperations::Gather(addresses, FlatVector::INCREMENTAL_SELECTION_VECTOR, column,
-		                      FlatVector::INCREMENTAL_SELECTION_VECTOR, result.size(), col_offset, i);
+		RowOperations::Gather(addresses, *FlatVector::IncrementalSelectionVector(), column,
+		                      *FlatVector::IncrementalSelectionVector(), result.size(), col_offset, i);
 	}
 
 	RowOperations::FinalizeStates(layout, addresses, result, group_cols);
@@ -48006,8 +47519,9 @@ static idx_t NestedSelectOperation(Vector &left, Vector &right, const SelectionV
 	// 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::INCREMENTAL_SELECTION_VECTOR;
+		sel = FlatVector::IncrementalSelectionVector(vcount, owned_sel);
 	}
 
 	VectorData lvdata, rvdata;
@@ -48027,7 +47541,9 @@ static idx_t NestedSelectOperation(Vector &left, Vector &right, const SelectionV
 
 	// If everything was NULL, fill in false_sel with sel
 	if (count == 0) {
-		ScatterSelection(false_sel, no_match_count, sel, FlatVector::INCREMENTAL_SELECTION_VECTOR);
+		SelectionVector owned_flat_sel;
+		auto flat_sel = FlatVector::IncrementalSelectionVector(vcount, owned_sel);
+		ScatterSelection(false_sel, no_match_count, sel, *flat_sel);
 		return count;
 	}
 
@@ -48761,8 +48277,10 @@ idx_t ExpressionExecutor::DefaultSelect(const Expression &expr, ExpressionState
 
 	VectorData idata;
 	intermediate.Orrify(count, idata);
+
+	SelectionVector owned_sel;
 	if (!sel) {
-		sel = &FlatVector::INCREMENTAL_SELECTION_VECTOR;
+		sel = FlatVector::IncrementalSelectionVector(count, owned_sel);
 	}
 	if (!idata.validity.AllValid()) {
 		return DefaultSelectSwitch<false>(idata, sel, count, true_sel, false_sel);
@@ -50636,7 +50154,7 @@ idx_t JoinHashTable::PrepareKeys(DataChunk &keys, unique_ptr<VectorData[]> &key_
 	key_data = keys.Orrify();
 
 	// figure out which keys are NULL, and create a selection vector out of them
-	current_sel = &FlatVector::INCREMENTAL_SELECTION_VECTOR;
+	current_sel = FlatVector::IncrementalSelectionVector();
 	idx_t added_count = keys.size();
 	if (build_side && IsRightOuterJoin(join_type)) {
 		// in case of a right or full outer join, we cannot remove NULL keys from the build side
@@ -50944,7 +50462,7 @@ void ScanStructure::GatherResult(Vector &result, const SelectionVector &result_v
 
 void ScanStructure::GatherResult(Vector &result, const SelectionVector &sel_vector, const idx_t count,
                                  const idx_t col_idx) {
-	GatherResult(result, FlatVector::INCREMENTAL_SELECTION_VECTOR, sel_vector, count, col_idx);
+	GatherResult(result, *FlatVector::IncrementalSelectionVector(), sel_vector, count, col_idx);
 }
 
 void ScanStructure::NextInnerJoin(DataChunk &keys, DataChunk &left, DataChunk &result) {
@@ -51267,7 +50785,7 @@ void JoinHashTable::ScanFullOuter(DataChunk &result, JoinHTScanState &state) {
 	result.SetCardinality(found_entries);
 	if (found_entries > 0) {
 		idx_t left_column_count = result.ColumnCount() - build_types.size();
-		const auto &sel_vector = FlatVector::INCREMENTAL_SELECTION_VECTOR;
+		const auto &sel_vector = *FlatVector::IncrementalSelectionVector();
 		// set the left side as a constant NULL
 		for (idx_t i = 0; i < left_column_count; i++) {
 			Vector &vec = result.data[i];
@@ -53082,8 +52600,9 @@ void PhysicalSimpleAggregate::Combine(ExecutionContext &context, GlobalSinkState
 		aggregate.function.combine(source_state, dest_state, 1);
 	}
 
+	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(this, &source.child_executor, "child_executor", 0);
-	context.client.profiler->Flush(context.thread.profiler);
+	client_profiler.Flush(context.thread.profiler);
 }
 
 SinkFinalizeType PhysicalSimpleAggregate::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
@@ -54888,7 +54407,8 @@ SinkResultType PhysicalExplainAnalyze::Sink(ExecutionContext &context, GlobalSin
 SinkFinalizeType PhysicalExplainAnalyze::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
                                                   GlobalSinkState &gstate_p) const {
 	auto &gstate = (ExplainAnalyzeStateGlobalState &)gstate_p;
-	gstate.analyzed_plan = context.profiler->ToString();
+	auto &profiler = QueryProfiler::Get(context);
+	gstate.analyzed_plan = profiler.ToString();
 	return SinkFinalizeType::READY;
 }
 
@@ -55412,7 +54932,10 @@ public:
 	static void LoadExternalExtension(DatabaseInstance &db, const string &extension);
 
 private:
-	static const vector<string> PATH_COMPONENTS;
+	static const vector<string> PathComponents();
+
+private:
+	static ExtensionLoadResult LoadExtensionInternal(DuckDB &db, const std::string &extension, bool initial_load);
 };
 
 } // namespace duckdb
@@ -57666,8 +57189,9 @@ SinkResultType PhysicalHashJoin::Sink(ExecutionContext &context, GlobalSinkState
 
 void PhysicalHashJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
 	auto &state = (HashJoinLocalState &)lstate;
+	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(this, &state.build_executor, "build_executor", 1);
-	context.client.profiler->Flush(context.thread.profiler);
+	client_profiler.Flush(context.thread.profiler);
 }
 
 //===--------------------------------------------------------------------===//
@@ -58081,7 +57605,7 @@ void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, Data
 		}
 		state.rhs_chunk.Reset();
 		ColumnFetchState fetch_state;
-		Vector row_ids(LOGICAL_ROW_TYPE, (data_ptr_t)&fetch_rows[0]);
+		Vector row_ids(LogicalType::ROW_TYPE, (data_ptr_t)&fetch_rows[0]);
 		tbl->Fetch(transaction, state.rhs_chunk, fetch_ids, row_ids, output_sel_idx, fetch_state);
 	}
 
@@ -58431,8 +57955,10 @@ SinkResultType PhysicalNestedLoopJoin::Sink(ExecutionContext &context, GlobalSin
 
 void PhysicalNestedLoopJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
 	auto &state = (NestedLoopJoinLocalState &)lstate;
+	auto &client_profiler = QueryProfiler::Get(context.client);
+
 	context.thread.profiler.Flush(this, &state.rhs_executor, "rhs_executor", 1);
-	context.client.profiler->Flush(context.thread.profiler);
+	client_profiler.Flush(context.thread.profiler);
 }
 
 SinkFinalizeType PhysicalNestedLoopJoin::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
@@ -58864,8 +58390,10 @@ SinkResultType PhysicalPiecewiseMergeJoin::Sink(ExecutionContext &context, Globa
 void PhysicalPiecewiseMergeJoin::Combine(ExecutionContext &context, GlobalSinkState &gstate,
                                          LocalSinkState &lstate) const {
 	auto &state = (MergeJoinLocalState &)lstate;
+	auto &client_profiler = QueryProfiler::Get(context.client);
+
 	context.thread.profiler.Flush(this, &state.rhs_executor, "rhs_executor", 1);
-	context.client.profiler->Flush(context.thread.profiler);
+	client_profiler.Flush(context.thread.profiler);
 }
 
 //===--------------------------------------------------------------------===//
@@ -59450,12 +58978,13 @@ public:
 	    : ExecutorTask(context), event(move(event_p)), context(context), state(state) {
 	}
 
-	void ExecuteTask() override {
+	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
 		// Initialize merge sorted and iterate until done
 		auto &global_sort_state = state.global_sort_state;
 		MergeSorter merge_sorter(global_sort_state, BufferManager::GetBufferManager(context));
 		merge_sorter.PerformInMergeRound();
 		event->FinishTask();
+		return TaskExecutionResult::TASK_FINISHED;
 	}
 
 private:
@@ -62791,8 +62320,9 @@ unique_ptr<LocalSinkState> PhysicalInsert::GetLocalSinkState(ExecutionContext &c
 
 void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
 	auto &state = (InsertLocalState &)lstate;
+	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(this, &state.default_executor, "default_executor", 1);
-	context.client.profiler->Flush(context.thread.profiler);
+	client_profiler.Flush(context.thread.profiler);
 }
 
 //===--------------------------------------------------------------------===//
@@ -62998,8 +62528,9 @@ unique_ptr<LocalSinkState> PhysicalUpdate::GetLocalSinkState(ExecutionContext &c
 
 void PhysicalUpdate::Combine(ExecutionContext &context, GlobalSinkState &gstate, LocalSinkState &lstate) const {
 	auto &state = (UpdateLocalState &)lstate;
+	auto &client_profiler = QueryProfiler::Get(context.client);
 	context.thread.profiler.Flush(this, &state.default_executor, "default_executor", 1);
-	context.client.profiler->Flush(context.thread.profiler);
+	client_profiler.Flush(context.thread.profiler);
 }
 
 //===--------------------------------------------------------------------===//
@@ -65223,7 +64754,7 @@ void PerfectAggregateHashTable::Combine(PerfectAggregateHashTable &other) {
 	data_ptr_t target_ptr = data;
 	idx_t combine_count = 0;
 	idx_t reinit_count = 0;
-	const auto &reinit_sel = FlatVector::INCREMENTAL_SELECTION_VECTOR;
+	const auto &reinit_sel = *FlatVector::IncrementalSelectionVector();
 	for (idx_t i = 0; i < total_groups; i++) {
 		auto has_entry_source = other.group_is_set[i];
 		// we only have any work to do if the source has an entry for this group
@@ -68995,25 +68526,27 @@ private:
 };
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(unique_ptr<LogicalOperator> op) {
+	auto &profiler = QueryProfiler::Get(context);
+
 	// first resolve column references
-	context.profiler->StartPhase("column_binding");
+	profiler.StartPhase("column_binding");
 	ColumnBindingResolver resolver;
 	resolver.VisitOperator(*op);
-	context.profiler->EndPhase();
+	profiler.EndPhase();
 
 	// now resolve types of all the operators
-	context.profiler->StartPhase("resolve_types");
+	profiler.StartPhase("resolve_types");
 	op->ResolveOperatorTypes();
-	context.profiler->EndPhase();
+	profiler.EndPhase();
 
 	// extract dependencies from the logical plan
 	DependencyExtractor extractor(dependencies);
 	extractor.VisitOperator(*op);
 
 	// then create the main physical plan
-	context.profiler->StartPhase("create_plan");
+	profiler.StartPhase("create_plan");
 	auto plan = CreatePlan(*op);
-	context.profiler->EndPhase();
+	profiler.EndPhase();
 	return plan;
 }
 
@@ -69375,6 +68908,7 @@ public:
 	                           idx_t radix_p)
 	    : ExecutorTask(executor), event(move(event_p)), state(state_p), radix(radix_p) {
 	}
+
 	static void FinalizeHT(RadixHTGlobalState &gstate, idx_t radix) {
 		D_ASSERT(gstate.partition_info.n_partitions <= gstate.finalized_hts.size());
 		D_ASSERT(gstate.finalized_hts[radix]);
@@ -69387,9 +68921,10 @@ public:
 		gstate.finalized_hts[radix]->Finalize();
 	}
 
-	void ExecuteTask() override {
+	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
 		FinalizeHT(state, radix);
 		event->FinishTask();
+		return TaskExecutionResult::TASK_FINISHED;
 	}
 
 private:
@@ -71375,7 +70910,7 @@ struct BitAndOperation {
 
 void BitAndFun::RegisterFunction(BuiltinFunctions &set) {
 	AggregateFunctionSet bit_and("bit_and");
-	for (auto &type : LogicalType::INTEGRAL) {
+	for (auto &type : LogicalType::Integral()) {
 		bit_and.AddFunction(GetBitfieldUnaryAggregate<BitAndOperation>(type));
 	}
 	set.AddFunction(bit_and);
@@ -71435,7 +70970,7 @@ struct BitOrOperation {
 
 void BitOrFun::RegisterFunction(BuiltinFunctions &set) {
 	AggregateFunctionSet bit_or("bit_or");
-	for (auto &type : LogicalType::INTEGRAL) {
+	for (auto &type : LogicalType::Integral()) {
 		bit_or.AddFunction(GetBitfieldUnaryAggregate<BitOrOperation>(type));
 	}
 	set.AddFunction(bit_or);
@@ -71495,7 +71030,7 @@ struct BitXorOperation {
 
 void BitXorFun::RegisterFunction(BuiltinFunctions &set) {
 	AggregateFunctionSet bit_xor("bit_xor");
-	for (auto &type : LogicalType::INTEGRAL) {
+	for (auto &type : LogicalType::Integral()) {
 		bit_xor.AddFunction(GetBitfieldUnaryAggregate<BitXorOperation>(type));
 	}
 	set.AddFunction(bit_xor);
@@ -72193,7 +71728,7 @@ unique_ptr<FunctionData> BindDecimalFirst(ClientContext &context, AggregateFunct
 void FirstFun::RegisterFunction(BuiltinFunctions &set) {
 	AggregateFunctionSet first("first");
 	AggregateFunctionSet last("last");
-	for (auto &type : LogicalType::ALL_TYPES) {
+	for (auto &type : LogicalType::AllTypes()) {
 		if (type.id() == LogicalTypeId::DECIMAL) {
 			first.AddFunction(AggregateFunction({type}, type, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
 			                                    BindDecimalFirst<false>, nullptr, nullptr, nullptr));
@@ -72833,7 +72368,7 @@ static AggregateFunction GetMinMaxFunction(const LogicalType &type) {
 
 template <class OP, class OP_STRING, class OP_VECTOR>
 static void AddMinMaxOperator(AggregateFunctionSet &set) {
-	for (auto &type : LogicalType::ALL_TYPES) {
+	for (auto &type : LogicalType::AllTypes()) {
 		if (type.id() == LogicalTypeId::VARCHAR || type.id() == LogicalTypeId::BLOB) {
 			set.AddFunction(
 			    AggregateFunction::UnaryAggregateDestructor<MinMaxState<string_t>, string_t, string_t, OP_STRING>(
@@ -74558,7 +74093,7 @@ void ModeFun::RegisterFunction(BuiltinFunctions &set) {
 	mode.AddFunction(AggregateFunction({LogicalTypeId::DECIMAL}, LogicalTypeId::DECIMAL, nullptr, nullptr, nullptr,
 	                                   nullptr, nullptr, nullptr, BindModeDecimal));
 
-	for (const auto &type : LogicalType::NUMERIC) {
+	for (const auto &type : LogicalType::Numeric()) {
 		if (type.id() != LogicalTypeId::DECIMAL) {
 			mode.AddFunction(GetModeAggregate(type));
 		}
@@ -78491,8 +78026,9 @@ struct PragmaFunctions {
 namespace duckdb {
 
 static void PragmaEnableProfilingStatement(ClientContext &context, const FunctionParameters &parameters) {
-	context.profiler->automatic_print_format = ProfilerPrintFormat::QUERY_TREE;
-	context.profiler->Enable();
+	auto &config = ClientConfig::GetConfig(context);
+	config.profiler_print_format = ProfilerPrintFormat::QUERY_TREE;
+	config.enable_profiler = true;
 }
 
 void RegisterEnableProfiling(BuiltinFunctions &set) {
@@ -78504,8 +78040,9 @@ void RegisterEnableProfiling(BuiltinFunctions &set) {
 }
 
 static void PragmaDisableProfiling(ClientContext &context, const FunctionParameters &parameters) {
-	context.profiler->Disable();
-	context.profiler->automatic_print_format = ProfilerPrintFormat::NONE;
+	auto &config = ClientConfig::GetConfig(context);
+	config.enable_profiler = false;
+	config.profiler_print_format = ProfilerPrintFormat::NONE;
 }
 
 static void PragmaEnableProgressBar(ClientContext &context, const FunctionParameters &parameters) {
@@ -84335,7 +83872,7 @@ unique_ptr<FunctionData> DecimalUnaryOpBind(ClientContext &context, ScalarFuncti
 
 void AbsFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet abs("abs");
-	for (auto &type : LogicalType::NUMERIC) {
+	for (auto &type : LogicalType::Numeric()) {
 		if (type.id() == LogicalTypeId::DECIMAL) {
 			abs.AddFunction(ScalarFunction({type}, type, nullptr, false, DecimalUnaryOpBind<AbsOperator>));
 		} else {
@@ -84393,7 +83930,7 @@ struct SignOperator {
 
 void SignFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet sign("sign");
-	for (auto &type : LogicalType::NUMERIC) {
+	for (auto &type : LogicalType::Numeric()) {
 		if (type.id() == LogicalTypeId::DECIMAL) {
 			continue;
 		} else {
@@ -84469,7 +84006,7 @@ struct CeilDecimalOperator {
 
 void CeilFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet ceil("ceil");
-	for (auto &type : LogicalType::NUMERIC) {
+	for (auto &type : LogicalType::Numeric()) {
 		scalar_function_t func = nullptr;
 		bind_scalar_function_t bind_func = nullptr;
 		if (type.IsIntegral()) {
@@ -84525,7 +84062,7 @@ struct FloorDecimalOperator {
 
 void FloorFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet floor("floor");
-	for (auto &type : LogicalType::NUMERIC) {
+	for (auto &type : LogicalType::Numeric()) {
 		scalar_function_t func = nullptr;
 		bind_scalar_function_t bind_func = nullptr;
 		if (type.IsIntegral()) {
@@ -84727,7 +84264,7 @@ unique_ptr<FunctionData> BindDecimalRoundPrecision(ClientContext &context, Scala
 
 void RoundFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet round("round");
-	for (auto &type : LogicalType::NUMERIC) {
+	for (auto &type : LogicalType::Numeric()) {
 		scalar_function_t round_prec_func = nullptr;
 		scalar_function_t round_func = nullptr;
 		bind_scalar_function_t bind_func = nullptr;
@@ -85872,7 +85409,7 @@ ScalarFunction AddFun::GetFunction(const LogicalType &left_type, const LogicalTy
 
 void AddFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("+");
-	for (auto &type : LogicalType::NUMERIC) {
+	for (auto &type : LogicalType::Numeric()) {
 		// unary add function is a nop, but only exists for numeric types
 		functions.AddFunction(GetFunction(type));
 		// binary add function adds two numbers together
@@ -86073,7 +85610,7 @@ ScalarFunction SubtractFun::GetFunction(const LogicalType &left_type, const Logi
 
 void SubtractFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("-");
-	for (auto &type : LogicalType::NUMERIC) {
+	for (auto &type : LogicalType::Numeric()) {
 		// unary subtract function, negates the input (i.e. multiplies by -1)
 		functions.AddFunction(GetFunction(type));
 		// binary subtract function "a - b", subtracts b from a
@@ -86208,7 +85745,7 @@ unique_ptr<FunctionData> BindDecimalMultiply(ClientContext &context, ScalarFunct
 
 void MultiplyFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("*");
-	for (auto &type : LogicalType::NUMERIC) {
+	for (auto &type : LogicalType::Numeric()) {
 		if (type.id() == LogicalTypeId::DECIMAL) {
 			functions.AddFunction(ScalarFunction({type, type}, type, nullptr, false, BindDecimalMultiply));
 		} else if (TypeIsIntegral(type.InternalType()) && type.id() != LogicalTypeId::HUGEINT) {
@@ -86336,7 +85873,7 @@ static scalar_function_t GetBinaryFunctionIgnoreZero(const LogicalType &type) {
 
 void DivideFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("/");
-	for (auto &type : LogicalType::NUMERIC) {
+	for (auto &type : LogicalType::Numeric()) {
 		if (type.id() == LogicalTypeId::DECIMAL) {
 			continue;
 		} else {
@@ -86376,7 +85913,7 @@ hugeint_t ModuloOperator::Operation(hugeint_t left, hugeint_t right) {
 
 void ModFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("%");
-	for (auto &type : LogicalType::NUMERIC) {
+	for (auto &type : LogicalType::Numeric()) {
 		if (type.id() == LogicalTypeId::DECIMAL) {
 			continue;
 		} else {
@@ -86481,7 +86018,7 @@ struct BitwiseANDOperator {
 
 void BitwiseAndFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("&");
-	for (auto &type : LogicalType::INTEGRAL) {
+	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseANDOperator>(type)));
 	}
@@ -86500,7 +86037,7 @@ struct BitwiseOROperator {
 
 void BitwiseOrFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("|");
-	for (auto &type : LogicalType::INTEGRAL) {
+	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseOROperator>(type)));
 	}
@@ -86519,7 +86056,7 @@ struct BitwiseXOROperator {
 
 void BitwiseXorFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("xor");
-	for (auto &type : LogicalType::INTEGRAL) {
+	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseXOROperator>(type)));
 	}
@@ -86543,7 +86080,7 @@ struct BitwiseShiftLeftOperator {
 
 void LeftShiftFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("<<");
-	for (auto &type : LogicalType::INTEGRAL) {
+	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseShiftLeftOperator>(type)));
 	}
@@ -86562,7 +86099,7 @@ struct BitwiseShiftRightOperator {
 
 void RightShiftFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions(">>");
-	for (auto &type : LogicalType::INTEGRAL) {
+	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(
 		    ScalarFunction({type, type}, type, GetScalarIntegerBinaryFunction<BitwiseShiftRightOperator>(type)));
 	}
@@ -86581,7 +86118,7 @@ struct BitwiseNotOperator {
 
 void BitwiseNotFun::RegisterFunction(BuiltinFunctions &set) {
 	ScalarFunctionSet functions("~");
-	for (auto &type : LogicalType::INTEGRAL) {
+	for (auto &type : LogicalType::Integral()) {
 		functions.AddFunction(ScalarFunction({type}, type, GetScalarIntegerUnaryFunction<BitwiseNotOperator>(type)));
 	}
 	set.AddFunction(functions);
@@ -87685,7 +87222,7 @@ static void ConcatWSFunction(DataChunk &args, ExpressionState &state, Vector &re
 		}
 	}
 	switch (separator.GetVectorType()) {
-	case VectorType::CONSTANT_VECTOR:
+	case VectorType::CONSTANT_VECTOR: {
 		if (ConstantVector::IsNull(separator)) {
 			// constant NULL as separator: return constant NULL vector
 			result.SetVectorType(VectorType::CONSTANT_VECTOR);
@@ -87693,9 +87230,11 @@ static void ConcatWSFunction(DataChunk &args, ExpressionState &state, Vector &re
 			return;
 		}
 		// no null values
-		TemplatedConcatWS(args, (string_t *)vdata.data, *vdata.sel, FlatVector::INCREMENTAL_SELECTION_VECTOR,
-		                  args.size(), result);
+		SelectionVector owned_sel;
+		auto sel = FlatVector::IncrementalSelectionVector(args.size(), owned_sel);
+		TemplatedConcatWS(args, (string_t *)vdata.data, *vdata.sel, *sel, args.size(), result);
 		return;
+	}
 	default: {
 		// default case: loop over nullmask and create a non-null selection vector
 		idx_t not_null_count = 0;
@@ -92135,8 +91674,7 @@ unique_ptr<FunctionData> BindSystemFunction(ClientContext &context, ScalarFuncti
 
 static void CurrentQueryFunction(DataChunk &input, ExpressionState &state, Vector &result) {
 	auto &info = SystemBindData::GetFrom(state);
-
-	Value val(info.context.query);
+	Value val(info.context.GetCurrentQuery());
 	result.Reference(val);
 }
 
@@ -92378,6 +91916,21 @@ void ScalarFunction::NopFunction(DataChunk &input, ExpressionState &state, Vecto
 
 
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/common/thread.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
+#include <thread>
+
+namespace duckdb {
+using std::thread;
+}
 
 #include <map>
 #include <condition_variable>
@@ -92523,7 +92076,7 @@ private:
 	//! Gets Arrow Table's Cardinality
 	static unique_ptr<NodeStatistics> ArrowScanCardinality(ClientContext &context, const FunctionData *bind_data);
 	//! Gets the progress on the table scan, used for Progress Bars
-	static int ArrowProgress(ClientContext &context, const FunctionData *bind_data_p);
+	static double ArrowProgress(ClientContext &context, const FunctionData *bind_data_p);
 };
 
 } // namespace duckdb
@@ -93622,12 +93175,12 @@ unique_ptr<NodeStatistics> ArrowTableFunction::ArrowScanCardinality(ClientContex
 	return make_unique<NodeStatistics>(bind_data.number_of_rows, bind_data.number_of_rows);
 }
 
-int ArrowTableFunction::ArrowProgress(ClientContext &context, const FunctionData *bind_data_p) {
+double ArrowTableFunction::ArrowProgress(ClientContext &context, const FunctionData *bind_data_p) {
 	auto &bind_data = (const ArrowScanFunctionData &)*bind_data_p;
 	if (bind_data.number_of_rows == 0) {
 		return 100;
 	}
-	auto percentage = bind_data.lines_read * 100 / bind_data.number_of_rows;
+	auto percentage = bind_data.lines_read * 100.0 / bind_data.number_of_rows;
 	return percentage;
 }
 
@@ -95312,12 +94865,12 @@ static void ReadCSVAddNamedParameters(TableFunction &table_function) {
 	table_function.named_parameters["skip"] = LogicalType::BIGINT;
 }
 
-int CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p) {
+double CSVReaderProgress(ClientContext &context, const FunctionData *bind_data_p) {
 	auto &bind_data = (ReadCSVData &)*bind_data_p;
 	if (bind_data.file_size == 0) {
 		return 100;
 	}
-	auto percentage = bind_data.bytes_read * 100 / bind_data.file_size;
+	auto percentage = (bind_data.bytes_read * 100.0) / bind_data.file_size;
 	return percentage;
 }
 
@@ -97207,7 +96760,7 @@ static unique_ptr<FunctionData> DuckDBTypesBind(ClientContext &context, vector<V
 unique_ptr<FunctionOperatorData> DuckDBTypesInit(ClientContext &context, const FunctionData *bind_data,
                                                  const vector<column_t> &column_ids, TableFilterCollection *filters) {
 	auto result = make_unique<DuckDBTypesData>();
-	result->types = LogicalType::ALL_TYPES;
+	result->types = LogicalType::AllTypes();
 	// FIXME: add user-defined types here (when we have them)
 	return move(result);
 }
@@ -98531,14 +98084,14 @@ bool TableScanParallelStateNext(ClientContext &context, const FunctionData *bind
 	                                                  state.column_ids);
 }
 
-int TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) {
+double TableScanProgress(ClientContext &context, const FunctionData *bind_data_p) {
 	auto &bind_data = (TableScanBindData &)*bind_data_p;
 	idx_t total_rows = bind_data.table->storage->GetTotalRows();
 	if (total_rows == 0 || total_rows < STANDARD_VECTOR_SIZE) {
 		//! Table is either empty or smaller than a vector size, so it is finished
 		return 100;
 	}
-	auto percentage = (bind_data.chunk_count * STANDARD_VECTOR_SIZE * 100) / total_rows;
+	auto percentage = double(bind_data.chunk_count * STANDARD_VECTOR_SIZE * 100.0) / total_rows;
 	if (percentage > 100) {
 		//! In case the last chunk has less elements than STANDARD_VECTOR_SIZE, if our percentage is over 100
 		//! It means we finished this table.
@@ -98564,7 +98117,7 @@ unique_ptr<NodeStatistics> TableScanCardinality(ClientContext &context, const Fu
 // Index Scan
 //===--------------------------------------------------------------------===//
 struct IndexScanOperatorData : public FunctionOperatorData {
-	explicit IndexScanOperatorData(data_ptr_t row_id_data) : row_ids(LOGICAL_ROW_TYPE, row_id_data) {
+	explicit IndexScanOperatorData(data_ptr_t row_id_data) : row_ids(LogicalType::ROW_TYPE, row_id_data) {
 	}
 
 	Vector row_ids;
@@ -101274,28 +100827,27 @@ private:
 
 namespace duckdb {
 
-class ClientContextLock {
-public:
-	explicit ClientContextLock(mutex &context_lock) : client_guard(context_lock) {
-	}
-
-	~ClientContextLock() {
-	}
-
-private:
-	lock_guard<mutex> client_guard;
+struct ActiveQueryContext {
+	//! The query that is currently being executed
+	string query;
+	//! The currently open result
+	BaseQueryResult *open_result = nullptr;
+	//! Prepared statement data
+	shared_ptr<PreparedStatementData> prepared;
+	//! The query executor
+	unique_ptr<Executor> executor;
+	//! The progress bar
+	unique_ptr<ProgressBar> progress_bar;
 };
 
 ClientContext::ClientContext(shared_ptr<DatabaseInstance> database)
-    : profiler(make_unique<QueryProfiler>()), query_profiler_history(make_unique<QueryProfilerHistory>()),
-      db(move(database)), transaction(db->GetTransactionManager(), *this), interrupted(false), executor(*this),
+    : profiler(make_unique<QueryProfiler>(*this)), query_profiler_history(make_unique<QueryProfilerHistory>()),
+      db(move(database)), transaction(db->GetTransactionManager(), *this), interrupted(false),
       temporary_objects(make_unique<SchemaCatalogEntry>(&db->GetCatalog(), TEMP_SCHEMA, true)),
       catalog_search_path(make_unique<CatalogSearchPath>(*this)),
-      file_opener(make_unique<ClientContextFileOpener>(*this)), open_result(nullptr) {
+      file_opener(make_unique<ClientContextFileOpener>(*this)) {
 	std::random_device rd;
 	random_engine.seed(rd());
-
-	progress_bar = make_unique<ProgressBar>(&executor, config.wait_time);
 }
 
 ClientContext::~ClientContext() {
@@ -101322,87 +100874,162 @@ void ClientContext::Destroy() {
 	CleanupInternal(*lock);
 }
 
-void ClientContext::Cleanup() {
-	auto lock = LockContext();
-	CleanupInternal(*lock);
+unique_ptr<DataChunk> ClientContext::Fetch(ClientContextLock &lock, StreamQueryResult &result) {
+	D_ASSERT(IsActiveResult(lock, &result));
+	D_ASSERT(active_query->executor);
+	return FetchInternal(lock, *active_query->executor, result);
 }
 
-unique_ptr<DataChunk> ClientContext::Fetch() {
-	auto lock = LockContext();
-	if (!open_result) {
-		throw InternalException("Fetch was called, but there is no open result (or the result was previously closed)");
-	}
+unique_ptr<DataChunk> ClientContext::FetchInternal(ClientContextLock &lock, Executor &executor,
+                                                   BaseQueryResult &result) {
+	bool invalidate_query = true;
 	try {
 		// fetch the chunk and return it
-		auto chunk = FetchInternal(*lock);
+		auto chunk = executor.FetchChunk();
+		if (!chunk || chunk->size() == 0) {
+			CleanupInternal(lock, &result);
+		}
 		return chunk;
+	} catch (StandardException &ex) {
+		// standard exceptions do not invalidate the current transaction
+		result.error = ex.what();
+		invalidate_query = false;
 	} catch (std::exception &ex) {
-		open_result->error = ex.what();
+		result.error = ex.what();
 	} catch (...) { // LCOV_EXCL_START
-		open_result->error = "Unhandled exception in Fetch";
+		result.error = "Unhandled exception in FetchInternal";
 	} // LCOV_EXCL_STOP
-	open_result->success = false;
-	CleanupInternal(*lock);
+	result.success = false;
+	CleanupInternal(lock, &result, invalidate_query);
 	return nullptr;
 }
 
-string ClientContext::FinalizeQuery(ClientContextLock &lock, bool success) {
+void ClientContext::BeginTransactionInternal(ClientContextLock &lock, bool requires_valid_transaction) {
+	// check if we are on AutoCommit. In this case we should start a transaction
+	D_ASSERT(!active_query);
+	if (requires_valid_transaction && transaction.HasActiveTransaction() &&
+	    transaction.ActiveTransaction().IsInvalidated()) {
+		throw Exception("Failed: transaction has been invalidated!");
+	}
+	active_query = make_unique<ActiveQueryContext>();
+	if (transaction.IsAutoCommit()) {
+		transaction.BeginTransaction();
+	}
+}
+
+void ClientContext::BeginQueryInternal(ClientContextLock &lock, const string &query) {
+	BeginTransactionInternal(lock, false);
+	LogQueryInternal(lock, query);
+	active_query->query = query;
+	query_progress = -1;
+	ActiveTransaction().active_query = db->GetTransactionManager().GetQueryNumber();
+}
+
+string ClientContext::EndQueryInternal(ClientContextLock &lock, bool success, bool invalidate_transaction) {
 	profiler->EndQuery();
-	executor.Reset();
 
+	D_ASSERT(active_query.get());
 	string error;
-	if (transaction.HasActiveTransaction()) {
-		ActiveTransaction().active_query = MAXIMUM_QUERY_ID;
-		// Move the query profiler into the history
-		auto &prev_profilers = query_profiler_history->GetPrevProfilers();
-		prev_profilers.emplace_back(transaction.ActiveTransaction().active_query, move(profiler));
-		// Reinitialize the query profiler
-		profiler = make_unique<QueryProfiler>();
-		// Propagate settings of the saved query into the new profiler.
-		profiler->Propagate(*prev_profilers.back().second);
-		if (prev_profilers.size() >= query_profiler_history->GetPrevProfilersSize()) {
-			prev_profilers.pop_front();
-		}
-		try {
+	try {
+		if (transaction.HasActiveTransaction()) {
+			// Move the query profiler into the history
+			auto &prev_profilers = query_profiler_history->GetPrevProfilers();
+			prev_profilers.emplace_back(transaction.ActiveTransaction().active_query, move(profiler));
+			// Reinitialize the query profiler
+			profiler = make_unique<QueryProfiler>(*this);
+			// Propagate settings of the saved query into the new profiler.
+			profiler->Propagate(*prev_profilers.back().second);
+			if (prev_profilers.size() >= query_profiler_history->GetPrevProfilersSize()) {
+				prev_profilers.pop_front();
+			}
+
+			ActiveTransaction().active_query = MAXIMUM_QUERY_ID;
 			if (transaction.IsAutoCommit()) {
 				if (success) {
-					// query was successful: commit
 					transaction.Commit();
 				} else {
-					// query was unsuccessful: rollback
 					transaction.Rollback();
 				}
+			} else if (invalidate_transaction) {
+				D_ASSERT(!success);
+				ActiveTransaction().Invalidate();
 			}
-		} catch (std::exception &ex) {
-			error = ex.what();
-		} catch (...) { // LCOV_EXCL_START
-			error = "Unhandled exception!";
-		} // LCOV_EXCL_STOP
-	}
+		}
+	} catch (std::exception &ex) {
+		error = ex.what();
+	} catch (...) { // LCOV_EXCL_START
+		error = "Unhandled exception!";
+	} // LCOV_EXCL_STOP
+	active_query.reset();
+	query_progress = -1;
 	return error;
 }
 
-void ClientContext::CleanupInternal(ClientContextLock &lock) {
-	if (!open_result) {
-		// no result currently open
+void ClientContext::CleanupInternal(ClientContextLock &lock, BaseQueryResult *result, bool invalidate_transaction) {
+	if (!active_query) {
+		// no query currently active
 		return;
 	}
+	if (active_query->executor) {
+		active_query->executor->CancelTasks();
+	}
+	active_query->progress_bar.reset();
 
-	auto error = FinalizeQuery(lock, open_result->success);
-	if (open_result->success) {
+	auto error = EndQueryInternal(lock, result ? result->success : false, invalidate_transaction);
+	if (result && result->success) {
 		// if an error occurred while committing report it in the result
-		open_result->error = error;
-		open_result->success = error.empty();
+		result->error = error;
+		result->success = error.empty();
 	}
+	D_ASSERT(!active_query);
+}
 
-	open_result->is_open = false;
-	open_result = nullptr;
+Executor &ClientContext::GetExecutor() {
+	D_ASSERT(active_query);
+	D_ASSERT(active_query->executor);
+	return *active_query->executor;
+}
 
-	this->query = string();
+const string &ClientContext::GetCurrentQuery() {
+	D_ASSERT(active_query);
+	return active_query->query;
 }
 
-unique_ptr<DataChunk> ClientContext::FetchInternal(ClientContextLock &) {
-	return executor.FetchChunk();
+unique_ptr<QueryResult> ClientContext::FetchResultInternal(ClientContextLock &lock, PendingQueryResult &pending,
+                                                           bool allow_stream_result) {
+	D_ASSERT(active_query);
+	D_ASSERT(active_query->open_result == &pending);
+	D_ASSERT(active_query->prepared);
+	auto &prepared = *active_query->prepared;
+	bool create_stream_result = prepared.allow_stream_result && allow_stream_result;
+	if (create_stream_result) {
+		active_query->progress_bar.reset();
+		query_progress = -1;
+
+		// successfully compiled SELECT clause and it is the last statement
+		// return a StreamQueryResult so the client can call Fetch() on it and stream the result
+		auto stream_result =
+		    make_unique<StreamQueryResult>(pending.statement_type, shared_from_this(), pending.types, pending.names);
+		active_query->open_result = stream_result.get();
+		return move(stream_result);
+	}
+	// create a materialized result by continuously fetching
+	auto result = make_unique<MaterializedQueryResult>(pending.statement_type, pending.types, pending.names);
+	while (true) {
+		auto chunk = FetchInternal(lock, GetExecutor(), *result);
+		if (!chunk || chunk->size() == 0) {
+			break;
+		}
+#ifdef DEBUG
+		for (idx_t i = 0; i < chunk->ColumnCount(); i++) {
+			if (pending.types[i].id() == LogicalTypeId::VARCHAR) {
+				chunk->data[i].UTFVerify(chunk->size());
+			}
+		}
+#endif
+		result->collection.Append(*chunk);
+	}
+	return move(result);
 }
 
 shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientContextLock &lock, const string &query,
@@ -101410,11 +101037,12 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 	StatementType statement_type = statement->type;
 	auto result = make_shared<PreparedStatementData>(statement_type);
 
-	profiler->StartPhase("planner");
+	auto &profiler = QueryProfiler::Get(*this);
+	profiler.StartPhase("planner");
 	Planner planner(*this);
 	planner.CreatePlan(move(statement));
 	D_ASSERT(planner.plan);
-	profiler->EndPhase();
+	profiler.EndPhase();
 
 	auto plan = move(planner.plan);
 #ifdef DEBUG
@@ -101430,22 +101058,22 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 	result->catalog_version = Transaction::GetTransaction(*this).catalog_version;
 
 	if (config.enable_optimizer) {
-		profiler->StartPhase("optimizer");
+		profiler.StartPhase("optimizer");
 		Optimizer optimizer(*planner.binder, *this);
 		plan = optimizer.Optimize(move(plan));
 		D_ASSERT(plan);
-		profiler->EndPhase();
+		profiler.EndPhase();
 
 #ifdef DEBUG
 		plan->Verify();
 #endif
 	}
 
-	profiler->StartPhase("physical_planner");
+	profiler.StartPhase("physical_planner");
 	// now convert logical query plan into a physical query plan
 	PhysicalPlanGenerator physical_planner(*this);
 	auto physical_plan = physical_planner.CreatePlan(move(plan));
-	profiler->EndPhase();
+	profiler.EndPhase();
 
 #ifdef DEBUG
 	D_ASSERT(!physical_plan->ToString().empty());
@@ -101454,14 +101082,14 @@ shared_ptr<PreparedStatementData> ClientContext::CreatePreparedStatement(ClientC
 	return result;
 }
 
-int ClientContext::GetProgress() {
-	D_ASSERT(progress_bar);
-	return progress_bar->GetCurrentPercentage();
+double ClientContext::GetProgress() {
+	return query_progress.load();
 }
 
-unique_ptr<QueryResult> ClientContext::ExecutePreparedStatement(ClientContextLock &lock, const string &query,
-                                                                shared_ptr<PreparedStatementData> statement_p,
-                                                                vector<Value> bound_values, bool allow_stream_result) {
+unique_ptr<PendingQueryResult> ClientContext::PendingPreparedStatement(ClientContextLock &lock,
+                                                                       shared_ptr<PreparedStatementData> statement_p,
+                                                                       vector<Value> bound_values) {
+	D_ASSERT(active_query);
 	auto &statement = *statement_p;
 	if (ActiveTransaction().IsInvalidated() && statement.requires_valid_transaction) {
 		throw Exception("Current transaction is aborted (please ROLLBACK)");
@@ -101475,47 +101103,42 @@ unique_ptr<QueryResult> ClientContext::ExecutePreparedStatement(ClientContextLoc
 	// bind the bound values before execution
 	statement.Bind(move(bound_values));
 
-	bool create_stream_result = statement.allow_stream_result && allow_stream_result;
+	active_query->executor = make_unique<Executor>(*this);
+	auto &executor = *active_query->executor;
 	if (config.enable_progress_bar) {
-		progress_bar->Initialize(config.wait_time);
-		progress_bar->Start();
+		active_query->progress_bar = make_unique<ProgressBar>(executor, config.wait_time);
+		active_query->progress_bar->Start();
+		query_progress = 0;
 	}
-	// store the physical plan in the context for calls to Fetch()
 	executor.Initialize(statement.plan.get());
-
 	auto types = executor.GetTypes();
-
 	D_ASSERT(types == statement.types);
+	D_ASSERT(!active_query->open_result);
 
-	if (create_stream_result) {
-		if (config.enable_progress_bar) {
-			progress_bar->Stop();
-		}
-		// successfully compiled SELECT clause and it is the last statement
-		// return a StreamQueryResult so the client can call Fetch() on it and stream the result
-		return make_unique<StreamQueryResult>(statement.statement_type, shared_from_this(), statement.types,
-		                                      statement.names, move(statement_p));
-	}
-	// create a materialized result by continuously fetching
-	auto result = make_unique<MaterializedQueryResult>(statement.statement_type, statement.types, statement.names);
-	while (true) {
-		auto chunk = FetchInternal(lock);
-		if (chunk->size() == 0) {
-			break;
-		}
-#ifdef DEBUG
-		for (idx_t i = 0; i < chunk->ColumnCount(); i++) {
-			if (statement.types[i].id() == LogicalTypeId::VARCHAR) {
-				chunk->data[i].UTFVerify(chunk->size());
-			}
+	auto pending_result = make_unique<PendingQueryResult>(shared_from_this(), *statement_p, move(types));
+	active_query->prepared = move(statement_p);
+	active_query->open_result = pending_result.get();
+	return pending_result;
+}
+
+PendingExecutionResult ClientContext::ExecuteTaskInternal(ClientContextLock &lock, PendingQueryResult &result) {
+	D_ASSERT(active_query);
+	D_ASSERT(active_query->open_result == &result);
+	try {
+		auto result = active_query->executor->ExecuteTask();
+		if (active_query->progress_bar) {
+			active_query->progress_bar->Update(result == PendingExecutionResult::RESULT_READY);
+			query_progress = active_query->progress_bar->GetCurrentPercentage();
 		}
-#endif
-		result->collection.Append(*chunk);
-	}
-	if (config.enable_progress_bar) {
-		progress_bar->Stop();
-	}
-	return move(result);
+		return result;
+	} catch (std::exception &ex) {
+		result.error = ex.what();
+	} catch (...) { // LCOV_EXCL_START
+		result.error = "Unhandled exception in ExecuteTaskInternal";
+	} // LCOV_EXCL_STOP
+	EndQueryInternal(lock, false, true);
+	result.success = false;
+	return PendingExecutionResult::EXECUTION_ERROR;
 }
 
 void ClientContext::InitialCleanup(ClientContextLock &lock) {
@@ -101618,27 +101241,58 @@ unique_ptr<PreparedStatement> ClientContext::Prepare(const string &query) {
 	}
 }
 
+unique_ptr<PendingQueryResult> ClientContext::PendingQueryPreparedInternal(ClientContextLock &lock, const string &query,
+                                                                           shared_ptr<PreparedStatementData> &prepared,
+                                                                           vector<Value> &values) {
+	try {
+		InitialCleanup(lock);
+	} catch (std::exception &ex) {
+		return make_unique<PendingQueryResult>(ex.what());
+	}
+	return PendingStatementOrPreparedStatementInternal(lock, query, nullptr, prepared, &values);
+}
+
+unique_ptr<PendingQueryResult>
+ClientContext::PendingQuery(const string &query, shared_ptr<PreparedStatementData> &prepared, vector<Value> &values) {
+	auto lock = LockContext();
+	return PendingQueryPreparedInternal(*lock, query, prepared, values);
+}
+
 unique_ptr<QueryResult> ClientContext::Execute(const string &query, shared_ptr<PreparedStatementData> &prepared,
                                                vector<Value> &values, bool allow_stream_result) {
 	auto lock = LockContext();
-	try {
-		InitialCleanup(*lock);
-	} catch (std::exception &ex) {
-		return make_unique<MaterializedQueryResult>(ex.what());
+	auto pending = PendingQueryPreparedInternal(*lock, query, prepared, values);
+	if (!pending->success) {
+		return make_unique<MaterializedQueryResult>(pending->error);
 	}
-	LogQueryInternal(*lock, query);
-	return RunStatementOrPreparedStatement(*lock, query, nullptr, prepared, &values, allow_stream_result);
+	return pending->ExecuteInternal(*lock, allow_stream_result);
 }
 
-unique_ptr<QueryResult> ClientContext::RunStatementInternal(ClientContextLock &lock, const string &query,
-                                                            unique_ptr<SQLStatement> statement,
-                                                            bool allow_stream_result) {
+unique_ptr<PendingQueryResult> ClientContext::PendingStatementInternal(ClientContextLock &lock, const string &query,
+                                                                       unique_ptr<SQLStatement> statement) {
 	// prepare the query for execution
 	auto prepared = CreatePreparedStatement(lock, query, move(statement));
 	// by default, no values are bound
 	vector<Value> bound_values;
 	// execute the prepared statement
-	return ExecutePreparedStatement(lock, query, move(prepared), move(bound_values), allow_stream_result);
+	return PendingPreparedStatement(lock, move(prepared), move(bound_values));
+}
+
+unique_ptr<QueryResult> ClientContext::RunStatementInternal(ClientContextLock &lock, const string &query,
+                                                            unique_ptr<SQLStatement> statement,
+                                                            bool allow_stream_result, bool verify) {
+	auto pending = PendingQueryInternal(lock, move(statement), verify);
+	if (!pending->success) {
+		return make_unique<MaterializedQueryResult>(move(pending->error));
+	}
+	return ExecutePendingQueryInternal(lock, *pending, allow_stream_result);
+}
+
+bool ClientContext::IsActiveResult(ClientContextLock &lock, BaseQueryResult *result) {
+	if (!active_query) {
+		return false;
+	}
+	return active_query->open_result == result;
 }
 
 static bool IsExplainAnalyze(SQLStatement *statement) {
@@ -101652,19 +101306,10 @@ static bool IsExplainAnalyze(SQLStatement *statement) {
 	return explain.explain_type == ExplainType::EXPLAIN_ANALYZE;
 }
 
-unique_ptr<QueryResult> ClientContext::RunStatementOrPreparedStatement(ClientContextLock &lock, const string &query,
-                                                                       unique_ptr<SQLStatement> statement,
-                                                                       shared_ptr<PreparedStatementData> &prepared,
-                                                                       vector<Value> *values,
-                                                                       bool allow_stream_result) {
-	this->query = query;
-
-	unique_ptr<QueryResult> result;
+unique_ptr<PendingQueryResult> ClientContext::PendingStatementOrPreparedStatementInternal(
+    ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement,
+    shared_ptr<PreparedStatementData> &prepared, vector<Value> *values) {
 	// check if we are on AutoCommit. In this case we should start a transaction.
-	if (transaction.IsAutoCommit()) {
-		transaction.BeginTransaction();
-	}
-	ActiveTransaction().active_query = db->GetTransactionManager().GetQueryNumber();
 	if (statement && config.query_verification_enabled) {
 		// query verification is enabled
 		// create a copy of the statement, and use the copy
@@ -101674,19 +101319,29 @@ unique_ptr<QueryResult> ClientContext::RunStatementOrPreparedStatement(ClientCon
 			// in case this is a select query, we verify the original statement
 			string error = VerifyQuery(lock, query, move(statement));
 			if (!error.empty()) {
-				// query failed: abort now
-				FinalizeQuery(lock, false);
 				// error in verifying query
-				return make_unique<MaterializedQueryResult>(error);
+				return make_unique<PendingQueryResult>(error);
 			}
 		}
 		statement = move(copied_statement);
 	}
+	return PendingStatementOrPreparedStatement(lock, query, move(statement), prepared, values);
+}
+
+unique_ptr<PendingQueryResult>
+ClientContext::PendingStatementOrPreparedStatement(ClientContextLock &lock, const string &query,
+                                                   unique_ptr<SQLStatement> statement,
+                                                   shared_ptr<PreparedStatementData> &prepared, vector<Value> *values) {
+	unique_ptr<PendingQueryResult> result;
+
+	BeginQueryInternal(lock, query);
 	// start the profiler
-	profiler->StartQuery(query, IsExplainAnalyze(statement ? statement.get() : prepared->unbound_statement.get()));
+	auto &profiler = QueryProfiler::Get(*this);
+	profiler.StartQuery(query, IsExplainAnalyze(statement ? statement.get() : prepared->unbound_statement.get()));
+	bool invalidate_query = true;
 	try {
 		if (statement) {
-			result = RunStatementInternal(lock, query, move(statement), allow_stream_result);
+			result = PendingStatementInternal(lock, query, move(statement));
 		} else {
 			auto &catalog = Catalog::GetCatalog(*this);
 			if (prepared->unbound_statement && catalog.GetCatalogVersion() != prepared->catalog_version) {
@@ -101699,68 +101354,22 @@ unique_ptr<QueryResult> ClientContext::RunStatementOrPreparedStatement(ClientCon
 				new_prepared->unbound_statement = move(prepared->unbound_statement);
 				prepared = move(new_prepared);
 			}
-			result = ExecutePreparedStatement(lock, query, prepared, *values, allow_stream_result);
+			result = PendingPreparedStatement(lock, prepared, *values);
 		}
 	} catch (StandardException &ex) {
 		// standard exceptions do not invalidate the current transaction
-		result = make_unique<MaterializedQueryResult>(ex.what());
+		result = make_unique<PendingQueryResult>(ex.what());
+		invalidate_query = false;
 	} catch (std::exception &ex) {
 		// other types of exceptions do invalidate the current transaction
-		if (transaction.HasActiveTransaction()) {
-			ActiveTransaction().Invalidate();
-		}
-		result = make_unique<MaterializedQueryResult>(ex.what());
+		result = make_unique<PendingQueryResult>(ex.what());
 	}
 	if (!result->success) {
-		// initial failures should always be reported as MaterializedResult
-		D_ASSERT(result->type != QueryResultType::STREAM_RESULT);
 		// query failed: abort now
-		FinalizeQuery(lock, false);
+		EndQueryInternal(lock, false, invalidate_query);
 		return result;
 	}
-	// query succeeded, append to list of results
-	if (result->type == QueryResultType::STREAM_RESULT) {
-		// store as currently open result if it is a stream result
-		this->open_result = (StreamQueryResult *)result.get();
-	} else {
-		// finalize the query if it is not a stream result
-		string error = FinalizeQuery(lock, true);
-		if (!error.empty()) {
-			// failure in committing transaction
-			return make_unique<MaterializedQueryResult>(error);
-		}
-	}
-	return result;
-}
-
-unique_ptr<QueryResult> ClientContext::RunStatement(ClientContextLock &lock, const string &query,
-                                                    unique_ptr<SQLStatement> statement, bool allow_stream_result) {
-	shared_ptr<PreparedStatementData> prepared;
-	return RunStatementOrPreparedStatement(lock, query, move(statement), prepared, nullptr, allow_stream_result);
-}
-
-unique_ptr<QueryResult> ClientContext::RunStatements(ClientContextLock &lock, const string &query,
-                                                     vector<unique_ptr<SQLStatement>> &statements,
-                                                     bool allow_stream_result) {
-	// now we have a list of statements
-	// iterate over them and execute them one by one
-	unique_ptr<QueryResult> result;
-	QueryResult *last_result = nullptr;
-	for (idx_t i = 0; i < statements.size(); i++) {
-		auto &statement = statements[i];
-		bool is_last_statement = i + 1 == statements.size();
-		auto current_result = RunStatement(lock, query, move(statement), allow_stream_result && is_last_statement);
-		// now append the result to the list of results
-		if (!last_result) {
-			// first result of the query
-			result = move(current_result);
-			last_result = result.get();
-		} else {
-			// later results; attach to the result chain
-			last_result->next = move(current_result);
-			last_result = last_result->next.get();
-		}
-	}
+	D_ASSERT(active_query->open_result == result.get());
 	return result;
 }
 
@@ -101786,34 +101395,96 @@ void ClientContext::LogQueryInternal(ClientContextLock &, const string &query) {
 }
 
 unique_ptr<QueryResult> ClientContext::Query(unique_ptr<SQLStatement> statement, bool allow_stream_result) {
-	auto lock = LockContext();
-	LogQueryInternal(*lock, statement->query.substr(statement->stmt_location, statement->stmt_length));
-
-	vector<unique_ptr<SQLStatement>> statements;
-	statements.push_back(move(statement));
-
-	return RunStatements(*lock, query, statements, allow_stream_result);
+	auto pending_query = PendingQuery(move(statement));
+	return pending_query->Execute(allow_stream_result);
 }
 
 unique_ptr<QueryResult> ClientContext::Query(const string &query, bool allow_stream_result) {
 	auto lock = LockContext();
-	LogQueryInternal(*lock, query);
 
+	string error;
 	vector<unique_ptr<SQLStatement>> statements;
+	if (!ParseStatements(*lock, query, statements, error)) {
+		return make_unique<MaterializedQueryResult>(move(error));
+	}
+	if (statements.empty()) {
+		// no statements, return empty successful result
+		return make_unique<MaterializedQueryResult>(StatementType::INVALID_STATEMENT);
+	}
+
+	unique_ptr<QueryResult> result;
+	QueryResult *last_result = nullptr;
+	for (idx_t i = 0; i < statements.size(); i++) {
+		auto &statement = statements[i];
+		bool is_last_statement = i + 1 == statements.size();
+		bool stream_result = allow_stream_result && is_last_statement;
+		auto pending_query = PendingQueryInternal(*lock, move(statement));
+		unique_ptr<QueryResult> current_result;
+		if (!pending_query->success) {
+			current_result = make_unique<MaterializedQueryResult>(pending_query->error);
+		} else {
+			current_result = ExecutePendingQueryInternal(*lock, *pending_query, stream_result);
+		}
+		// now append the result to the list of results
+		if (!last_result) {
+			// first result of the query
+			result = move(current_result);
+			last_result = result.get();
+		} else {
+			// later results; attach to the result chain
+			last_result->next = move(current_result);
+			last_result = last_result->next.get();
+		}
+	}
+	return result;
+}
+
+bool ClientContext::ParseStatements(ClientContextLock &lock, const string &query,
+                                    vector<unique_ptr<SQLStatement>> &result, string &error) {
 	try {
-		InitialCleanup(*lock);
+		InitialCleanup(lock);
 		// parse the query and transform it into a set of statements
-		statements = ParseStatementsInternal(*lock, query);
+		result = ParseStatementsInternal(lock, query);
+		return true;
 	} catch (std::exception &ex) {
-		return make_unique<MaterializedQueryResult>(ex.what());
+		error = ex.what();
+		return false;
 	}
+}
 
-	if (statements.empty()) {
-		// no statements, return empty successful result
-		return make_unique<MaterializedQueryResult>(StatementType::INVALID_STATEMENT);
+unique_ptr<PendingQueryResult> ClientContext::PendingQuery(const string &query) {
+	auto lock = LockContext();
+
+	string error;
+	vector<unique_ptr<SQLStatement>> statements;
+	if (!ParseStatements(*lock, query, statements, error)) {
+		return make_unique<PendingQueryResult>(move(error));
+	}
+	if (statements.size() != 1) {
+		return make_unique<PendingQueryResult>("PendingQuery can only take a single statement");
 	}
+	return PendingQueryInternal(*lock, move(statements[0]));
+}
 
-	return RunStatements(*lock, query, statements, allow_stream_result);
+unique_ptr<PendingQueryResult> ClientContext::PendingQuery(unique_ptr<SQLStatement> statement) {
+	auto lock = LockContext();
+	return PendingQueryInternal(*lock, move(statement));
+}
+
+unique_ptr<PendingQueryResult> ClientContext::PendingQueryInternal(ClientContextLock &lock,
+                                                                   unique_ptr<SQLStatement> statement, bool verify) {
+	auto query = statement->query;
+	shared_ptr<PreparedStatementData> prepared;
+	if (verify) {
+		return PendingStatementOrPreparedStatementInternal(lock, query, move(statement), prepared, nullptr);
+	} else {
+		return PendingStatementOrPreparedStatement(lock, query, move(statement), prepared, nullptr);
+	}
+}
+
+unique_ptr<QueryResult> ClientContext::ExecutePendingQueryInternal(ClientContextLock &lock, PendingQueryResult &query,
+                                                                   bool allow_stream_result) {
+	return query.ExecuteInternal(lock, allow_stream_result);
 }
 
 void ClientContext::Interrupt() {
@@ -101822,12 +101493,14 @@ void ClientContext::Interrupt() {
 
 void ClientContext::EnableProfiling() {
 	auto lock = LockContext();
-	profiler->Enable();
+	auto &config = ClientConfig::GetConfig(*this);
+	config.enable_profiler = true;
 }
 
 void ClientContext::DisableProfiling() {
 	auto lock = LockContext();
-	profiler->Disable();
+	auto &config = ClientConfig::GetConfig(*this);
+	config.enable_profiler = false;
 }
 
 string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query, unique_ptr<SQLStatement> statement) {
@@ -101889,9 +101562,10 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 #endif
 
 	// disable profiling if it is enabled
-	bool profiling_is_enabled = profiler->IsEnabled();
+	auto &config = ClientConfig::GetConfig(*this);
+	bool profiling_is_enabled = config.enable_profiler;
 	if (profiling_is_enabled) {
-		profiler->Disable();
+		config.enable_profiler = false;
 	}
 
 	// see below
@@ -101908,7 +101582,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 
 	// execute the original statement
 	try {
-		auto result = RunStatementInternal(lock, query, move(statement), false);
+		auto result = RunStatementInternal(lock, query, move(statement), false, false);
 		original_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
 	} catch (std::exception &ex) {
 		original_result->error = ex.what();
@@ -101921,7 +101595,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 		auto explain_q = "EXPLAIN " + query;
 		auto explain_stmt = make_unique<ExplainStatement>(move(statement_copy_for_explain));
 		try {
-			RunStatementInternal(lock, explain_q, move(explain_stmt), false);
+			RunStatementInternal(lock, explain_q, move(explain_stmt), false, false);
 		} catch (std::exception &ex) { // LCOV_EXCL_START
 			return "EXPLAIN failed but query did not (" + string(ex.what()) + ")";
 		} // LCOV_EXCL_STOP
@@ -101929,7 +101603,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 
 	// now execute the copied statement
 	try {
-		auto result = RunStatementInternal(lock, query, move(copied_stmt), false);
+		auto result = RunStatementInternal(lock, query, move(copied_stmt), false, false);
 		copied_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
 	} catch (std::exception &ex) {
 		copied_result->error = ex.what();
@@ -101938,7 +101612,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	}
 	// now execute the deserialized statement
 	try {
-		auto result = RunStatementInternal(lock, query, move(deserialized_stmt), false);
+		auto result = RunStatementInternal(lock, query, move(deserialized_stmt), false, false);
 		deserialized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
 	} catch (std::exception &ex) {
 		deserialized_result->error = ex.what();
@@ -101948,7 +101622,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	// now execute the unoptimized statement
 	config.enable_optimizer = false;
 	try {
-		auto result = RunStatementInternal(lock, query, move(unoptimized_stmt), false);
+		auto result = RunStatementInternal(lock, query, move(unoptimized_stmt), false, false);
 		unoptimized_result = unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
 	} catch (std::exception &ex) {
 		unoptimized_result->error = ex.what();
@@ -101958,7 +101632,7 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	config.enable_optimizer = true;
 
 	if (profiling_is_enabled) {
-		profiler->Enable();
+		config.enable_profiler = true;
 	}
 
 	// now compare the results
@@ -102012,7 +101686,7 @@ bool ClientContext::UpdateFunctionInfoFromEntry(ScalarFunctionCatalogEntry *exis
 void ClientContext::RegisterFunction(CreateFunctionInfo *info) {
 	RunFunctionInTransaction([&]() {
 		auto &catalog = Catalog::GetCatalog(*this);
-		ScalarFunctionCatalogEntry *existing_function = (ScalarFunctionCatalogEntry *)catalog.GetEntry(
+		auto existing_function = (ScalarFunctionCatalogEntry *)catalog.GetEntry(
 		    *this, CatalogType::SCALAR_FUNCTION_ENTRY, info->schema, info->name, true);
 		if (existing_function) {
 			if (UpdateFunctionInfoFromEntry(existing_function, (CreateScalarFunctionInfo *)info)) {
@@ -102034,6 +101708,7 @@ void ClientContext::RunFunctionInTransactionInternal(ClientContextLock &lock, co
 	// check if we are on AutoCommit. In this case we should start a transaction
 	bool require_new_transaction = transaction.IsAutoCommit() && !transaction.HasActiveTransaction();
 	if (require_new_transaction) {
+		D_ASSERT(!active_query);
 		transaction.BeginTransaction();
 	}
 	try {
@@ -102148,12 +101823,14 @@ unique_ptr<QueryResult> ClientContext::Execute(const shared_ptr<Relation> &relat
 			// verify read only statements by running a select statement
 			auto select = make_unique<SelectStatement>();
 			select->node = relation->GetQueryNode();
-			RunStatement(*lock, query, move(select), false);
+			RunStatementInternal(*lock, query, move(select), false);
 		}
 	}
 	auto &expected_columns = relation->Columns();
 	auto relation_stmt = make_unique<RelationStatement>(relation);
-	auto result = RunStatement(*lock, query, move(relation_stmt), false);
+
+	unique_ptr<QueryResult> result;
+	result = RunStatementInternal(*lock, query, move(relation_stmt), false);
 	if (!result->success) {
 		return result;
 	}
@@ -102925,10 +102602,11 @@ Connection::Connection(DuckDB &database) : Connection(*database.instance) {
 }
 
 string Connection::GetProfilingInformation(ProfilerPrintFormat format) {
+	auto &profiler = QueryProfiler::Get(*context);
 	if (format == ProfilerPrintFormat::JSON) {
-		return context->profiler->ToJSON();
+		return profiler.ToJSON();
 	} else {
-		return context->profiler->ToString();
+		return profiler.ToString();
 	}
 }
 
@@ -102972,6 +102650,14 @@ unique_ptr<MaterializedQueryResult> Connection::Query(unique_ptr<SQLStatement> s
 	return unique_ptr_cast<QueryResult, MaterializedQueryResult>(move(result));
 }
 
+unique_ptr<PendingQueryResult> Connection::PendingQuery(const string &query) {
+	return context->PendingQuery(query);
+}
+
+unique_ptr<PendingQueryResult> Connection::PendingQuery(unique_ptr<SQLStatement> statement) {
+	return context->PendingQuery(move(statement));
+}
+
 unique_ptr<PreparedStatement> Connection::Prepare(const string &query) {
 	return context->Prepare(query);
 }
@@ -103443,6 +103129,7 @@ void DuckDB::SetExtensionLoaded(const std::string &name) {
 
 
 
+
 #ifdef BUILD_ICU_EXTENSION
 #include "icu-extension.hpp"
 #endif
@@ -103476,7 +103163,7 @@ namespace duckdb {
 void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
 	unordered_set<string> extensions {"parquet", "icu", "tpch", "tpcds", "fts", "httpfs", "visualizer"};
 	for (auto &ext : extensions) {
-		LoadExtension(db, ext);
+		LoadExtensionInternal(db, ext, true);
 	}
 }
 
@@ -103484,6 +103171,27 @@ void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
 // Load Statically Compiled Extension
 //===--------------------------------------------------------------------===//
 ExtensionLoadResult ExtensionHelper::LoadExtension(DuckDB &db, const std::string &extension) {
+	return LoadExtensionInternal(db, extension, false);
+}
+
+ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std::string &extension,
+                                                           bool initial_load) {
+#ifdef DUCKDB_TEST_REMOTE_INSTALL
+	if (!initial_load && StringUtil::Contains(DUCKDB_TEST_REMOTE_INSTALL, extension)) {
+		Connection con(db);
+		auto result = con.Query("INSTALL " + extension);
+		if (!result->success) {
+			result->Print();
+			return ExtensionLoadResult::EXTENSION_UNKNOWN;
+		}
+		result = con.Query("LOAD " + extension);
+		if (!result->success) {
+			result->Print();
+			return ExtensionLoadResult::EXTENSION_UNKNOWN;
+		}
+		return ExtensionLoadResult::LOADED_EXTENSION;
+	}
+#endif
 	if (extension == "parquet") {
 #ifdef BUILD_PARQUET_EXTENSION
 		db.LoadExtension<ParquetExtension>();
@@ -103795,6 +103503,11 @@ inline const unsigned char *ASN1_STRING_get0_data(const ASN1_STRING *asn1) {
 #include <brotli/encode.h>
 #endif
 
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
 /*
  * Declaration
  */
@@ -110971,6 +110684,10 @@ inline SSL_CTX *Client::ssl_context() const {
 
 } // namespace CPPHTTPLIB_NAMESPACE
 
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
 #endif // CPPHTTPLIB_HTTPLIB_H
 
 
@@ -110982,12 +110699,13 @@ inline SSL_CTX *Client::ssl_context() const {
 
 namespace duckdb {
 
-const vector<string> ExtensionHelper::PATH_COMPONENTS = {".duckdb", "extensions", DuckDB::SourceID(),
-                                                         DuckDB::Platform()};
-
 //===--------------------------------------------------------------------===//
 // Install Extension
 //===--------------------------------------------------------------------===//
+const vector<string> ExtensionHelper::PathComponents() {
+	return vector<string> {".duckdb", "extensions", DuckDB::SourceID(), DuckDB::Platform()};
+}
+
 void ExtensionHelper::InstallExtension(DatabaseInstance &db, const string &extension, bool force_install) {
 	auto &config = DBConfig::GetConfig(db);
 	if (!config.enable_external_access) {
@@ -110999,7 +110717,8 @@ void ExtensionHelper::InstallExtension(DatabaseInstance &db, const string &exten
 	if (!fs.DirectoryExists(local_path)) {
 		throw InternalException("Can't find the home directory at " + local_path);
 	}
-	for (auto &path_ele : PATH_COMPONENTS) {
+	auto path_components = PathComponents();
+	for (auto &path_ele : path_components) {
 		local_path = fs.JoinPath(local_path, path_ele);
 		if (!fs.DirectoryExists(local_path)) {
 			fs.CreateDirectory(local_path);
@@ -111138,7 +110857,8 @@ void ExtensionHelper::LoadExternalExtension(DatabaseInstance &db, const string &
 	// shorthand case
 	if (!StringUtil::Contains(extension, ".") && !StringUtil::Contains(extension, fs.PathSeparator())) {
 		string local_path = fs.GetHomeDirectory();
-		for (auto &path_ele : PATH_COMPONENTS) {
+		auto path_components = PathComponents();
+		for (auto &path_ele : path_components) {
 			local_path = fs.JoinPath(local_path, path_ele);
 		}
 		filename = fs.JoinPath(local_path, extension + ".duckdb_extension");
@@ -111246,6 +110966,75 @@ unique_ptr<DataChunk> MaterializedQueryResult::FetchRaw() {
 
 
 
+namespace duckdb {
+
+PendingQueryResult::PendingQueryResult(shared_ptr<ClientContext> context_p, PreparedStatementData &statement,
+                                       vector<LogicalType> types_p)
+    : BaseQueryResult(QueryResultType::PENDING_RESULT, statement.statement_type, move(types_p), statement.names),
+      context(move(context_p)) {
+}
+
+PendingQueryResult::PendingQueryResult(string error) : BaseQueryResult(QueryResultType::PENDING_RESULT, move(error)) {
+}
+
+PendingQueryResult::~PendingQueryResult() {
+}
+
+unique_ptr<ClientContextLock> PendingQueryResult::LockContext() {
+	if (!context) {
+		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result\nError: %s",
+		                            error);
+	}
+	return context->LockContext();
+}
+
+void PendingQueryResult::CheckExecutableInternal(ClientContextLock &lock) {
+	bool invalidated = !success || !context;
+	if (!invalidated) {
+		invalidated = !context->IsActiveResult(lock, this);
+	}
+	if (invalidated) {
+		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result\nError: %s",
+		                            error);
+	}
+}
+
+PendingExecutionResult PendingQueryResult::ExecuteTask() {
+	auto lock = LockContext();
+	return ExecuteTaskInternal(*lock);
+}
+
+PendingExecutionResult PendingQueryResult::ExecuteTaskInternal(ClientContextLock &lock) {
+	CheckExecutableInternal(lock);
+	return context->ExecuteTaskInternal(lock, *this);
+}
+
+unique_ptr<QueryResult> PendingQueryResult::ExecuteInternal(ClientContextLock &lock, bool allow_streaming_result) {
+	CheckExecutableInternal(lock);
+	while (ExecuteTaskInternal(lock) == PendingExecutionResult::RESULT_NOT_READY) {
+	}
+	if (!success) {
+		return make_unique<MaterializedQueryResult>(error);
+	}
+	auto result = context->FetchResultInternal(lock, *this, allow_streaming_result);
+	Close();
+	return result;
+}
+
+unique_ptr<QueryResult> PendingQueryResult::Execute(bool allow_streaming_result) {
+	auto lock = LockContext();
+	return ExecuteInternal(*lock, allow_streaming_result);
+}
+
+void PendingQueryResult::Close() {
+	context.reset();
+}
+
+} // namespace duckdb
+
+
+
+
 
 namespace duckdb {
 
@@ -111282,11 +111071,19 @@ const vector<string> &PreparedStatement::GetNames() {
 }
 
 unique_ptr<QueryResult> PreparedStatement::Execute(vector<Value> &values, bool allow_stream_result) {
+	auto pending = PendingQuery(values);
+	if (!pending->success) {
+		return make_unique<MaterializedQueryResult>(pending->error);
+	}
+	return pending->Execute(allow_stream_result && data->allow_stream_result);
+}
+
+unique_ptr<PendingQueryResult> PreparedStatement::PendingQuery(vector<Value> &values) {
 	if (!success) {
 		throw InvalidInputException("Attempting to execute an unsuccessfully prepared statement!");
 	}
 	D_ASSERT(data);
-	auto result = context->Execute(query, data, values, allow_stream_result && data->allow_stream_result);
+	auto result = context->PendingQuery(query, data, values);
 	return result;
 }
 
@@ -111372,16 +111169,42 @@ using std::ofstream;
 
 
 
+
+
 #include <utility>
 #include <algorithm>
 
 namespace duckdb {
 
+QueryProfiler::QueryProfiler(ClientContext &context_p)
+    : context(context_p), running(false), query_requires_profiling(false), is_explain_analyze(false) {
+}
+
+bool QueryProfiler::IsEnabled() const {
+	return is_explain_analyze ? true : ClientConfig::GetConfig(context).enable_profiler;
+}
+
+bool QueryProfiler::IsDetailedEnabled() const {
+	return is_explain_analyze ? false : ClientConfig::GetConfig(context).enable_detailed_profiling;
+}
+
+ProfilerPrintFormat QueryProfiler::GetPrintFormat() const {
+	return is_explain_analyze ? ProfilerPrintFormat::NONE : ClientConfig::GetConfig(context).profiler_print_format;
+}
+
+string QueryProfiler::GetSaveLocation() const {
+	return is_explain_analyze ? string() : ClientConfig::GetConfig(context).profiler_save_location;
+}
+
+QueryProfiler &QueryProfiler::Get(ClientContext &context) {
+	return *context.profiler;
+}
+
 void QueryProfiler::StartQuery(string query, bool is_explain_analyze) {
 	if (is_explain_analyze) {
 		StartExplainAnalyze();
 	}
-	if (!enabled) {
+	if (!IsEnabled()) {
 		return;
 	}
 	this->running = true;
@@ -111439,17 +111262,10 @@ void QueryProfiler::Finalize(TreeNode &node) {
 
 void QueryProfiler::StartExplainAnalyze() {
 	this->is_explain_analyze = true;
-	this->stored_enabled = enabled;
-	this->stored_automatic_print_format = automatic_print_format;
-	this->stored_save_location = save_location;
-
-	this->enabled = true;
-	this->save_location = string();
-	this->automatic_print_format = ProfilerPrintFormat::NONE;
 }
 
 void QueryProfiler::EndQuery() {
-	if (!enabled || !running) {
+	if (!IsEnabled() || !running) {
 		return;
 	}
 
@@ -111458,6 +111274,7 @@ void QueryProfiler::EndQuery() {
 		Finalize(*root);
 	}
 	this->running = false;
+	auto automatic_print_format = GetPrintFormat();
 	// print or output the query profiling after termination, if this is enabled
 	if (automatic_print_format != ProfilerPrintFormat::NONE) {
 		// check if this query should be output based on the operator types
@@ -111469,7 +111286,7 @@ void QueryProfiler::EndQuery() {
 		} else if (automatic_print_format == ProfilerPrintFormat::QUERY_TREE_OPTIMIZER) {
 			query_info = ToString(true);
 		}
-
+		auto save_location = GetSaveLocation();
 		if (save_location.empty()) {
 			Printer::Print(query_info);
 			Printer::Print("\n");
@@ -111477,16 +111294,11 @@ void QueryProfiler::EndQuery() {
 			WriteToFile(save_location.c_str(), query_info);
 		}
 	}
-	if (is_explain_analyze) {
-		this->is_explain_analyze = false;
-		this->enabled = stored_enabled;
-		this->automatic_print_format = stored_automatic_print_format;
-		this->save_location = stored_save_location;
-	}
+	this->is_explain_analyze = false;
 }
 
 void QueryProfiler::StartPhase(string new_phase) {
-	if (!enabled || !running) {
+	if (!IsEnabled() || !running) {
 		return;
 	}
 
@@ -111510,7 +111322,7 @@ void QueryProfiler::StartPhase(string new_phase) {
 }
 
 void QueryProfiler::EndPhase() {
-	if (!enabled || !running) {
+	if (!IsEnabled() || !running) {
 		return;
 	}
 	D_ASSERT(phase_stack.size() > 0);
@@ -111530,7 +111342,7 @@ void QueryProfiler::EndPhase() {
 }
 
 void QueryProfiler::Initialize(PhysicalOperator *root_op) {
-	if (!enabled || !running) {
+	if (!IsEnabled() || !running) {
 		return;
 	}
 	this->query_requires_profiling = false;
@@ -111611,7 +111423,7 @@ void OperatorProfiler::Flush(const PhysicalOperator *phys_op, ExpressionExecutor
 }
 
 void QueryProfiler::Flush(OperatorProfiler &profiler) {
-	if (!enabled || !running) {
+	if (!IsEnabled() || !running) {
 		return;
 	}
 	lock_guard<mutex> guard(flush_lock);
@@ -111621,7 +111433,7 @@ void QueryProfiler::Flush(OperatorProfiler &profiler) {
 
 		entry->second->info.time += node.second.time;
 		entry->second->info.elements += node.second.elements;
-		if (!detailed_enabled) {
+		if (!IsDetailedEnabled()) {
 			continue;
 		}
 		for (auto &info : node.second.executors_info) {
@@ -111682,7 +111494,7 @@ string QueryProfiler::ToString(bool print_optimizer_output) const {
 }
 
 void QueryProfiler::ToStream(std::ostream &ss, bool print_optimizer_output) const {
-	if (!enabled) {
+	if (!IsEnabled()) {
 		ss << "Query profiling is disabled. Call "
 		      "Connection::EnableProfiling() to enable profiling!";
 		return;
@@ -111853,7 +111665,7 @@ static void ToJSONRecursive(QueryProfiler::TreeNode &node, std::ostream &ss, int
 }
 
 string QueryProfiler::ToJSON() const {
-	if (!enabled) {
+	if (!IsEnabled()) {
 		return "{ \"result\": \"disabled\" }\n";
 	}
 	if (query.empty()) {
@@ -111968,10 +111780,6 @@ vector<QueryProfiler::PhaseTimingItem> QueryProfiler::GetOrderedPhaseTimings() c
 	return result;
 }
 void QueryProfiler::Propagate(QueryProfiler &qp) {
-	this->automatic_print_format = qp.automatic_print_format;
-	this->save_location = qp.save_location;
-	this->enabled = qp.enabled;
-	this->detailed_enabled = qp.detailed_enabled;
 }
 
 void ExpressionInfo::ExtractExpressionsRecursive(unique_ptr<ExpressionState> &state) {
@@ -112028,17 +111836,44 @@ ExpressionRootInfo::ExpressionRootInfo(ExpressionExecutorState &state, string na
 
 namespace duckdb {
 
-QueryResult::QueryResult(QueryResultType type, StatementType statement_type)
+BaseQueryResult::BaseQueryResult(QueryResultType type, StatementType statement_type)
     : type(type), statement_type(statement_type), success(true) {
 }
 
-QueryResult::QueryResult(QueryResultType type, StatementType statement_type, vector<LogicalType> types_p,
-                         vector<string> names_p)
+BaseQueryResult::BaseQueryResult(QueryResultType type, StatementType statement_type, vector<LogicalType> types_p,
+                                 vector<string> names_p)
     : type(type), statement_type(statement_type), types(move(types_p)), names(move(names_p)), success(true) {
 	D_ASSERT(types.size() == names.size());
 }
 
-QueryResult::QueryResult(QueryResultType type, string error) : type(type), success(false), error(move(error)) {
+BaseQueryResult::BaseQueryResult(QueryResultType type, string error) : type(type), success(false), error(move(error)) {
+}
+
+BaseQueryResult::~BaseQueryResult() {
+}
+
+bool BaseQueryResult::HasError() {
+	return !success;
+}
+const string &BaseQueryResult::GetError() {
+	return error;
+}
+idx_t BaseQueryResult::ColumnCount() {
+	return types.size();
+}
+
+QueryResult::QueryResult(QueryResultType type, StatementType statement_type) : BaseQueryResult(type, statement_type) {
+}
+
+QueryResult::QueryResult(QueryResultType type, StatementType statement_type, vector<LogicalType> types_p,
+                         vector<string> names_p)
+    : BaseQueryResult(type, statement_type, move(types_p), move(names_p)) {
+}
+
+QueryResult::QueryResult(QueryResultType type, string error) : BaseQueryResult(type, move(error)) {
+}
+
+QueryResult::~QueryResult() {
 }
 
 unique_ptr<DataChunk> QueryResult::Fetch() {
@@ -115057,24 +114892,27 @@ Value EnableObjectCacheSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 void EnableProfilingSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = StringUtil::Lower(input.ToString());
+
+	auto &config = ClientConfig::GetConfig(context);
 	if (parameter == "json") {
-		context.profiler->automatic_print_format = ProfilerPrintFormat::JSON;
+		config.profiler_print_format = ProfilerPrintFormat::JSON;
 	} else if (parameter == "query_tree") {
-		context.profiler->automatic_print_format = ProfilerPrintFormat::QUERY_TREE;
+		config.profiler_print_format = ProfilerPrintFormat::QUERY_TREE;
 	} else if (parameter == "query_tree_optimizer") {
-		context.profiler->automatic_print_format = ProfilerPrintFormat::QUERY_TREE_OPTIMIZER;
+		config.profiler_print_format = ProfilerPrintFormat::QUERY_TREE_OPTIMIZER;
 	} else {
 		throw ParserException(
 		    "Unrecognized print format %s, supported formats: [json, query_tree, query_tree_optimizer]", parameter);
 	}
-	context.profiler->Enable();
+	config.enable_profiler = true;
 }
 
 Value EnableProfilingSetting::GetSetting(ClientContext &context) {
-	if (!context.profiler->IsEnabled()) {
+	auto &config = ClientConfig::GetConfig(context);
+	if (!config.enable_profiler) {
 		return Value();
 	}
-	switch (context.profiler->automatic_print_format) {
+	switch (config.profiler_print_format) {
 	case ProfilerPrintFormat::NONE:
 		return Value("none");
 	case ProfilerPrintFormat::JSON:
@@ -115218,12 +115056,14 @@ Value ProfilerHistorySize::GetSetting(ClientContext &context) {
 // Profile Output
 //===--------------------------------------------------------------------===//
 void ProfileOutputSetting::SetLocal(ClientContext &context, const Value &input) {
+	auto &config = ClientConfig::GetConfig(context);
 	auto parameter = input.ToString();
-	context.profiler->save_location = parameter;
+	config.profiler_save_location = parameter;
 }
 
 Value ProfileOutputSetting::GetSetting(ClientContext &context) {
-	return Value(context.profiler->save_location);
+	auto &config = ClientConfig::GetConfig(context);
+	return Value(config.profiler_save_location);
 }
 
 //===--------------------------------------------------------------------===//
@@ -115231,17 +115071,24 @@ Value ProfileOutputSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 void ProfilingModeSetting::SetLocal(ClientContext &context, const Value &input) {
 	auto parameter = StringUtil::Lower(input.ToString());
+	auto &config = ClientConfig::GetConfig(context);
 	if (parameter == "standard") {
-		context.profiler->Enable();
+		config.enable_profiler = true;
+		config.enable_detailed_profiling = false;
 	} else if (parameter == "detailed") {
-		context.profiler->DetailedEnable();
+		config.enable_profiler = true;
+		config.enable_detailed_profiling = true;
 	} else {
 		throw ParserException("Unrecognized profiling mode \"%s\", supported formats: [standard, detailed]", parameter);
 	}
 }
 
 Value ProfilingModeSetting::GetSetting(ClientContext &context) {
-	return Value(context.profiler->IsDetailedEnabled() ? "detailed" : "standard");
+	auto &config = ClientConfig::GetConfig(context);
+	if (!config.enable_profiler) {
+		return Value();
+	}
+	return Value(config.enable_detailed_profiling ? "detailed" : "standard");
 }
 
 //===--------------------------------------------------------------------===//
@@ -115321,14 +115168,11 @@ Value ThreadsSetting::GetSetting(ClientContext &context) {
 namespace duckdb {
 
 StreamQueryResult::StreamQueryResult(StatementType statement_type, shared_ptr<ClientContext> context,
-                                     vector<LogicalType> types, vector<string> names,
-                                     shared_ptr<PreparedStatementData> prepared)
-    : QueryResult(QueryResultType::STREAM_RESULT, statement_type, move(types), move(names)), is_open(true),
-      context(move(context)), prepared(move(prepared)) {
+                                     vector<LogicalType> types, vector<string> names)
+    : QueryResult(QueryResultType::STREAM_RESULT, statement_type, move(types), move(names)), context(move(context)) {
 }
 
 StreamQueryResult::~StreamQueryResult() {
-	Close();
 }
 
 string StreamQueryResult::ToString() {
@@ -115342,12 +115186,28 @@ string StreamQueryResult::ToString() {
 	return result;
 }
 
+unique_ptr<ClientContextLock> StreamQueryResult::LockContext() {
+	if (!context) {
+		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result\nError: %s",
+		                            error);
+	}
+	return context->LockContext();
+}
+
+void StreamQueryResult::CheckExecutableInternal(ClientContextLock &lock) {
+	if (!IsOpenInternal(lock)) {
+		throw InvalidInputException("Attempting to execute an unsuccessful or closed pending query result\nError: %s",
+		                            error);
+	}
+}
+
 unique_ptr<DataChunk> StreamQueryResult::FetchRaw() {
-	if (!success || !is_open) {
-		throw InvalidInputException(
-		    "Attempting to fetch from an unsuccessful or closed streaming query result\nError: %s", error);
+	unique_ptr<DataChunk> chunk;
+	{
+		auto lock = LockContext();
+		CheckExecutableInternal(*lock);
+		chunk = context->Fetch(*lock, *this);
 	}
-	auto chunk = context->Fetch();
 	if (!chunk || chunk->ColumnCount() == 0 || chunk->size() == 0) {
 		Close();
 		return nullptr;
@@ -115373,12 +115233,24 @@ unique_ptr<MaterializedQueryResult> StreamQueryResult::Materialize() {
 	return result;
 }
 
-void StreamQueryResult::Close() {
-	if (!is_open) {
-		return;
+bool StreamQueryResult::IsOpenInternal(ClientContextLock &lock) {
+	bool invalidated = !success || !context;
+	if (!invalidated) {
+		invalidated = !context->IsActiveResult(lock, this);
+	}
+	return !invalidated;
+}
+
+bool StreamQueryResult::IsOpen() {
+	if (!success || !context) {
+		return false;
 	}
-	is_open = false;
-	context->Cleanup();
+	auto lock = LockContext();
+	return IsOpenInternal(*lock);
+}
+
+void StreamQueryResult::Close() {
+	context.reset();
 }
 
 } // namespace duckdb
@@ -120173,9 +120045,10 @@ void Optimizer::RunOptimizer(OptimizerType type, const std::function<void()> &ca
 		// optimizer is marked as disabled: skip
 		return;
 	}
-	context.profiler->StartPhase(OptimizerTypeToString(type));
+	auto &profiler = QueryProfiler::Get(context);
+	profiler.StartPhase(OptimizerTypeToString(type));
 	callback();
-	context.profiler->EndPhase();
+	profiler.EndPhase();
 }
 
 unique_ptr<LogicalOperator> Optimizer::Optimize(unique_ptr<LogicalOperator> plan) {
@@ -124134,6 +124007,10 @@ public:
 
 	//! Fully execute a pipeline with a source and a sink until the source is completely exhausted
 	void Execute();
+	//! Execute a pipeline with a source and a sink until finished, or until max_chunks have been processed
+	//! Returns true if execution is finished, false if Execute should be called again
+	bool Execute(idx_t max_chunks);
+
 	//! Push a single input DataChunk into the pipeline.
 	//! Returns either OperatorResultType::NEED_MORE_INPUT or OperatorResultType::FINISHED
 	//! If OperatorResultType::FINISHED is returned, more input will not change the result anymore
@@ -124302,7 +124179,7 @@ Executor::~Executor() {
 }
 
 Executor &Executor::Get(ClientContext &context) {
-	return context.executor;
+	return context.GetExecutor();
 }
 
 void Executor::AddEvent(shared_ptr<Event> event) {
@@ -124531,16 +124408,6 @@ void Executor::VerifyPipelines() {
 #endif
 }
 
-void Executor::WorkOnTasks() {
-	auto &scheduler = TaskScheduler::GetScheduler(context);
-
-	unique_ptr<Task> task;
-	while (scheduler.GetTaskFromProducer(*producer, task)) {
-		task->Execute();
-		task.reset();
-	}
-}
-
 void Executor::Initialize(PhysicalOperator *plan) {
 	Reset();
 
@@ -124549,7 +124416,8 @@ void Executor::Initialize(PhysicalOperator *plan) {
 		lock_guard<mutex> elock(executor_lock);
 		physical_plan = plan;
 
-		context.profiler->Initialize(physical_plan);
+		auto &profiler = QueryProfiler::Get(context);
+		profiler.Initialize(physical_plan);
 		this->producer = scheduler.CreateProducer();
 
 		auto root_pipeline = make_shared<Pipeline>(*this);
@@ -124565,60 +124433,102 @@ void Executor::Initialize(PhysicalOperator *plan) {
 
 		ScheduleEvents();
 	}
+}
 
-	// now execute tasks from this producer until all pipelines are completed
-	while (completed_pipelines < total_pipelines) {
-		WorkOnTasks();
-		if (!HasError()) {
-			// no exceptions: continue
-			continue;
+void Executor::CancelTasks() {
+	task.reset();
+	// we do this by creating weak pointers to all pipelines
+	// then clearing our references to the pipelines
+	// and waiting until all pipelines have been destroyed
+	vector<weak_ptr<Pipeline>> weak_references;
+	{
+		lock_guard<mutex> elock(executor_lock);
+		if (pipelines.empty()) {
+			return;
 		}
-
-		// an exception has occurred executing one of the pipelines
-		// we need to wait until all threads are finished
-		// we do this by creating weak pointers to all pipelines
-		// then clearing our references to the pipelines
-		// and waiting until all pipelines have been destroyed
-		vector<weak_ptr<Pipeline>> weak_references;
-		{
-			lock_guard<mutex> elock(executor_lock);
-			weak_references.reserve(pipelines.size());
-			for (auto &pipeline : pipelines) {
+		weak_references.reserve(pipelines.size());
+		for (auto &pipeline : pipelines) {
+			weak_references.push_back(weak_ptr<Pipeline>(pipeline));
+		}
+		for (auto &kv : union_pipelines) {
+			for (auto &pipeline : kv.second) {
 				weak_references.push_back(weak_ptr<Pipeline>(pipeline));
 			}
-			for (auto &kv : union_pipelines) {
-				for (auto &pipeline : kv.second) {
-					weak_references.push_back(weak_ptr<Pipeline>(pipeline));
-				}
+		}
+		for (auto &kv : child_pipelines) {
+			for (auto &pipeline : kv.second) {
+				weak_references.push_back(weak_ptr<Pipeline>(pipeline));
 			}
-			for (auto &kv : child_pipelines) {
-				for (auto &pipeline : kv.second) {
-					weak_references.push_back(weak_ptr<Pipeline>(pipeline));
-				}
+		}
+		pipelines.clear();
+		union_pipelines.clear();
+		child_pipelines.clear();
+		events.clear();
+	}
+	WorkOnTasks();
+	for (auto &weak_ref : weak_references) {
+		while (true) {
+			auto weak = weak_ref.lock();
+			if (!weak) {
+				break;
 			}
-			pipelines.clear();
-			union_pipelines.clear();
-			child_pipelines.clear();
-			events.clear();
 		}
-		for (auto &weak_ref : weak_references) {
-			while (true) {
-				auto weak = weak_ref.lock();
-				if (!weak) {
-					break;
-				}
+	}
+}
+
+void Executor::WorkOnTasks() {
+	auto &scheduler = TaskScheduler::GetScheduler(context);
+
+	unique_ptr<Task> task;
+	while (scheduler.GetTaskFromProducer(*producer, task)) {
+		task->Execute(TaskExecutionMode::PROCESS_ALL);
+		task.reset();
+	}
+}
+
+PendingExecutionResult Executor::ExecuteTask() {
+	if (execution_result != PendingExecutionResult::RESULT_NOT_READY) {
+		return execution_result;
+	}
+	// check if there are any incomplete pipelines
+	auto &scheduler = TaskScheduler::GetScheduler(context);
+	while (completed_pipelines < total_pipelines) {
+		// there are! if we don't already have a task, fetch one
+		if (!task) {
+			scheduler.GetTaskFromProducer(*producer, task);
+		}
+		if (task) {
+			// if we have a task, partially process it
+			auto result = task->Execute(TaskExecutionMode::PROCESS_PARTIAL);
+			if (result != TaskExecutionResult::TASK_NOT_FINISHED) {
+				// if the task is finished, clean it up
+				task.reset();
 			}
 		}
+		if (!HasError()) {
+			// we (partially) processed a task and no exceptions were thrown
+			// give back control to the caller
+			return PendingExecutionResult::RESULT_NOT_READY;
+		}
+		execution_result = PendingExecutionResult::EXECUTION_ERROR;
+
+		// an exception has occurred executing one of the pipelines
+		// we need to cancel all tasks associated with this executor
+		CancelTasks();
 		ThrowException();
 	}
+	D_ASSERT(!task);
 
 	lock_guard<mutex> elock(executor_lock);
 	pipelines.clear();
 	NextExecutor();
 	if (!exceptions.empty()) { // LCOV_EXCL_START
 		// an exception has occurred executing one of the pipelines
+		execution_result = PendingExecutionResult::EXECUTION_ERROR;
 		ThrowExceptionInternal();
 	} // LCOV_EXCL_STOP
+	execution_result = PendingExecutionResult::RESULT_READY;
+	return execution_result;
 }
 
 void Executor::Reset() {
@@ -124637,6 +124547,7 @@ void Executor::Reset() {
 	union_pipelines.clear();
 	child_pipelines.clear();
 	child_dependencies.clear();
+	execution_result = PendingExecutionResult::RESULT_NOT_READY;
 }
 
 void Executor::AddChildPipeline(Pipeline *current) {
@@ -124918,10 +124829,11 @@ void Executor::ThrowExceptionInternal() { // LCOV_EXCL_START
 
 void Executor::Flush(ThreadContext &tcontext) {
 	lock_guard<mutex> elock(executor_lock);
-	context.profiler->Flush(tcontext.profiler);
+	auto &profiler = QueryProfiler::Get(context);
+	profiler.Flush(tcontext.profiler);
 }
 
-bool Executor::GetPipelinesProgress(int &current_progress) { // LCOV_EXCL_START
+bool Executor::GetPipelinesProgress(double &current_progress) { // LCOV_EXCL_START
 	lock_guard<mutex> elock(executor_lock);
 
 	if (!pipelines.empty()) {
@@ -124967,9 +124879,9 @@ ExecutorTask::ExecutorTask(ClientContext &context) : ExecutorTask(Executor::Get(
 ExecutorTask::~ExecutorTask() {
 }
 
-void ExecutorTask::Execute() {
+TaskExecutionResult ExecutorTask::Execute(TaskExecutionMode mode) {
 	try {
-		ExecuteTask();
+		return ExecuteTask(mode);
 	} catch (Exception &ex) {
 		executor.PushError(ex.type, ex.what());
 	} catch (std::exception &ex) {
@@ -124977,6 +124889,7 @@ void ExecutorTask::Execute() {
 	} catch (...) { // LCOV_EXCL_START
 		executor.PushError(ExceptionType::UNKNOWN_TYPE, "Unknown exception in Finalize!");
 	} // LCOV_EXCL_STOP
+	return TaskExecutionResult::TASK_ERROR;
 }
 
 } // namespace duckdb
@@ -125004,6 +124917,8 @@ void ExecutorTask::Execute() {
 namespace duckdb {
 
 class PipelineTask : public ExecutorTask {
+	static constexpr const idx_t PARTIAL_CHUNK_COUNT = 50;
+
 public:
 	explicit PipelineTask(Pipeline &pipeline_p, shared_ptr<Event> event_p)
 	    : ExecutorTask(pipeline_p.executor), pipeline(pipeline_p), event(move(event_p)) {
@@ -125011,12 +124926,24 @@ public:
 
 	Pipeline &pipeline;
 	shared_ptr<Event> event;
+	unique_ptr<PipelineExecutor> pipeline_executor;
 
 public:
-	void ExecuteTask() override {
-		PipelineExecutor executor(pipeline.GetClientContext(), pipeline);
-		executor.Execute();
+	TaskExecutionResult ExecuteTask(TaskExecutionMode mode) override {
+		if (!pipeline_executor) {
+			pipeline_executor = make_unique<PipelineExecutor>(pipeline.GetClientContext(), pipeline);
+		}
+		if (mode == TaskExecutionMode::PROCESS_PARTIAL) {
+			bool finished = pipeline_executor->Execute(PARTIAL_CHUNK_COUNT);
+			if (!finished) {
+				return TaskExecutionResult::TASK_NOT_FINISHED;
+			}
+		} else {
+			pipeline_executor->Execute();
+		}
 		event->FinishTask();
+		pipeline_executor.reset();
+		return TaskExecutionResult::TASK_FINISHED;
 	}
 };
 
@@ -125028,7 +124955,7 @@ ClientContext &Pipeline::GetClientContext() {
 }
 
 // LCOV_EXCL_START
-bool Pipeline::GetProgressInternal(ClientContext &context, PhysicalOperator *op, int &current_percentage) {
+bool Pipeline::GetProgressInternal(ClientContext &context, PhysicalOperator *op, double &current_percentage) {
 	current_percentage = -1;
 	switch (op->type) {
 	case PhysicalOperatorType::TABLE_SCAN: {
@@ -125047,7 +124974,7 @@ bool Pipeline::GetProgressInternal(ClientContext &context, PhysicalOperator *op,
 }
 // LCOV_EXCL_STOP
 
-bool Pipeline::GetProgress(int &current_percentage) {
+bool Pipeline::GetProgress(double &current_percentage) {
 	auto &client = executor.context;
 	return GetProgressInternal(client, source, current_percentage);
 }
@@ -125248,16 +125175,18 @@ PipelineExecutor::PipelineExecutor(ClientContext &context_p, Pipeline &pipeline_
 	InitializeChunk(final_chunk);
 }
 
-void PipelineExecutor::Execute() {
+bool PipelineExecutor::Execute(idx_t max_chunks) {
 	D_ASSERT(pipeline.sink);
+	bool exhausted_source = false;
 	auto &source_chunk = pipeline.operators.empty() ? final_chunk : *intermediate_chunks[0];
-	while (true) {
+	for (idx_t i = 0; i < max_chunks; i++) {
 		if (finished_processing) {
 			break;
 		}
 		source_chunk.Reset();
 		FetchFromSource(source_chunk);
 		if (source_chunk.size() == 0) {
+			exhausted_source = true;
 			break;
 		}
 		auto result = ExecutePushInternal(source_chunk);
@@ -125266,7 +125195,15 @@ void PipelineExecutor::Execute() {
 			break;
 		}
 	}
+	if (!exhausted_source && !finished_processing) {
+		return false;
+	}
 	PushFinalize();
+	return true;
+}
+
+void PipelineExecutor::Execute() {
+	Execute(NumericLimits<idx_t>::Maximum());
 }
 
 OperatorResultType PipelineExecutor::ExecutePush(DataChunk &input) { // LCOV_EXCL_START
@@ -129797,7 +129734,7 @@ void TaskScheduler::ExecuteForever(atomic<bool> *marker) {
 		// wait for a signal with a timeout; the timeout allows us to periodically check
 		queue->semaphore.wait(TASK_TIMEOUT_USECS);
 		if (queue->q.try_dequeue(task)) {
-			task->Execute();
+			task->Execute(TaskExecutionMode::PROCESS_ALL);
 			task.reset();
 		}
 	}
@@ -129870,7 +129807,7 @@ void TaskScheduler::SetThreadsInternal(int32_t n) {
 
 namespace duckdb {
 
-ThreadContext::ThreadContext(ClientContext &context) : profiler(context.profiler->IsEnabled()) {
+ThreadContext::ThreadContext(ClientContext &context) : profiler(QueryProfiler::Get(context).IsEnabled()) {
 }
 
 } // namespace duckdb
@@ -149039,8 +148976,8 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 	del->AddChild(move(root));
 
 	// set up the delete expression
-	del->expressions.push_back(
-	    make_unique<BoundColumnRefExpression>(LOGICAL_ROW_TYPE, ColumnBinding(get.table_index, get.column_ids.size())));
+	del->expressions.push_back(make_unique<BoundColumnRefExpression>(
+	    LogicalType::ROW_TYPE, ColumnBinding(get.table_index, get.column_ids.size())));
 	get.column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
 
 	result.plan = move(del);
@@ -149980,7 +149917,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 
 	// finally add the row id column to the projection list
 	proj->expressions.push_back(make_unique<BoundColumnRefExpression>(
-	    LOGICAL_ROW_TYPE, ColumnBinding(get->table_index, get->column_ids.size())));
+	    LogicalType::ROW_TYPE, ColumnBinding(get->table_index, get->column_ids.size())));
 	get->column_ids.push_back(COLUMN_IDENTIFIER_ROW_ID);
 
 	// set the projection as child of the update node and finalize the result
@@ -154713,7 +154650,7 @@ void LogicalGet::ResolveTypes() {
 	}
 	for (auto &index : column_ids) {
 		if (index == COLUMN_IDENTIFIER_ROW_ID) {
-			types.push_back(LOGICAL_ROW_TYPE);
+			types.emplace_back(LogicalType::ROW_TYPE);
 		} else {
 			types.push_back(returned_types[index]);
 		}
@@ -154874,13 +154811,15 @@ Planner::Planner(ClientContext &context) : binder(Binder::CreateBinder(context))
 }
 
 void Planner::CreatePlan(SQLStatement &statement) {
+	auto &profiler = QueryProfiler::Get(context);
+
 	vector<BoundParameterExpression *> bound_parameters;
 
 	// first bind the tables and columns to the catalog
-	context.profiler->StartPhase("binder");
+	profiler.StartPhase("binder");
 	binder->parameters = &bound_parameters;
 	auto bound_statement = binder->Bind(statement);
-	context.profiler->EndPhase();
+	profiler.EndPhase();
 
 	this->read_only = binder->read_only;
 	this->requires_valid_transaction = binder->requires_valid_transaction;
@@ -161586,7 +161525,7 @@ DataTable::DataTable(ClientContext &context, DataTable &parent, idx_t changed_id
 	vector<LogicalType> scan_types;
 	for (idx_t i = 0; i < bound_columns.size(); i++) {
 		if (bound_columns[i] == COLUMN_IDENTIFIER_ROW_ID) {
-			scan_types.push_back(LOGICAL_ROW_TYPE);
+			scan_types.emplace_back(LogicalType::ROW_TYPE);
 		} else {
 			scan_types.push_back(parent.column_definitions[bound_columns[i]].type);
 		}
@@ -162053,7 +161992,7 @@ void DataTable::RevertAppend(idx_t start_row, idx_t count) {
 	if (!info->indexes.Empty()) {
 		idx_t current_row_base = start_row;
 		row_t row_data[STANDARD_VECTOR_SIZE];
-		Vector row_identifiers(LOGICAL_ROW_TYPE, (data_ptr_t)row_data);
+		Vector row_identifiers(LogicalType::ROW_TYPE, (data_ptr_t)row_data);
 		ScanTableSegment(start_row, count, [&](DataChunk &chunk) {
 			for (idx_t i = 0; i < chunk.size(); i++) {
 				row_data[i] = current_row_base + i;
@@ -162077,7 +162016,7 @@ bool DataTable::AppendToIndexes(TableAppendState &state, DataChunk &chunk, row_t
 		return true;
 	}
 	// first generate the vector of row identifiers
-	Vector row_identifiers(LOGICAL_ROW_TYPE);
+	Vector row_identifiers(LogicalType::ROW_TYPE);
 	VectorOperations::GenerateSequence(row_identifiers, chunk.size(), row_start, 1);
 
 	vector<Index *> already_appended;
@@ -162111,7 +162050,7 @@ void DataTable::RemoveFromIndexes(TableAppendState &state, DataChunk &chunk, row
 		return;
 	}
 	// first generate the vector of row identifiers
-	Vector row_identifiers(LOGICAL_ROW_TYPE);
+	Vector row_identifiers(LogicalType::ROW_TYPE);
 	VectorOperations::GenerateSequence(row_identifiers, chunk.size(), row_start, 1);
 
 	// now remove the entries from the indices
@@ -162422,7 +162361,7 @@ void DataTable::AddIndex(unique_ptr<Index> index, const vector<unique_ptr<Expres
 	for (auto &id : index->column_ids) {
 		intermediate_types.push_back(column_definitions[id].type);
 	}
-	intermediate_types.push_back(LOGICAL_ROW_TYPE);
+	intermediate_types.emplace_back(LogicalType::ROW_TYPE);
 	intermediate.Initialize(intermediate_types);
 
 	// initialize an index scan
@@ -162736,7 +162675,7 @@ void LocalStorage::Scan(LocalScanState &state, const vector<column_t> &column_id
 	if (count != chunk_count) {
 		sel.Initialize(valid_sel);
 	} else {
-		sel.Initialize(FlatVector::INCREMENTAL_SELECTION_VECTOR);
+		sel.Initialize(nullptr);
 	}
 	// now scan the vectors of the chunk
 	for (idx_t i = 0; i < column_ids.size(); i++) {
@@ -162788,7 +162727,7 @@ void LocalStorage::Append(DataTable *table, DataChunk &chunk) {
 		idx_t base_id = MAX_ROW_ID + storage->collection.Count();
 
 		// first generate the vector of row identifiers
-		Vector row_ids(LOGICAL_ROW_TYPE);
+		Vector row_ids(LogicalType::ROW_TYPE);
 		VectorOperations::GenerateSequence(row_ids, chunk.size(), base_id, 1);
 
 		// now append the entries to the indices
@@ -162907,7 +162846,7 @@ static void TemplatedUpdateLoop(Vector &data_vector, Vector &update_vector, Vect
 
 static void UpdateChunk(Vector &data, Vector &updates, Vector &row_ids, idx_t count, idx_t base_index) {
 	D_ASSERT(data.GetType() == updates.GetType());
-	D_ASSERT(row_ids.GetType() == LOGICAL_ROW_TYPE);
+	D_ASSERT(row_ids.GetType() == LogicalType::ROW_TYPE);
 
 	switch (data.GetType().InternalType()) {
 	case PhysicalType::INT8:
@@ -163830,7 +163769,9 @@ void BaseStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t co
 }
 
 void BaseStatistics::Verify(Vector &vector, idx_t count) {
-	Verify(vector, FlatVector::INCREMENTAL_SELECTION_VECTOR, count);
+	SelectionVector owned_sel;
+	auto sel = FlatVector::IncrementalSelectionVector(count, owned_sel);
+	Verify(vector, *sel, count);
 }
 
 } // namespace duckdb
@@ -166869,7 +166810,7 @@ void ListColumnData::Append(BaseStatistics &stats_p, ColumnAppendState &state, V
 
 	VectorData vdata;
 	vdata.validity = list_validity;
-	vdata.sel = &FlatVector::INCREMENTAL_SELECTION_VECTOR;
+	vdata.sel = FlatVector::IncrementalSelectionVector(count, vdata.owned_sel);
 	vdata.data = (data_ptr_t)append_offsets.get();
 
 	// append the list offsets
@@ -167381,7 +167322,7 @@ void RowGroup::TemplatedScan(Transaction *transaction, RowGroupScanState &state,
 			if (count != max_count) {
 				sel.Initialize(valid_sel);
 			} else {
-				sel.Initialize(FlatVector::INCREMENTAL_SELECTION_VECTOR);
+				sel.Initialize(nullptr);
 			}
 			//! first, we scan the columns with filters, fetch their data and generate a selection vector.
 			//! get runtime statistics
@@ -169426,7 +169367,7 @@ idx_t UpdateValidityStatistics(UpdateSegment *segment, SegmentStatistics &stats,
 			}
 		}
 	}
-	sel.Initialize((sel_t *)(FlatVector::INCREMENTAL_VECTOR));
+	sel.Initialize(nullptr);
 	return count;
 }
 
@@ -169440,7 +169381,7 @@ idx_t TemplatedUpdateNumericStatistics(UpdateSegment *segment, SegmentStatistics
 		for (idx_t i = 0; i < count; i++) {
 			NumericStatistics::Update<T>(stats, update_data[i]);
 		}
-		sel.Initialize((sel_t *)(FlatVector::INCREMENTAL_VECTOR));
+		sel.Initialize(nullptr);
 		return count;
 	} else {
 		idx_t not_null_count = 0;
@@ -169466,7 +169407,7 @@ idx_t UpdateStringStatistics(UpdateSegment *segment, SegmentStatistics &stats, V
 				update_data[i] = segment->GetStringHeap().AddString(update_data[i]);
 			}
 		}
-		sel.Initialize(FlatVector::INCREMENTAL_SELECTION_VECTOR);
+		sel.Initialize(nullptr);
 		return count;
 	} else {
 		idx_t not_null_count = 0;
@@ -170186,9 +170127,9 @@ void ReplayState::ReplayDelete() {
 		throw InternalException("Corrupt WAL: delete without table");
 	}
 
-	D_ASSERT(chunk.ColumnCount() == 1 && chunk.data[0].GetType() == LOGICAL_ROW_TYPE);
+	D_ASSERT(chunk.ColumnCount() == 1 && chunk.data[0].GetType() == LogicalType::ROW_TYPE);
 	row_t row_ids[1];
-	Vector row_identifiers(LOGICAL_ROW_TYPE, (data_ptr_t)row_ids);
+	Vector row_identifiers(LogicalType::ROW_TYPE, (data_ptr_t)row_ids);
 
 	auto source_ids = FlatVector::GetData<row_t>(chunk.data[0]);
 	// delete the tuples from the current table
@@ -170453,7 +170394,7 @@ void WriteAheadLog::WriteDelete(DataChunk &chunk) {
 		return;
 	}
 	D_ASSERT(chunk.size() > 0);
-	D_ASSERT(chunk.ColumnCount() == 1 && chunk.data[0].GetType() == LOGICAL_ROW_TYPE);
+	D_ASSERT(chunk.ColumnCount() == 1 && chunk.data[0].GetType() == LogicalType::ROW_TYPE);
 	chunk.Verify();
 
 	writer->Write<WALType>(WALType::DELETE_TUPLE);
@@ -170466,7 +170407,7 @@ void WriteAheadLog::WriteUpdate(DataChunk &chunk, const vector<column_t> &column
 	}
 	D_ASSERT(chunk.size() > 0);
 	D_ASSERT(chunk.ColumnCount() == 2);
-	D_ASSERT(chunk.data[1].GetType().id() == LOGICAL_ROW_TYPE.id());
+	D_ASSERT(chunk.data[1].GetType().id() == LogicalType::ROW_TYPE);
 	chunk.Verify();
 
 	writer->Write<WALType>(WALType::UPDATE_TUPLE);
@@ -170644,7 +170585,7 @@ void CleanupState::Flush() {
 	}
 
 	// set up the row identifiers vector
-	Vector row_identifiers(LOGICAL_ROW_TYPE, (data_ptr_t)row_numbers);
+	Vector row_identifiers(LogicalType::ROW_TYPE, (data_ptr_t)row_numbers);
 
 	// delete the tuples from all the indexes
 	current_table->RemoveFromIndexes(row_identifiers, count);
@@ -170866,7 +170807,7 @@ void CommitState::WriteDelete(DeleteInfo *info) {
 
 	if (!delete_chunk) {
 		delete_chunk = make_unique<DataChunk>();
-		vector<LogicalType> delete_types = {LOGICAL_ROW_TYPE};
+		vector<LogicalType> delete_types = {LogicalType::ROW_TYPE};
 		delete_chunk->Initialize(delete_types);
 	}
 	auto rows = FlatVector::GetData<row_t>(delete_chunk->data[0]);
@@ -170892,7 +170833,7 @@ void CommitState::WriteUpdate(UpdateInfo *info) {
 	} else {
 		update_types.push_back(column_data.type);
 	}
-	update_types.push_back(LOGICAL_ROW_TYPE);
+	update_types.emplace_back(LogicalType::ROW_TYPE);
 
 	update_chunk = make_unique<DataChunk>();
 	update_chunk->Initialize(update_types);