diff --git a/expressions/scalar/ScalarCaseExpression.cpp b/expressions/scalar/ScalarCaseExpression.cpp
index 00a7710..6847425 100644
--- a/expressions/scalar/ScalarCaseExpression.cpp
+++ b/expressions/scalar/ScalarCaseExpression.cpp
@@ -319,7 +319,7 @@
                                                 *right_accessor,
                                                 right_relation_id,
                                                 check_pair.second)) {
-        current_case_positions->set(pos, true);
+        current_case_positions->set(pos);
         current_case_matches.emplace_back(check_pair);
       }
     }
diff --git a/relational_operators/HashJoinOperator.cpp b/relational_operators/HashJoinOperator.cpp
index b07e4cb..4083bd3 100644
--- a/relational_operators/HashJoinOperator.cpp
+++ b/relational_operators/HashJoinOperator.cpp
@@ -758,7 +758,7 @@
                                                       *probe_accessor,
                                                       probe_relation_id,
                                                       hash_match.second)) {
-        filter.set(hash_match.second, true);
+        filter.set(hash_match.second);
       }
     }
   }
diff --git a/storage/AggregationOperationState.cpp b/storage/AggregationOperationState.cpp
index 0f4795f..73f1983 100644
--- a/storage/AggregationOperationState.cpp
+++ b/storage/AggregationOperationState.cpp
@@ -579,8 +579,7 @@
           accessor->getTupleWithAttributes(group_by_key_ids));
       const std::size_t curr_tuple_partition_id =
           curr_tuple->getTupleHash() % num_partitions;
-      partition_membership[curr_tuple_partition_id]->set(
-          accessor->getCurrentPosition(), true);
+      partition_membership[curr_tuple_partition_id]->set(accessor->getCurrentPosition());
     }
 
     // Aggregate each partition.
diff --git a/storage/BloomFilterIndexSubBlock.cpp b/storage/BloomFilterIndexSubBlock.cpp
index 4351c05..1af3872 100644
--- a/storage/BloomFilterIndexSubBlock.cpp
+++ b/storage/BloomFilterIndexSubBlock.cpp
@@ -206,7 +206,7 @@
     } else {
       for (tuple_id tid = 0; tid <= tuple_store_.getMaxTupleID(); ++tid) {
         if (tuple_store_.hasTupleWithID(tid)) {
-          tuple_sequence->set(tid, true);
+          tuple_sequence->set(tid);
         }
       }
     }
diff --git a/storage/CMakeLists.txt b/storage/CMakeLists.txt
index 92a3292..fb09e49 100644
--- a/storage/CMakeLists.txt
+++ b/storage/CMakeLists.txt
@@ -1065,6 +1065,7 @@
                       quickstep_utility_Macros
                       quickstep_utility_ScopedBuffer)
 target_link_libraries(quickstep_storage_TupleIdSequence
+                      glog
                       quickstep_storage_StorageBlockInfo
                       quickstep_utility_BitVector
                       quickstep_utility_Macros)
diff --git a/storage/CSBTreeIndexSubBlock.cpp b/storage/CSBTreeIndexSubBlock.cpp
index dd75467..cc18e89 100644
--- a/storage/CSBTreeIndexSubBlock.cpp
+++ b/storage/CSBTreeIndexSubBlock.cpp
@@ -1791,7 +1791,7 @@
           // End of matches.
           return matches.release();
         }
-        matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_), true);
+        matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_));
       }
       key_ptr += key_tuple_id_pair_length_bytes_;
     }
@@ -1824,7 +1824,7 @@
                                + sizeof(NodeHeader)
                                + key_length_bytes_;
     for (uint16_t entry_num = 0; entry_num < num_keys; ++entry_num) {
-      matches->set(*reinterpret_cast<const tuple_id*>(tuple_id_ptr), true);
+      matches->set(*reinterpret_cast<const tuple_id*>(tuple_id_ptr));
       tuple_id_ptr += key_tuple_id_pair_length_bytes_;
     }
     search_node = getRightSiblingOfLeafNode(search_node);
@@ -1841,7 +1841,7 @@
       if (!equal_found) {
         if (key_less_literal_comparator.compareDataPtrsInl(key_ptr, literal)) {
           // key < literal
-          matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_), true);
+          matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_));
         } else {
           equal_found = true;
         }
@@ -1854,7 +1854,7 @@
           for (uint16_t subsequent_num = entry_num;
                subsequent_num < num_keys;
                ++subsequent_num) {
-            matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_), true);
+            matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_));
             key_ptr += key_tuple_id_pair_length_bytes_;
           }
           past_equal = true;
@@ -1877,7 +1877,7 @@
                                + sizeof(NodeHeader)
                                + key_length_bytes_;
     for (uint16_t entry_num = 0; entry_num < num_keys; ++entry_num) {
-      matches->set(*reinterpret_cast<const tuple_id*>(tuple_id_ptr), true);
+      matches->set(*reinterpret_cast<const tuple_id*>(tuple_id_ptr));
       tuple_id_ptr += key_tuple_id_pair_length_bytes_;
     }
     search_node = getRightSiblingOfLeafNode(search_node);
@@ -1910,7 +1910,7 @@
                                + sizeof(NodeHeader)
                                + key_length_bytes_;
     for (uint16_t entry_num = 0; entry_num < num_keys; ++entry_num) {
-      matches->set(*reinterpret_cast<const tuple_id*>(tuple_id_ptr), true);
+      matches->set(*reinterpret_cast<const tuple_id*>(tuple_id_ptr));
       tuple_id_ptr += key_tuple_id_pair_length_bytes_;
     }
     search_node = getRightSiblingOfLeafNode(search_node);
