duckdb 0.7.1-dev37.0 → 0.7.1-dev415.0

package/src/duckdb/src/execution/index/art/node.cpp

@@ -299,16 +299,11 @@ Node *Node::Deserialize(ART &art, idx_t block_id, idx_t offset) {
 	NodeType node_type((NodeType)(n));
 
 	Node *deserialized_node = nullptr;
-	auto old_memory_size = art.memory_size;
 	switch (node_type) {
 	case NodeType::NLeaf: {
 		auto leaf = Leaf::New();
 		leaf->Deserialize(art, reader);
-		art.memory_size += leaf->MemorySize(art, false);
-		D_ASSERT(art.memory_size >= old_memory_size);
-		if (art.track_memory) {
-			art.buffer_manager.IncreaseUsedMemory(art.memory_size - old_memory_size);
-		}
+		art.IncreaseMemorySize(leaf->MemorySize(art, false));
 		return leaf;
 	}
 	case NodeType::N4: {
@@ -331,11 +326,7 @@ Node *Node::Deserialize(ART &art, idx_t block_id, idx_t offset) {
 		throw InternalException("Unrecognized node type");
 	}
 	deserialized_node->DeserializeInternal(art, reader);
-	art.memory_size += deserialized_node->MemorySize(art, false);
-	D_ASSERT(art.memory_size >= old_memory_size);
-	if (art.track_memory) {
-		art.buffer_manager.IncreaseUsedMemory(art.memory_size - old_memory_size);
-	}
+	art.IncreaseMemorySize(deserialized_node->MemorySize(art, false));
 	return deserialized_node;
 }
 
@@ -356,12 +347,10 @@ void SwapNodes(MergeInfo &info, ParentsOfNodes &parents) {
 	auto l_node_memory_size = info.l_node->MemorySize(*info.l_art, true);
 	auto r_node_memory_size = info.r_node->MemorySize(*info.r_art, true);
 
-	D_ASSERT(info.root_l_art->memory_size >= l_node_memory_size);
-	D_ASSERT(info.root_r_art->memory_size >= r_node_memory_size);
-	info.root_l_art->memory_size -= l_node_memory_size;
-	info.root_r_art->memory_size -= r_node_memory_size;
-	info.root_l_art->memory_size += r_node_memory_size;
-	info.root_r_art->memory_size += l_node_memory_size;
+	info.root_l_art->DecreaseMemorySize(l_node_memory_size);
+	info.root_r_art->DecreaseMemorySize(r_node_memory_size);
+	info.root_l_art->IncreaseMemorySize(r_node_memory_size);
+	info.root_r_art->IncreaseMemorySize(l_node_memory_size);
 
 	// actual swap
 	swap(info.l_art, info.r_art);
@@ -409,9 +398,8 @@ bool Merge(MergeInfo &info, ParentsOfNodes &parents) {
 			auto r_memory_size = r_child->MemorySize(*info.r_art, true);
 			Node::InsertChild(*info.root_l_art, info.l_node, key_byte, r_child);
 
-			info.root_l_art->memory_size += r_memory_size;
-			D_ASSERT(info.root_r_art->memory_size >= r_memory_size);
-			info.root_r_art->memory_size -= r_memory_size;
+			info.root_l_art->IncreaseMemorySize(r_memory_size);
+			info.root_r_art->DecreaseMemorySize(r_memory_size);
 			if (parents.l_parent) {
 				parents.l_parent->ReplaceChildPointer(parents.l_pos, info.l_node);
 			}
@@ -473,9 +461,8 @@ bool ResolvePrefixesAndMerge(MergeInfo &info, ParentsOfNodes &parents) {
 			auto r_memory_size = r_node->MemorySize(*info.r_art, true);
 			Node::InsertChild(*info.root_l_art, l_node, mismatch_byte, r_node);
 
-			info.root_l_art->memory_size += r_memory_size;
-			D_ASSERT(info.root_r_art->memory_size >= r_memory_size);
-			info.root_r_art->memory_size -= r_memory_size;
+			info.root_l_art->IncreaseMemorySize(r_memory_size);
+			info.root_r_art->DecreaseMemorySize(r_memory_size);
 			UpdateParentsOfNodes(l_node, null_parent, parents);
 			r_node = nullptr;
 			return true;
@@ -493,7 +480,7 @@ bool ResolvePrefixesAndMerge(MergeInfo &info, ParentsOfNodes &parents) {
 	// create new node
 	Node *new_node = Node4::New();
 	new_node->prefix = Prefix(l_node->prefix, mismatch_pos);
-	info.root_l_art->memory_size += new_node->MemorySize(*info.l_art, false);
+	info.root_l_art->IncreaseMemorySize(new_node->MemorySize(*info.l_art, false));
 
 	// insert l_node, break up prefix of l_node
 	auto key_byte = l_node->prefix.Reduce(*info.root_l_art, mismatch_pos);
@@ -504,9 +491,8 @@ bool ResolvePrefixesAndMerge(MergeInfo &info, ParentsOfNodes &parents) {
 	auto r_memory_size = r_node->MemorySize(*info.r_art, true);
 	Node4::InsertChild(*info.root_l_art, new_node, key_byte, r_node);
 
-	info.root_l_art->memory_size += r_memory_size;
-	D_ASSERT(info.root_r_art->memory_size >= r_memory_size);
-	info.root_r_art->memory_size -= r_memory_size;
+	info.root_l_art->IncreaseMemorySize(r_memory_size);
+	info.root_r_art->DecreaseMemorySize(r_memory_size);
 
 	l_node = new_node;
 	UpdateParentsOfNodes(l_node, null_parent, parents);

package/src/duckdb/src/execution/index/art/node16.cpp

@@ -104,7 +104,7 @@ void Node16::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_chil
 	} else {
 		// node is full, grow to Node48
 		auto new_node = Node48::New();
-		art.memory_size += new_node->MemorySize(art, false);
+		art.IncreaseMemorySize(new_node->MemorySize(art, false));
 		new_node->count = node->count;
 		new_node->prefix = std::move(n->prefix);
 
@@ -114,8 +114,7 @@ void Node16::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_chil
 			n->children[i] = nullptr;
 		}
 
-		D_ASSERT(art.memory_size >= node->MemorySize(art, false));
-		art.memory_size -= node->MemorySize(art, false);
+		art.DecreaseMemorySize(node->MemorySize(art, false));
 		Node::Delete(node);
 		node = new_node;
 		Node48::InsertChild(art, node, key_byte, new_child);
@@ -130,8 +129,7 @@ void Node16::EraseChild(ART &art, Node *&node, idx_t pos) {
 	// adjust the ART size
 	if (n->ChildIsInMemory(pos)) {
 		auto child = n->GetChild(art, pos);
-		D_ASSERT(art.memory_size >= child->MemorySize(art, true));
-		art.memory_size -= child->MemorySize(art, true);
+		art.DecreaseMemorySize(child->MemorySize(art, true));
 	}
 
 	// erase the child and decrease the count
@@ -155,7 +153,7 @@ void Node16::EraseChild(ART &art, Node *&node, idx_t pos) {
 	if (node->count < Node4::GetSize()) {
 
 		auto new_node = Node4::New();
-		art.memory_size += new_node->MemorySize(art, false);
+		art.IncreaseMemorySize(new_node->MemorySize(art, false));
 		new_node->prefix = std::move(n->prefix);
 
 		for (idx_t i = 0; i < n->count; i++) {
@@ -164,8 +162,7 @@ void Node16::EraseChild(ART &art, Node *&node, idx_t pos) {
 			n->children[i] = nullptr;
 		}
 
-		D_ASSERT(art.memory_size >= node->MemorySize(art, false));
-		art.memory_size -= node->MemorySize(art, false);
+		art.DecreaseMemorySize(node->MemorySize(art, false));
 		Node::Delete(node);
 		node = new_node;
 	}

package/src/duckdb/src/execution/index/art/node256.cpp

@@ -92,8 +92,7 @@ void Node256::EraseChild(ART &art, Node *&node, idx_t pos) {
 	// adjust the ART size
 	if (n->ChildIsInMemory(pos)) {
 		auto child = n->GetChild(art, pos);
-		D_ASSERT(art.memory_size >= child->MemorySize(art, true));
-		art.memory_size -= child->MemorySize(art, true);
+		art.DecreaseMemorySize(child->MemorySize(art, true));
 	}
 
 	// erase the child and decrease the count
@@ -104,7 +103,7 @@ void Node256::EraseChild(ART &art, Node *&node, idx_t pos) {
 	if (node->count <= NODE_256_SHRINK_THRESHOLD) {
 
 		auto new_node = Node48::New();
-		art.memory_size += new_node->MemorySize(art, false);
+		art.IncreaseMemorySize(new_node->MemorySize(art, false));
 		new_node->prefix = std::move(n->prefix);
 
 		for (idx_t i = 0; i < Node256::GetSize(); i++) {
@@ -115,8 +114,7 @@ void Node256::EraseChild(ART &art, Node *&node, idx_t pos) {
 			}
 		}
 
-		D_ASSERT(art.memory_size >= node->MemorySize(art, false));
-		art.memory_size -= node->MemorySize(art, false);
+		art.DecreaseMemorySize(node->MemorySize(art, false));
 		Node::Delete(node);
 		node = new_node;
 	}

package/src/duckdb/src/execution/index/art/node4.cpp

@@ -101,7 +101,7 @@ void Node4::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_child
 	} else {
 		// node is full, grow to Node16
 		auto new_node = Node16::New();
-		art.memory_size += new_node->MemorySize(art, false);
+		art.IncreaseMemorySize(new_node->MemorySize(art, false));
 		new_node->count = n->count;
 		new_node->prefix = std::move(node->prefix);
 
@@ -112,8 +112,7 @@ void Node4::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_child
 		}
 		n->count = 0;
 
-		D_ASSERT(art.memory_size >= node->MemorySize(art, false));
-		art.memory_size -= node->MemorySize(art, false);
+		art.DecreaseMemorySize(node->MemorySize(art, false));
 		Node::Delete(node);
 		node = new_node;
 		Node16::InsertChild(art, node, key_byte, new_child);
@@ -129,8 +128,7 @@ void Node4::EraseChild(ART &art, Node *&node, idx_t pos) {
 	// adjust the ART size
 	if (n->ChildIsInMemory(pos)) {
 		auto child = n->GetChild(art, pos);
-		D_ASSERT(art.memory_size >= child->MemorySize(art, true));
-		art.memory_size -= child->MemorySize(art, true);
+		art.DecreaseMemorySize(child->MemorySize(art, true));
 	}
 
 	// erase the child and decrease the count
@@ -158,8 +156,7 @@ void Node4::EraseChild(ART &art, Node *&node, idx_t pos) {
 		// ensure that when deleting the node, we do not delete the child (because we move it)
 		n->children[0] = nullptr;
 
-		D_ASSERT(art.memory_size >= n->MemorySize(art, false));
-		art.memory_size -= n->MemorySize(art, false);
+		art.DecreaseMemorySize(n->MemorySize(art, false));
 		Node::Delete(node);
 		node = child_ref;
 	}

package/src/duckdb/src/execution/index/art/node48.cpp

@@ -105,7 +105,7 @@ void Node48::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_chil
 	} else {
 		// node is full, grow to Node256
 		auto new_node = Node256::New();
-		art.memory_size += new_node->MemorySize(art, false);
+		art.IncreaseMemorySize(new_node->MemorySize(art, false));
 		new_node->count = n->count;
 		new_node->prefix = std::move(n->prefix);
 
@@ -116,8 +116,7 @@ void Node48::InsertChild(ART &art, Node *&node, uint8_t key_byte, Node *new_chil
 			}
 		}
 
-		D_ASSERT(art.memory_size >= node->MemorySize(art, false));
-		art.memory_size -= node->MemorySize(art, false);
+		art.DecreaseMemorySize(node->MemorySize(art, false));
 		Node::Delete(node);
 		node = new_node;
 		Node256::InsertChild(art, node, key_byte, new_child);
@@ -130,8 +129,7 @@ void Node48::EraseChild(ART &art, Node *&node, idx_t pos) {
 	// adjust the ART size
 	if (n->ChildIsInMemory(pos)) {
 		auto child = n->GetChild(art, pos);
-		D_ASSERT(art.memory_size >= child->MemorySize(art, true));
-		art.memory_size -= child->MemorySize(art, true);
+		art.DecreaseMemorySize(child->MemorySize(art, true));
 	}
 
 	// erase the child and decrease the count
@@ -143,7 +141,7 @@ void Node48::EraseChild(ART &art, Node *&node, idx_t pos) {
 	if (node->count < NODE_48_SHRINK_THRESHOLD) {
 
 		auto new_node = Node16::New();
-		art.memory_size += new_node->MemorySize(art, false);
+		art.IncreaseMemorySize(new_node->MemorySize(art, false));
 		new_node->prefix = std::move(n->prefix);
 
 		for (idx_t i = 0; i < Node256::GetSize(); i++) {
@@ -154,8 +152,7 @@ void Node48::EraseChild(ART &art, Node *&node, idx_t pos) {
 			}
 		}
 
-		D_ASSERT(art.memory_size >= node->MemorySize(art, false));
-		art.memory_size -= node->MemorySize(art, false);
+		art.DecreaseMemorySize(node->MemorySize(art, false));
 		Node::Delete(node);
 		node = new_node;
 	}

package/src/duckdb/src/execution/index/art/prefix.cpp

@@ -113,7 +113,7 @@ void Prefix::Overwrite(uint32_t new_size, uint8_t *data) {
 
 void Prefix::Concatenate(ART &art, uint8_t key, Prefix &other) {
 	auto new_size = size + 1 + other.size;
-	art.memory_size += (new_size - size) * sizeof(uint8_t);
+	art.IncreaseMemorySize((new_size - size) * sizeof(uint8_t));
 	// have to allocate space in our prefix array
 	auto new_prefix = AllocateArray<uint8_t>(new_size);
 	idx_t new_prefix_idx = 0;
@@ -136,8 +136,7 @@ void Prefix::Concatenate(ART &art, uint8_t key, Prefix &other) {
 
 uint8_t Prefix::Reduce(ART &art, uint32_t n) {
 	auto new_size = size - n - 1;
-	D_ASSERT(art.memory_size >= (size - new_size) * sizeof(uint8_t));
-	art.memory_size -= (size - new_size) * sizeof(uint8_t);
+	art.DecreaseMemorySize((size - new_size) * sizeof(uint8_t));
 	auto prefix = GetPrefixData();
 	auto partial_key = prefix[n];
 

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -169,6 +169,10 @@ private:
 };
 
 void WindowGlobalSinkState::ResizeGroupingData(idx_t cardinality) {
+	//	Have we started to combine? Then just live with it.
+	if (grouping_data && !grouping_data->GetPartitions().empty()) {
+		return;
+	}
 	//	Is the average partition size too large?
 	const idx_t partition_size = STANDARD_ROW_GROUPS_SIZE;
 	const auto bits = grouping_data ? grouping_data->GetRadixBits() : 0;
@@ -180,31 +184,7 @@ void WindowGlobalSinkState::ResizeGroupingData(idx_t cardinality) {
 	// Repartition the grouping data
 	if (new_bits != bits) {
 		const auto hash_col_idx = payload_types.size();
-		auto new_grouping_data =
-		    make_unique<RadixPartitionedColumnData>(context, grouping_types, new_bits, hash_col_idx);
-
-		// We have to append to a shared copy for some reason
-		if (grouping_data) {
-			auto new_shared = new_grouping_data->CreateShared();
-			PartitionedColumnDataAppendState shared_append;
-			new_shared->InitializeAppendState(shared_append);
-
-			auto &partitions = grouping_data->GetPartitions();
-			for (auto &partition : partitions) {
-				ColumnDataScanState scanner;
-				partition->InitializeScan(scanner);
-
-				DataChunk scan_chunk;
-				partition->InitializeScanChunk(scan_chunk);
-				for (scan_chunk.Reset(); partition->Scan(scanner, scan_chunk); scan_chunk.Reset()) {
-					new_shared->Append(shared_append, scan_chunk);
-				}
-			}
-			new_shared->FlushAppendState(shared_append);
-			new_grouping_data->Combine(*new_shared);
-		}
-
-		grouping_data = std::move(new_grouping_data);
+		grouping_data = make_unique<RadixPartitionedColumnData>(context, grouping_types, new_bits, hash_col_idx);
 	}
 }
 
@@ -432,8 +412,6 @@ void WindowLocalSinkState::Sink(DataChunk &input_chunk, WindowGlobalSinkState &g
 	}
 
 	// OVER(...)
-	gstate.UpdateLocalPartition(local_partition, local_append);
-
 	payload_chunk.Reset();
 	auto &hash_vector = payload_chunk.data.back();
 	Hash(input_chunk, hash_vector);
@@ -442,6 +420,7 @@ void WindowLocalSinkState::Sink(DataChunk &input_chunk, WindowGlobalSinkState &g
 	}
 	payload_chunk.SetCardinality(input_chunk);
 
+	gstate.UpdateLocalPartition(local_partition, local_append);
 	local_partition->Append(*local_append, payload_chunk);
 }
 

package/src/duckdb/src/execution/operator/helper/physical_reset.cpp

@@ -27,15 +27,7 @@ void PhysicalReset::GetData(ExecutionContext &context, DataChunk &chunk, GlobalS
 		auto &config = DBConfig::GetConfig(context.client);
 		auto entry = config.extension_parameters.find(name);
 		if (entry == config.extension_parameters.end()) {
-			// it is not!
-			// get a list of all options
-			vector<string> potential_names = DBConfig::GetOptionNames();
-			for (auto &entry : config.extension_parameters) {
-				potential_names.push_back(entry.first);
-			}
-
-			throw CatalogException("unrecognized configuration parameter \"%s\"\n%s", name,
-			                       StringUtil::CandidatesErrorMessage(potential_names, name, "Did you mean"));
+			throw Catalog::UnrecognizedConfigurationError(context.client, name);
 		}
 		ResetExtensionVariable(context, config, entry->second);
 		return;

package/src/duckdb/src/execution/operator/helper/physical_set.cpp

@@ -30,15 +30,7 @@ void PhysicalSet::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSou
 		auto &config = DBConfig::GetConfig(context.client);
 		auto entry = config.extension_parameters.find(name);
 		if (entry == config.extension_parameters.end()) {
-			// it is not!
-			// get a list of all options
-			vector<string> potential_names = DBConfig::GetOptionNames();
-			for (auto &entry : config.extension_parameters) {
-				potential_names.push_back(entry.first);
-			}
-
-			throw CatalogException("unrecognized configuration parameter \"%s\"\n%s", name,
-			                       StringUtil::CandidatesErrorMessage(potential_names, name, "Did you mean"));
+			throw Catalog::UnrecognizedConfigurationError(context.client, name);
 		}
 		SetExtensionVariable(context.client, entry->second, name, scope, value);
 		return;

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

@@ -664,6 +664,7 @@ public:
 			if (!matches[outer_idx]) {
 				true_sel.set_index(count++, outer_idx);
 				if (count >= STANDARD_VECTOR_SIZE) {
+					outer_idx++;
 					break;
 				}
 			}
@@ -847,8 +848,6 @@ public:
 
 			lstate.joiner = make_unique<IEJoinUnion>(client, op, left_table, b1, right_table, b2);
 			return;
-		} else {
-			--next_pair;
 		}
 
 		// Outer joins
@@ -864,6 +863,7 @@ public:
 		// Left outer blocks
 		const auto l = next_left++;
 		if (l < left_outers) {
+			lstate.joiner = nullptr;
 			lstate.left_block_index = l;
 			lstate.left_base = left_bases[l];
 
@@ -873,12 +873,12 @@ public:
 			return;
 		} else {
 			lstate.left_matches = nullptr;
-			--next_left;
 		}
 
 		// Right outer block
 		const auto r = next_right++;
 		if (r < right_outers) {
+			lstate.joiner = nullptr;
 			lstate.right_block_index = r;
 			lstate.right_base = right_bases[r];
 
@@ -888,7 +888,6 @@ public:
 			return;
 		} else {
 			lstate.right_matches = nullptr;
-			--next_right;
 		}
 	}
 
@@ -936,7 +935,7 @@ void PhysicalIEJoin::GetData(ExecutionContext &context, DataChunk &result, Globa
 
 	ie_gstate.Initialize(ie_sink);
 
-	if (!ie_lstate.joiner) {
+	if (!ie_lstate.joiner && !ie_lstate.left_matches && !ie_lstate.right_matches) {
 		ie_gstate.GetNextPair(context.client, ie_sink, ie_lstate);
 	}
 
@@ -959,8 +958,7 @@ void PhysicalIEJoin::GetData(ExecutionContext &context, DataChunk &result, Globa
 			ie_gstate.GetNextPair(context.client, ie_sink, ie_lstate);
 			continue;
 		}
-
-		SliceSortedPayload(result, ie_sink.tables[0]->global_sort_state, ie_lstate.left_base, ie_lstate.true_sel,
+		SliceSortedPayload(result, ie_sink.tables[0]->global_sort_state, ie_lstate.left_block_index, ie_lstate.true_sel,
 		                   count);
 
 		// Fill in NULLs to the right
@@ -983,8 +981,8 @@ void PhysicalIEJoin::GetData(ExecutionContext &context, DataChunk &result, Globa
 			continue;
 		}
 
-		SliceSortedPayload(result, ie_sink.tables[1]->global_sort_state, ie_lstate.right_base, ie_lstate.true_sel,
-		                   count, left_cols);
+		SliceSortedPayload(result, ie_sink.tables[1]->global_sort_state, ie_lstate.right_block_index,
+		                   ie_lstate.true_sel, count, left_cols);
 
 		// Fill in NULLs to the left
 		for (idx_t col_idx = 0; col_idx < left_cols; ++col_idx) {

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

@@ -30,15 +30,10 @@ string BaseCSVReader::GetLineNumberStr(idx_t linenr, bool linenr_estimated) {
 	return to_string(linenr + 1) + estimated;
 }
 
-BaseCSVReader::BaseCSVReader(FileSystem &fs_p, Allocator &allocator, FileOpener *opener_p,
-                             BufferedCSVReaderOptions options_p, const vector<LogicalType> &requested_types)
-    : fs(fs_p), allocator(allocator), opener(opener_p), options(std::move(options_p)) {
-}
-
-BaseCSVReader::BaseCSVReader(ClientContext &context, BufferedCSVReaderOptions options_p,
+BaseCSVReader::BaseCSVReader(ClientContext &context_p, BufferedCSVReaderOptions options_p,
                              const vector<LogicalType> &requested_types)
-    : BaseCSVReader(FileSystem::GetFileSystem(context), Allocator::Get(context), FileSystem::GetFileOpener(context),
-                    std::move(options_p), requested_types) {
+    : context(context_p), fs(FileSystem::GetFileSystem(context)), allocator(Allocator::Get(context)),
+      opener(FileSystem::GetFileOpener(context)), options(std::move(options_p)) {
 }
 
 BaseCSVReader::~BaseCSVReader() {
@@ -144,7 +139,7 @@ bool BaseCSVReader::TryCastValue(const Value &value, const LogicalType &sql_type
 	} else {
 		Value new_value;
 		string error_message;
-		return value.DefaultTryCastAs(sql_type, new_value, &error_message, true);
+		return value.TryCastAs(context, sql_type, new_value, &error_message, true);
 	}
 }
 
@@ -481,8 +476,8 @@ bool BaseCSVReader::Flush(DataChunk &insert_chunk, bool try_add_line) {
 				                                             error_message, return_types[col_idx]);
 			} else {
 				// target type is not varchar: perform a cast
-				success = VectorOperations::DefaultTryCast(parse_chunk.data[col_idx], insert_chunk.data[insert_idx],
-				                                           parse_chunk.size(), &error_message);
+				success = VectorOperations::TryCast(context, parse_chunk.data[col_idx], insert_chunk.data[insert_idx],
+				                                    parse_chunk.size(), &error_message);
 			}
 			if (success) {
 				continue;

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

@@ -23,25 +23,16 @@
 
 namespace duckdb {
 
-BufferedCSVReader::BufferedCSVReader(FileSystem &fs_p, Allocator &allocator, FileOpener *opener_p,
-                                     BufferedCSVReaderOptions options_p, const vector<LogicalType> &requested_types)
-    : BaseCSVReader(fs_p, allocator, opener_p, std::move(options_p), requested_types), buffer_size(0), position(0),
-      start(0) {
-	file_handle = OpenCSV(options);
-	Initialize(requested_types);
-}
-
 BufferedCSVReader::BufferedCSVReader(ClientContext &context, BufferedCSVReaderOptions options_p,
                                      const vector<LogicalType> &requested_types)
-    : BufferedCSVReader(FileSystem::GetFileSystem(context), Allocator::Get(context), FileSystem::GetFileOpener(context),
-                        std::move(options_p), requested_types) {
+    : BaseCSVReader(context, std::move(options_p), requested_types), buffer_size(0), position(0), start(0) {
+	file_handle = OpenCSV(options);
+	Initialize(requested_types);
 }
 
 BufferedCSVReader::BufferedCSVReader(ClientContext &context, string filename, BufferedCSVReaderOptions options_p,
                                      const vector<LogicalType> &requested_types)
-    : BaseCSVReader(FileSystem::GetFileSystem(context), Allocator::Get(context), FileSystem::GetFileOpener(context),
-                    std::move(options_p), requested_types),
-      buffer_size(0), position(0), start(0) {
+    : BaseCSVReader(context, std::move(options_p), requested_types), buffer_size(0), position(0), start(0) {
 	options.file_path = std::move(filename);
 	file_handle = OpenCSV(options);
 	Initialize(requested_types);
@@ -730,6 +721,9 @@ void BufferedCSVReader::DetectHeader(const vector<vector<LogicalType>> &best_sql
 			names.push_back(column_name);
 		}
 	}
+	for (idx_t i = 0; i < MinValue<idx_t>(names.size(), options.name_list.size()); i++) {
+		names[i] = options.name_list[i];
+	}
 }
 
 vector<LogicalType> BufferedCSVReader::RefineTypeDetection(const vector<LogicalType> &type_candidates,
@@ -899,6 +893,12 @@ vector<LogicalType> BufferedCSVReader::SniffCSV(const vector<LogicalType> &reque
 	DetectCandidateTypes(type_candidates, format_template_candidates, info_candidates, original_options, best_num_cols,
 	                     best_sql_types_candidates, best_format_candidates, best_header_row);
 
+	if (best_format_candidates.empty() || best_header_row.size() == 0) {
+		throw InvalidInputException(
+		    "Error in file \"%s\": CSV options could not be auto-detected. Consider setting parser options manually.",
+		    original_options.file_path);
+	}
+
 	// #######
 	// ### header detection
 	// #######

package/src/duckdb/src/execution/operator/schema/physical_detach.cpp

@@ -0,0 +1,37 @@
+#include "duckdb/execution/operator/schema/physical_detach.hpp"
+#include "duckdb/parser/parsed_data/detach_info.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/main/attached_database.hpp"
+#include "duckdb/main/database.hpp"
+#include "duckdb/storage/storage_extension.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Source
+//===--------------------------------------------------------------------===//
+class DetachSourceState : public GlobalSourceState {
+public:
+	DetachSourceState() : finished(false) {
+	}
+
+	bool finished;
+};
+
+unique_ptr<GlobalSourceState> PhysicalDetach::GetGlobalSourceState(ClientContext &context) const {
+	return make_unique<DetachSourceState>();
+}
+
+void PhysicalDetach::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
+                             LocalSourceState &lstate) const {
+	auto &state = (DetachSourceState &)gstate;
+	if (state.finished) {
+		return;
+	}
+	auto &db_manager = DatabaseManager::Get(context.client);
+	db_manager.DetachDatabase(context.client, info->name, info->if_exists);
+	state.finished = true;
+}
+
+} // namespace duckdb

package/src/duckdb/src/execution/operator/schema/physical_drop.cpp

@@ -38,11 +38,6 @@ void PhysicalDrop::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSo
 		}
 		break;
 	}
-	case CatalogType::DATABASE_ENTRY: {
-		auto &db_manager = DatabaseManager::Get(context.client);
-		db_manager.DetachDatabase(context.client, info->name, info->if_exists);
-		break;
-	}
 	case CatalogType::SCHEMA_ENTRY: {
 		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
 		catalog.DropEntry(context.client, info.get());

package/src/duckdb/src/execution/physical_operator.cpp

@@ -252,15 +252,15 @@ OperatorResultType CachingPhysicalOperator::Execute(ExecutionContext &context, D
 	if (!state.initialized) {
 		state.initialized = true;
 		state.can_cache_chunk = true;
+
 		if (!context.pipeline || !caching_supported) {
 			state.can_cache_chunk = false;
-		}
-
-		if (context.pipeline->GetSink() && context.pipeline->GetSink()->RequiresBatchIndex()) {
+		} else if (!context.pipeline->GetSink()) {
+			// Disabling for pipelines without Sink, i.e. when pulling
 			state.can_cache_chunk = false;
-		}
-
-		if (context.pipeline->IsOrderDependent()) {
+		} else if (context.pipeline->GetSink()->RequiresBatchIndex()) {
+			state.can_cache_chunk = false;
+		} else if (context.pipeline->IsOrderDependent()) {
 			state.can_cache_chunk = false;
 		}
 	}

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

@@ -6,6 +6,7 @@
 #include "duckdb/execution/operator/schema/physical_create_schema.hpp"
 #include "duckdb/execution/operator/schema/physical_create_sequence.hpp"
 #include "duckdb/execution/operator/schema/physical_create_view.hpp"
+#include "duckdb/execution/operator/schema/physical_detach.hpp"
 #include "duckdb/execution/operator/schema/physical_drop.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
 #include "duckdb/planner/logical_operator.hpp"
@@ -39,6 +40,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalSimple &op
 	case LogicalOperatorType::LOGICAL_ATTACH:
 		return make_unique<PhysicalAttach>(unique_ptr_cast<ParseInfo, AttachInfo>(std::move(op.info)),
 		                                   op.estimated_cardinality);
+	case LogicalOperatorType::LOGICAL_DETACH:
+		return make_unique<PhysicalDetach>(unique_ptr_cast<ParseInfo, DetachInfo>(std::move(op.info)),
+		                                   op.estimated_cardinality);
 	default:
 		throw NotImplementedException("Unimplemented type for logical simple operator");
 	}

package/src/duckdb/src/execution/physical_plan_generator.cpp

@@ -184,6 +184,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalOperator &
 	case LogicalOperatorType::LOGICAL_VACUUM:
 	case LogicalOperatorType::LOGICAL_LOAD:
 	case LogicalOperatorType::LOGICAL_ATTACH:
+	case LogicalOperatorType::LOGICAL_DETACH:
 		plan = CreatePlan((LogicalSimple &)op);
 		break;
 	case LogicalOperatorType::LOGICAL_RECURSIVE_CTE: