duckdb 0.5.2-dev708.0 → 0.5.2-dev737.0

package/src/duckdb.cpp

@@ -1388,11 +1388,6 @@ CopyFunctionCatalogEntry::CopyFunctionCatalogEntry(Catalog *catalog, SchemaCatal
 
 
 
-
-
-
-
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1609,34 +1604,47 @@ inline void Radix::EncodeData(data_ptr_t dataptr, interval_t value) {
 
 
 
+
 namespace duckdb {
 
 class Key {
 public:
-	Key(unique_ptr<data_t[]> data, idx_t len);
-
-	explicit Key(idx_t len);
+	Key();
+	Key(data_ptr_t data, idx_t len);
+	Key(ArenaAllocator &allocator, idx_t len);
 
 	idx_t len;
-	unique_ptr<data_t[]> data;
+	data_ptr_t data;
 
 public:
 	template <class T>
-	static inline unique_ptr<Key> CreateKey(T element) {
-		auto data = Key::CreateData<T>(element);
-		return make_unique<Key>(move(data), sizeof(element));
+	static inline Key CreateKey(ArenaAllocator &allocator, T element) {
+		auto data = Key::CreateData<T>(allocator, element);
+		return Key(data, sizeof(element));
+	}
+
+	template <class T>
+	static inline Key CreateKey(ArenaAllocator &allocator, const Value &element) {
+		return CreateKey(allocator, element.GetValueUnsafe<T>());
 	}
 
 	template <class T>
-	static inline unique_ptr<Key> CreateKey(const Value &element) {
-		return CreateKey(element.GetValueUnsafe<T>());
+	static inline void CreateKey(ArenaAllocator &allocator, Key &key, T element) {
+		key.data = Key::CreateData<T>(allocator, element);
+		key.len = sizeof(element);
+	}
+
+	template <class T>
+	static inline void CreateKey(ArenaAllocator &allocator, Key &key, const Value element) {
+		key.data = Key::CreateData<T>(allocator, element.GetValueUnsafe<T>());
+		key.len = sizeof(element);
 	}
 
 public:
-	data_t &operator[](std::size_t i) {
+	data_t &operator[](size_t i) {
 		return data[i];
 	}
-	const data_t &operator[](std::size_t i) const {
+	const data_t &operator[](size_t i) const {
 		return data[i];
 	}
 	bool operator>(const Key &k) const;
@@ -1645,23 +1653,39 @@ public:
 	bool operator==(const Key &k) const;
 
 	bool ByteMatches(Key &other, idx_t &depth);
+	bool Empty();
+	void ConcatenateKey(ArenaAllocator &allocator, Key &concat_key);
 
 private:
 	template <class T>
-	static inline unique_ptr<data_t[]> CreateData(T value) {
-		auto data = unique_ptr<data_t[]>(new data_t[sizeof(value)]);
-		Radix::EncodeData<T>(data.get(), value);
+	static inline data_ptr_t CreateData(ArenaAllocator &allocator, T value) {
+		auto data = allocator.Allocate(sizeof(value));
+		Radix::EncodeData<T>(data, value);
 		return data;
 	}
 };
 
 template <>
-unique_ptr<Key> Key::CreateKey(string_t value);
+Key Key::CreateKey(ArenaAllocator &allocator, string_t value);
+template <>
+Key Key::CreateKey(ArenaAllocator &allocator, const char *value);
 template <>
-unique_ptr<Key> Key::CreateKey(const char *value);
+void Key::CreateKey(ArenaAllocator &allocator, Key &key, string_t value);
+template <>
+void Key::CreateKey(ArenaAllocator &allocator, Key &key, const char *value);
 
 } // namespace duckdb
 
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/index/art/iterator.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1683,6 +1707,7 @@ unique_ptr<Key> Key::CreateKey(const char *value);
 
 
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1693,7 +1718,6 @@ unique_ptr<Key> Key::CreateKey(const char *value);
 
 
 
-
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1738,6 +1762,7 @@ private:
 } // namespace duckdb
 
 
+
 namespace duckdb {
 class Prefix {
 public:
@@ -1786,7 +1811,6 @@ private:
 
 
 
-
 namespace duckdb {
 enum class NodeType : uint8_t { NLeaf = 0, N4 = 1, N16 = 2, N48 = 3, N256 = 4 };
 class ART;
@@ -1870,16 +1894,18 @@ public:
 	//! Create a new node of the specified type
 	static void New(NodeType &type, Node *&node);
 
+	//! Returns the string representation of a node
+	string ToString(ART &art);
 	//! Serialize this node
 	BlockPointer Serialize(ART &art, duckdb::MetaBlockWriter &writer);
+
 	//! Deserialize this node
 	static Node *Deserialize(ART &art, idx_t block_id, idx_t offset);
-
 	//! Merge r_node into l_node at the specified byte
-	static void MergeAtByte(MergeInfo &info, idx_t depth, idx_t &l_child_pos, idx_t &r_pos, uint8_t &key_byte,
+	static bool MergeAtByte(MergeInfo &info, idx_t depth, idx_t &l_child_pos, idx_t &r_pos, uint8_t &key_byte,
 	                        Node *&l_parent, idx_t l_pos);
 	//! Merge two ART
-	static void MergeARTs(ART *l_art, ART *r_art);
+	static bool MergeARTs(ART *l_art, ART *r_art);
 
 private:
 	//! Serialize internal nodes
@@ -1912,8 +1938,10 @@ public:
 	//! Remove a row_id from a leaf
 	void Remove(row_t row_id);
 
+	//! Returns the string representation of a leaf
+	static string ToString(Node *node);
 	//! Merge two NLeaf nodes
-	static void Merge(bool &has_constraint, Node *&l_node, Node *&r_node);
+	static void Merge(Node *&l_node, Node *&r_node);
 
 	//! Serialize a leaf
 	BlockPointer Serialize(duckdb::MetaBlockWriter &writer);
@@ -1927,10 +1955,73 @@ private:
 } // namespace duckdb
 
 
+
+namespace duckdb {
+
+struct IteratorEntry {
+	IteratorEntry() {
+	}
+	IteratorEntry(Node *node, idx_t pos) : node(node), pos(pos) {
+	}
+
+	Node *node = nullptr;
+	idx_t pos = 0;
+};
+
+//! Keeps track of the current key in the iterator
+class IteratorCurrentKey {
+public:
+	//! Push Byte
+	void Push(uint8_t key);
+	//! Pops n elements
+	void Pop(idx_t n);
+	//! Subscript operator
+	uint8_t &operator[](idx_t idx);
+	bool operator>(const Key &k) const;
+	bool operator>=(const Key &k) const;
+	bool operator==(const Key &k) const;
+
+private:
+	//! The current key position
+	idx_t cur_key_pos = 0;
+	//! The current key of the Leaf Node
+	vector<uint8_t> key;
+};
+
+class Iterator {
+public:
+	//! Current Key
+	IteratorCurrentKey cur_key;
+	//! Pointer to the ART tree we are iterating
+	ART *art = nullptr;
+
+	//! Scan the tree
+	bool Scan(Key &bound, idx_t max_count, vector<row_t> &result_ids, bool is_inclusive);
+	//! Finds minimum value of the tree
+	void FindMinimum(Node &node);
+	//! Goes to lower bound
+	bool LowerBound(Node *node, Key &key, bool inclusive);
+
+private:
+	//! Stack of iterator entries
+	stack<IteratorEntry> nodes;
+	//! Last visited leaf
+	Leaf *last_leaf = nullptr;
+	//! Go to the next node
+	bool Next();
+	//! Push part of the key to cur_key
+	void PushKey(Node *node, uint16_t pos);
+	//! Pop node
+	void PopNode();
+};
+} // namespace duckdb
+
+
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/execution/index/art/node4.hpp
+// duckdb/execution/index/art/node16.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -1977,14 +2068,14 @@ public:
 
 namespace duckdb {
 
-class Node4 : public Node {
+class Node16 : public Node {
 public:
-	Node4();
-	uint8_t key[4];
-	SwizzleablePointer children[4];
+	explicit Node16();
+	uint8_t key[16];
+	SwizzleablePointer children[16];
 
 public:
-	//! Get position of a byte, returns DConstants::INVALID_INDEX if not exists
+	//! 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
 	//! if there are no children matching the criteria
@@ -1993,18 +2084,18 @@ public:
 	idx_t GetMin() override;
 	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
 	idx_t GetNextPos(idx_t pos) override;
-	//! Get Node4 child
+	//! Get Node16 child
 	Node *GetChild(ART &art, idx_t pos) override;
 	//! Replace child pointer
 	void ReplaceChildPointer(idx_t pos, Node *node) override;
 
-	//! Insert a new child node at key_byte into the Node4
+	//! Insert a new child node at key_byte into the Node16
 	static void InsertChild(Node *&node, uint8_t key_byte, Node *new_child);
-	//! Erase the child at pos and (if necessary) merge with last child
+	//! Erase the child at pos and (if necessary) shrink to Node4
 	static void EraseChild(Node *&node, int pos, ART &art);
-	//! Merge Node4 into l_node
-	static void Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos);
-	//! Returns the size (maximum capacity) of the Node4
+	//! Merge Node16 into l_node
+	static bool Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos);
+	//! Returns the size (maximum capacity) of the Node16
 	static idx_t GetSize();
 };
 } // namespace duckdb
@@ -2012,7 +2103,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/execution/index/art/node16.hpp
+// duckdb/execution/index/art/node256.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -2023,11 +2114,10 @@ public:
 
 namespace duckdb {
 
-class Node16 : public Node {
+class Node256 : public Node {
 public:
-	explicit Node16();
-	uint8_t key[16];
-	SwizzleablePointer children[16];
+	explicit Node256();
+	SwizzleablePointer children[256];
 
 public:
 	//! Get position of a specific byte, returns DConstants::INVALID_INDEX if not exists
@@ -2039,18 +2129,18 @@ public:
 	idx_t GetMin() override;
 	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
 	idx_t GetNextPos(idx_t pos) override;
-	//! Get Node16 child
+	//! Get Node256 child
 	Node *GetChild(ART &art, idx_t pos) override;
 	//! Replace child pointer
 	void ReplaceChildPointer(idx_t pos, Node *node) override;
 
-	//! Insert a new child node at key_byte into the Node16
+	//! Insert a new child node at key_byte into the Node256
 	static void InsertChild(Node *&node, uint8_t key_byte, Node *new_child);
-	//! Erase the child at pos and (if necessary) shrink to Node4
+	//! Erase the child at pos and (if necessary) shrink to Node48
 	static void EraseChild(Node *&node, int pos, ART &art);
-	//! Merge Node16 into l_node
-	static void Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos);
-	//! Returns the size (maximum capacity) of the Node16
+	//! Merge Node256 into l_node
+	static bool Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos);
+	//! Returns the size (maximum capacity) of the Node256
 	static idx_t GetSize();
 };
 } // namespace duckdb
@@ -2058,7 +2148,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/execution/index/art/node48.hpp
+// duckdb/execution/index/art/node4.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -2069,14 +2159,14 @@ public:
 
 namespace duckdb {
 
-class Node48 : public Node {
+class Node4 : public Node {
 public:
-	explicit Node48();
-	uint8_t child_index[256];
-	SwizzleablePointer children[48];
+	Node4();
+	uint8_t key[4];
+	SwizzleablePointer children[4];
 
 public:
-	//! Get position of a specific byte, returns DConstants::INVALID_INDEX if not exists
+	//! 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
 	//! if there are no children matching the criteria
@@ -2085,18 +2175,18 @@ public:
 	idx_t GetMin() override;
 	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
 	idx_t GetNextPos(idx_t pos) override;
-	//! Get Node48 child
+	//! Get Node4 child
 	Node *GetChild(ART &art, idx_t pos) override;
 	//! Replace child pointer
 	void ReplaceChildPointer(idx_t pos, Node *node) override;
 
-	//! Insert a new child node at key_byte into the Node48
+	//! Insert a new child node at key_byte into the Node4
 	static void InsertChild(Node *&node, uint8_t key_byte, Node *new_child);
-	//! Erase the child at pos and (if necessary) shrink to Node16
+	//! Erase the child at pos and (if necessary) merge with last child
 	static void EraseChild(Node *&node, int pos, ART &art);
-	//! Merge Node48 into l_node
-	static void Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos);
-	//! Returns the size (maximum capacity) of the Node48
+	//! Merge Node4 into l_node
+	static bool Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos);
+	//! Returns the size (maximum capacity) of the Node4
 	static idx_t GetSize();
 };
 } // namespace duckdb
@@ -2104,7 +2194,7 @@ public:
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// duckdb/execution/index/art/node256.hpp
+// duckdb/execution/index/art/node48.hpp
 //
 //
 //===----------------------------------------------------------------------===//
@@ -2115,10 +2205,11 @@ public:
 
 namespace duckdb {
 
-class Node256 : public Node {
+class Node48 : public Node {
 public:
-	explicit Node256();
-	SwizzleablePointer children[256];
+	explicit Node48();
+	uint8_t child_index[256];
+	SwizzleablePointer children[48];
 
 public:
 	//! Get position of a specific byte, returns DConstants::INVALID_INDEX if not exists
@@ -2130,94 +2221,25 @@ public:
 	idx_t GetMin() override;
 	//! Get the next position in the node, or DConstants::INVALID_INDEX if there is no next position
 	idx_t GetNextPos(idx_t pos) override;
-	//! Get Node256 child
+	//! Get Node48 child
 	Node *GetChild(ART &art, idx_t pos) override;
 	//! Replace child pointer
 	void ReplaceChildPointer(idx_t pos, Node *node) override;
 
-	//! Insert a new child node at key_byte into the Node256
+	//! Insert a new child node at key_byte into the Node48
 	static void InsertChild(Node *&node, uint8_t key_byte, Node *new_child);
-	//! Erase the child at pos and (if necessary) shrink to Node48
+	//! Erase the child at pos and (if necessary) shrink to Node16
 	static void EraseChild(Node *&node, int pos, ART &art);
-	//! Merge Node256 into l_node
-	static void Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos);
-	//! Returns the size (maximum capacity) of the Node256
+	//! Merge Node48 into l_node
+	static bool Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos);
+	//! Returns the size (maximum capacity) of the Node48
 	static idx_t GetSize();
 };
 } // namespace duckdb
 
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/execution/index/art/iterator.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-
-
-namespace duckdb {
-
-struct IteratorEntry {
-	IteratorEntry() {
-	}
-	IteratorEntry(Node *node, idx_t pos) : node(node), pos(pos) {
-	}
-
-	Node *node = nullptr;
-	idx_t pos = 0;
-};
 
-//! Keeps track of the current key in the iterator
-class IteratorCurrentKey {
-public:
-	//! Push Byte
-	void Push(uint8_t key);
-	//! Pops n elements
-	void Pop(idx_t n);
-	//! Subscript operator
-	uint8_t &operator[](idx_t idx);
-	bool operator>(const Key &k) const;
-	bool operator>=(const Key &k) const;
-	bool operator==(const Key &k) const;
-
-private:
-	//! The current key position
-	idx_t cur_key_pos = 0;
-	//! The current key of the Leaf Node
-	vector<uint8_t> key;
-};
-
-class Iterator {
-public:
-	//! Current Key
-	IteratorCurrentKey cur_key;
-	//! Pointer to the ART tree we are iterating
-	ART *art = nullptr;
 
-	//! Scan the tree
-	bool Scan(Key *bound, idx_t max_count, vector<row_t> &result_ids, bool is_inclusive);
-	//! Finds minimum value of the tree
-	void FindMinimum(Node &node);
-	//! Goes to lower bound
-	bool LowerBound(Node *node, Key &key, bool inclusive);
 
-private:
-	//! Stack of iterator entries
-	stack<IteratorEntry> nodes;
-	//! Last visited leaf
-	Leaf *last_leaf = nullptr;
-	//! Go to the next node
-	bool Next();
-	//! Push part of the key to cur_key
-	void PushKey(Node *node, uint16_t pos);
-	//! Pop node
-	void PopNode();
-};
-} // namespace duckdb
 
 
 namespace duckdb {
@@ -2287,33 +2309,37 @@ public:
 	//! Construct ARTs from sorted chunks and merge them.
 	void ConstructAndMerge(IndexLock &lock, PayloadScanner &scanner, Allocator &allocator) override;
 
-	bool SearchEqual(ARTIndexScanState *state, idx_t max_count, vector<row_t> &result_ids);
+	//! Search Equal and fetches the row IDs
+	bool SearchEqual(Key &key, idx_t max_count, vector<row_t> &result_ids);
 	//! Search Equal used for Joins that do not need to fetch data
-	void SearchEqualJoinNoFetch(Value &equal_value, idx_t &result_size);
+	void SearchEqualJoinNoFetch(Key &key, idx_t &result_size);
 	//! Serialized the ART
 	BlockPointer Serialize(duckdb::MetaBlockWriter &writer) override;
 
 	//! Merge two ARTs
-	static void Merge(ART *l_art, ART *r_art);
+	bool MergeIndexes(IndexLock &state, Index *other_index) override;
+	//! Generate ART keys for an input chunk
+	static void GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector<Key> &keys);
+	//! Returns the string representation of an ART
+	string ToString() override;
 
 private:
 	//! Insert a row id into a leaf node
 	bool InsertToLeaf(Leaf &leaf, row_t row_id);
 	//! Insert the leaf value into the tree
-	bool Insert(Node *&node, unique_ptr<Key> key, unsigned depth, row_t row_id);
+	bool Insert(Node *&node, Key &key, idx_t depth, row_t row_id);
 
 	//! Erase element from leaf (if leaf has more than one value) or eliminate the leaf itself
-	void Erase(Node *&node, Key &key, unsigned depth, row_t row_id);
+	void Erase(Node *&node, Key &key, idx_t depth, row_t row_id);
 
 	//! Find the node with a matching key, optimistic version
-	Node *Lookup(Node *node, Key &key, unsigned depth);
-
-	bool SearchGreater(ARTIndexScanState *state, bool inclusive, idx_t max_count, vector<row_t> &result_ids);
-	bool SearchLess(ARTIndexScanState *state, bool inclusive, idx_t max_count, vector<row_t> &result_ids);
-	bool SearchCloseRange(ARTIndexScanState *state, bool left_inclusive, bool right_inclusive, idx_t max_count,
-	                      vector<row_t> &result_ids);
+	Leaf *Lookup(Node *node, Key &key, idx_t depth);
 
-	void GenerateKeys(DataChunk &input, vector<unique_ptr<Key>> &keys);
+	bool SearchGreater(ARTIndexScanState *state, Key &key, bool inclusive, idx_t max_count, vector<row_t> &result_ids);
+	bool SearchLess(ARTIndexScanState *state, Key &upper_bound, bool inclusive, idx_t max_count,
+	                vector<row_t> &result_ids);
+	bool SearchCloseRange(ARTIndexScanState *state, Key &lower_bound, Key &upper_bound, bool left_inclusive,
+	                      bool right_inclusive, idx_t max_count, vector<row_t> &result_ids);
 
 	void VerifyExistence(DataChunk &chunk, VerifyExistenceType verify_type, string *err_msg_ptr = nullptr);
 };
@@ -33323,7 +33349,7 @@ void RowOperations::SwizzleColumns(const RowLayout &layout, const data_ptr_t bas
 			}
 			data_ptr_t col_ptr = row_ptr + layout.GetOffsets()[col_idx];
 			if (physical_type == PhysicalType::VARCHAR) {
-				data_ptr_t string_ptr = col_ptr + sizeof(uint32_t) + string_t::PREFIX_LENGTH;
+				data_ptr_t string_ptr = col_ptr + string_t::HEADER_SIZE;
 				for (idx_t i = 0; i < next; i++) {
 					if (Load<uint32_t>(col_ptr) > string_t::INLINE_LENGTH) {
 						// Overwrite the string pointer with the within-row offset (if not inlined)
@@ -33427,7 +33453,7 @@ void RowOperations::UnswizzlePointers(const RowLayout &layout, const data_ptr_t
 			}
 			data_ptr_t col_ptr = row_ptr + layout.GetOffsets()[col_idx];
 			if (physical_type == PhysicalType::VARCHAR) {
-				data_ptr_t string_ptr = col_ptr + sizeof(uint32_t) + string_t::PREFIX_LENGTH;
+				data_ptr_t string_ptr = col_ptr + string_t::HEADER_SIZE;
 				for (idx_t i = 0; i < next; i++) {
 					if (Load<uint32_t>(col_ptr) > string_t::INLINE_LENGTH) {
 						// Overwrite the string offset with the pointer (if not inlined)
@@ -33584,7 +33610,7 @@ static void GatherVarchar(Vector &rows, const SelectionVector &row_sel, Vector &
 			//	Not inline, so unswizzle the copied pointer the pointer
 			auto heap_ptr_ptr = row + heap_offset;
 			auto heap_row_ptr = base_heap_ptr + Load<idx_t>(heap_ptr_ptr);
-			auto string_ptr = data_ptr_t(data + col_idx) + sizeof(uint32_t) + string_t::PREFIX_LENGTH;
+			auto string_ptr = data_ptr_t(data + col_idx) + string_t::HEADER_SIZE;
 			Store<data_ptr_t>(heap_row_ptr + Load<idx_t>(string_ptr), string_ptr);
 #ifdef DEBUG
 			data[col_idx].Verify();
@@ -35753,14 +35779,14 @@ int Comparators::TemplatedCompareListLoop(data_ptr_t &left_ptr, data_ptr_t &righ
 
 void Comparators::UnswizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type) {
 	if (type.InternalType() == PhysicalType::VARCHAR) {
-		data_ptr += sizeof(uint32_t) + string_t::PREFIX_LENGTH;
+		data_ptr += string_t::HEADER_SIZE;
 	}
 	Store<data_ptr_t>(heap_ptr + Load<idx_t>(data_ptr), data_ptr);
 }
 
 void Comparators::SwizzleSingleValue(data_ptr_t data_ptr, const data_ptr_t &heap_ptr, const LogicalType &type) {
 	if (type.InternalType() == PhysicalType::VARCHAR) {
-		data_ptr += sizeof(uint32_t) + string_t::PREFIX_LENGTH;
+		data_ptr += string_t::HEADER_SIZE;
 	}
 	Store<idx_t>(Load<data_ptr_t>(data_ptr) - heap_ptr, data_ptr);
 }
@@ -58262,6 +58288,7 @@ ExpressionExecutorState::ExpressionExecutorState(const string &name) : profiler(
 
 
 
+
 #include <algorithm>
 #include <cstring>
 #include <ctgmath>
@@ -58326,90 +58353,87 @@ unique_ptr<IndexScanState> ART::InitializeScanTwoPredicates(Transaction &transac
 }
 
 //===--------------------------------------------------------------------===//
-// Insert
+// Keys
 //===--------------------------------------------------------------------===//
+
 template <class T>
-static void TemplatedGenerateKeys(Vector &input, idx_t count, vector<unique_ptr<Key>> &keys) {
+static void TemplatedGenerateKeys(ArenaAllocator &allocator, Vector &input, idx_t count, vector<Key> &keys) {
 	UnifiedVectorFormat idata;
 	input.ToUnifiedFormat(count, idata);
 
+	D_ASSERT(keys.size() >= count);
 	auto input_data = (T *)idata.data;
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = idata.sel->get_index(i);
 		if (idata.validity.RowIsValid(idx)) {
-			keys.push_back(Key::CreateKey<T>(input_data[idx]));
-		} else {
-			keys.push_back(nullptr);
+			Key::CreateKey<T>(allocator, keys[i], input_data[idx]);
 		}
 	}
 }
 
 template <class T>
-static void ConcatenateKeys(Vector &input, idx_t count, vector<unique_ptr<Key>> &keys) {
+static void ConcatenateKeys(ArenaAllocator &allocator, Vector &input, idx_t count, vector<Key> &keys) {
 	UnifiedVectorFormat idata;
 	input.ToUnifiedFormat(count, idata);
 
 	auto input_data = (T *)idata.data;
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = idata.sel->get_index(i);
-		if (!idata.validity.RowIsValid(idx) || !keys[i]) {
-			// either this column is NULL, or the previous column is NULL!
-			keys[i] = nullptr;
-		} else {
-			// concatenate the keys
-			auto old_key = move(keys[i]);
-			auto new_key = Key::CreateKey<T>(input_data[idx]);
-			auto key_len = old_key->len + new_key->len;
-			auto compound_data = unique_ptr<data_t[]>(new data_t[key_len]);
-			memcpy(compound_data.get(), old_key->data.get(), old_key->len);
-			memcpy(compound_data.get() + old_key->len, new_key->data.get(), new_key->len);
-			keys[i] = make_unique<Key>(move(compound_data), key_len);
+
+		// key is not NULL (no previous column entry was NULL)
+		if (!keys[i].Empty()) {
+			if (!idata.validity.RowIsValid(idx)) {
+				// this column entry is NULL, set whole key to NULL
+				keys[i] = Key();
+			} else {
+				auto other_key = Key::CreateKey<T>(allocator, input_data[idx]);
+				keys[i].ConcatenateKey(allocator, other_key);
+			}
 		}
 	}
 }
 
-void ART::GenerateKeys(DataChunk &input, vector<unique_ptr<Key>> &keys) {
-	keys.reserve(STANDARD_VECTOR_SIZE);
+void ART::GenerateKeys(ArenaAllocator &allocator, DataChunk &input, vector<Key> &keys) {
 	// generate keys for the first input column
 	switch (input.data[0].GetType().InternalType()) {
 	case PhysicalType::BOOL:
-		TemplatedGenerateKeys<bool>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<bool>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::INT8:
-		TemplatedGenerateKeys<int8_t>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<int8_t>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::INT16:
-		TemplatedGenerateKeys<int16_t>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<int16_t>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::INT32:
-		TemplatedGenerateKeys<int32_t>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<int32_t>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::INT64:
-		TemplatedGenerateKeys<int64_t>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<int64_t>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::INT128:
-		TemplatedGenerateKeys<hugeint_t>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<hugeint_t>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::UINT8:
-		TemplatedGenerateKeys<uint8_t>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<uint8_t>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::UINT16:
-		TemplatedGenerateKeys<uint16_t>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<uint16_t>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::UINT32:
-		TemplatedGenerateKeys<uint32_t>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<uint32_t>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::UINT64:
-		TemplatedGenerateKeys<uint64_t>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<uint64_t>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::FLOAT:
-		TemplatedGenerateKeys<float>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<float>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::DOUBLE:
-		TemplatedGenerateKeys<double>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<double>(allocator, input.data[0], input.size(), keys);
 		break;
 	case PhysicalType::VARCHAR:
-		TemplatedGenerateKeys<string_t>(input.data[0], input.size(), keys);
+		TemplatedGenerateKeys<string_t>(allocator, input.data[0], input.size(), keys);
 		break;
 	default:
 		throw InternalException("Invalid type for index");
@@ -58419,43 +58443,43 @@ void ART::GenerateKeys(DataChunk &input, vector<unique_ptr<Key>> &keys) {
 		// for each of the remaining columns, concatenate
 		switch (input.data[i].GetType().InternalType()) {
 		case PhysicalType::BOOL:
-			ConcatenateKeys<bool>(input.data[i], input.size(), keys);
+			ConcatenateKeys<bool>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::INT8:
-			ConcatenateKeys<int8_t>(input.data[i], input.size(), keys);
+			ConcatenateKeys<int8_t>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::INT16:
-			ConcatenateKeys<int16_t>(input.data[i], input.size(), keys);
+			ConcatenateKeys<int16_t>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::INT32:
-			ConcatenateKeys<int32_t>(input.data[i], input.size(), keys);
+			ConcatenateKeys<int32_t>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::INT64:
-			ConcatenateKeys<int64_t>(input.data[i], input.size(), keys);
+			ConcatenateKeys<int64_t>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::INT128:
-			ConcatenateKeys<hugeint_t>(input.data[i], input.size(), keys);
+			ConcatenateKeys<hugeint_t>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::UINT8:
-			ConcatenateKeys<uint8_t>(input.data[i], input.size(), keys);
+			ConcatenateKeys<uint8_t>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::UINT16:
-			ConcatenateKeys<uint16_t>(input.data[i], input.size(), keys);
+			ConcatenateKeys<uint16_t>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::UINT32:
-			ConcatenateKeys<uint32_t>(input.data[i], input.size(), keys);
+			ConcatenateKeys<uint32_t>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::UINT64:
-			ConcatenateKeys<uint64_t>(input.data[i], input.size(), keys);
+			ConcatenateKeys<uint64_t>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::FLOAT:
-			ConcatenateKeys<float>(input.data[i], input.size(), keys);
+			ConcatenateKeys<float>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::DOUBLE:
-			ConcatenateKeys<double>(input.data[i], input.size(), keys);
+			ConcatenateKeys<double>(allocator, input.data[i], input.size(), keys);
 			break;
 		case PhysicalType::VARCHAR:
-			ConcatenateKeys<string_t>(input.data[i], input.size(), keys);
+			ConcatenateKeys<string_t>(allocator, input.data[i], input.size(), keys);
 			break;
 		default:
 			throw InternalException("Invalid type for index");
@@ -58463,22 +58487,26 @@ void ART::GenerateKeys(DataChunk &input, vector<unique_ptr<Key>> &keys) {
 	}
 }
 
+//===--------------------------------------------------------------------===//
+// Insert
+//===--------------------------------------------------------------------===//
+
 struct KeySection {
 	KeySection(idx_t start_p, idx_t end_p, idx_t depth_p, data_t key_byte_p)
 	    : start(start_p), end(end_p), depth(depth_p), key_byte(key_byte_p) {};
-	KeySection(idx_t start_p, idx_t end_p, vector<unique_ptr<Key>> &keys, KeySection &key_section)
-	    : start(start_p), end(end_p), depth(key_section.depth + 1), key_byte(keys[end_p]->data[key_section.depth]) {};
+	KeySection(idx_t start_p, idx_t end_p, vector<Key> &keys, KeySection &key_section)
+	    : start(start_p), end(end_p), depth(key_section.depth + 1), key_byte(keys[end_p].data[key_section.depth]) {};
 	idx_t start;
 	idx_t end;
 	idx_t depth;
 	data_t key_byte;
 };
 
-void GetChildSections(vector<KeySection> &child_sections, vector<unique_ptr<Key>> &keys, KeySection &key_section) {
+void GetChildSections(vector<KeySection> &child_sections, vector<Key> &keys, KeySection &key_section) {
 
 	idx_t child_start_idx = key_section.start;
 	for (idx_t i = key_section.start + 1; i <= key_section.end; i++) {
-		if (keys[i - 1]->data[key_section.depth] != keys[i]->data[key_section.depth]) {
+		if (keys[i - 1].data[key_section.depth] != keys[i].data[key_section.depth]) {
 			child_sections.emplace_back(child_start_idx, i - 1, keys, key_section);
 			child_start_idx = i;
 		}
@@ -58486,15 +58514,14 @@ void GetChildSections(vector<KeySection> &child_sections, vector<unique_ptr<Key>
 	child_sections.emplace_back(child_start_idx, key_section.end, keys, key_section);
 }
 
-void Construct(vector<unique_ptr<Key>> &keys, row_t *row_ids, Node *&node, KeySection &key_section,
-               bool &has_constraint) {
+void Construct(vector<Key> &keys, row_t *row_ids, Node *&node, KeySection &key_section, bool &has_constraint) {
 
 	D_ASSERT(key_section.start < keys.size());
 	D_ASSERT(key_section.end < keys.size());
 	D_ASSERT(key_section.start <= key_section.end);
 
-	auto &start_key = *keys[key_section.start];
-	auto &end_key = *keys[key_section.end];
+	auto &start_key = keys[key_section.start];
+	auto &end_key = keys[key_section.end];
 
 	// increment the depth until we reach a leaf or find a mismatching byte
 	auto prefix_start = key_section.depth;
@@ -58542,11 +58569,11 @@ void Construct(vector<unique_ptr<Key>> &keys, row_t *row_ids, Node *&node, KeySe
 	}
 }
 
-void FindFirstNotNullKey(vector<unique_ptr<Key>> &keys, bool &skipped_all_nulls, idx_t &start_idx) {
+void FindFirstNotNullKey(vector<Key> &keys, bool &skipped_all_nulls, idx_t &start_idx) {
 
 	if (!skipped_all_nulls) {
 		for (idx_t i = 0; i < keys.size(); i++) {
-			if (keys[i]) {
+			if (!keys[i].Empty()) {
 				start_idx = i;
 				skipped_all_nulls = true;
 				return;
@@ -58560,9 +58587,13 @@ void ART::ConstructAndMerge(IndexLock &lock, PayloadScanner &scanner, Allocator
 	auto payload_types = logical_types;
 	payload_types.emplace_back(LogicalType::ROW_TYPE);
 
+	ArenaAllocator arena_allocator(allocator);
+	vector<Key> keys(STANDARD_VECTOR_SIZE);
+
 	auto skipped_all_nulls = false;
 	auto temp_art = make_unique<ART>(this->column_ids, this->table_io_manager, this->unbound_expressions,
 	                                 this->constraint_type, this->db);
+
 	for (;;) {
 		DataChunk ordered_chunk;
 		ordered_chunk.Initialize(allocator, payload_types);
@@ -58581,8 +58612,8 @@ void ART::ConstructAndMerge(IndexLock &lock, PayloadScanner &scanner, Allocator
 		D_ASSERT(logical_types[0] == ordered_chunk.data[0].GetType());
 
 		// generate the keys for the given input
-		vector<unique_ptr<Key>> keys;
-		GenerateKeys(ordered_chunk, keys);
+		arena_allocator.Reset();
+		GenerateKeys(arena_allocator, ordered_chunk, keys);
 
 		// we order NULLS FIRST, so we might have to skip nulls at the start of our sorted data
 		idx_t start_idx = 0;
@@ -58608,16 +58639,21 @@ void ART::ConstructAndMerge(IndexLock &lock, PayloadScanner &scanner, Allocator
 		auto art = make_unique<ART>(this->column_ids, this->table_io_manager, this->unbound_expressions,
 		                            this->constraint_type, this->db);
 		auto key_section = KeySection(start_idx, ordered_chunk.size() - 1, 0, 0);
-		auto has_constraint = IsPrimary() || IsUnique();
+		auto has_constraint = IsUnique();
 		Construct(keys, row_ids, art->tree, key_section, has_constraint);
 
 		// merge art into temp_art
-		ART::Merge(temp_art.get(), art.get());
+		if (!temp_art->MergeIndexes(lock, art.get())) {
+			throw ConstraintException("Data contains duplicates on indexed column(s)");
+		}
 	}
 
 	// NOTE: currently this code is only used for index creation, so we can assume that there are no
-	// duplicate violations between the existing index and the new data
-	ART::Merge(this, temp_art.get());
+	// duplicate violations between the existing index and the new data,
+	// so we do not need to revert any changes
+	if (!this->MergeIndexes(lock, temp_art.get())) {
+		throw ConstraintException("Data contains duplicates on indexed column(s)");
+	}
 }
 
 bool ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
@@ -58625,39 +58661,35 @@ bool ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 	D_ASSERT(logical_types[0] == input.data[0].GetType());
 
 	// generate the keys for the given input
-	vector<unique_ptr<Key>> keys;
-	GenerateKeys(input, keys);
+	ArenaAllocator arena_allocator(Allocator::DefaultAllocator());
+	vector<Key> keys(input.size());
+	GenerateKeys(arena_allocator, input, keys);
 
 	// now insert the elements into the index
 	row_ids.Flatten(input.size());
 	auto row_identifiers = FlatVector::GetData<row_t>(row_ids);
 	idx_t failed_index = DConstants::INVALID_INDEX;
 	for (idx_t i = 0; i < input.size(); i++) {
-		if (!keys[i]) {
+		if (keys[i].Empty()) {
 			continue;
 		}
 
 		row_t row_id = row_identifiers[i];
-		if (!Insert(tree, move(keys[i]), 0, row_id)) {
+		if (!Insert(tree, keys[i], 0, row_id)) {
 			// failed to insert because of constraint violation
 			failed_index = i;
 			break;
 		}
 	}
 	if (failed_index != DConstants::INVALID_INDEX) {
-		// failed to insert because of constraint violation: remove previously inserted entries
-		// generate keys again
-		keys.clear();
-		GenerateKeys(input, keys);
-		unique_ptr<Key> key;
 
-		// now erase the entries
+		// failed to insert because of constraint violation: remove previously inserted entries
 		for (idx_t i = 0; i < failed_index; i++) {
-			if (!keys[i]) {
+			if (keys[i].Empty()) {
 				continue;
 			}
 			row_t row_id = row_identifiers[i];
-			Erase(tree, *keys[i], 0, row_id);
+			Erase(tree, keys[i], 0, row_id);
 		}
 		return false;
 	}
@@ -58700,11 +58732,11 @@ bool ART::InsertToLeaf(Leaf &leaf, row_t row_id) {
 	return true;
 }
 
-bool ART::Insert(Node *&node, unique_ptr<Key> value, unsigned depth, row_t row_id) {
-	Key &key = *value;
+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(*value, depth, row_id);
+		node = new Leaf(key, depth, row_id);
 		return true;
 	}
 
@@ -58731,7 +58763,7 @@ bool ART::Insert(Node *&node, unique_ptr<Key> value, unsigned depth, row_t row_i
 		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(*value, depth + new_prefix_length + 1, row_id);
+		Node *leaf_node = new Leaf(key, depth + new_prefix_length + 1, row_id);
 		Node4::InsertChild(new_node, key[depth + new_prefix_length], leaf_node);
 		node = new_node;
 		return true;
@@ -58748,7 +58780,7 @@ bool ART::Insert(Node *&node, unique_ptr<Key> value, unsigned depth, row_t row_i
 			auto key_byte = node->prefix.Reduce(mismatch_pos);
 			Node4::InsertChild(new_node, key_byte, node);
 
-			Node *leaf_node = new Leaf(*value, depth + mismatch_pos + 1, row_id);
+			Node *leaf_node = new Leaf(key, depth + mismatch_pos + 1, row_id);
 			Node4::InsertChild(new_node, key[depth + mismatch_pos], leaf_node);
 			node = new_node;
 			return true;
@@ -58761,11 +58793,11 @@ bool ART::Insert(Node *&node, unique_ptr<Key> value, unsigned depth, row_t row_i
 	idx_t pos = node->GetChildPos(key[depth]);
 	if (pos != DConstants::INVALID_INDEX) {
 		auto child = node->GetChild(*this, pos);
-		bool insertion_result = Insert(child, move(value), depth + 1, row_id);
+		bool insertion_result = Insert(child, key, depth + 1, row_id);
 		node->ReplaceChildPointer(pos, child);
 		return insertion_result;
 	}
-	Node *new_node = new Leaf(*value, depth + 1, row_id);
+	Node *new_node = new Leaf(key, depth + 1, row_id);
 	Node::InsertChild(node, key[depth], new_node);
 	return true;
 }
@@ -58781,20 +58813,21 @@ void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) {
 	ExecuteExpressions(input, expression);
 
 	// then generate the keys for the given input
-	vector<unique_ptr<Key>> keys;
-	GenerateKeys(expression, keys);
+	ArenaAllocator arena_allocator(Allocator::DefaultAllocator());
+	vector<Key> keys(expression.size());
+	GenerateKeys(arena_allocator, expression, keys);
 
 	// now erase the elements from the database
 	row_ids.Flatten(input.size());
 	auto row_identifiers = FlatVector::GetData<row_t>(row_ids);
 
 	for (idx_t i = 0; i < input.size(); i++) {
-		if (!keys[i]) {
+		if (keys[i].Empty()) {
 			continue;
 		}
-		Erase(tree, *keys[i], 0, row_identifiers[i]);
+		Erase(tree, keys[i], 0, row_identifiers[i]);
 #ifdef DEBUG
-		auto node = Lookup(tree, *keys[i], 0);
+		auto node = Lookup(tree, keys[i], 0);
 		if (node) {
 			auto leaf = static_cast<Leaf *>(node);
 			for (idx_t k = 0; k < leaf->count; k++) {
@@ -58805,7 +58838,7 @@ void ART::Delete(IndexLock &state, DataChunk &input, Vector &row_ids) {
 	}
 }
 
-void ART::Erase(Node *&node, Key &key, unsigned depth, row_t row_id) {
+void ART::Erase(Node *&node, Key &key, idx_t depth, row_t row_id) {
 	if (!node) {
 		return;
 	}
@@ -58853,43 +58886,43 @@ void ART::Erase(Node *&node, Key &key, unsigned depth, row_t row_id) {
 //===--------------------------------------------------------------------===//
 // Point Query
 //===--------------------------------------------------------------------===//
-static unique_ptr<Key> CreateKey(ART &art, PhysicalType type, Value &value) {
+static Key CreateKey(ArenaAllocator &allocator, PhysicalType type, Value &value) {
 	D_ASSERT(type == value.type().InternalType());
 	switch (type) {
 	case PhysicalType::BOOL:
-		return Key::CreateKey<bool>(value);
+		return Key::CreateKey<bool>(allocator, value);
 	case PhysicalType::INT8:
-		return Key::CreateKey<int8_t>(value);
+		return Key::CreateKey<int8_t>(allocator, value);
 	case PhysicalType::INT16:
-		return Key::CreateKey<int16_t>(value);
+		return Key::CreateKey<int16_t>(allocator, value);
 	case PhysicalType::INT32:
-		return Key::CreateKey<int32_t>(value);
+		return Key::CreateKey<int32_t>(allocator, value);
 	case PhysicalType::INT64:
-		return Key::CreateKey<int64_t>(value);
+		return Key::CreateKey<int64_t>(allocator, value);
 	case PhysicalType::UINT8:
-		return Key::CreateKey<uint8_t>(value);
+		return Key::CreateKey<uint8_t>(allocator, value);
 	case PhysicalType::UINT16:
-		return Key::CreateKey<uint16_t>(value);
+		return Key::CreateKey<uint16_t>(allocator, value);
 	case PhysicalType::UINT32:
-		return Key::CreateKey<uint32_t>(value);
+		return Key::CreateKey<uint32_t>(allocator, value);
 	case PhysicalType::UINT64:
-		return Key::CreateKey<uint64_t>(value);
+		return Key::CreateKey<uint64_t>(allocator, value);
 	case PhysicalType::INT128:
-		return Key::CreateKey<hugeint_t>(value);
+		return Key::CreateKey<hugeint_t>(allocator, value);
 	case PhysicalType::FLOAT:
-		return Key::CreateKey<float>(value);
+		return Key::CreateKey<float>(allocator, value);
 	case PhysicalType::DOUBLE:
-		return Key::CreateKey<double>(value);
+		return Key::CreateKey<double>(allocator, value);
 	case PhysicalType::VARCHAR:
-		return Key::CreateKey<string_t>(value);
+		return Key::CreateKey<string_t>(allocator, value);
 	default:
 		throw InternalException("Invalid type for index");
 	}
 }
 
-bool ART::SearchEqual(ARTIndexScanState *state, idx_t max_count, vector<row_t> &result_ids) {
-	auto key = CreateKey(*this, types[0], state->values[0]);
-	auto leaf = static_cast<Leaf *>(Lookup(tree, *key, 0));
+bool ART::SearchEqual(Key &key, idx_t max_count, vector<row_t> &result_ids) {
+
+	auto leaf = static_cast<Leaf *>(Lookup(tree, key, 0));
 	if (!leaf) {
 		return true;
 	}
@@ -58903,17 +58936,17 @@ bool ART::SearchEqual(ARTIndexScanState *state, idx_t max_count, vector<row_t> &
 	return true;
 }
 
-void ART::SearchEqualJoinNoFetch(Value &equal_value, idx_t &result_size) {
-	//! We need to look for a leaf
-	auto key = CreateKey(*this, types[0], equal_value);
-	auto leaf = (Leaf *)(Lookup(tree, *key, 0));
+void ART::SearchEqualJoinNoFetch(Key &key, idx_t &result_size) {
+
+	// we need to look for a leaf
+	auto leaf = Lookup(tree, key, 0);
 	if (!leaf) {
 		return;
 	}
 	result_size = leaf->count;
 }
 
-Node *ART::Lookup(Node *node, Key &key, unsigned depth) {
+Leaf *ART::Lookup(Node *node, Key &key, idx_t depth) {
 	while (node) {
 		if (node->type == NodeType::NLeaf) {
 			auto leaf = (Leaf *)node;
@@ -58924,7 +58957,7 @@ Node *ART::Lookup(Node *node, Key &key, unsigned depth) {
 					return nullptr;
 				}
 			}
-			return node;
+			return (Leaf *)node;
 		}
 		if (node->prefix.Size()) {
 			for (idx_t pos = 0; pos < node->prefix.Size(); pos++) {
@@ -58950,112 +58983,127 @@ Node *ART::Lookup(Node *node, Key &key, unsigned depth) {
 // Returns: True (If found leaf >= key)
 //          False (Otherwise)
 //===--------------------------------------------------------------------===//
-bool ART::SearchGreater(ARTIndexScanState *state, bool inclusive, idx_t max_count, vector<row_t> &result_ids) {
+bool ART::SearchGreater(ARTIndexScanState *state, Key &key, bool inclusive, idx_t max_count,
+                        vector<row_t> &result_ids) {
+
 	Iterator *it = &state->iterator;
-	auto key = CreateKey(*this, types[0], state->values[0]);
 
 	// greater than scan: first set the iterator to the node at which we will start our scan by finding the lowest node
 	// that satisfies our requirement
 	if (!it->art) {
 		it->art = this;
-		bool found = it->LowerBound(tree, *key, inclusive);
+		bool found = it->LowerBound(tree, key, inclusive);
 		if (!found) {
 			return true;
 		}
 	}
 	// after that we continue the scan; we don't need to check the bounds as any value following this value is
 	// automatically bigger and hence satisfies our predicate
-	return it->Scan(nullptr, max_count, result_ids, false);
+	Key empty_key = Key();
+	return it->Scan(empty_key, max_count, result_ids, false);
 }
 
 //===--------------------------------------------------------------------===//
 // Less Than
 //===--------------------------------------------------------------------===//
-bool ART::SearchLess(ARTIndexScanState *state, bool inclusive, idx_t max_count, vector<row_t> &result_ids) {
+bool ART::SearchLess(ARTIndexScanState *state, Key &upper_bound, bool inclusive, idx_t max_count,
+                     vector<row_t> &result_ids) {
+
 	if (!tree) {
 		return true;
 	}
 
 	Iterator *it = &state->iterator;
-	auto upper_bound = CreateKey(*this, types[0], state->values[0]);
 
 	if (!it->art) {
 		it->art = this;
 		// first find the minimum value in the ART: we start scanning from this value
 		it->FindMinimum(*tree);
 		// early out min value higher than upper bound query
-		if (it->cur_key > *upper_bound) {
+		if (it->cur_key > upper_bound) {
 			return true;
 		}
 	}
 	// now continue the scan until we reach the upper bound
-	return it->Scan(upper_bound.get(), max_count, result_ids, inclusive);
+	return it->Scan(upper_bound, max_count, result_ids, inclusive);
 }
 
 //===--------------------------------------------------------------------===//
 // Closed Range Query
 //===--------------------------------------------------------------------===//
-bool ART::SearchCloseRange(ARTIndexScanState *state, bool left_inclusive, bool right_inclusive, idx_t max_count,
-                           vector<row_t> &result_ids) {
-	auto lower_bound = CreateKey(*this, types[0], state->values[0]);
-	auto upper_bound = CreateKey(*this, types[0], state->values[1]);
+bool ART::SearchCloseRange(ARTIndexScanState *state, Key &lower_bound, Key &upper_bound, bool left_inclusive,
+                           bool right_inclusive, idx_t max_count, vector<row_t> &result_ids) {
+
 	Iterator *it = &state->iterator;
+
 	// first find the first node that satisfies the left predicate
 	if (!it->art) {
 		it->art = this;
-		bool found = it->LowerBound(tree, *lower_bound, left_inclusive);
+		bool found = it->LowerBound(tree, lower_bound, left_inclusive);
 		if (!found) {
 			return true;
 		}
 	}
 	// now continue the scan until we reach the upper bound
-	return it->Scan(upper_bound.get(), max_count, result_ids, right_inclusive);
+	return it->Scan(upper_bound, max_count, result_ids, right_inclusive);
 }
 
 bool ART::Scan(Transaction &transaction, DataTable &table, IndexScanState &table_state, idx_t max_count,
                vector<row_t> &result_ids) {
+
 	auto state = (ARTIndexScanState *)&table_state;
+	vector<row_t> row_ids;
+	bool success;
 
+	// FIXME: the key directly owning the data for a single key might be more efficient
 	D_ASSERT(state->values[0].type().InternalType() == types[0]);
+	ArenaAllocator arena_allocator(Allocator::DefaultAllocator());
+	auto key = CreateKey(arena_allocator, types[0], state->values[0]);
 
-	vector<row_t> row_ids;
-	bool success;
 	if (state->values[1].IsNull()) {
-		lock_guard<mutex> l(lock);
+
 		// single predicate
+		lock_guard<mutex> l(lock);
 		switch (state->expressions[0]) {
 		case ExpressionType::COMPARE_EQUAL:
-			success = SearchEqual(state, max_count, row_ids);
+			success = SearchEqual(key, max_count, row_ids);
 			break;
 		case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-			success = SearchGreater(state, true, max_count, row_ids);
+			success = SearchGreater(state, key, true, max_count, row_ids);
 			break;
 		case ExpressionType::COMPARE_GREATERTHAN:
-			success = SearchGreater(state, false, max_count, row_ids);
+			success = SearchGreater(state, key, false, max_count, row_ids);
 			break;
 		case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-			success = SearchLess(state, true, max_count, row_ids);
+			success = SearchLess(state, key, true, max_count, row_ids);
 			break;
 		case ExpressionType::COMPARE_LESSTHAN:
-			success = SearchLess(state, false, max_count, row_ids);
+			success = SearchLess(state, key, false, max_count, row_ids);
 			break;
 		default:
 			throw InternalException("Operation not implemented");
 		}
+
 	} else {
-		lock_guard<mutex> l(lock);
+
 		// two predicates
+		lock_guard<mutex> l(lock);
+
 		D_ASSERT(state->values[1].type().InternalType() == types[0]);
+		auto upper_bound = CreateKey(arena_allocator, types[0], state->values[1]);
+
 		bool left_inclusive = state->expressions[0] == ExpressionType ::COMPARE_GREATERTHANOREQUALTO;
 		bool right_inclusive = state->expressions[1] == ExpressionType ::COMPARE_LESSTHANOREQUALTO;
-		success = SearchCloseRange(state, left_inclusive, right_inclusive, max_count, row_ids);
+		success = SearchCloseRange(state, key, upper_bound, left_inclusive, right_inclusive, max_count, row_ids);
 	}
+
 	if (!success) {
 		return false;
 	}
 	if (row_ids.empty()) {
 		return true;
 	}
+
 	// sort the row ids
 	sort(row_ids.begin(), row_ids.end());
 	// duplicate eliminate the row ids and append them to the row ids of the state
@@ -59084,14 +59132,15 @@ void ART::VerifyExistence(DataChunk &chunk, VerifyExistenceType verify_type, str
 	ExecuteExpressions(chunk, expression_chunk);
 
 	// generate the keys for the given input
-	vector<unique_ptr<Key>> keys;
-	GenerateKeys(expression_chunk, keys);
+	ArenaAllocator arena_allocator(Allocator::DefaultAllocator());
+	vector<Key> keys(expression_chunk.size());
+	GenerateKeys(arena_allocator, expression_chunk, keys);
 
 	for (idx_t i = 0; i < chunk.size(); i++) {
-		if (!keys[i]) {
+		if (keys[i].Empty()) {
 			continue;
 		}
-		Node *node_ptr = Lookup(tree, *keys[i], 0);
+		Node *node_ptr = Lookup(tree, keys[i], 0);
 		bool throw_exception =
 		    verify_type == VerifyExistenceType::APPEND_FK ? node_ptr == nullptr : node_ptr != nullptr;
 		if (!throw_exception) {
@@ -59148,15 +59197,24 @@ BlockPointer ART::Serialize(duckdb::MetaBlockWriter &writer) {
 //===--------------------------------------------------------------------===//
 // Merge ARTs
 //===--------------------------------------------------------------------===//
-void ART::Merge(ART *l_art, ART *r_art) {
+bool ART::MergeIndexes(IndexLock &state, Index *other_index) {
 
-	if (!l_art->tree) {
-		l_art->tree = r_art->tree;
-		r_art->tree = nullptr;
-		return;
+	auto other_art = (ART *)other_index;
+
+	if (!this->tree) {
+		this->tree = other_art->tree;
+		other_art->tree = nullptr;
+		return true;
 	}
 
-	Node::MergeARTs(l_art, r_art);
+	return Node::MergeARTs(this, other_art);
+}
+
+string ART::ToString() {
+	if (tree) {
+		return tree->ToString(*this);
+	}
+	return "[empty]";
 }
 
 } // namespace duckdb
@@ -59166,25 +59224,41 @@ void ART::Merge(ART *l_art, ART *r_art) {
 
 namespace duckdb {
 
-Key::Key(unique_ptr<data_t[]> data, idx_t len) : len(len), data(move(data)) {
+Key::Key() : len(0) {
 }
 
-Key::Key(idx_t len) : len(len) {
-	data = unique_ptr<data_t[]>(new data_t[len]);
+Key::Key(data_ptr_t data, idx_t len) : len(len), data(data) {
+}
+
+Key::Key(ArenaAllocator &allocator, idx_t len) : len(len) {
+	data = allocator.Allocate(len);
 }
 
 template <>
-unique_ptr<Key> Key::CreateKey(string_t value) {
+Key Key::CreateKey(ArenaAllocator &allocator, string_t value) {
 	idx_t len = value.GetSize() + 1;
-	auto data = unique_ptr<data_t[]>(new data_t[len]);
-	memcpy(data.get(), value.GetDataUnsafe(), len - 1);
+	auto data = allocator.Allocate(len);
+	memcpy(data, value.GetDataUnsafe(), len - 1);
 	data[len - 1] = '\0';
-	return make_unique<Key>(move(data), len);
+	return Key(data, len);
 }
 
 template <>
-unique_ptr<Key> Key::CreateKey(const char *value) {
-	return Key::CreateKey(string_t(value, strlen(value)));
+Key Key::CreateKey(ArenaAllocator &allocator, const char *value) {
+	return Key::CreateKey(allocator, string_t(value, strlen(value)));
+}
+
+template <>
+void Key::CreateKey(ArenaAllocator &allocator, Key &key, string_t value) {
+	key.len = value.GetSize() + 1;
+	key.data = allocator.Allocate(key.len);
+	memcpy(key.data, value.GetDataUnsafe(), key.len - 1);
+	key.data[key.len - 1] = '\0';
+}
+
+template <>
+void Key::CreateKey(ArenaAllocator &allocator, Key &key, const char *value) {
+	Key::CreateKey(allocator, key, string_t(value, strlen(value)));
 }
 
 bool Key::operator>(const Key &k) const {
@@ -59235,6 +59309,19 @@ bool Key::operator==(const Key &k) const {
 bool Key::ByteMatches(Key &other, idx_t &depth) {
 	return data[depth] == other[depth];
 }
+
+bool Key::Empty() {
+	return len == 0;
+}
+
+void Key::ConcatenateKey(ArenaAllocator &allocator, Key &other_key) {
+
+	auto compound_data = allocator.Allocate(len + other_key.len);
+	memcpy(compound_data, data, len);
+	memcpy(compound_data + len, other_key.data, other_key.len);
+	len += other_key.len;
+	data = compound_data;
+}
 } // namespace duckdb
 
 
@@ -59358,16 +59445,16 @@ void Iterator::PushKey(Node *cur_node, uint16_t pos) {
 	}
 }
 
-bool Iterator::Scan(Key *bound, idx_t max_count, vector<row_t> &result_ids, bool is_inclusive) {
+bool Iterator::Scan(Key &bound, idx_t max_count, vector<row_t> &result_ids, bool is_inclusive) {
 	bool has_next;
 	do {
-		if (bound) {
+		if (!bound.Empty()) {
 			if (is_inclusive) {
-				if (cur_key > *bound) {
+				if (cur_key > bound) {
 					break;
 				}
 			} else {
-				if (cur_key >= *bound) {
+				if (cur_key >= bound) {
 					break;
 				}
 			}
@@ -59589,6 +59676,27 @@ void Leaf::Remove(row_t row_id) {
 	}
 }
 
+string Leaf::ToString(Node *node) {
+
+	Leaf *leaf = (Leaf *)node;
+	string str = "Leaf: [";
+	for (idx_t i = 0; i < leaf->count; i++) {
+		str += i == 0 ? to_string(leaf->row_ids[i]) : ", " + to_string(leaf->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;
+
+	// append non-duplicate row_ids to l_n
+	for (idx_t i = 0; i < r_n->count; i++) {
+		l_n->Insert(r_n->GetRowId(i));
+	}
+}
+
 BlockPointer Leaf::Serialize(duckdb::MetaBlockWriter &writer) {
 	auto ptr = writer.GetBlockPointer();
 	// Write Node Type
@@ -59616,21 +59724,6 @@ Leaf *Leaf::Deserialize(MetaBlockReader &reader) {
 	return new Leaf(move(elements), num_elements, prefix);
 }
 
-void Leaf::Merge(bool &has_constraint, Node *&l_node, Node *&r_node) {
-
-	Leaf *l_n = (Leaf *)l_node;
-	Leaf *r_n = (Leaf *)r_node;
-
-	// append non-duplicate row_ids to l_n
-	for (idx_t i = 0; i < r_n->count; i++) {
-		l_n->Insert(r_n->GetRowId(i));
-	}
-
-	if (has_constraint && l_n->count > 1) {
-		throw ConstraintException("Data contains duplicates on indexed column(s)");
-	}
-}
-
 } // namespace duckdb
 
 
@@ -59782,6 +59875,36 @@ void Node::New(NodeType &type, Node *&node) {
 	}
 }
 
+string Node::ToString(ART &art) {
+
+	string str = "Node";
+	switch (this->type) {
+	case NodeType::NLeaf:
+		return Leaf::ToString(this);
+	case NodeType::N4:
+		str += to_string(Node4::GetSize());
+		break;
+	case NodeType::N16:
+		str += to_string(Node16::GetSize());
+		break;
+	case NodeType::N48:
+		str += to_string(Node48::GetSize());
+		break;
+	case NodeType::N256:
+		str += to_string(Node256::GetSize());
+		break;
+	}
+
+	str += ": [";
+	auto next_pos = GetNextPos(DConstants::INVALID_INDEX);
+	while (next_pos != DConstants::INVALID_INDEX) {
+		auto child = GetChild(art, next_pos);
+		str += "(" + to_string(next_pos) + ", " + child->ToString(art) + ")";
+		next_pos = GetNextPos(next_pos);
+	}
+	return str + "]";
+}
+
 BlockPointer Node::SerializeInternal(ART &art, duckdb::MetaBlockWriter &writer, InternalType &internal_type) {
 	// Iterate through children and annotate their offsets
 	vector<BlockPointer> child_offsets;
@@ -59879,7 +60002,7 @@ void UpdateParentsOfNodes(Node *&l_node, Node *&r_node, ParentsOfNodes &parents)
 	}
 }
 
-void Merge(MergeInfo &info, idx_t depth, ParentsOfNodes &parents) {
+bool Merge(MergeInfo &info, idx_t depth, ParentsOfNodes &parents) {
 
 	// always try to merge the smaller node into the bigger node
 	// because maybe there is enough free space in the bigger node to fit the smaller one
@@ -59904,13 +60027,16 @@ void Merge(MergeInfo &info, idx_t depth, ParentsOfNodes &parents) {
 	case NodeType::NLeaf:
 		D_ASSERT(info.l_node->type == NodeType::NLeaf);
 		D_ASSERT(info.r_node->type == NodeType::NLeaf);
-		auto has_constraint = info.l_art->IsPrimary() || info.l_art->IsUnique();
-		return Leaf::Merge(has_constraint, info.l_node, info.r_node);
+		if (info.l_art->IsUnique()) {
+			return false;
+		}
+		Leaf::Merge(info.l_node, info.r_node);
+		return true;
 	}
 	throw InternalException("Invalid node type for right node in merge.");
 }
 
-void ResolvePrefixesAndMerge(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;
@@ -59951,7 +60077,7 @@ void ResolvePrefixesAndMerge(MergeInfo &info, idx_t depth, ParentsOfNodes &paren
 			Node::InsertChild(l_node, mismatch_byte, r_node);
 			UpdateParentsOfNodes(l_node, null_parent, parents);
 			r_node = nullptr;
-			return;
+			return true;
 		}
 
 		// recurse
@@ -59978,9 +60104,10 @@ void ResolvePrefixesAndMerge(MergeInfo &info, idx_t depth, ParentsOfNodes &paren
 	l_node = new_node;
 	UpdateParentsOfNodes(l_node, null_parent, parents);
 	r_node = nullptr;
+	return true;
 }
 
-void Node::MergeAtByte(MergeInfo &info, idx_t depth, idx_t &l_child_pos, idx_t &r_pos, uint8_t &key_byte,
+bool Node::MergeAtByte(MergeInfo &info, idx_t depth, idx_t &l_child_pos, idx_t &r_pos, uint8_t &key_byte,
                        Node *&l_parent, idx_t l_pos) {
 
 	auto r_child = info.r_node->GetChild(*info.r_art, r_pos);
@@ -59992,22 +60119,22 @@ void Node::MergeAtByte(MergeInfo &info, idx_t depth, idx_t &l_child_pos, idx_t &
 			l_parent->ReplaceChildPointer(l_pos, info.l_node);
 		}
 		info.r_node->ReplaceChildPointer(r_pos, nullptr);
-		return;
+		return true;
 	}
 
 	// recurse
 	auto l_child = info.l_node->GetChild(*info.l_art, l_child_pos);
 	MergeInfo child_info(info.l_art, info.r_art, l_child, r_child);
 	ParentsOfNodes child_parents(info.l_node, l_child_pos, info.r_node, r_pos);
-	ResolvePrefixesAndMerge(child_info, depth + 1, child_parents);
+	return ResolvePrefixesAndMerge(child_info, depth + 1, child_parents);
 }
 
-void Node::MergeARTs(ART *l_art, ART *r_art) {
+bool Node::MergeARTs(ART *l_art, ART *r_art) {
 
 	Node *null_parent = nullptr;
 	MergeInfo info(l_art, r_art, l_art->tree, r_art->tree);
 	ParentsOfNodes parents(null_parent, 0, null_parent, 0);
-	ResolvePrefixesAndMerge(info, 0, parents);
+	return ResolvePrefixesAndMerge(info, 0, parents);
 }
 
 } // namespace duckdb
@@ -60137,15 +60264,18 @@ void Node16::EraseChild(Node *&node, int pos, ART &art) {
 	}
 }
 
-void Node16::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
+bool Node16::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
 
 	Node16 *r_n = (Node16 *)info.r_node;
 
 	for (idx_t i = 0; i < info.r_node->count; i++) {
 
 		auto l_child_pos = info.l_node->GetChildPos(r_n->key[i]);
-		Node::MergeAtByte(info, depth, l_child_pos, i, r_n->key[i], l_parent, l_pos);
+		if (!Node::MergeAtByte(info, depth, l_child_pos, i, r_n->key[i], l_parent, l_pos)) {
+			return false;
+		}
 	}
+	return true;
 }
 
 idx_t Node16::GetSize() {
@@ -60237,16 +60367,19 @@ void Node256::EraseChild(Node *&node, int pos, ART &art) {
 	}
 }
 
-void Node256::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
+bool Node256::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
 
 	for (idx_t i = 0; i < 256; i++) {
 		if (info.r_node->GetChildPos(i) != DConstants::INVALID_INDEX) {
 
 			auto l_child_pos = info.l_node->GetChildPos(i);
 			auto key_byte = (uint8_t)i;
-			Node::MergeAtByte(info, depth, l_child_pos, i, key_byte, l_parent, l_pos);
+			if (!Node::MergeAtByte(info, depth, l_child_pos, i, key_byte, l_parent, l_pos)) {
+				return false;
+			}
 		}
 	}
+	return true;
 }
 
 idx_t Node256::GetSize() {
@@ -60373,15 +60506,18 @@ void Node4::EraseChild(Node *&node, int pos, ART &art) {
 	}
 }
 
-void Node4::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
+bool Node4::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
 
 	Node4 *r_n = (Node4 *)info.r_node;
 
 	for (idx_t i = 0; i < info.r_node->count; i++) {
 
 		auto l_child_pos = info.l_node->GetChildPos(r_n->key[i]);
-		Node::MergeAtByte(info, depth, l_child_pos, i, r_n->key[i], l_parent, l_pos);
+		if (!Node::MergeAtByte(info, depth, l_child_pos, i, r_n->key[i], l_parent, l_pos)) {
+			return false;
+		}
 	}
+	return true;
 }
 
 idx_t Node4::GetSize() {
@@ -60505,7 +60641,7 @@ void Node48::EraseChild(Node *&node, int pos, ART &art) {
 	}
 }
 
-void Node48::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
+bool Node48::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
 
 	Node48 *r_n = (Node48 *)info.r_node;
 
@@ -60514,9 +60650,12 @@ void Node48::Merge(MergeInfo &info, idx_t depth, Node *&l_parent, idx_t l_pos) {
 
 			auto l_child_pos = info.l_node->GetChildPos(i);
 			auto key_byte = (uint8_t)i;
-			Node::MergeAtByte(info, depth, l_child_pos, i, key_byte, l_parent, l_pos);
+			if (!Node::MergeAtByte(info, depth, l_child_pos, i, key_byte, l_parent, l_pos)) {
+				return false;
+			}
 		}
 	}
+	return true;
 }
 
 idx_t Node48::GetSize() {
@@ -72728,7 +72867,8 @@ namespace duckdb {
 
 class IndexJoinOperatorState : public OperatorState {
 public:
-	IndexJoinOperatorState(Allocator &allocator, const PhysicalIndexJoin &op) : probe_executor(allocator) {
+	IndexJoinOperatorState(Allocator &allocator, const PhysicalIndexJoin &op)
+	    : probe_executor(allocator), arena_allocator(allocator), keys(STANDARD_VECTOR_SIZE) {
 		rhs_rows.resize(STANDARD_VECTOR_SIZE);
 		result_sizes.resize(STANDARD_VECTOR_SIZE);
 
@@ -72750,10 +72890,14 @@ public:
 	DataChunk join_keys;
 	DataChunk rhs_chunk;
 	SelectionVector rhs_sel;
+
 	//! Vector of rows that mush be fetched for every LHS key
 	vector<vector<row_t>> rhs_rows;
 	ExpressionExecutor probe_executor;
 
+	ArenaAllocator arena_allocator;
+	vector<Key> keys;
+
 public:
 	void Finalize(PhysicalOperator *op, ExecutionContext &context) override {
 		context.thread.profiler.Flush(op, &probe_executor, "probe_executor", 0);
@@ -72858,22 +73002,25 @@ void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, Data
 }
 
 void PhysicalIndexJoin::GetRHSMatches(ExecutionContext &context, DataChunk &input, OperatorState &state_p) const {
+
 	auto &state = (IndexJoinOperatorState &)state_p;
 	auto &art = (ART &)*index;
-	auto &transaction = Transaction::GetTransaction(context.client);
+
+	// generate the keys for this chunk
+	state.arena_allocator.Reset();
+	ART::GenerateKeys(state.arena_allocator, state.join_keys, state.keys);
+
 	for (idx_t i = 0; i < input.size(); i++) {
-		auto equal_value = state.join_keys.GetValue(0, i);
-		auto index_state = art.InitializeScanSinglePredicate(transaction, equal_value, ExpressionType::COMPARE_EQUAL);
 		state.rhs_rows[i].clear();
-		if (!equal_value.IsNull()) {
+		if (!state.keys[i].Empty()) {
 			if (fetch_types.empty()) {
 				IndexLock lock;
 				index->InitializeLock(lock);
-				art.SearchEqualJoinNoFetch(equal_value, state.result_sizes[i]);
+				art.SearchEqualJoinNoFetch(state.keys[i], state.result_sizes[i]);
 			} else {
 				IndexLock lock;
 				index->InitializeLock(lock);
-				art.SearchEqual((ARTIndexScanState *)index_state.get(), (idx_t)-1, state.rhs_rows[i]);
+				art.SearchEqual(state.keys[i], (idx_t)-1, state.rhs_rows[i]);
 				state.result_sizes[i] = state.rhs_rows[i].size();
 			}
 		} else {
@@ -80005,11 +80152,7 @@ void PhysicalCreateIndex::Combine(ExecutionContext &context, GlobalSinkState &gs
 	}
 
 	// merge the local index into the global index
-	{
-		IndexLock global_lock;
-		gstate.global_index->InitializeLock(global_lock);
-		gstate.global_index->MergeIndexes(lstate.local_index.get());
-	}
+	gstate.global_index->MergeIndexes(lstate.local_index.get());
 }
 
 SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event, ClientContext &context,
@@ -88375,6 +88518,9 @@ template <bool LAST, bool SKIP_NULLS>
 struct FirstFunctionString : public FirstFunctionBase {
 	template <class STATE>
 	static void SetValue(STATE *state, string_t value, bool is_null) {
+		if (LAST && state->is_set) {
+			Destroy(state);
+		}
 		if (is_null) {
 			if (!SKIP_NULLS) {
 				state->is_set = true;
@@ -193092,6 +193238,24 @@ data_ptr_t ArenaAllocator::Allocate(idx_t len) {
 	return result;
 }
 
+void ArenaAllocator::Reset() {
+
+	if (head) {
+		// destroy all chunks except the current one
+		if (head->next) {
+			auto current_next = move(head->next);
+			while (current_next) {
+				current_next = move(current_next->next);
+			}
+		}
+		tail = head.get();
+
+		// reset the head
+		head->current_position = 0;
+		head->prev = nullptr;
+	}
+}
+
 void ArenaAllocator::Destroy() {
 	head = nullptr;
 	tail = nullptr;
@@ -201767,15 +201931,15 @@ void Index::Delete(DataChunk &entries, Vector &row_identifiers) {
 	Delete(state, entries, row_identifiers);
 }
 
-void Index::MergeIndexes(Index *other_index) {
+bool Index::MergeIndexes(Index *other_index) {
+
+	IndexLock state;
+	InitializeLock(state);
 
-	// create the global index
 	switch (this->type) {
 	case IndexType::ART: {
-		auto this_art = (ART *)this;
-		auto other_art = (ART *)other_index;
-		ART::Merge(this_art, other_art);
-		break;
+		auto art = (ART *)this;
+		return art->MergeIndexes(state, other_index);
 	}
 	default:
 		throw InternalException("Unimplemented index type for merge");