@@ -1927,7 +1927,7 @@
         if (!equal_found) {
           if (key_less_literal_comparator.compareDataPtrsInl(key_ptr, literal)) {
             // key < literal
-            matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_), true);
+            matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_));
           } else {
             equal_found = true;
           }
@@ -1938,7 +1938,7 @@
             // literal < key
             return matches.release();
           } else {
-            matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_), true);
+            matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_));
           }
         }
 
@@ -1954,7 +1954,7 @@
       for (uint16_t entry_num = 0; entry_num < num_keys; ++entry_num) {
         if (key_less_literal_comparator.compareDataPtrsInl(key_ptr, literal)) {
           // key < literal
-          matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_), true);
+          matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_));
         } else {
           return matches.release();
         }
@@ -2001,7 +2001,7 @@
       if (match_found) {
         // Fill in the matching entries from this leaf.
         for (uint16_t match_num = entry_num; match_num < num_keys; ++match_num) {
-          matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_), true);
+          matches->set(*reinterpret_cast<const tuple_id*>(key_ptr + key_length_bytes_));
           key_ptr += key_tuple_id_pair_length_bytes_;
         }
         break;
@@ -2024,7 +2024,7 @@
                                + sizeof(NodeHeader)
                                + key_length_bytes_;
     for (uint16_t entry_num = 0; entry_num < num_keys; ++entry_num) {
-      matches->set(*reinterpret_cast<const tuple_id*>(tuple_id_ptr), true);
+      matches->set(*reinterpret_cast<const tuple_id*>(tuple_id_ptr));
       tuple_id_ptr += key_tuple_id_pair_length_bytes_;
     }
     search_node = getRightSiblingOfLeafNode(search_node);
diff --git a/storage/CompressedColumnStoreTupleStorageSubBlock.cpp b/storage/CompressedColumnStoreTupleStorageSubBlock.cpp
index 3bd0c3a..cc23445 100644
--- a/storage/CompressedColumnStoreTupleStorageSubBlock.cpp
+++ b/storage/CompressedColumnStoreTupleStorageSubBlock.cpp
@@ -538,7 +538,7 @@
                ++tid) {
             if ((code != static_cast<const uint8_t*>(attr_stripe)[tid])
                 && (null_code != static_cast<const uint8_t*>(attr_stripe)[tid])) {
-              matches->set(tid, true);
+              matches->set(tid);
             }
           }
           break;
@@ -548,7 +548,7 @@
                ++tid) {
             if ((code != static_cast<const uint16_t*>(attr_stripe)[tid])
                 && (null_code != static_cast<const uint16_t*>(attr_stripe)[tid])) {
-              matches->set(tid, true);
+              matches->set(tid);
             }
           }
           break;
@@ -558,7 +558,7 @@
                ++tid) {
             if ((code != static_cast<const uint16_t*>(attr_stripe)[tid])
                 && (null_code != static_cast<const uint16_t*>(attr_stripe)[tid])) {
-              matches->set(tid, true);
+              matches->set(tid);
             }
           }
           break;
@@ -578,7 +578,7 @@
                ++filter_it) {
             if ((code != static_cast<const uint8_t*>(attr_stripe)[*filter_it])
                 && (null_code != static_cast<const uint8_t*>(attr_stripe)[*filter_it])) {
-              matches->set(*filter_it, true);
+              matches->set(*filter_it);
             }
           }
           break;
@@ -588,7 +588,7 @@
                ++filter_it) {
             if ((code != static_cast<const uint16_t*>(attr_stripe)[*filter_it])
                 && (null_code != static_cast<const uint16_t*>(attr_stripe)[*filter_it])) {
-              matches->set(*filter_it, true);
+              matches->set(*filter_it);
             }
           }
           break;
@@ -598,7 +598,7 @@
                ++filter_it) {
             if ((code != static_cast<const uint16_t*>(attr_stripe)[*filter_it])
                 && (null_code != static_cast<const uint16_t*>(attr_stripe)[*filter_it])) {
-              matches->set(*filter_it, true);
+              matches->set(*filter_it);
             }
           }
           break;
@@ -677,7 +677,7 @@
                ++tid) {
             if (range.first <= (static_cast<const uint8_t*>(attr_stripe)[tid])
                 && (static_cast<const uint8_t*>(attr_stripe)[tid] < range.second)) {
-              matches->set(tid, true);
+              matches->set(tid);
             }
           }
           break;
@@ -687,7 +687,7 @@
                ++tid) {
             if (range.first <= (static_cast<const uint16_t*>(attr_stripe)[tid])
                 && (static_cast<const uint16_t*>(attr_stripe)[tid] < range.second)) {
-              matches->set(tid, true);
+              matches->set(tid);
             }
           }
           break;
@@ -697,7 +697,7 @@
                ++tid) {
             if (range.first <= (static_cast<const uint32_t*>(attr_stripe)[tid])
                 && (static_cast<const uint32_t*>(attr_stripe)[tid] < range.second)) {
-              matches->set(tid, true);
+              matches->set(tid);
             }
           }
           break;
@@ -717,7 +717,7 @@
                ++filter_it) {
             if (range.first <= (static_cast<const uint8_t*>(attr_stripe)[*filter_it])
                 && (static_cast<const uint8_t*>(attr_stripe)[*filter_it] < range.second)) {
-              matches->set(*filter_it, true);
+              matches->set(*filter_it);
             }
           }
           break;
