duckdb 0.5.2-dev2164.0 → 0.5.2-dev2189.0

package/src/duckdb.cpp

@@ -1767,15 +1767,21 @@ private:
 
 namespace duckdb {
 class Prefix {
+	static constexpr idx_t PREFIX_INLINE_BYTES = 8;
+
 public:
 	Prefix();
 	// Prefix created from key starting on `depth`
 	Prefix(Key &key, uint32_t depth, uint32_t size);
 	// Prefix created from other prefix up to size
 	Prefix(Prefix &other_prefix, uint32_t size);
+	~Prefix();
 
 	// Returns the Prefix's size
 	uint32_t Size() const;
+	//! Return a pointer to the prefix data
+	uint8_t *GetPrefixData();
+	const uint8_t *GetPrefixData() const;
 
 	// Subscript operator
 	uint8_t &operator[](idx_t idx);
@@ -1803,8 +1809,17 @@ public:
 	uint32_t MismatchPosition(Prefix &other);
 
 private:
-	unique_ptr<uint8_t[]> prefix;
 	uint32_t size;
+	union {
+		uint8_t *ptr;
+		uint8_t inlined[8];
+	} value;
+
+private:
+	bool IsInlined() const;
+	uint8_t *AllocatePrefix(uint32_t size);
+	void Overwrite(uint32_t new_size, uint8_t *data);
+	void Destroy();
 };
 
 } // namespace duckdb
@@ -1813,6 +1828,7 @@ private:
 
 
 
