Don't reload hash index after copy

src/include/storage/index/in_mem_hash_index.h

@@ -76,11 +76,7 @@ class InMemHashIndex final {
 
     uint64_t size() { return this->indexHeader.numEntries; }
 
-    inline void clear() {
-        indexHeader = HashIndexHeader();
-        pSlots = std::make_unique<InMemDiskArrayBuilder<Slot<T>>>(dummy, 0, 0, true);
-        oSlots = std::make_unique<InMemDiskArrayBuilder<Slot<T>>>(dummy, 0, 1, true);
-    }
+    void clear();
 
     struct SlotIterator {
         explicit SlotIterator(slot_id_t newSlotId, InMemHashIndex<T>* builder)

src/storage/index/in_mem_hash_index.cpp

@@ -35,6 +35,14 @@ InMemHashIndex<T>::InMemHashIndex(OverflowFileHandle* overflowFileHandle)
     allocateSlots(BufferPoolConstants::PAGE_4KB_SIZE / pSlots->getAlignedElementSize());
 }
 
+template<typename T>
+void InMemHashIndex<T>::clear() {
+    indexHeader = HashIndexHeader(TypeUtils::getPhysicalTypeIDForType<T>());
+    pSlots = std::make_unique<InMemDiskArrayBuilder<Slot<T>>>(dummy, 0, 0, true);
+    oSlots = std::make_unique<InMemDiskArrayBuilder<Slot<T>>>(dummy, 0, 1, true);
+    allocateSlots(BufferPoolConstants::PAGE_4KB_SIZE / pSlots->getAlignedElementSize());
+}
+
 template<typename T>
 void InMemHashIndex<T>::allocateSlots(uint32_t newNumSlots) {
     auto numSlotsOfCurrentLevel = 1u << this->indexHeader.currentLevel;
@@ -129,11 +137,7 @@ void InMemHashIndex<T>::splitSlot(HashIndexHeader& header) {
 
 template<typename T>
 size_t InMemHashIndex<T>::append(const IndexBuffer<BufferKeyType>& buffer) {
-    slot_id_t numRequiredEntries =
-        HashIndexUtils::getNumRequiredEntries(this->indexHeader.numEntries + buffer.size());
-    while (numRequiredEntries > pSlots->size() * getSlotCapacity<T>()) {
-        this->splitSlot(this->indexHeader);
-    }
+    reserve(this->indexHeader.numEntries + buffer.size());
     // Do both searches after splitting. Returning early if the key already exists isn't a
     // particular concern and doing both after splitting allows the slotID to be reused
     common::hash_t hashes[BUFFER_SIZE];

src/storage/wal_replayer.cpp

@@ -220,25 +220,10 @@ void WALReplayer::replayRdfGraphRecord(const WALRecord& walRecord) {
     replayCreateTableRecord(*rdfGraphRecord.literalTripleTableRecord);
 }
 
-void WALReplayer::replayCopyTableRecord(const WALRecord& walRecord) {
-    auto& copyTableRecord = ku_dynamic_cast<const WALRecord&, const CopyTableRecord&>(walRecord);
-    auto tableID = copyTableRecord.tableID;
+void WALReplayer::replayCopyTableRecord(const WALRecord& /*walRecord*/) {
     if (isCheckpoint) {
         if (!isRecovering) {
             // CHECKPOINT.
-            // If we are not recovering, i.e., we are checkpointing during normal execution,
-            // then we need to update the nodeTable because the actual columns and lists
-            // files have been changed during checkpoint. So the in memory
-            // fileHandles are obsolete and should be reconstructed (e.g. since the numPages
-            // have likely changed they need to reconstruct their page locks).
-            auto catalogEntry = catalog->getTableCatalogEntry(&DUMMY_READ_TRANSACTION, tableID);
-            if (catalogEntry->getType() == CatalogEntryType::NODE_TABLE_ENTRY) {
-                auto nodeTableEntry =
-                    ku_dynamic_cast<TableCatalogEntry*, NodeTableCatalogEntry*>(catalogEntry);
-                auto nodeTable =
-                    ku_dynamic_cast<Table*, NodeTable*>(storageManager->getTable(tableID));
-                nodeTable->initializePKIndex(nodeTableEntry, false /* readOnly */, vfs);
-            }
         } else {
             // RECOVERY.
             if (wal->isLastLoggedRecordCommit()) {