@@ -727,7 +727,7 @@
                ++filter_it) {
             if (range.first <= (static_cast<const uint16_t*>(attr_stripe)[*filter_it])
                 && (static_cast<const uint16_t*>(attr_stripe)[*filter_it] < range.second)) {
-              matches->set(*filter_it, true);
+              matches->set(*filter_it);
             }
           }
           break;
@@ -737,7 +737,7 @@
                ++filter_it) {
             if (range.first <= (static_cast<const uint32_t*>(attr_stripe)[*filter_it])
                 && (static_cast<const uint32_t*>(attr_stripe)[*filter_it] < range.second)) {
-              matches->set(*filter_it, true);
+              matches->set(*filter_it);
             }
           }
           break;
@@ -924,7 +924,7 @@
              tid < *static_cast<const tuple_id*>(sub_block_memory_);
              ++tid) {
           if (comp(code, static_cast<const uint8_t*>(attr_stripe)[tid])) {
-            matches->set(tid, true);
+            matches->set(tid);
           }
         }
         break;
@@ -933,7 +933,7 @@
              tid < *static_cast<const tuple_id*>(sub_block_memory_);
              ++tid) {
           if (comp(code, static_cast<const uint16_t*>(attr_stripe)[tid])) {
-            matches->set(tid, true);
+            matches->set(tid);
           }
         }
         break;
@@ -942,7 +942,7 @@
              tid < *static_cast<const tuple_id*>(sub_block_memory_);
              ++tid) {
           if (comp(code, static_cast<const uint32_t*>(attr_stripe)[tid])) {
-            matches->set(tid, true);
+            matches->set(tid);
           }
         }
         break;
@@ -961,7 +961,7 @@
              filter_it != filter->end();
              ++filter_it) {
           if (comp(code, static_cast<const uint8_t*>(attr_stripe)[*filter_it])) {
-            matches->set(*filter_it, true);
+            matches->set(*filter_it);
           }
         }
         break;
@@ -970,7 +970,7 @@
              filter_it != filter->end();
              ++filter_it) {
           if (comp(code, static_cast<const uint16_t*>(attr_stripe)[*filter_it])) {
-            matches->set(*filter_it, true);
+            matches->set(*filter_it);
           }
         }
         break;
@@ -979,7 +979,7 @@
              filter_it != filter->end();
              ++filter_it) {
           if (comp(code, static_cast<const uint32_t*>(attr_stripe)[*filter_it])) {
-            matches->set(*filter_it, true);
+            matches->set(*filter_it);
           }
         }
         break;
diff --git a/storage/CompressedPackedRowStoreTupleStorageSubBlock.cpp b/storage/CompressedPackedRowStoreTupleStorageSubBlock.cpp
index d362f98..f087293 100644
--- a/storage/CompressedPackedRowStoreTupleStorageSubBlock.cpp
+++ b/storage/CompressedPackedRowStoreTupleStorageSubBlock.cpp
@@ -403,7 +403,7 @@
              ++tid, attr_location += tuple_length_bytes_) {
           if ((code != *reinterpret_cast<const uint8_t*>(attr_location))
               && (null_code != *reinterpret_cast<const uint8_t*>(attr_location))) {
-            matches->set(tid, true);
+            matches->set(tid);
           }
         }
         break;
@@ -413,7 +413,7 @@
              ++tid, attr_location += tuple_length_bytes_) {
           if ((code != *reinterpret_cast<const uint16_t*>(attr_location))
               && (null_code != *reinterpret_cast<const uint16_t*>(attr_location))) {
-            matches->set(tid, true);
+            matches->set(tid);
           }
         }
         break;
@@ -423,7 +423,7 @@
              ++tid, attr_location += tuple_length_bytes_) {
           if ((code != *reinterpret_cast<const uint32_t*>(attr_location))
               && (null_code != *reinterpret_cast<const uint32_t*>(attr_location))) {
-            matches->set(tid, true);
+            matches->set(tid);
           }
         }
         break;
@@ -444,7 +444,7 @@
           const void *local_attr_location = attr_location + (*filter_it) * tuple_length_bytes_;
           if ((code != *reinterpret_cast<const uint8_t*>(local_attr_location))
               && (null_code != *reinterpret_cast<const uint8_t*>(local_attr_location))) {
-            matches->set(*filter_it, true);
+            matches->set(*filter_it);
           }
         }
         break;
@@ -455,7 +455,7 @@
           const void *local_attr_location = attr_location + (*filter_it) * tuple_length_bytes_;
           if ((code != *reinterpret_cast<const uint16_t*>(local_attr_location))
               && (null_code != *reinterpret_cast<const uint16_t*>(local_attr_location))) {
-            matches->set(*filter_it, true);
+            matches->set(*filter_it);
           }
         }
         break;
@@ -466,7 +466,7 @@
           const void *local_attr_location = attr_location + (*filter_it) * tuple_length_bytes_;
           if ((code != *reinterpret_cast<const uint32_t*>(local_attr_location))
               && (null_code != *reinterpret_cast<const uint32_t*>(local_attr_location))) {
-            matches->set(*filter_it, true);
+            matches->set(*filter_it);
           }
         }
         break;