+
 namespace duckdb {
 enum class NodeType : uint8_t { NLeaf = 0, N4 = 1, N16 = 2, N48 = 3, N256 = 4 };
 class ART;
@@ -1867,6 +1883,7 @@ public:
 	//! Compressed path (prefix)
 	Prefix prefix;
 
+	static void Delete(Node *node);
 	//! Get the position of a child corresponding exactly to the specific byte, returns DConstants::INVALID_INDEX if not
 	//! exists
 	virtual idx_t GetChildPos(uint8_t k) {
@@ -1928,16 +1945,21 @@ namespace duckdb {
 class Leaf : public Node {
 public:
 	Leaf(Key &value, uint32_t depth, row_t row_id);
-	Leaf(Key &value, uint32_t depth, unique_ptr<row_t[]> row_ids, idx_t num_elements);
-	Leaf(unique_ptr<row_t[]> row_ids, idx_t num_elements, Prefix &prefix);
+	Leaf(Key &value, uint32_t depth, row_t *row_ids, idx_t num_elements);
+	Leaf(row_t *row_ids, idx_t num_elements, Prefix &prefix);
+	Leaf(row_t row_id, Prefix &prefix);
+	~Leaf();
 
-	idx_t capacity;
-
-	row_t GetRowId(idx_t index) {
-		return row_ids[index];
-	}
+	row_t GetRowId(idx_t index);
+	idx_t GetCapacity() const;
+	bool IsInlined() const;
+	row_t *GetRowIds();
 
 public:
+	static Leaf *New(Key &value, uint32_t depth, row_t row_id);
+	static Leaf *New(Key &value, uint32_t depth, row_t *row_ids, idx_t num_elements);
+	static Leaf *New(row_t *row_ids, idx_t num_elements, Prefix &prefix);
+	static Leaf *New(row_t row_id, Prefix &prefix);
 	//! Insert a row_id into a leaf
 	void Insert(row_t row_id);
 	//! Remove a row_id from a leaf
@@ -1954,7 +1976,13 @@ public:
 	static Leaf *Deserialize(duckdb::MetaBlockReader &reader);
 
 private:
-	unique_ptr<row_t[]> row_ids;
+	union {
+		row_t inlined;
+		row_t *ptr;
+	} rowids;
+
+private:
+	row_t *Resize(row_t *current_row_ids, uint32_t current_count, idx_t new_capacity);
 };
 
 } // namespace duckdb
@@ -2043,6 +2071,7 @@ private:
 
 
 
+
 namespace duckdb {
 
 class ART;
@@ -2094,6 +2123,7 @@ public:
 	ARTPointer children[16];
 
 public:
+	static Node16 *New();
 	//! Get position of a specific byte, returns DConstants::INVALID_INDEX if not exists
 	idx_t GetChildPos(uint8_t k) override;
 	//! Get the position of the first child that is greater or equal to the specific byte, or DConstants::INVALID_INDEX
@@ -2139,6 +2169,7 @@ public:
 	ARTPointer children[256];
 
 public:
+	static Node256 *New();
 	//! Get position of a specific byte, returns DConstants::INVALID_INDEX if not exists
 	idx_t GetChildPos(uint8_t k) override;
 	//! Get the position of the first child that is greater or equal to the specific byte, or DConstants::INVALID_INDEX
@@ -2181,11 +2212,13 @@ namespace duckdb {
 class Node4 : public Node {
 public:
 	Node4();
+
 	uint8_t key[4];
 	// Pointers to the child nodes
 	ARTPointer children[4];
 
 public:
+	static Node4 *New();
 	//! Get position of a byte, returns DConstants::INVALID_INDEX if not exists
 	idx_t GetChildPos(uint8_t k) override;
 	//! Get the position of the first child that is greater or equal to the specific byte, or DConstants::INVALID_INDEX
@@ -2232,6 +2265,7 @@ public:
 	ARTPointer children[48];
 
 public:
+	static Node48 *New();
 	//! Get position of a specific byte, returns DConstants::INVALID_INDEX if not exists
 	idx_t GetChildPos(uint8_t k) override;
 	//! Get the position of the first child that is greater or equal to the specific byte, or DConstants::INVALID_INDEX
@@ -2362,6 +2396,12 @@ private:
 	                      bool right_inclusive, idx_t max_count, vector<row_t> &result_ids);
 
 	void VerifyExistence(DataChunk &chunk, VerifyExistenceType verify_type, string *err_msg_ptr = nullptr);
+
+private:
+	//! The estimated ART memory consumption
+	idx_t estimated_art_size;
+	//! The estimated memory consumption of a single key
+	idx_t estimated_key_size;
 };
 
 } // namespace duckdb
@@ -6543,6 +6583,7 @@ Allocator::~Allocator() {
 }
 
 data_ptr_t Allocator::AllocateData(idx_t size) {
+	D_ASSERT(size > 0);
 	auto result = allocate_function(private_data.get(), size);
 #ifdef DEBUG
 	D_ASSERT(private_data);
@@ -6555,6 +6596,7 @@ void Allocator::FreeData(data_ptr_t pointer, idx_t size) {
 	if (!pointer) {
 		return;
 	}
+	D_ASSERT(size > 0);
 #ifdef DEBUG
 	D_ASSERT(private_data);
 	private_data->debug_info->FreeData(pointer, size);
@@ -6574,11 +6616,15 @@ data_ptr_t Allocator::ReallocateData(data_ptr_t pointer, idx_t old_size, idx_t s
 	return new_pointer;
 }
 
-Allocator &Allocator::DefaultAllocator() {
-	static Allocator DEFAULT_ALLOCATOR;
+shared_ptr<Allocator> &Allocator::DefaultAllocatorReference() {
+	static shared_ptr<Allocator> DEFAULT_ALLOCATOR = make_shared<Allocator>();
 	return DEFAULT_ALLOCATOR;
 }
 
+Allocator &Allocator::DefaultAllocator() {
+	return *DefaultAllocatorReference();
+}
+
 //===--------------------------------------------------------------------===//
 // Debug Info (extended)
 //===--------------------------------------------------------------------===//
@@ -60543,7 +60589,8 @@ namespace duckdb {
 ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
          const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type,
          DatabaseInstance &db, idx_t block_id, idx_t block_offset)
-    : Index(IndexType::ART, table_io_manager, column_ids, unbound_expressions, constraint_type), db(db) {
+    : Index(IndexType::ART, table_io_manager, column_ids, unbound_expressions, constraint_type), db(db),
+      estimated_art_size(0), estimated_key_size(16) {
 	if (block_id != DConstants::INVALID_INDEX) {
 		tree = Node::Deserialize(*this, block_id, block_offset);
 	} else {
@@ -60554,17 +60601,28 @@ ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
 		switch (types[i]) {
 		case PhysicalType::BOOL:
 		case PhysicalType::INT8:
-		case PhysicalType::INT16:
-		case PhysicalType::INT32:
-		case PhysicalType::INT64:
-		case PhysicalType::INT128:
 		case PhysicalType::UINT8:
+			estimated_key_size += sizeof(int8_t);
+			break;
+		case PhysicalType::INT16:
 		case PhysicalType::UINT16:
+			estimated_key_size += sizeof(int16_t);
+			break;
+		case PhysicalType::INT32:
 		case PhysicalType::UINT32:
-		case PhysicalType::UINT64:
 		case PhysicalType::FLOAT:
+			estimated_key_size += sizeof(int32_t);
+			break;
+		case PhysicalType::INT64:
+		case PhysicalType::UINT64:
 		case PhysicalType::DOUBLE:
+			estimated_key_size += sizeof(int64_t);
+			break;
+		case PhysicalType::INT128:
+			estimated_key_size += sizeof(hugeint_t);
+			break;
 		case PhysicalType::VARCHAR:
+			estimated_key_size += 16; // oh well
 			break;
 		default:
 			throw InvalidTypeException(logical_types[i], "Invalid type for index");
@@ -60573,8 +60631,12 @@ ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
 }
 
 ART::~ART() {
+	if (estimated_art_size > 0) {
+		BufferManager::GetBufferManager(db).FreeReservedMemory(estimated_art_size);
+		estimated_art_size = 0;
+	}
 	if (tree) {
-		delete tree;
+		Node::Delete(tree);
 		tree = nullptr;
 	}
 }
@@ -60777,7 +60839,6 @@ void Construct(vector<Key> &keys, row_t *row_ids, Node *&node, KeySection &key_s
 
 	// we reached a leaf, i.e. all the bytes of start_key and end_key match
 	if (start_key.len == key_section.depth) {
-
 		// end_idx is inclusive
 		auto num_row_ids = key_section.end - key_section.start + 1;
 
@@ -60786,14 +60847,7 @@ void Construct(vector<Key> &keys, row_t *row_ids, Node *&node, KeySection &key_s
 			throw ConstraintException("New data contains duplicates on indexed column(s)");
 		}
 
-		// new row ids of this leaf
-		auto new_row_ids = unique_ptr<row_t[]>(new row_t[num_row_ids]);
-		for (idx_t i = 0; i < num_row_ids; i++) {
-			new_row_ids[i] = row_ids[key_section.start + i];
-		}
-
-		node = new Leaf(start_key, prefix_start, move(new_row_ids), num_row_ids);
-
+		node = Leaf::New(start_key, prefix_start, row_ids + key_section.start, num_row_ids);
 	} else { // create a new node and recurse
 
 		// we will find at least two child entries of this node, otherwise we'd have reached a leaf
@@ -60881,6 +60935,10 @@ bool ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 	vector<Key> keys(input.size());
 	GenerateKeys(arena_allocator, input, keys);
 
+	idx_t extra_memory = estimated_key_size * input.size();
+	BufferManager::GetBufferManager(db).ReserveMemory(extra_memory);
+	estimated_art_size += extra_memory;
+
 	// now insert the elements into the index
 	row_ids.Flatten(input.size());
 	auto row_identifiers = FlatVector::GetData<row_t>(row_ids);
@@ -60952,7 +61010,7 @@ bool ART::Insert(Node *&node, Key &key, idx_t depth, row_t row_id) {
 
 	if (!node) {
 		// node is currently empty, create a leaf here with the key
-		node = new Leaf(key, depth, row_id);
+		node = Leaf::New(key, depth, row_id);
 		return true;
 	}
 
@@ -60975,11 +61033,11 @@ bool ART::Insert(Node *&node, Key &key, idx_t depth, row_t row_id) {
 			}
 		}
 
-		Node *new_node = new Node4();
+		Node *new_node = Node4::New();
 		new_node->prefix = Prefix(key, depth, new_prefix_length);
 		auto key_byte = node->prefix.Reduce(new_prefix_length);
 		Node4::InsertChild(new_node, key_byte, node);
-		Node *leaf_node = new Leaf(key, depth + new_prefix_length + 1, row_id);
+		Node *leaf_node = Leaf::New(key, depth + new_prefix_length + 1, row_id);
 		Node4::InsertChild(new_node, key[depth + new_prefix_length], leaf_node);
 		node = new_node;
 		return true;
@@ -60990,13 +61048,13 @@ bool ART::Insert(Node *&node, Key &key, idx_t depth, row_t row_id) {
 		uint32_t mismatch_pos = node->prefix.KeyMismatchPosition(key, depth);
 		if (mismatch_pos != node->prefix.Size()) {
 			// Prefix differs, create new node
-			Node *new_node = new Node4();
+			Node *new_node = Node4::New();
 			new_node->prefix = Prefix(key, depth, mismatch_pos);
 			// Break up prefix
 			auto key_byte = node->prefix.Reduce(mismatch_pos);
 			Node4::InsertChild(new_node, key_byte, node);
 
-			Node *leaf_node = new Leaf(key, depth + mismatch_pos + 1, row_id);
+			Node *leaf_node = Leaf::New(key, depth + mismatch_pos + 1, row_id);
 			Node4::InsertChild(new_node, key[depth + mismatch_pos], leaf_node);
 			node = new_node;
 			return true;
@@ -61013,7 +61071,7 @@ bool ART::Insert(Node *&node, Key &key, idx_t depth, row_t row_id) {
 		node->ReplaceChildPointer(pos, child);
 		return insertion_result;
 	}
-	Node *new_node = new Leaf(key, depth + 1, row_id);
+	Node *new_node = Leaf::New(key, depth + 1, row_id);
 	Node::InsertChild(node, key[depth], new_node);
 	return true;
 }
@@ -61028,6 +61086,10 @@ void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) {
 	// first resolve the expressions
 	ExecuteExpressions(input, expression);
 
+	idx_t released_memory = MinValue<idx_t>(estimated_art_size, estimated_key_size * input.size());
+	BufferManager::GetBufferManager(db).FreeReservedMemory(released_memory);
+	estimated_art_size -= released_memory;
+
 	// then generate the keys for the given input
 	ArenaAllocator arena_allocator(Allocator::DefaultAllocator());
 	vector<Key> keys(expression.size());
@@ -61064,7 +61126,7 @@ void ART::Erase(Node *&node, Key &key, idx_t depth, row_t row_id) {
 		auto leaf = static_cast<Leaf *>(node);
 		leaf->Remove(row_id);
 		if (leaf->count == 0) {
-			delete node;
+			Node::Delete(node);
 			node = nullptr;
 		}
 
@@ -61416,9 +61478,9 @@ BlockPointer ART::Serialize(duckdb::MetaBlockWriter &writer) {
 // Merge ARTs
 //===--------------------------------------------------------------------===//
 bool ART::MergeIndexes(IndexLock &state, Index *other_index) {
-
 	auto other_art = (ART *)other_index;
-
+	estimated_art_size += other_art->estimated_art_size;
+	other_art->estimated_art_size = 0;
 	if (!this->tree) {
 		this->tree = other_art->tree;
 		other_art->tree = nullptr;
@@ -61831,45 +61893,104 @@ bool Iterator::LowerBound(Node *node, Key &key, bool inclusive) {
 #include <cstring>
 
 namespace duckdb {
+idx_t Leaf::GetCapacity() const {
+	return IsInlined() ? 1 : rowids.ptr[0];
+}
+
+bool Leaf::IsInlined() const {
+	return count <= 1;
+}
+
+row_t Leaf::GetRowId(idx_t index) {
+	D_ASSERT(index < count);
+	if (IsInlined()) {
+		return rowids.inlined;
+	} else {
+		D_ASSERT(rowids.ptr[0] >= count);
+		return rowids.ptr[index + 1];
+	}
+}
+
+row_t *Leaf::GetRowIds() {
+	if (IsInlined()) {
+		return &rowids.inlined;
+	} else {
+		return rowids.ptr + 1;
+	}
+}
 
 Leaf::Leaf(Key &value, uint32_t depth, row_t row_id) : Node(NodeType::NLeaf) {
-	capacity = 1;
-	row_ids = unique_ptr<row_t[]>(new row_t[capacity]);
-	row_ids[0] = row_id;
 	count = 1;
+	rowids.inlined = row_id;
 	D_ASSERT(value.len >= depth);
 	prefix = Prefix(value, depth, value.len - depth);
 }
 
-Leaf::Leaf(Key &value, uint32_t depth, unique_ptr<row_t[]> row_ids_p, idx_t num_elements_p) : Node(NodeType::NLeaf) {
-	capacity = num_elements_p;
-	row_ids = move(row_ids_p);
+Leaf::Leaf(Key &value, uint32_t depth, row_t *row_ids_p, idx_t num_elements_p) : Node(NodeType::NLeaf) {
+	D_ASSERT(num_elements_p >= 1);
+	if (num_elements_p == 1) {
+		// we can inline the row ids
+		rowids.inlined = row_ids_p[0];
+	} else {
+		// new row ids of this leaf
+		count = 0;
+		Resize(row_ids_p, num_elements_p, num_elements_p);
+	}
 	count = num_elements_p;
 	D_ASSERT(value.len >= depth);
 	prefix = Prefix(value, depth, value.len - depth);
 }
 
-Leaf::Leaf(unique_ptr<row_t[]> row_ids_p, idx_t num_elements_p, Prefix &prefix_p) : Node(NodeType::NLeaf) {
-	capacity = num_elements_p;
-	row_ids = move(row_ids_p);
+Leaf::Leaf(row_t *row_ids_p, idx_t num_elements_p, Prefix &prefix_p) : Node(NodeType::NLeaf) {
+	D_ASSERT(num_elements_p > 1);
+	D_ASSERT(row_ids_p[0] == row_t(num_elements_p)); // first element should contain capacity
+	rowids.ptr = row_ids_p;
 	count = num_elements_p;
 	prefix = prefix_p;
 }
 
-void Leaf::Insert(row_t row_id) {
+Leaf::Leaf(row_t row_id, Prefix &prefix_p) : Node(NodeType::NLeaf) {
+	rowids.inlined = row_id;
+	count = 1;
+	prefix = prefix_p;
+}
 
-	// Grow array
+Leaf::~Leaf() {
+	if (!IsInlined()) {
+		DeleteArray<row_t>(rowids.ptr, rowids.ptr[0] + 1);
+		count = 0;
+	}
+}
+
+row_t *Leaf::Resize(row_t *current_row_ids, uint32_t current_count, idx_t new_capacity) {
+	D_ASSERT(new_capacity >= current_count);
+	auto new_allocation = AllocateArray<row_t>(new_capacity + 1);
+	new_allocation[0] = new_capacity;
+	auto new_row_ids = new_allocation + 1;
+	memcpy(new_row_ids, current_row_ids, current_count * sizeof(row_t));
+	if (!IsInlined()) {
+		// delete the old data
+		DeleteArray<row_t>(rowids.ptr, rowids.ptr[0] + 1);
+	}
+	// set up the new pointers
+	rowids.ptr = new_allocation;
+	return new_row_ids;
+}
+
+void Leaf::Insert(row_t row_id) {
+	auto capacity = GetCapacity();
+	row_t *row_ids = GetRowIds();
+	D_ASSERT(count <= capacity);
 	if (count == capacity) {
-		auto new_row_id = unique_ptr<row_t[]>(new row_t[capacity * 2]);
-		memcpy(new_row_id.get(), row_ids.get(), capacity * sizeof(row_t));
-		capacity *= 2;
-		row_ids = move(new_row_id);
+		// Grow array
+		row_ids = Resize(row_ids, count, capacity * 2);
 	}
 	row_ids[count++] = row_id;
 }
 
 void Leaf::Remove(row_t row_id) {
 	idx_t entry_offset = DConstants::INVALID_INDEX;
+	row_t *row_ids = GetRowIds();
 	for (idx_t i = 0; i < count; i++) {
 		if (row_ids[i] == row_id) {
 			entry_offset = i;
@@ -61879,33 +62000,48 @@ void Leaf::Remove(row_t row_id) {
 	if (entry_offset == DConstants::INVALID_INDEX) {
 		return;
 	}
+	if (IsInlined()) {
+		D_ASSERT(count == 1);
+		count--;
+		return;
+	}
 	count--;
+	if (count == 1) {
+		// after erasing we can now inline the leaf
+		// delete the pointer and inline the remaining rowid
+		auto remaining_row_id = row_ids[0] == row_id ? row_ids[1] : row_ids[0];
+		DeleteArray<row_t>(rowids.ptr, rowids.ptr[0] + 1);
+		rowids.inlined = remaining_row_id;
+		return;
+	}
+	auto capacity = GetCapacity();
 	if (capacity > 2 && count < capacity / 2) {
 		// Shrink array, if less than half full
-		auto new_row_id = unique_ptr<row_t[]>(new row_t[capacity / 2]);
-		memcpy(new_row_id.get(), row_ids.get(), entry_offset * sizeof(row_t));
-		memcpy(new_row_id.get() + entry_offset, row_ids.get() + entry_offset + 1,
-		       (count - entry_offset) * sizeof(row_t));
-		capacity /= 2;
-		row_ids = move(new_row_id);
+		auto new_capacity = capacity / 2;
+		auto new_allocation = AllocateArray<row_t>(new_capacity + 1);
+		new_allocation[0] = new_capacity;
+		auto new_row_ids = new_allocation + 1;
+		memcpy(new_row_ids, row_ids, entry_offset * sizeof(row_t));
+		memcpy(new_row_ids + entry_offset, row_ids + entry_offset + 1, (count - entry_offset) * sizeof(row_t));
+		DeleteArray<row_t>(rowids.ptr, rowids.ptr[0] + 1);
+		rowids.ptr = new_allocation;
 	} else {
 		// Copy the rest
-		memmove(row_ids.get() + entry_offset, row_ids.get() + entry_offset + 1, (count - entry_offset) * sizeof(row_t));
+		memmove(row_ids + entry_offset, row_ids + entry_offset + 1, (count - entry_offset) * sizeof(row_t));
 	}
 }
 
 string Leaf::ToString(Node *node) {
-
 	Leaf *leaf = (Leaf *)node;
 	string str = "Leaf: [";
+	auto row_ids = leaf->GetRowIds();
 	for (idx_t i = 0; i < leaf->count; i++) {
-		str += i == 0 ? to_string(leaf->row_ids[i]) : ", " + to_string(leaf->row_ids[i]);
+		str += i == 0 ? to_string(row_ids[i]) : ", " + to_string(row_ids[i]);
 	}
 	return str + "]";
 }
 
 void Leaf::Merge(Node *&l_node, Node *&r_node) {
-
 	Leaf *l_n = (Leaf *)l_node;
 	Leaf *r_n = (Leaf *)r_node;
 
@@ -61923,8 +62059,9 @@ BlockPointer Leaf::Serialize(duckdb::MetaBlockWriter &writer) {
 	prefix.Serialize(writer);
 	// Write Row Ids
 	// Length
-	writer.Write(count);
+	writer.Write<uint16_t>(count);
 	// Actual Row Ids
+	auto row_ids = GetRowIds();
 	for (idx_t i = 0; i < count; i++) {
 		writer.Write(row_ids[i]);
 	}
@@ -61935,11 +62072,19 @@ Leaf *Leaf::Deserialize(MetaBlockReader &reader) {
 	Prefix prefix;
 	prefix.Deserialize(reader);
 	auto num_elements = reader.Read<uint16_t>();
-	auto elements = unique_ptr<row_t[]>(new row_t[num_elements]);
-	for (idx_t i = 0; i < num_elements; i++) {
-		elements[i] = reader.Read<row_t>();
+	if (num_elements == 1) {
+		// inlined
+		auto element = reader.Read<row_t>();
+		return Leaf::New(element, prefix);
+	} else {
+		// non-inlined
+		auto elements = AllocateArray<row_t>(num_elements + 1);
+		elements[0] = num_elements;
+		for (idx_t i = 0; i < num_elements; i++) {
+			elements[i + 1] = reader.Read<row_t>();
+		}
+		return Leaf::New(elements, num_elements, prefix);
 	}
-	return new Leaf(move(elements), num_elements, prefix);
 }
 
 } // namespace duckdb
@@ -62074,25 +62219,78 @@ NodeType Node::GetTypeBySize(idx_t size) {
 }
 
 void Node::New(NodeType &type, Node *&node) {
-
 	switch (type) {
 	case NodeType::N4:
-		node = new Node4();
+		node = (Node *)Node4::New();
 		return;
 	case NodeType::N16:
-		node = new Node16();
+		node = (Node *)Node16::New();
 		return;
 	case NodeType::N48:
-		node = new Node48();
+		node = (Node *)Node48::New();
 		return;
 	case NodeType::N256:
-		node = new Node256();
+		node = (Node *)Node256::New();
 		return;
 	default:
 		throw InternalException("Unrecognized type for new node creation!");
 	}
 }
 
+Node4 *Node4::New() {
+	return AllocateObject<Node4>();
+}
+
+Node16 *Node16::New() {
+	return AllocateObject<Node16>();
+}
+
+Node48 *Node48::New() {
+	return AllocateObject<Node48>();
+}
+
+Node256 *Node256::New() {
+	return AllocateObject<Node256>();
+}
+
+Leaf *Leaf::New(Key &value, uint32_t depth, row_t row_id) {
+	return AllocateObject<Leaf>(value, depth, row_id);
+}
+
+Leaf *Leaf::New(Key &value, uint32_t depth, row_t *row_ids, idx_t num_elements) {
+	return AllocateObject<Leaf>(value, depth, row_ids, num_elements);
+}
+
+Leaf *Leaf::New(row_t *row_ids, idx_t num_elements, Prefix &prefix) {
+	return AllocateObject<Leaf>(row_ids, num_elements, prefix);
+}
+
+Leaf *Leaf::New(row_t row_id, Prefix &prefix) {
+	return AllocateObject<Leaf>(row_id, prefix);
+}
+
+void Node::Delete(Node *ptr) {
+	switch (ptr->type) {
+	case NodeType::NLeaf:
+		DestroyObject((Leaf *)ptr);
+		break;
+	case NodeType::N4:
+		DestroyObject((Node4 *)ptr);
+		break;
+	case NodeType::N16:
+		DestroyObject((Node16 *)ptr);
+		break;
+	case NodeType::N48:
+		DestroyObject((Node48 *)ptr);
+		break;
+	case NodeType::N256:
+		DestroyObject((Node256 *)ptr);
+		break;
+	default:
+		throw InternalException("eek");
+	}
+}
+
 string Node::ToString(ART &art) {
 
 	string str = "Node";
@@ -62133,7 +62331,7 @@ BlockPointer Node::SerializeInternal(ART &art, duckdb::MetaBlockWriter &writer,
 	// Write Node Type
 	writer.Write(type);
 	// Write count
-	writer.Write(count);
+	writer.Write<uint16_t>(count);
 	// Write Prefix
 	prefix.Serialize(writer);
 	// Write Key values
@@ -62190,19 +62388,19 @@ Node *Node::Deserialize(ART &art, idx_t block_id, idx_t offset) {
 	case NodeType::NLeaf:
 		return Leaf::Deserialize(reader);
 	case NodeType::N4: {
-		deserialized_node = (Node *)new Node4();
+		deserialized_node = (Node *)Node4::New();
 		break;
 	}
 	case NodeType::N16: {
-		deserialized_node = (Node *)new Node16();
+		deserialized_node = (Node *)Node16::New();
 		break;
 	}
 	case NodeType::N48: {
-		deserialized_node = (Node *)new Node48();
+		deserialized_node = (Node *)Node48::New();
 		break;
 	}
 	case NodeType::N256: {
-		deserialized_node = (Node *)new Node256();
+		deserialized_node = (Node *)Node256::New();
 		break;
 	}
 	}
@@ -62211,7 +62409,6 @@ Node *Node::Deserialize(ART &art, idx_t block_id, idx_t offset) {
 }
 
 void UpdateParentsOfNodes(Node *&l_node, Node *&r_node, ParentsOfNodes &parents) {
-
 	if (parents.l_parent) {
 		parents.l_parent->ReplaceChildPointer(parents.l_pos, l_node);
 	}
@@ -62255,7 +62452,6 @@ bool Merge(MergeInfo &info, idx_t depth, ParentsOfNodes &parents) {
 }
 
 bool ResolvePrefixesAndMerge(MergeInfo &info, idx_t depth, ParentsOfNodes &parents) {
-
 	auto &l_node = info.l_node;
 	auto &r_node = info.r_node;
 	Node *null_parent = nullptr;
@@ -62308,7 +62504,7 @@ bool ResolvePrefixesAndMerge(MergeInfo &info, idx_t depth, ParentsOfNodes &paren
 	// prefixes differ, create new node and insert both nodes as children
 
 	// create new node
-	Node *new_node = new Node4();
+	Node *new_node = Node4::New();
 	new_node->prefix = Prefix(l_node->prefix, mismatch_pos);
 
 	// insert l_node, break up prefix of l_node
@@ -62435,7 +62631,7 @@ void Node16::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
 		n->count++;
 	} else {
 		// Grow to Node48
-		auto new_node = new Node48();
+		auto new_node = Node48::New();
 		for (idx_t i = 0; i < node->count; i++) {
 			new_node->child_index[n->key[i]] = i;
 			new_node->children[i] = n->children[i];
@@ -62443,7 +62639,7 @@ void Node16::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
 		}
 		new_node->prefix = move(n->prefix);
 		new_node->count = node->count;
-		delete node;
+		Node::Delete(node);
 		node = new_node;
 
 		Node48::InsertChild(node, key_byte, new_child);
@@ -62470,14 +62666,14 @@ void Node16::EraseChild(Node *&node, int pos, ART &art) {
 
 	if (node->count <= 3) {
 		// Shrink node
-		auto new_node = new Node4();
+		auto new_node = Node4::New();
 		for (unsigned i = 0; i < n->count; i++) {
 			new_node->key[new_node->count] = n->key[i];
 			new_node->children[new_node->count++] = n->children[i];
 			n->children[i] = nullptr;
 		}
 		new_node->prefix = move(n->prefix);
-		delete node;
+		Node::Delete(node);
 		node = new_node;
 	}
 }
@@ -62570,7 +62766,7 @@ void Node256::EraseChild(Node *&node, int pos, ART &art) {
 	n->children[pos].Reset();
 	n->count--;
 	if (node->count <= 36) {
-		auto new_node = new Node48();
+		auto new_node = Node48::New();
 		new_node->prefix = move(n->prefix);
 		for (idx_t i = 0; i < 256; i++) {
 			if (n->children[i]) {
@@ -62580,7 +62776,7 @@ void Node256::EraseChild(Node *&node, int pos, ART &art) {
 				new_node->count++;
 			}
 		}
-		delete node;
+		Node::Delete(node);
 		node = new_node;
 	}
 }
@@ -62682,7 +62878,7 @@ void Node4::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
 		n->count++;
 	} else {
 		// Grow to Node16
-		auto new_node = new Node16();
+		auto new_node = Node16::New();
 		new_node->count = 4;
 		new_node->prefix = move(node->prefix);
 		for (idx_t i = 0; i < 4; i++) {
@@ -62691,7 +62887,7 @@ void Node4::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
 			n->children[i] = nullptr;
 		}
 		// Delete old node and replace it with new Node16
-		delete node;
+		Node::Delete(node);
 		node = new_node;
 		Node16::InsertChild(node, key_byte, new_child);
 	}
@@ -62719,7 +62915,7 @@ void Node4::EraseChild(Node *&node, int pos, ART &art) {
 		// concatenate prefixes
 		child_ref->prefix.Concatenate(n->key[0], node->prefix);
 		n->children[0] = nullptr;
-		delete node;
+		Node::Delete(node);
 		node = child_ref;
 	}
 }
@@ -62824,7 +63020,7 @@ void Node48::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
 		n->count++;
 	} else {
 		// Grow to Node256
-		auto new_node = new Node256();
+		auto new_node = Node256::New();
 		for (idx_t i = 0; i < 256; i++) {
 			if (n->child_index[i] != Node::EMPTY_MARKER) {
 				new_node->children[i] = n->children[n->child_index[i]];
@@ -62833,7 +63029,7 @@ void Node48::InsertChild(Node *&node, uint8_t key_byte, Node *new_child) {
 		}
 		new_node->count = n->count;
 		new_node->prefix = move(n->prefix);
-		delete node;
+		Node::Delete(node);
 		node = new_node;
 		Node256::InsertChild(node, key_byte, new_child);
 	}
@@ -62845,7 +63041,7 @@ void Node48::EraseChild(Node *&node, int pos, ART &art) {
 	n->child_index[pos] = Node::EMPTY_MARKER;
 	n->count--;
 	if (node->count <= 12) {
-		auto new_node = new Node16();
+		auto new_node = Node16::New();
 		new_node->prefix = move(n->prefix);
 		for (idx_t i = 0; i < 256; i++) {
 			if (n->child_index[i] != Node::EMPTY_MARKER) {
@@ -62854,7 +63050,7 @@ void Node48::EraseChild(Node *&node, int pos, ART &art) {
 				n->children[n->child_index[i]] = nullptr;
 			}
 		}
-		delete node;
+		Node::Delete(node);
 		node = new_node;
 	}
 }
@@ -62889,12 +63085,38 @@ uint32_t Prefix::Size() const {
 	return size;
 }
 
+bool Prefix::IsInlined() const {
+	return size <= PREFIX_INLINE_BYTES;
+}
+
+uint8_t *Prefix::GetPrefixData() {
+	return IsInlined() ? &value.inlined[0] : value.ptr;
+}
+
+const uint8_t *Prefix::GetPrefixData() const {
+	return IsInlined() ? &value.inlined[0] : value.ptr;
+}
+
+uint8_t *Prefix::AllocatePrefix(uint32_t size) {
+	Destroy();
+
+	this->size = size;
+	uint8_t *prefix;
+	if (IsInlined()) {
+		prefix = &value.inlined[0];
+	} else {
+		// allocate new prefix
+		value.ptr = AllocateArray<uint8_t>(size);
+		prefix = value.ptr;
+	}
+	return prefix;
+}
+
 Prefix::Prefix() : size(0) {
 }
 
-Prefix::Prefix(Key &key, uint32_t depth, uint32_t size) : size(size) {
-	// allocate new prefix
-	prefix = unique_ptr<uint8_t[]>(new uint8_t[size]);
+Prefix::Prefix(Key &key, uint32_t depth, uint32_t size) : size(0) {
+	auto prefix = AllocatePrefix(size);
 
 	// copy key to prefix
 	idx_t prefix_idx = 0;
@@ -62903,43 +63125,72 @@ Prefix::Prefix(Key &key, uint32_t depth, uint32_t size) : size(size) {
 	}
 }
 
-Prefix::Prefix(Prefix &other_prefix, uint32_t size) : size(size) {
-	// allocate new prefix
-	prefix = unique_ptr<uint8_t[]>(new uint8_t[size]);
+Prefix::Prefix(Prefix &other_prefix, uint32_t size) : size(0) {
+	auto prefix = AllocatePrefix(size);
 
 	// copy key to Prefix
+	auto other_data = other_prefix.GetPrefixData();
 	for (idx_t i = 0; i < size; i++) {
-		prefix[i] = other_prefix[i];
+		prefix[i] = other_data[i];
+	}
+}
+
+Prefix::~Prefix() {
+	Destroy();
+}
+
+void Prefix::Destroy() {
+	if (!IsInlined()) {
+		DeleteArray<uint8_t>(value.ptr, size);
+		size = 0;
 	}
 }
 
 uint8_t &Prefix::operator[](idx_t idx) {
 	D_ASSERT(idx < Size());
-	return prefix[idx];
+	return GetPrefixData()[idx];
 }
 
 Prefix &Prefix::operator=(const Prefix &src) {
-	// allocate new prefix
-	prefix = unique_ptr<uint8_t[]>(new uint8_t[src.size]);
+	auto prefix = AllocatePrefix(src.size);
 
 	// copy prefix
+	auto src_prefix = src.GetPrefixData();
 	for (idx_t i = 0; i < src.size; i++) {
-		prefix[i] = src.prefix[i];
+		prefix[i] = src_prefix[i];
 	}
 	size = src.size;
 	return *this;
 }
 
 Prefix &Prefix::operator=(Prefix &&other) noexcept {
-	prefix = move(other.prefix);
-	size = other.size;
+	std::swap(size, other.size);
+	std::swap(value, other.value);
 	return *this;
 }
 
+void Prefix::Overwrite(uint32_t new_size, uint8_t *data) {
+	if (new_size <= PREFIX_INLINE_BYTES) {
+		// new entry would be inlined
+		// inline the data and destroy the pointer
+		auto prefix = AllocatePrefix(new_size);
+		for (idx_t i = 0; i < new_size; i++) {
+			prefix[i] = data[i];
+		}
+		DeleteArray<uint8_t>(data, new_size);
+	} else {
+		// new entry would not be inlined
+		// take over the data directly
+		Destroy();
+		size = new_size;
+		value.ptr = data;
+	}
+}
+
 void Prefix::Concatenate(uint8_t key, Prefix &other) {
 	auto new_length = size + 1 + other.size;
 	// have to allocate space in our prefix array
-	unique_ptr<uint8_t[]> new_prefix = unique_ptr<uint8_t[]>(new uint8_t[new_length]);
+	auto new_prefix = AllocateArray<uint8_t>(new_length);
 	idx_t new_prefix_idx = 0;
 	// 1) add the to-be deleted node's prefix
 	for (uint32_t i = 0; i < other.size; i++) {
@@ -62948,42 +63199,46 @@ void Prefix::Concatenate(uint8_t key, Prefix &other) {
 	// 2) now move the current key as part of the prefix
 	new_prefix[new_prefix_idx++] = key;
 	// 3) move the existing prefix (if any)
+	auto prefix = GetPrefixData();
 	for (uint32_t i = 0; i < size; i++) {
 		new_prefix[new_prefix_idx++] = prefix[i];
 	}
-	prefix = move(new_prefix);
-	size = new_length;
+	Overwrite(new_length, new_prefix);
 }
 
 uint8_t Prefix::Reduce(uint32_t n) {
 	auto new_size = size - n - 1;
-	auto new_prefix = unique_ptr<uint8_t[]>(new uint8_t[new_size]);
+	auto prefix = GetPrefixData();
 	auto key = prefix[n];
+	if (new_size == 0) {
+		Destroy();
+		size = 0;
+		return key;
+	}
+	auto new_prefix = AllocateArray<uint8_t>(new_size);
 	for (idx_t i = 0; i < new_size; i++) {
 		new_prefix[i] = prefix[i + n + 1];
 	}
-	prefix = move(new_prefix);
-	size = new_size;
+	Overwrite(new_size, new_prefix);
 	return key;
 }
 
 void Prefix::Serialize(duckdb::MetaBlockWriter &writer) {
 	writer.Write(size);
-	for (idx_t i = 0; i < size; i++) {
-		writer.Write(prefix[i]);
-	}
+	auto prefix = GetPrefixData();
+	writer.WriteData(prefix, size);
 }
 
 void Prefix::Deserialize(duckdb::MetaBlockReader &reader) {
-	size = reader.Read<uint32_t>();
-	prefix = unique_ptr<uint8_t[]>(new uint8_t[size]);
-	for (idx_t i = 0; i < size; i++) {
-		prefix[i] = reader.Read<uint8_t>();
-	}
+	auto prefix_size = reader.Read<uint32_t>();
+	auto prefix = AllocatePrefix(prefix_size);
+	this->size = prefix_size;
+	reader.ReadData(prefix, size);
 }
 
 uint32_t Prefix::KeyMismatchPosition(Key &key, uint64_t depth) {
 	uint64_t pos;
+	auto prefix = GetPrefixData();
 	for (pos = 0; pos < size; pos++) {
 		if (key[depth + pos] != prefix[pos]) {
 			return pos;
@@ -62993,9 +63248,10 @@ uint32_t Prefix::KeyMismatchPosition(Key &key, uint64_t depth) {
 }
 
 uint32_t Prefix::MismatchPosition(Prefix &other) {
-
+	auto prefix = GetPrefixData();
+	auto other_data = other.GetPrefixData();
 	for (idx_t i = 0; i < size; i++) {
-		if (prefix[i] != other[i]) {
+		if (prefix[i] != other_data[i]) {
 			return i;
 		}
 	}
@@ -63009,7 +63265,7 @@ namespace duckdb {
 SwizzleablePointer::~SwizzleablePointer() {
 	if (pointer) {
 		if (!IsSwizzled()) {
-			delete (Node *)pointer;
+			Node::Delete((Node *)pointer);
 		}
 	}
 }
@@ -63071,7 +63327,7 @@ bool SwizzleablePointer::IsSwizzled() {
 void SwizzleablePointer::Reset() {
 	if (pointer) {
 		if (!IsSwizzled()) {
-			delete (Node *)pointer;
+			Node::Delete((Node *)pointer);
 		}
 	}
 	*this = nullptr;
@@ -81125,17 +81381,21 @@ bool BufferedCSVReader::TryParseCSV(ParserMode parser_mode, DataChunk &insert_ch
 
 namespace duckdb {
 
-CSVBuffer::CSVBuffer(idx_t buffer_size_p, CSVFileHandle &file_handle) : first_buffer(true) {
-	buffer = unique_ptr<char[]>(new char[buffer_size_p]);
-	actual_size = file_handle.Read(buffer.get(), buffer_size_p);
+CSVBuffer::CSVBuffer(ClientContext &context, idx_t buffer_size_p, CSVFileHandle &file_handle)
+    : context(context), first_buffer(true) {
+	this->handle = AllocateBuffer(buffer_size_p);
+
+	auto buffer = Ptr();
+	actual_size = file_handle.Read(buffer, buffer_size_p);
 	if (actual_size >= 3 && buffer[0] == '\xEF' && buffer[1] == '\xBB' && buffer[2] == '\xBF') {
 		start_position += 3;
 	}
 	last_buffer = file_handle.FinishedReading();
 }
 
-CSVBuffer::CSVBuffer(unique_ptr<char[]> buffer_p, idx_t buffer_size_p, idx_t actual_size_p, bool final_buffer)
-    : buffer(move(buffer_p)), actual_size(actual_size_p), last_buffer(final_buffer) {
+CSVBuffer::CSVBuffer(ClientContext &context, BufferHandle buffer_p, idx_t buffer_size_p, idx_t actual_size_p,
+                     bool final_buffer)
+    : context(context), handle(move(buffer_p)), actual_size(actual_size_p), last_buffer(final_buffer) {
 }
 
 unique_ptr<CSVBuffer> CSVBuffer::Next(CSVFileHandle &file_handle, idx_t set_buffer_size) {
@@ -81144,14 +81404,18 @@ unique_ptr<CSVBuffer> CSVBuffer::Next(CSVFileHandle &file_handle, idx_t set_buff
 		return nullptr;
 	}
 
-	auto next_buffer = unique_ptr<char[]>(new char[set_buffer_size]);
-
-	idx_t next_buffer_actual_size = file_handle.Read(next_buffer.get(), set_buffer_size);
+	auto next_buffer = AllocateBuffer(set_buffer_size);
+	idx_t next_buffer_actual_size = file_handle.Read(next_buffer.Ptr(), set_buffer_size);
 
-	return make_unique<CSVBuffer>(move(next_buffer), set_buffer_size, next_buffer_actual_size,
+	return make_unique<CSVBuffer>(context, move(next_buffer), set_buffer_size, next_buffer_actual_size,
 	                              file_handle.FinishedReading());
 }
 
+BufferHandle CSVBuffer::AllocateBuffer(idx_t buffer_size) {
+	auto &buffer_manager = BufferManager::GetBufferManager(context);
+	return buffer_manager.Allocate(MaxValue<idx_t>(Storage::BLOCK_SIZE, buffer_size));
+}
+
 idx_t CSVBuffer::GetBufferSize() {
 	return actual_size;
 }
@@ -81202,6 +81466,9 @@ static bool ParseBoolean(const Value &value, const string &loption) {
 }
 
 static string ParseString(const Value &value, const string &loption) {
+	if (value.IsNull()) {
+		return string();
+	}
 	if (value.type().id() == LogicalTypeId::LIST) {
 		auto &children = ListValue::GetChildren(value);
 		if (children.size() != 1) {
@@ -81356,6 +81623,11 @@ void BufferedCSVReaderOptions::SetReadOption(const string &loption, const Value
 		ignore_errors = ParseBoolean(value, loption);
 	} else if (loption == "union_by_name") {
 		union_by_name = ParseBoolean(value, loption);
+	} else if (loption == "buffer_size") {
+		buffer_size = ParseInteger(value, loption);
+		if (buffer_size == 0) {
+			throw InvalidInputException("Buffer Size option must be higher than 0");
+		}
 	} else {
 		throw BinderException("Unrecognized option for CSV reader \"%s\"", loption);
 	}
@@ -81469,34 +81741,38 @@ struct CSVBufferRead {
 
 	const char &operator[](size_t i) const {
 		if (i < buffer->GetBufferSize()) {
-			return buffer->buffer[i];
+			auto buffer_ptr = buffer->Ptr();
+			return buffer_ptr[i];
 		}
-		return next_buffer->buffer[i - buffer->GetBufferSize()];
+		auto next_ptr = next_buffer->Ptr();
+		return next_ptr[i - buffer->GetBufferSize()];
 	}
 
 	string_t GetValue(idx_t start_buffer, idx_t position_buffer, idx_t offset) {
 		idx_t length = position_buffer - start_buffer - offset;
 		// 1) It's all in the current buffer
 		if (start_buffer + length <= buffer->GetBufferSize()) {
-			auto buffer_ptr = buffer->buffer.get();
+			auto buffer_ptr = buffer->Ptr();
 			return string_t(buffer_ptr + start_buffer, length);
 		} else if (start_buffer >= buffer->GetBufferSize()) {
 			// 2) It's all in the next buffer
 			D_ASSERT(next_buffer);
 			D_ASSERT(next_buffer->GetBufferSize() >= length + (start_buffer - buffer->GetBufferSize()));
-			auto buffer_ptr = next_buffer->buffer.get();
+			auto buffer_ptr = next_buffer->Ptr();
 			return string_t(buffer_ptr + (start_buffer - buffer->GetBufferSize()), length);
 		} else {
 			// 3) It starts in the current buffer and ends in the next buffer
 			D_ASSERT(next_buffer);
 			auto intersection = unique_ptr<char[]>(new char[length]);
 			idx_t cur_pos = 0;
+			auto buffer_ptr = buffer->Ptr();
 			for (idx_t i = start_buffer; i < buffer->GetBufferSize(); i++) {
-				intersection[cur_pos++] = buffer->buffer[i];
+				intersection[cur_pos++] = buffer_ptr[i];
 			}
 			idx_t nxt_buffer_pos = 0;
+			auto next_buffer_ptr = next_buffer->Ptr();
 			for (; cur_pos < length; cur_pos++) {
-				intersection[cur_pos] = next_buffer->buffer[nxt_buffer_pos++];
+				intersection[cur_pos] = next_buffer_ptr[nxt_buffer_pos++];
 			}
 			intersections.emplace_back(move(intersection));
 			return string_t(intersections.back().get(), length);
@@ -81809,10 +82085,11 @@ normal : {
 	/* state: normal parsing state */
 	// this state parses the remainder of a non-quoted value until we reach a delimiter or newline
 	for (; position_buffer < end_buffer; position_buffer++) {
-		if ((*buffer)[position_buffer] == options.delimiter[0]) {
+		auto c = (*buffer)[position_buffer];
+		if (c == options.delimiter[0]) {
 			// delimiter: end the value and add it to the chunk
 			goto add_value;
-		} else if (StringUtil::CharacterIsNewline((*buffer)[position_buffer])) {
+		} else if (StringUtil::CharacterIsNewline(c)) {
 			// newline: add row
 			D_ASSERT(try_add_line || column == insert_chunk.ColumnCount() - 1);
 			goto add_row;
@@ -81882,10 +82159,11 @@ in_quotes:
 	has_quotes = true;
 	position_buffer++;
 	for (; position_buffer < end_buffer; position_buffer++) {
-		if ((*buffer)[position_buffer] == options.quote[0]) {
+		auto c = (*buffer)[position_buffer];
+		if (c == options.quote[0]) {
 			// quote: move to unquoted state
 			goto unquote;
-		} else if ((*buffer)[position_buffer] == options.escape[0]) {
+		} else if (c == options.escape[0]) {
 			// escape: store the escaped position and move to handle_escape state
 			escape_positions.push_back(position_buffer - start_buffer);
 			goto handle_escape;
@@ -81907,7 +82185,7 @@ in_quotes:
 		goto in_quotes;
 	}
 
-unquote:
+unquote : {
 	/* state: unquote: this state handles the state directly after we unquote*/
 	//
 	// in this state we expect either another quote (entering the quoted state again, and escaping the quote)
@@ -81917,16 +82195,16 @@ unquote:
 		offset = 1;
 		goto final_state;
 	}
-	if ((*buffer)[position_buffer] == options.quote[0] &&
-	    (options.escape.empty() || options.escape[0] == options.quote[0])) {
+	auto c = (*buffer)[position_buffer];
+	if (c == options.quote[0] && (options.escape.empty() || options.escape[0] == options.quote[0])) {
 		// escaped quote, return to quoted state and store escape position
 		escape_positions.push_back(position_buffer - start_buffer);
 		goto in_quotes;
-	} else if ((*buffer)[position_buffer] == options.delimiter[0]) {
+	} else if (c == options.delimiter[0]) {
 		// delimiter, add value
 		offset = 1;
 		goto add_value;
-	} else if (StringUtil::CharacterIsNewline((*buffer)[position_buffer])) {
+	} else if (StringUtil::CharacterIsNewline(c)) {
 		offset = 1;
 		D_ASSERT(column == insert_chunk.ColumnCount() - 1);
 		goto add_row;
@@ -81941,6 +82219,7 @@ unquote:
 		    options.file_path, GetLineNumberStr(linenr, linenr_estimated).c_str(), options.ToString());
 		return false;
 	}
+}
 handle_escape : {
 	/* state: handle_escape */
 	// escape should be followed by a quote or another escape character
@@ -124848,7 +125127,7 @@ void SubstringDetection(string &str_1, string &str_2, const string &name_str_1,
 	if (str_1.empty() || str_2.empty()) {
 		return;
 	}
-	if ((str_1.find(str_2) != string::npos || str_2.find(str_1) != std::string::npos) && str_1 != "NULL") {
+	if ((str_1.find(str_2) != string::npos || str_2.find(str_1) != std::string::npos)) {
 		throw BinderException("%s must not appear in the %s specification and vice versa", name_str_1, name_str_2);
 	}
 }
@@ -124941,6 +125220,11 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, CopyInfo &in
 		options.force_not_null.resize(expected_types.size(), false);
 	}
 	bind_data->FinalizeRead(context);
+	if (!bind_data->single_threaded && options.auto_detect) {
+		options.file_path = bind_data->files[0];
+		auto initial_reader = make_unique<BufferedCSVReader>(context, options);
+		options = initial_reader->options;
+	}
 	return move(bind_data);
 }
 
@@ -126083,11 +126367,6 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 			options.include_file_name = BooleanValue::Get(kv.second);
 		} else if (loption == "hive_partitioning") {
 			options.include_parsed_hive_partitions = BooleanValue::Get(kv.second);
-		} else if (loption == "buffer_size") {
-			options.buffer_size = kv.second.GetValue<uint64_t>();
-			if (options.buffer_size == 0) {
-				throw InvalidInputException("Buffer Size option must be higher than 0");
-			}
 		} else {
 			options.SetReadOption(loption, kv.second, names);
 		}
@@ -126106,7 +126385,7 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 		} else {
 			D_ASSERT(return_types.size() == names.size());
 		}
-		options = result->options;
+		options = initial_reader->options;
 		result->sql_types = initial_reader->sql_types;
 		result->initial_reader = move(initial_reader);
 	} else {
@@ -126204,8 +126483,9 @@ static unique_ptr<FunctionData> ReadCSVAutoBind(ClientContext &context, TableFun
 //===--------------------------------------------------------------------===//
 struct ParallelCSVGlobalState : public GlobalTableFunctionState {
 public:
-	ParallelCSVGlobalState(unique_ptr<CSVFileHandle> file_handle_p, vector<string> &files_path_p,
-	                       idx_t system_threads_p, idx_t buffer_size_p, idx_t rows_to_skip)
+	ParallelCSVGlobalState(ClientContext &context, unique_ptr<CSVFileHandle> file_handle_p,
+	                       vector<string> &files_path_p, idx_t system_threads_p, idx_t buffer_size_p,
+	                       idx_t rows_to_skip)
 	    : file_handle(move(file_handle_p)), system_threads(system_threads_p), buffer_size(buffer_size_p) {
 		for (idx_t i = 0; i < rows_to_skip; i++) {
 			file_handle->ReadLine();
@@ -126219,7 +126499,7 @@ public:
 		} else {
 			bytes_per_local_state = file_size / MaxThreads();
 		}
-		current_buffer = make_shared<CSVBuffer>(buffer_size, *file_handle);
+		current_buffer = make_shared<CSVBuffer>(context, buffer_size, *file_handle);
 		next_buffer = current_buffer->Next(*file_handle, buffer_size);
 	}
 	ParallelCSVGlobalState() {
@@ -126306,7 +126586,7 @@ unique_ptr<CSVBufferRead> ParallelCSVGlobalState::Next(ClientContext &context, R
 		if (file_index < bind_data.files.size()) {
 			bind_data.options.file_path = bind_data.files[file_index++];
 			file_handle = ReadCSV::OpenCSV(bind_data.options, context);
-			next_buffer = make_shared<CSVBuffer>(buffer_size, *file_handle);
+			next_buffer = make_shared<CSVBuffer>(context, buffer_size, *file_handle);
 		}
 	}
 	return result;
@@ -126327,8 +126607,9 @@ static unique_ptr<GlobalTableFunctionState> ParallelCSVInitGlobal(ClientContext
 		file_handle = ReadCSV::OpenCSV(bind_data.options, context);
 	}
 	idx_t rows_to_skip = bind_data.options.skip_rows + (bind_data.options.has_header ? 1 : 0);
-	return make_unique<ParallelCSVGlobalState>(move(file_handle), bind_data.files, context.db->NumberOfThreads(),
-	                                           bind_data.options.buffer_size, rows_to_skip);
+	return make_unique<ParallelCSVGlobalState>(context, move(file_handle), bind_data.files,
+	                                           context.db->NumberOfThreads(), bind_data.options.buffer_size,
+	                                           rows_to_skip);
 }
 
 //===--------------------------------------------------------------------===//
@@ -138102,6 +138383,9 @@ void DatabaseInstance::Configure(DBConfig &new_config) {
 	if (!config.error_manager) {
 		config.error_manager = make_unique<ErrorManager>();
 	}
+	if (!config.default_allocator) {
+		config.default_allocator = Allocator::DefaultAllocatorReference();
+	}
 }
 
 DBConfig &DBConfig::GetConfig(ClientContext &context) {
@@ -202438,6 +202722,22 @@ string BufferManager::InMemoryWarning() {
 	       "\nOr set PRAGMA temp_directory='/path/to/tmp.tmp'";
 }
 
+void BufferManager::ReserveMemory(idx_t size) {
+	if (size == 0) {
+		return;
+	}
+	auto reservation =
+	    EvictBlocksOrThrow(size, maximum_memory, nullptr, "failed to reserve memory data of size %lld%s", size);
+	reservation.size = 0;
+}
+
+void BufferManager::FreeReservedMemory(idx_t size) {
+	if (size == 0) {
+		return;
+	}
+	current_memory -= size;
+}
+
 //===--------------------------------------------------------------------===//
 // Buffer Allocator
 //===--------------------------------------------------------------------===//