@@ -513,7 +513,7 @@
              ++tid, attr_location += tuple_length_bytes_) {
           if (range.first <= (*reinterpret_cast<const uint8_t*>(attr_location))
               && (*reinterpret_cast<const uint8_t*>(attr_location) < range.second)) {
-            matches->set(tid, true);
+            matches->set(tid);
           }
         }
         break;
@@ -523,7 +523,7 @@
              ++tid, attr_location += tuple_length_bytes_) {
           if (range.first <= (*reinterpret_cast<const uint16_t*>(attr_location))
               && (*reinterpret_cast<const uint16_t*>(attr_location) < range.second)) {
-            matches->set(tid, true);
+            matches->set(tid);
           }
         }
         break;
@@ -533,7 +533,7 @@
              ++tid, attr_location += tuple_length_bytes_) {
           if (range.first <= (*reinterpret_cast<const uint32_t*>(attr_location))
               && (*reinterpret_cast<const uint32_t*>(attr_location) < range.second)) {
-            matches->set(tid, true);
+            matches->set(tid);
           }
         }
         break;
@@ -554,7 +554,7 @@
           const void *local_attr_location = attr_location + (*filter_it) * tuple_length_bytes_;
           if (range.first <= (*reinterpret_cast<const uint8_t*>(local_attr_location))
               && (*reinterpret_cast<const uint8_t*>(local_attr_location) < range.second)) {
-            matches->set(*filter_it, true);
+            matches->set(*filter_it);
           }
         }
         break;
@@ -565,7 +565,7 @@
           const void *local_attr_location = attr_location + (*filter_it) * tuple_length_bytes_;
           if (range.first <= (*reinterpret_cast<const uint16_t*>(local_attr_location))
               && (*reinterpret_cast<const uint16_t*>(local_attr_location) < range.second)) {
-            matches->set(*filter_it, true);
+            matches->set(*filter_it);
           }
         }
         break;
@@ -576,7 +576,7 @@
           const void *local_attr_location = attr_location + (*filter_it) * tuple_length_bytes_;
           if (range.first <= (*reinterpret_cast<const uint32_t*>(local_attr_location))
               && (*reinterpret_cast<const uint32_t*>(local_attr_location) < range.second)) {
-            matches->set(*filter_it, true);
+            matches->set(*filter_it);
           }
         }
         break;
@@ -638,7 +638,7 @@
              tid < *static_cast<const tuple_id*>(sub_block_memory_);
              ++tid, attr_location += tuple_length_bytes_) {
           if (comp(code, *reinterpret_cast<const uint8_t*>(attr_location))) {
-            matches->set(tid, true);
+            matches->set(tid);
           }
         }
         break;
@@ -647,7 +647,7 @@
              tid < *static_cast<const tuple_id*>(sub_block_memory_);
              ++tid, attr_location += tuple_length_bytes_) {
           if (comp(code, *reinterpret_cast<const uint16_t*>(attr_location))) {
-            matches->set(tid, true);
+            matches->set(tid);
           }
         }
         break;
@@ -656,7 +656,7 @@
              tid < *static_cast<const tuple_id*>(sub_block_memory_);
              ++tid, attr_location += tuple_length_bytes_) {
           if (comp(code, *reinterpret_cast<const uint32_t*>(attr_location))) {
-            matches->set(tid, true);
+            matches->set(tid);
           }
         }
         break;
@@ -676,7 +676,7 @@
              ++filter_it) {
           const void *local_attr_location = attr_location + (*filter_it) * tuple_length_bytes_;
           if (comp(code, *reinterpret_cast<const uint8_t*>(local_attr_location))) {
-            matches->set(*filter_it, true);
+            matches->set(*filter_it);
           }
         }
         break;
@@ -686,7 +686,7 @@
              ++filter_it) {
           const void *local_attr_location = attr_location + (*filter_it) * tuple_length_bytes_;
           if (comp(code, *reinterpret_cast<const uint16_t*>(local_attr_location))) {
-            matches->set(*filter_it, true);
+            matches->set(*filter_it);
           }
         }
         break;
@@ -696,7 +696,7 @@
              ++filter_it) {
           const void *local_attr_location = attr_location + (*filter_it) * tuple_length_bytes_;
           if (comp(code, *reinterpret_cast<const uint32_t*>(local_attr_location))) {
-            matches->set(*filter_it, true);
+            matches->set(*filter_it);
           }
         }
         break;
diff --git a/storage/InsertDestination.hpp b/storage/InsertDestination.hpp
index a0a7bc2..ab791b1 100644
--- a/storage/InsertDestination.hpp
+++ b/storage/InsertDestination.hpp
@@ -646,7 +646,7 @@
 
     if (partition_attr_ids.empty()) {
       while (accessor->next()) {
-        (*partition_membership)[input_partition_id_]->set(accessor->getCurrentPosition(), true);
+        (*partition_membership)[input_partition_id_]->set(accessor->getCurrentPosition());
       }
     } else {
       PartitionSchemeHeader::PartitionValues values(partition_attr_ids.size());
@@ -655,7 +655,7 @@
           values[i] = accessor->getTypedValue(partition_attr_ids[i]);
         }
         (*partition_membership)[partition_scheme_header_->getPartitionId(values)]->set(
-            accessor->getCurrentPosition(), true);
+            accessor->getCurrentPosition());
       }
     }
   }
diff --git a/storage/SMAIndexSubBlock.cpp b/storage/SMAIndexSubBlock.cpp
index 3b3b879..81cf6c0 100644
--- a/storage/SMAIndexSubBlock.cpp
+++ b/storage/SMAIndexSubBlock.cpp
@@ -685,7 +685,7 @@
       } else {
         for (tuple_id tid = 0; tid <= tuple_store_.getMaxTupleID(); ++tid) {
           if (tuple_store_.hasTupleWithID(tid)) {
-            tidseq->set(tid, true);
+            tidseq->set(tid);
           }
         }
       }
diff --git a/storage/StorageBlock.cpp b/storage/StorageBlock.cpp
index 31f1db2..e3e47d1 100644
--- a/storage/StorageBlock.cpp
+++ b/storage/StorageBlock.cpp
@@ -347,8 +347,7 @@
         sequence_mask->set(tuple_index_mapping.find(random_number) ==
                                    tuple_index_mapping.end()
                                ? random_number
-                               : tuple_index_mapping[random_number],
-                           true);
+                               : tuple_index_mapping[random_number]);
         tuple_index_mapping[random_number] = sequence->length() - (n + 1);
     }
 
@@ -461,7 +460,7 @@
         tuple_store_->setAttributeValueInPlaceTyped(*match_it, update_it->first, update_it->second);
       }
 
-      in_place_ids.set(*match_it, true);
+      in_place_ids.set(*match_it);
     } else {
       // Make a copy of the tuple with the updated values.
       std::vector<TypedValue> updated_tuple_values;
@@ -479,7 +478,7 @@
       }
 
       relocation_buffer.emplace_back(std::move(updated_tuple_values));
-      relocate_ids.set(*match_it, true);
+      relocate_ids.set(*match_it);
     }
   }
 
@@ -526,7 +525,7 @@
             rebuild_all = true;
           } else {
             // Only bother adding 'reinsert_id' to 'in_place_ids' if not rebuilding.
-            in_place_ids.set(reinsert_result.inserted_id, true);
+            in_place_ids.set(reinsert_result.inserted_id);
           }
         }
       }
diff --git a/storage/TupleIdSequence.hpp b/storage/TupleIdSequence.hpp
index 5047270..8c3a074 100644
--- a/storage/TupleIdSequence.hpp
+++ b/storage/TupleIdSequence.hpp
@@ -28,6 +28,8 @@
 #include "utility/BitVector.hpp"
 #include "utility/Macros.hpp"
 
+#include "glog/logging.h"
+
 namespace quickstep {
 
 /** \addtogroup Storage
@@ -155,6 +157,19 @@
   }
 
   /**
+   * @brief Set a particular tuple ID as being on or off in this sequence.
+   *
+   * @param on If true, tuple should be part of this sequence. If false,
+   *        remove tuple from this sequence (if it was present).
+   **/
+  inline void set(const tuple_id tuple) {
+    DCHECK_GE(tuple, 0);
+    DCHECK_LT(static_cast<std::size_t>(tuple), internal_bitvector_.size());
+
+    internal_bitvector_.setBit(tuple);
+  }
+
+  /**
    * @brief Set a range of tuple IDs all at once.
    *
    * @param first_tuple The first ID to set.
diff --git a/storage/TupleStorageSubBlock.cpp b/storage/TupleStorageSubBlock.cpp
index c5d482f..f2eef49 100644
--- a/storage/TupleStorageSubBlock.cpp
+++ b/storage/TupleStorageSubBlock.cpp
@@ -65,7 +65,7 @@
   } else {
     for (tuple_id tid = 0; tid <= max_tid; ++tid) {
       if (hasTupleWithID(tid)) {
-        existing_tuples->set(tid, true);
+        existing_tuples->set(tid);
       }
     }
   }
diff --git a/utility/BitVector.hpp b/utility/BitVector.hpp
index c404b7e..4472407 100644
--- a/utility/BitVector.hpp
+++ b/utility/BitVector.hpp
@@ -279,6 +279,18 @@
   }
 
   /**
+   * @brief Set the value of a single bit.
+   *
+   * @param bit_num The desired bit in this BitVector.
+   **/
+  inline void setBit(const std::size_t bit_num) {
+    DCHECK(!short_version_) << "Not implemented.";
+    DCHECK_LT(bit_num, num_bits_);
+
+    setBitRegularVersion(bit_num);
+  }
+
+  /**
    * @brief Set the value of a range of bits simulaneously.
    *
    * @param start_bit_num The first bit whose value should be set.
@@ -918,6 +930,10 @@
     data_array_[index_pos_in_data_array] |= op_value;
   }
 
+  inline void setBitRegularVersion(const std::size_t bit_num) {
+    data_array_[bit_num >> kHigherOrderShift] |= (TopBit<std::size_t>() >> (bit_num & kLowerOrderMask));
+  }
+
   template <typename VectorType>
   inline void setBitShortVersion(const std::size_t bit_num, bool value) {
     if (value) {
diff --git a/utility/lip_filter/LIPFilterAdaptiveProber.hpp b/utility/lip_filter/LIPFilterAdaptiveProber.hpp
index e1a75d6..fb826da 100644
--- a/utility/lip_filter/LIPFilterAdaptiveProber.hpp
+++ b/utility/lip_filter/LIPFilterAdaptiveProber.hpp
@@ -147,7 +147,7 @@
 
       const std::uint32_t num_hits = filterBatch(accessor, &batch, batch_size);
       for (std::uint32_t i = 0; i < num_hits; ++i) {
-        matches->set(batch[i], true);
+        matches->set(batch[i]);
       }
 
       batch_start += batch_size;
@@ -181,7 +181,7 @@
 
       const std::uint32_t num_hits = filterBatch(accessor, &batch, batch_size);
       for (std::uint32_t i = 0; i < num_hits; ++i) {
-        matches->set(batch[i], true);
+        matches->set(batch[i]);
       }
 
       num_tuples_left -= batch_size;
diff --git a/utility/tests/BitVector_unittest.cpp b/utility/tests/BitVector_unittest.cpp
index 774b830..053f405 100644
--- a/utility/tests/BitVector_unittest.cpp
+++ b/utility/tests/BitVector_unittest.cpp
@@ -357,14 +357,14 @@
   big_bit_vector->clear();
 
   // Set some bits, particularly around potential boundaries between size_t strides.
-  big_bit_vector->setBit(0, true);
-  big_bit_vector->setBit(5, true);
-  big_bit_vector->setBit(31, true);
-  big_bit_vector->setBit(32, true);
-  big_bit_vector->setBit(63, true);
-  big_bit_vector->setBit(64, true);
-  big_bit_vector->setBit(127, true);
-  big_bit_vector->setBit(128, true);
+  big_bit_vector->setBit(0);
+  big_bit_vector->setBit(5);
+  big_bit_vector->setBit(31);
+  big_bit_vector->setBit(32);
+  big_bit_vector->setBit(63);
+  big_bit_vector->setBit(64);
+  big_bit_vector->setBit(127);
+  big_bit_vector->setBit(128);
 
   for (size_t i = 0; i < TestFixture::kBigBitSize; ++i) {
     if ((i == 0) || (i == 5) || (i == 31) || (i == 32) || (i == 63) || (i == 64) || (i == 127) || (i == 128)) {
@@ -454,7 +454,7 @@
 
   // Set all the bits.
   for (size_t i = 0; i < TestFixture::kBigBitSize; ++i) {
-    big_bit_vector->setBit(i, true);
+    big_bit_vector->setBit(i);
   }
   EXPECT_EQ(TestFixture::kBigBitSize, big_bit_vector->onesCount());
   EXPECT_EQ(TestFixture::kBigBitSize, big_bit_vector->firstZero());
@@ -487,10 +487,10 @@
   std::unique_ptr<TypeParam> big_bit_vector(this->createBitVector(TestFixture::kBigBitSize));
   big_bit_vector->clear();
 
-  big_bit_vector->setBit(2, true);
-  big_bit_vector->setBit(4, true);
-  big_bit_vector->setBit(42, true);
-  big_bit_vector->setBit(77, true);
+  big_bit_vector->setBit(2);
+  big_bit_vector->setBit(4);
+  big_bit_vector->setBit(42);
+  big_bit_vector->setBit(77);
 
   std::unique_ptr<TypeParam> big_bit_vector_copy(this->createBitVector(TestFixture::kBigBitSize));
   big_bit_vector_copy->assignFrom(*big_bit_vector);
@@ -693,14 +693,14 @@
   std::unique_ptr<TypeParam> big_bit_vector(this->createBitVector(TestFixture::kBigBitSize));
   big_bit_vector->clear();
 
-  big_bit_vector->setBit(11, true);
-  big_bit_vector->setBit(13, true);
-  big_bit_vector->setBit(27, true);
-  big_bit_vector->setBit(42, true);
-  big_bit_vector->setBit(84, true);
-  big_bit_vector->setBit(88, true);
-  big_bit_vector->setBit(91, true);
-  big_bit_vector->setBit(123, true);
+  big_bit_vector->setBit(11);
+  big_bit_vector->setBit(13);
+  big_bit_vector->setBit(27);
+  big_bit_vector->setBit(42);
+  big_bit_vector->setBit(84);
+  big_bit_vector->setBit(88);
+  big_bit_vector->setBit(91);
+  big_bit_vector->setBit(123);
 
   big_bit_vector->shiftTailForward(15, 70);
   for (size_t i = 0; i < TestFixture::kBigBitSize; ++i) {
@@ -714,16 +714,16 @@
 
   // Also try a relatively small shift within the same word.
   big_bit_vector->clear();
-  big_bit_vector->setBit(11, true);
-  big_bit_vector->setBit(13, true);
-  big_bit_vector->setBit(27, true);
-  big_bit_vector->setBit(42, true);
-  big_bit_vector->setBit(45, true);
-  big_bit_vector->setBit(51, true);
-  big_bit_vector->setBit(84, true);
-  big_bit_vector->setBit(88, true);
-  big_bit_vector->setBit(91, true);
-  big_bit_vector->setBit(123, true);
+  big_bit_vector->setBit(11);
+  big_bit_vector->setBit(13);
+  big_bit_vector->setBit(27);
+  big_bit_vector->setBit(42);
+  big_bit_vector->setBit(45);
+  big_bit_vector->setBit(51);
+  big_bit_vector->setBit(84);
+  big_bit_vector->setBit(88);
+  big_bit_vector->setBit(91);
+  big_bit_vector->setBit(123);
 
   big_bit_vector->shiftTailForward(43, 7);
   for (size_t i = 0; i < TestFixture::kBigBitSize; ++i) {
@@ -738,18 +738,18 @@
 
   // Align the shift distance to size_t.
   big_bit_vector->clear();
-  big_bit_vector->setBit(11, true);
-  big_bit_vector->setBit(13, true);
-  big_bit_vector->setBit(27, true);
-  big_bit_vector->setBit(42, true);
-  big_bit_vector->setBit(45, true);
-  big_bit_vector->setBit(51, true);
-  big_bit_vector->setBit(84, true);
-  big_bit_vector->setBit(88, true);
-  big_bit_vector->setBit(91, true);
-  big_bit_vector->setBit(123, true);
-  big_bit_vector->setBit(128, true);
-  big_bit_vector->setBit(137, true);
+  big_bit_vector->setBit(11);
+  big_bit_vector->setBit(13);
+  big_bit_vector->setBit(27);
+  big_bit_vector->setBit(42);
+  big_bit_vector->setBit(45);
+  big_bit_vector->setBit(51);
+  big_bit_vector->setBit(84);
+  big_bit_vector->setBit(88);
+  big_bit_vector->setBit(91);
+  big_bit_vector->setBit(123);
+  big_bit_vector->setBit(128);
+  big_bit_vector->setBit(137);
 
   big_bit_vector->shiftTailForward(43, 64);
   for (size_t i = 0; i < TestFixture::kBigBitSize; ++i) {
@@ -764,18 +764,18 @@
 
   // Exactly align both the tail start and the shift distance to size_t.
   big_bit_vector->clear();
-  big_bit_vector->setBit(11, true);
-  big_bit_vector->setBit(13, true);
-  big_bit_vector->setBit(27, true);
-  big_bit_vector->setBit(42, true);
-  big_bit_vector->setBit(45, true);
-  big_bit_vector->setBit(51, true);
-  big_bit_vector->setBit(84, true);
-  big_bit_vector->setBit(88, true);
-  big_bit_vector->setBit(91, true);
-  big_bit_vector->setBit(123, true);
-  big_bit_vector->setBit(128, true);
-  big_bit_vector->setBit(137, true);
+  big_bit_vector->setBit(11);
+  big_bit_vector->setBit(13);
+  big_bit_vector->setBit(27);
+  big_bit_vector->setBit(42);
+  big_bit_vector->setBit(45);
+  big_bit_vector->setBit(51);
+  big_bit_vector->setBit(84);
+  big_bit_vector->setBit(88);
+  big_bit_vector->setBit(91);
+  big_bit_vector->setBit(123);
+  big_bit_vector->setBit(128);
+  big_bit_vector->setBit(137);
 
   big_bit_vector->shiftTailForward(64, 64);
   for (size_t i = 0; i < TestFixture::kBigBitSize; ++i) {
@@ -867,14 +867,14 @@
   std::unique_ptr<TypeParam> big_bit_vector(this->createBitVector(TestFixture::kBigBitSize));
   big_bit_vector->clear();
 
-  big_bit_vector->setBit(11, true);
-  big_bit_vector->setBit(13, true);
-  big_bit_vector->setBit(27, true);
-  big_bit_vector->setBit(42, true);
-  big_bit_vector->setBit(84, true);
-  big_bit_vector->setBit(88, true);
-  big_bit_vector->setBit(91, true);
-  big_bit_vector->setBit(123, true);
+  big_bit_vector->setBit(11);
+  big_bit_vector->setBit(13);
+  big_bit_vector->setBit(27);
+  big_bit_vector->setBit(42);
+  big_bit_vector->setBit(84);
+  big_bit_vector->setBit(88);
+  big_bit_vector->setBit(91);
+  big_bit_vector->setBit(123);
 
   big_bit_vector->shiftTailBackward(15, 70);
   for (size_t i = 0; i < TestFixture::kBigBitSize; ++i) {
@@ -889,16 +889,16 @@
 
   // Also try a relatively small shift within the same word.
   big_bit_vector->clear();
-  big_bit_vector->setBit(11, true);
-  big_bit_vector->setBit(13, true);
-  big_bit_vector->setBit(27, true);
-  big_bit_vector->setBit(42, true);
-  big_bit_vector->setBit(45, true);
-  big_bit_vector->setBit(51, true);
-  big_bit_vector->setBit(84, true);
-  big_bit_vector->setBit(88, true);
-  big_bit_vector->setBit(91, true);
-  big_bit_vector->setBit(123, true);
+  big_bit_vector->setBit(11);
+  big_bit_vector->setBit(13);
+  big_bit_vector->setBit(27);
+  big_bit_vector->setBit(42);
+  big_bit_vector->setBit(45);
+  big_bit_vector->setBit(51);
+  big_bit_vector->setBit(84);
+  big_bit_vector->setBit(88);
+  big_bit_vector->setBit(91);
+  big_bit_vector->setBit(123);
 
   big_bit_vector->shiftTailBackward(43, 7);
   for (size_t i = 0; i < TestFixture::kBigBitSize; ++i) {
@@ -913,18 +913,18 @@
 
   // Align the shift distance to size_t.
   big_bit_vector->clear();
-  big_bit_vector->setBit(11, true);
-  big_bit_vector->setBit(13, true);
-  big_bit_vector->setBit(27, true);
-  big_bit_vector->setBit(42, true);
-  big_bit_vector->setBit(45, true);
-  big_bit_vector->setBit(51, true);
-  big_bit_vector->setBit(84, true);
-  big_bit_vector->setBit(88, true);
-  big_bit_vector->setBit(91, true);
-  big_bit_vector->setBit(123, true);
-  big_bit_vector->setBit(128, true);
-  big_bit_vector->setBit(137, true);
+  big_bit_vector->setBit(11);
+  big_bit_vector->setBit(13);
+  big_bit_vector->setBit(27);
+  big_bit_vector->setBit(42);
+  big_bit_vector->setBit(45);
+  big_bit_vector->setBit(51);
+  big_bit_vector->setBit(84);
+  big_bit_vector->setBit(88);
+  big_bit_vector->setBit(91);
+  big_bit_vector->setBit(123);
+  big_bit_vector->setBit(128);
+  big_bit_vector->setBit(137);
 
   big_bit_vector->shiftTailBackward(43, 64);
   for (size_t i = 0; i < TestFixture::kBigBitSize; ++i) {
@@ -940,18 +940,18 @@
 
   // Exactly align both the tail start and the shift distance to size_t.
   big_bit_vector->clear();
-  big_bit_vector->setBit(11, true);
-  big_bit_vector->setBit(13, true);
-  big_bit_vector->setBit(27, true);
-  big_bit_vector->setBit(42, true);
-  big_bit_vector->setBit(45, true);
-  big_bit_vector->setBit(51, true);
-  big_bit_vector->setBit(84, true);
-  big_bit_vector->setBit(88, true);
-  big_bit_vector->setBit(91, true);
-  big_bit_vector->setBit(123, true);
-  big_bit_vector->setBit(128, true);
-  big_bit_vector->setBit(137, true);
+  big_bit_vector->setBit(11);
+  big_bit_vector->setBit(13);
+  big_bit_vector->setBit(27);
+  big_bit_vector->setBit(42);
+  big_bit_vector->setBit(45);
+  big_bit_vector->setBit(51);
+  big_bit_vector->setBit(84);
+  big_bit_vector->setBit(88);
+  big_bit_vector->setBit(91);
+  big_bit_vector->setBit(123);
+  big_bit_vector->setBit(128);
+  big_bit_vector->setBit(137);
 
   big_bit_vector->shiftTailBackward(64, 64);
   for (size_t i = 0; i < TestFixture::kBigBitSize; ++i) {
@@ -1027,14 +1027,14 @@
 
   // Set some bits, particularly around potential boundaries between size_t
   // strides.
-  big_bit_vector->setBit(0, true);
-  big_bit_vector->setBit(5, true);
-  big_bit_vector->setBit(31, true);
-  big_bit_vector->setBit(32, true);
-  big_bit_vector->setBit(63, true);
-  big_bit_vector->setBit(64, true);
-  big_bit_vector->setBit(127, true);
-  big_bit_vector->setBit(128, true);
+  big_bit_vector->setBit(0);
+  big_bit_vector->setBit(5);
+  big_bit_vector->setBit(31);
+  big_bit_vector->setBit(32);
+  big_bit_vector->setBit(63);
+  big_bit_vector->setBit(64);
+  big_bit_vector->setBit(127);
+  big_bit_vector->setBit(128);
 
   // Destroy the old BitVector and create a new one bound to the same memory.
   ASSERT_EQ(1u, this->allocated_chunks_.size());
@@ -1093,19 +1093,19 @@
   big_bit_vector->clear();
   EXPECT_FALSE(big_bit_vector->any());
 
-  big_bit_vector->setBit(0, true);
+  big_bit_vector->setBit(0);
   EXPECT_TRUE(big_bit_vector->any());
   big_bit_vector->setBit(0, false);
   EXPECT_FALSE(big_bit_vector->any());
 
-  big_bit_vector->setBit(TestFixture::kBigBitSize - 1, true);
+  big_bit_vector->setBit(TestFixture::kBigBitSize - 1);
   EXPECT_TRUE(big_bit_vector->any());
   big_bit_vector->setBit(TestFixture::kBigBitSize - 1, false);
   EXPECT_FALSE(big_bit_vector->any());
 
-  big_bit_vector->setBit(TestFixture::kBigBitSize / 2, true);
+  big_bit_vector->setBit(TestFixture::kBigBitSize / 2);
   EXPECT_TRUE(big_bit_vector->any());
-  big_bit_vector->setBit(TestFixture::kBigBitSize / 2 + 1, true);
+  big_bit_vector->setBit(TestFixture::kBigBitSize / 2 + 1);
   EXPECT_TRUE(big_bit_vector->any());
   big_bit_vector->setBit(TestFixture::kBigBitSize / 2, false);
   EXPECT_TRUE(big_bit_vector->any());
@@ -1150,21 +1150,21 @@
 
   big_bit_vector->setBit(0, false);
   EXPECT_FALSE(big_bit_vector->all());
-  big_bit_vector->setBit(0, true);
+  big_bit_vector->setBit(0);
   EXPECT_TRUE(big_bit_vector->all());
 
   big_bit_vector->setBit(TestFixture::kBigBitSize - 1, false);
   EXPECT_FALSE(big_bit_vector->all());
-  big_bit_vector->setBit(TestFixture::kBigBitSize - 1, true);
+  big_bit_vector->setBit(TestFixture::kBigBitSize - 1);
   EXPECT_TRUE(big_bit_vector->all());
 
   big_bit_vector->setBit(TestFixture::kBigBitSize / 2, false);
   EXPECT_FALSE(big_bit_vector->all());
   big_bit_vector->setBit(TestFixture::kBigBitSize / 2 + 1, false);
   EXPECT_FALSE(big_bit_vector->all());
-  big_bit_vector->setBit(TestFixture::kBigBitSize / 2, true);
+  big_bit_vector->setBit(TestFixture::kBigBitSize / 2);
   EXPECT_FALSE(big_bit_vector->all());
-  big_bit_vector->setBit(TestFixture::kBigBitSize / 2 + 1, true);
+  big_bit_vector->setBit(TestFixture::kBigBitSize / 2 + 1);
   EXPECT_TRUE(big_bit_vector->all());
 }