diff --git a/src/edge_table.rs b/src/edge_table.rs
index bd044730b..21d91ffae 100644
--- a/src/edge_table.rs
+++ b/src/edge_table.rs
@@ -31,7 +31,7 @@ fn make_edge_table_row(table: &EdgeTable, pos: tsk_id_t) -> Option<EdgeTableRow>
     // set up the iterator
     let p = crate::SizeType::try_from(pos).unwrap();
     if p < table.num_rows() {
-        let table_ref = table.table_;
+        let table_ref = &unsafe { *table.table_ };
         let rv = EdgeTableRow {
             id: pos.into(),
             left: table.left(pos).unwrap(),
@@ -46,8 +46,8 @@ fn make_edge_table_row(table: &EdgeTable, pos: tsk_id_t) -> Option<EdgeTableRow>
     }
 }
 
-pub(crate) type EdgeTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a EdgeTable<'a>>;
-pub(crate) type EdgeTableIterator<'a> = crate::table_iterator::TableIterator<EdgeTable<'a>>;
+pub(crate) type EdgeTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a EdgeTable>;
+pub(crate) type EdgeTableIterator<'a> = crate::table_iterator::TableIterator<EdgeTable>;
 
 impl<'a> Iterator for EdgeTableRefIterator<'a> {
     type Item = EdgeTableRow;
@@ -74,18 +74,34 @@ impl<'a> Iterator for EdgeTableIterator<'a> {
 /// These are not created directly.
 /// Instead, use [`TableAccess::edges`](crate::TableAccess::edges)
 /// to get a reference to an existing edge table;
-pub struct EdgeTable<'a> {
-    table_: &'a ll_bindings::tsk_edge_table_t,
+pub struct EdgeTable {
+    table_: *const ll_bindings::tsk_edge_table_t,
 }
 
-impl<'a> EdgeTable<'a> {
-    pub(crate) fn new_from_table(edges: &'a ll_bindings::tsk_edge_table_t) -> Self {
+impl EdgeTable {
+    pub(crate) fn as_ll_ref(&self) -> &ll_bindings::tsk_edge_table_t {
+        // SAFETY: cannot be constructed with null pointer
+        unsafe { &(*self.table_) }
+    }
+
+    pub(crate) fn new_from_table(edges: &ll_bindings::tsk_edge_table_t) -> Self {
         EdgeTable { table_: edges }
     }
 
+    pub(crate) fn new_null() -> Self {
+        Self {
+            table_: std::ptr::null(),
+        }
+    }
+
+    pub(crate) fn set_ptr(&mut self, ptr: *const ll_bindings::tsk_edge_table_t) {
+        assert!(!ptr.is_null());
+        self.table_ = ptr;
+    }
+
     /// Return the number of rows
-    pub fn num_rows(&'a self) -> crate::SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> crate::SizeType {
+        self.as_ll_ref().num_rows.into()
     }
 
     /// Return the ``parent`` value from row ``row`` of the table.
@@ -94,8 +110,14 @@ impl<'a> EdgeTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn parent<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Result<NodeId, TskitError> {
-        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.parent, NodeId)
+    pub fn parent<E: Into<EdgeId> + Copy>(&self, row: E) -> Result<NodeId, TskitError> {
+        unsafe_tsk_column_access!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ll_ref().parent,
+            NodeId
+        )
     }
 
     /// Return the ``child`` value from row ``row`` of the table.
@@ -104,8 +126,14 @@ impl<'a> EdgeTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn child<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Result<NodeId, TskitError> {
-        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.child, NodeId)
+    pub fn child<E: Into<EdgeId> + Copy>(&self, row: E) -> Result<NodeId, TskitError> {
+        unsafe_tsk_column_access!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ll_ref().child,
+            NodeId
+        )
     }
 
     /// Return the ``left`` value from row ``row`` of the table.
@@ -114,8 +142,8 @@ impl<'a> EdgeTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn left<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Result<Position, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.left) {
+    pub fn left<E: Into<EdgeId> + Copy>(&self, row: E) -> Result<Position, TskitError> {
+        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.as_ll_ref().left) {
             Ok(p) => Ok(p.into()),
             Err(e) => Err(e),
         }
@@ -127,18 +155,18 @@ impl<'a> EdgeTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn right<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Result<Position, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.right) {
+    pub fn right<E: Into<EdgeId> + Copy>(&self, row: E) -> Result<Position, TskitError> {
+        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.as_ll_ref().right) {
             Ok(p) => Ok(p.into()),
             Err(e) => Err(e),
         }
     }
 
     pub fn metadata<T: metadata::MetadataRoundtrip>(
-        &'a self,
+        &self,
         row: EdgeId,
     ) -> Result<Option<T>, TskitError> {
-        let table_ref = self.table_;
+        let table_ref = &unsafe { *self.table_ };
         let buffer = metadata_to_vector!(table_ref, row.0)?;
         decode_metadata_row!(T, buffer)
     }
@@ -147,7 +175,7 @@ impl<'a> EdgeTable<'a> {
     /// The value of the iterator is [`EdgeTableRow`].
     ///
     pub fn iter(&self) -> impl Iterator<Item = EdgeTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&EdgeTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&EdgeTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/individual_table.rs b/src/individual_table.rs
index 96b7106b9..c1e4617a6 100644
--- a/src/individual_table.rs
+++ b/src/individual_table.rs
@@ -46,8 +46,8 @@ impl PartialEq for IndividualTableRow {
 /// These are not created directly.
 /// Instead, use [`TableAccess::individuals`](crate::TableAccess::individuals)
 /// to get a reference to an existing node table;
-pub struct IndividualTable<'a> {
-    table_: &'a ll_bindings::tsk_individual_table_t,
+pub struct IndividualTable {
+    table_: *const ll_bindings::tsk_individual_table_t,
 }
 
 fn make_individual_table_row(table: &IndividualTable, pos: tsk_id_t) -> Option<IndividualTableRow> {
@@ -56,7 +56,7 @@ fn make_individual_table_row(table: &IndividualTable, pos: tsk_id_t) -> Option<I
     // set up the iterator
     let p = crate::SizeType::try_from(pos).unwrap();
     if p < table.num_rows() {
-        let table_ref = table.table_;
+        let table_ref = &unsafe { *table.table_ };
         let rv = IndividualTableRow {
             id: pos.into(),
             flags: table.flags(pos).unwrap(),
@@ -71,9 +71,8 @@ fn make_individual_table_row(table: &IndividualTable, pos: tsk_id_t) -> Option<I
 }
 
 pub(crate) type IndividualTableRefIterator<'a> =
-    crate::table_iterator::TableIterator<&'a IndividualTable<'a>>;
-pub(crate) type IndividualTableIterator<'a> =
-    crate::table_iterator::TableIterator<IndividualTable<'a>>;
+    crate::table_iterator::TableIterator<&'a IndividualTable>;
+pub(crate) type IndividualTableIterator<'a> = crate::table_iterator::TableIterator<IndividualTable>;
 
 impl<'a> Iterator for IndividualTableRefIterator<'a> {
     type Item = IndividualTableRow;
@@ -95,16 +94,31 @@ impl<'a> Iterator for IndividualTableIterator<'a> {
     }
 }
 
-impl<'a> IndividualTable<'a> {
-    pub(crate) fn new_from_table(individuals: &'a ll_bindings::tsk_individual_table_t) -> Self {
+impl IndividualTable {
+    pub(crate) fn as_ll_ref(&self) -> &ll_bindings::tsk_individual_table_t {
+        unsafe { &(*self.table_) }
+    }
+
+    pub(crate) fn new_from_table(individuals: &ll_bindings::tsk_individual_table_t) -> Self {
         IndividualTable {
             table_: individuals,
         }
     }
 
+    pub(crate) fn new_null() -> Self {
+        Self {
+            table_: std::ptr::null(),
+        }
+    }
+
+    pub(crate) fn set_ptr(&mut self, ptr: *const ll_bindings::tsk_individual_table_t) {
+        assert!(!ptr.is_null());
+        self.table_ = ptr;
+    }
+
     /// Return the number of rows
-    pub fn num_rows(&'a self) -> crate::SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> crate::SizeType {
+        self.as_ll_ref().num_rows.into()
     }
 
     /// Return the flags for a given row.
@@ -116,7 +130,7 @@ impl<'a> IndividualTable<'a> {
         &self,
         row: I,
     ) -> Result<IndividualFlags, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.flags) {
+        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.as_ll_ref().flags) {
             Ok(f) => Ok(IndividualFlags::from(f)),
             Err(e) => Err(e),
         }
@@ -135,9 +149,9 @@ impl<'a> IndividualTable<'a> {
             row.into().0,
             0,
             self.num_rows(),
-            self.table_.location,
-            self.table_.location_offset,
-            self.table_.location_length,
+            self.as_ll_ref().location,
+            self.as_ll_ref().location_offset,
+            self.as_ll_ref().location_length,
             Location
         )
     }
@@ -155,9 +169,9 @@ impl<'a> IndividualTable<'a> {
             row.into().0,
             0,
             self.num_rows(),
-            self.table_.parents,
-            self.table_.parents_offset,
-            self.table_.parents_length,
+            self.as_ll_ref().parents,
+            self.as_ll_ref().parents_offset,
+            self.as_ll_ref().parents_length,
             IndividualId
         )
     }
@@ -243,10 +257,10 @@ impl<'a> IndividualTable<'a> {
     /// # }
     /// ```
     pub fn metadata<T: metadata::MetadataRoundtrip>(
-        &'a self,
+        &self,
         row: IndividualId,
     ) -> Result<Option<T>, TskitError> {
-        let table_ref = self.table_;
+        let table_ref = &unsafe { *self.table_ };
         let buffer = metadata_to_vector!(table_ref, row.0)?;
         decode_metadata_row!(T, buffer)
     }
@@ -255,7 +269,7 @@ impl<'a> IndividualTable<'a> {
     /// The value of the iterator is [`IndividualTableRow`].
     ///
     pub fn iter(&self) -> impl Iterator<Item = IndividualTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&IndividualTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&IndividualTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/migration_table.rs b/src/migration_table.rs
index 7468d5ae5..da84b76ba 100644
--- a/src/migration_table.rs
+++ b/src/migration_table.rs
@@ -37,7 +37,7 @@ fn make_migration_table_row(table: &MigrationTable, pos: tsk_id_t) -> Option<Mig
     // set up the iterator
     let p = crate::SizeType::try_from(pos).unwrap();
     if p < table.num_rows() {
-        let table_ref = table.table_;
+        let table_ref = &unsafe { *table.table_ };
         Some(MigrationTableRow {
             id: pos.into(),
             left: table.left(pos).unwrap(),
@@ -54,9 +54,8 @@ fn make_migration_table_row(table: &MigrationTable, pos: tsk_id_t) -> Option<Mig
 }
 
 pub(crate) type MigrationTableRefIterator<'a> =
-    crate::table_iterator::TableIterator<&'a MigrationTable<'a>>;
-pub(crate) type MigrationTableIterator<'a> =
-    crate::table_iterator::TableIterator<MigrationTable<'a>>;
+    crate::table_iterator::TableIterator<&'a MigrationTable>;
+pub(crate) type MigrationTableIterator<'a> = crate::table_iterator::TableIterator<MigrationTable>;
 
 impl<'a> Iterator for MigrationTableRefIterator<'a> {
     type Item = MigrationTableRow;
@@ -83,18 +82,32 @@ impl<'a> Iterator for MigrationTableIterator<'a> {
 /// These are not created directly.
 /// Instead, use [`TableAccess::migrations`](crate::TableAccess::migrations)
 /// to get a reference to an existing node table;
-pub struct MigrationTable<'a> {
-    table_: &'a ll_bindings::tsk_migration_table_t,
+pub struct MigrationTable {
+    table_: *const ll_bindings::tsk_migration_table_t,
 }
 
-impl<'a> MigrationTable<'a> {
-    pub(crate) fn new_from_table(migrations: &'a ll_bindings::tsk_migration_table_t) -> Self {
+impl MigrationTable {
+    pub(crate) fn as_ll_ref(&self) -> &ll_bindings::tsk_migration_table_t {
+        unsafe { &(*self.table_) }
+    }
+    pub(crate) fn new_from_table(migrations: &ll_bindings::tsk_migration_table_t) -> Self {
         MigrationTable { table_: migrations }
     }
 
+    pub(crate) fn new_null() -> Self {
+        Self {
+            table_: std::ptr::null(),
+        }
+    }
+
+    pub(crate) fn set_ptr(&mut self, ptr: *const ll_bindings::tsk_migration_table_t) {
+        assert!(!ptr.is_null());
+        self.table_ = ptr;
+    }
+
     /// Return the number of rows
-    pub fn num_rows(&'a self) -> SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> SizeType {
+        self.as_ll_ref().num_rows.into()
     }
 
     /// Return the left coordinate for a given row.
@@ -102,8 +115,8 @@ impl<'a> MigrationTable<'a> {
     /// # Errors
     ///
     /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn left<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Result<Position, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.left) {
+    pub fn left<M: Into<MigrationId> + Copy>(&self, row: M) -> Result<Position, TskitError> {
+        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.as_ll_ref().left) {
             Ok(p) => Ok(p.into()),
             Err(e) => Err(e),
         }
@@ -114,8 +127,8 @@ impl<'a> MigrationTable<'a> {
     /// # Errors
     ///
     /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn right<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Result<Position, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.right) {
+    pub fn right<M: Into<MigrationId> + Copy>(&self, row: M) -> Result<Position, TskitError> {
+        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.as_ll_ref().right) {
             Ok(p) => Ok(p.into()),
             Err(e) => Err(e),
         }
@@ -126,8 +139,14 @@ impl<'a> MigrationTable<'a> {
     /// # Errors
     ///
     /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn node<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Result<NodeId, TskitError> {
-        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.node, NodeId)
+    pub fn node<M: Into<MigrationId> + Copy>(&self, row: M) -> Result<NodeId, TskitError> {
+        unsafe_tsk_column_access!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ll_ref().node,
+            NodeId
+        )
     }
 
     /// Return the source population for a given row.
@@ -135,15 +154,12 @@ impl<'a> MigrationTable<'a> {
     /// # Errors
     ///
     /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn source<M: Into<MigrationId> + Copy>(
-        &'a self,
-        row: M,
-    ) -> Result<PopulationId, TskitError> {
+    pub fn source<M: Into<MigrationId> + Copy>(&self, row: M) -> Result<PopulationId, TskitError> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_.source,
+            self.as_ll_ref().source,
             PopulationId
         )
     }
@@ -153,12 +169,12 @@ impl<'a> MigrationTable<'a> {
     /// # Errors
     ///
     /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn dest<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Result<PopulationId, TskitError> {
+    pub fn dest<M: Into<MigrationId> + Copy>(&self, row: M) -> Result<PopulationId, TskitError> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_.dest,
+            self.as_ll_ref().dest,
             PopulationId
         )
     }
@@ -168,8 +184,8 @@ impl<'a> MigrationTable<'a> {
     /// # Errors
     ///
     /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn time<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Result<Time, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.time) {
+    pub fn time<M: Into<MigrationId> + Copy>(&self, row: M) -> Result<Time, TskitError> {
+        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.as_ll_ref().time) {
             Ok(t) => Ok(t.into()),
             Err(e) => Err(e),
         }
@@ -181,10 +197,10 @@ impl<'a> MigrationTable<'a> {
     ///
     /// * [`TskitError::IndexError`] if `row` is out of range.
     pub fn metadata<T: metadata::MetadataRoundtrip>(
-        &'a self,
+        &self,
         row: MigrationId,
     ) -> Result<Option<T>, TskitError> {
-        let table_ref = self.table_;
+        let table_ref = &unsafe { *self.table_ };
         let buffer = metadata_to_vector!(table_ref, row.0)?;
         decode_metadata_row!(T, buffer)
     }
@@ -192,7 +208,7 @@ impl<'a> MigrationTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`MigrationTableRow`].
     pub fn iter(&self) -> impl Iterator<Item = MigrationTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&MigrationTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&MigrationTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/mutation_table.rs b/src/mutation_table.rs
index 04995e543..091559b51 100644
--- a/src/mutation_table.rs
+++ b/src/mutation_table.rs
@@ -34,7 +34,7 @@ fn make_mutation_table_row(table: &MutationTable, pos: tsk_id_t) -> Option<Mutat
     // set up the iterator
     let p = crate::SizeType::try_from(pos).unwrap();
     if p < table.num_rows() {
-        let table_ref = table.table_;
+        let table_ref = &unsafe { *table.table_ };
         let rv = MutationTableRow {
             id: pos.into(),
             site: table.site(pos).unwrap(),
@@ -50,8 +50,8 @@ fn make_mutation_table_row(table: &MutationTable, pos: tsk_id_t) -> Option<Mutat
     }
 }
 pub(crate) type MutationTableRefIterator<'a> =
-    crate::table_iterator::TableIterator<&'a MutationTable<'a>>;
-pub(crate) type MutationTableIterator<'a> = crate::table_iterator::TableIterator<MutationTable<'a>>;
+    crate::table_iterator::TableIterator<&'a MutationTable>;
+pub(crate) type MutationTableIterator<'a> = crate::table_iterator::TableIterator<MutationTable>;
 
 impl<'a> Iterator for MutationTableRefIterator<'a> {
     type Item = MutationTableRow;
@@ -78,18 +78,34 @@ impl<'a> Iterator for MutationTableIterator<'a> {
 /// These are not created directly.
 /// Instead, use [`TableAccess::mutations`](crate::TableAccess::mutations)
 /// to get a reference to an existing mutation table;
-pub struct MutationTable<'a> {
-    table_: &'a ll_bindings::tsk_mutation_table_t,
+pub struct MutationTable {
+    table_: *const ll_bindings::tsk_mutation_table_t,
 }
 
-impl<'a> MutationTable<'a> {
-    pub(crate) fn new_from_table(mutations: &'a ll_bindings::tsk_mutation_table_t) -> Self {
+impl MutationTable {
+    fn as_ll_ref(&self) -> &ll_bindings::tsk_mutation_table_t {
+        // SAFETY: cannot be constructed with null pointer
+        unsafe { &(*self.table_) }
+    }
+
+    pub(crate) fn new_from_table(mutations: &ll_bindings::tsk_mutation_table_t) -> Self {
         MutationTable { table_: mutations }
     }
 
+    pub(crate) fn new_null() -> Self {
+        Self {
+            table_: std::ptr::null(),
+        }
+    }
+
+    pub(crate) fn set_ptr(&mut self, ptr: *const ll_bindings::tsk_mutation_table_t) {
+        assert!(!ptr.is_null());
+        self.table_ = ptr;
+    }
+
     /// Return the number of rows.
-    pub fn num_rows(&'a self) -> SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> SizeType {
+        self.as_ll_ref().num_rows.into()
     }
 
     /// Return the ``site`` value from row ``row`` of the table.
@@ -98,8 +114,14 @@ impl<'a> MutationTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn site<M: Into<MutationId> + Copy>(&'a self, row: M) -> Result<SiteId, TskitError> {
-        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.site, SiteId)
+    pub fn site<M: Into<MutationId> + Copy>(&self, row: M) -> Result<SiteId, TskitError> {
+        unsafe_tsk_column_access!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ll_ref().site,
+            SiteId
+        )
     }
 
     /// Return the ``node`` value from row ``row`` of the table.
@@ -108,8 +130,14 @@ impl<'a> MutationTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn node<M: Into<MutationId> + Copy>(&'a self, row: M) -> Result<NodeId, TskitError> {
-        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.node, NodeId)
+    pub fn node<M: Into<MutationId> + Copy>(&self, row: M) -> Result<NodeId, TskitError> {
+        unsafe_tsk_column_access!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ll_ref().node,
+            NodeId
+        )
     }
 
     /// Return the ``parent`` value from row ``row`` of the table.
@@ -118,12 +146,12 @@ impl<'a> MutationTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn parent<M: Into<MutationId> + Copy>(&'a self, row: M) -> Result<MutationId, TskitError> {
+    pub fn parent<M: Into<MutationId> + Copy>(&self, row: M) -> Result<MutationId, TskitError> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_.parent,
+            self.as_ll_ref().parent,
             MutationId
         )
     }
@@ -134,8 +162,8 @@ impl<'a> MutationTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn time<M: Into<MutationId> + Copy>(&'a self, row: M) -> Result<Time, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.time) {
+    pub fn time<M: Into<MutationId> + Copy>(&self, row: M) -> Result<Time, TskitError> {
+        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.as_ll_ref().time) {
             Ok(t) => Ok(t.into()),
             Err(e) => Err(e),
         }
@@ -152,23 +180,23 @@ impl<'a> MutationTable<'a> {
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
     pub fn derived_state<M: Into<MutationId>>(
-        &'a self,
+        &self,
         row: M,
     ) -> Result<Option<Vec<u8>>, TskitError> {
         metadata::char_column_to_vector(
-            self.table_.derived_state,
-            self.table_.derived_state_offset,
+            self.as_ll_ref().derived_state,
+            self.as_ll_ref().derived_state_offset,
             row.into().0,
-            self.table_.num_rows,
-            self.table_.derived_state_length,
+            self.as_ll_ref().num_rows,
+            self.as_ll_ref().derived_state_length,
         )
     }
 
     pub fn metadata<T: metadata::MetadataRoundtrip>(
-        &'a self,
+        &self,
         row: MutationId,
     ) -> Result<Option<T>, TskitError> {
-        let table_ref = self.table_;
+        let table_ref = &unsafe { *self.table_ };
         let buffer = metadata_to_vector!(table_ref, row.0)?;
         decode_metadata_row!(T, buffer)
     }
@@ -176,7 +204,7 @@ impl<'a> MutationTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`MutationTableRow`].
     pub fn iter(&self) -> impl Iterator<Item = MutationTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&MutationTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&MutationTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/node_table.rs b/src/node_table.rs
index 35b73c6aa..af8e07016 100644
--- a/src/node_table.rs
+++ b/src/node_table.rs
@@ -33,7 +33,7 @@ fn make_node_table_row(table: &NodeTable, pos: tsk_id_t) -> Option<NodeTableRow>
     // set up the iterator
     let p = crate::SizeType::try_from(pos).unwrap();
     if p < table.num_rows() {
-        let table_ref = table.table_;
+        let table_ref = &unsafe { *table.table_ };
         Some(NodeTableRow {
             id: pos.into(),
             time: table.time(pos).unwrap(),
@@ -47,8 +47,8 @@ fn make_node_table_row(table: &NodeTable, pos: tsk_id_t) -> Option<NodeTableRow>
     }
 }
 
-pub(crate) type NodeTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a NodeTable<'a>>;
-pub(crate) type NodeTableIterator<'a> = crate::table_iterator::TableIterator<NodeTable<'a>>;
+pub(crate) type NodeTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a NodeTable>;
+pub(crate) type NodeTableIterator<'a> = crate::table_iterator::TableIterator<NodeTable>;
 
 impl<'a> Iterator for NodeTableRefIterator<'a> {
     type Item = NodeTableRow;
@@ -75,18 +75,34 @@ impl<'a> Iterator for NodeTableIterator<'a> {
 /// These are not created directly.
 /// Instead, use [`TableAccess::nodes`](crate::TableAccess::nodes)
 /// to get a reference to an existing node table;
-pub struct NodeTable<'a> {
-    table_: &'a ll_bindings::tsk_node_table_t,
+pub struct NodeTable {
+    table_: *const ll_bindings::tsk_node_table_t,
 }
 
-impl<'a> NodeTable<'a> {
-    pub(crate) fn new_from_table(nodes: &'a ll_bindings::tsk_node_table_t) -> Self {
+impl NodeTable {
+    fn as_ll_ref(&self) -> &ll_bindings::tsk_node_table_t {
+        // SAFETY: cannot be constructed with null pointer
+        unsafe { &(*self.table_) }
+    }
+
+    pub(crate) fn new_from_table(nodes: &ll_bindings::tsk_node_table_t) -> Self {
         NodeTable { table_: nodes }
     }
 
+    pub(crate) fn new_null() -> Self {
+        Self {
+            table_: std::ptr::null(),
+        }
+    }
+
+    pub(crate) fn set_ptr(&mut self, ptr: *const ll_bindings::tsk_node_table_t) {
+        assert!(!ptr.is_null());
+        self.table_ = ptr;
+    }
+
     /// Return the number of rows
-    pub fn num_rows(&'a self) -> SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> SizeType {
+        self.as_ll_ref().num_rows.into()
     }
 
     /// Return the ``time`` value from row ``row`` of the table.
@@ -95,8 +111,8 @@ impl<'a> NodeTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn time<N: Into<NodeId> + Copy>(&'a self, row: N) -> Result<Time, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.time) {
+    pub fn time<N: Into<NodeId> + Copy>(&self, row: N) -> Result<Time, TskitError> {
+        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.as_ll_ref().time) {
             Ok(t) => Ok(t.into()),
             Err(e) => Err(e),
         }
@@ -108,48 +124,25 @@ impl<'a> NodeTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn flags<N: Into<NodeId> + Copy>(&'a self, row: N) -> Result<NodeFlags, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.flags) {
+    pub fn flags<N: Into<NodeId> + Copy>(&self, row: N) -> Result<NodeFlags, TskitError> {
+        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.as_ll_ref().flags) {
             Ok(f) => Ok(NodeFlags::from(f)),
             Err(e) => Err(e),
         }
     }
 
-    /// Mutable access to node flags.
-    pub fn flags_array_mut(&mut self) -> &mut [NodeFlags] {
-        unsafe {
-            std::slice::from_raw_parts_mut(
-                self.table_.flags.cast::<NodeFlags>(),
-                usize::try_from(self.table_.num_rows).unwrap(),
-            )
-        }
-    }
-
-    /// Mutable access to node times.
-    pub fn time_array_mut(&mut self) -> &mut [Time] {
-        unsafe {
-            std::slice::from_raw_parts_mut(
-                self.table_.time.cast::<Time>(),
-                usize::try_from(self.table_.num_rows).unwrap(),
-            )
-        }
-    }
-
     /// Return the ``population`` value from row ``row`` of the table.
     ///
     /// # Errors
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn population<N: Into<NodeId> + Copy>(
-        &'a self,
-        row: N,
-    ) -> Result<PopulationId, TskitError> {
+    pub fn population<N: Into<NodeId> + Copy>(&self, row: N) -> Result<PopulationId, TskitError> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_.population,
+            self.as_ll_ref().population,
             PopulationId
         )
     }
@@ -160,7 +153,7 @@ impl<'a> NodeTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn deme<N: Into<NodeId> + Copy>(&'a self, row: N) -> Result<PopulationId, TskitError> {
+    pub fn deme<N: Into<NodeId> + Copy>(&self, row: N) -> Result<PopulationId, TskitError> {
         self.population(row)
     }
 
@@ -170,24 +163,21 @@ impl<'a> NodeTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn individual<N: Into<NodeId> + Copy>(
-        &'a self,
-        row: N,
-    ) -> Result<IndividualId, TskitError> {
+    pub fn individual<N: Into<NodeId> + Copy>(&self, row: N) -> Result<IndividualId, TskitError> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_.individual,
+            self.as_ll_ref().individual,
             IndividualId
         )
     }
 
     pub fn metadata<T: metadata::MetadataRoundtrip>(
-        &'a self,
+        &self,
         row: NodeId,
     ) -> Result<Option<T>, TskitError> {
-        let table_ref = self.table_;
+        let table_ref = &unsafe { *self.table_ };
         let buffer = metadata_to_vector!(table_ref, row.0)?;
         decode_metadata_row!(T, buffer)
     }
@@ -195,7 +185,7 @@ impl<'a> NodeTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`NodeTableRow`].
     pub fn iter(&self) -> impl Iterator<Item = NodeTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&NodeTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&NodeTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/population_table.rs b/src/population_table.rs
index e5c06d4f3..d2f4160c7 100644
--- a/src/population_table.rs
+++ b/src/population_table.rs
@@ -24,7 +24,7 @@ fn make_population_table_row(table: &PopulationTable, pos: tsk_id_t) -> Option<P
     // set up the iterator
     let p = crate::SizeType::try_from(pos).unwrap();
     if p < table.num_rows() {
-        let table_ref = table.table_;
+        let table_ref = table.as_ll_ref();
         let rv = PopulationTableRow {
             id: pos.into(),
             metadata: table_row_decode_metadata!(table_ref, pos),
@@ -36,9 +36,8 @@ fn make_population_table_row(table: &PopulationTable, pos: tsk_id_t) -> Option<P
 }
 
 pub(crate) type PopulationTableRefIterator<'a> =
-    crate::table_iterator::TableIterator<&'a PopulationTable<'a>>;
-pub(crate) type PopulationTableIterator<'a> =
-    crate::table_iterator::TableIterator<PopulationTable<'a>>;
+    crate::table_iterator::TableIterator<&'a PopulationTable>;
+pub(crate) type PopulationTableIterator<'a> = crate::table_iterator::TableIterator<PopulationTable>;
 
 impl<'a> Iterator for PopulationTableRefIterator<'a> {
     type Item = PopulationTableRow;
@@ -65,25 +64,44 @@ impl<'a> Iterator for PopulationTableIterator<'a> {
 /// These are not created directly.
 /// Instead, use [`TableAccess::populations`](crate::TableAccess::populations)
 /// to get a reference to an existing population table;
-pub struct PopulationTable<'a> {
-    table_: &'a ll_bindings::tsk_population_table_t,
+pub struct PopulationTable {
+    table_: *const ll_bindings::tsk_population_table_t,
 }
 
-impl<'a> PopulationTable<'a> {
-    pub(crate) fn new_from_table(mutations: &'a ll_bindings::tsk_population_table_t) -> Self {
-        PopulationTable { table_: mutations }
+impl PopulationTable {
+    fn as_ll_ref(&self) -> &ll_bindings::tsk_population_table_t {
+        // SAFETY: cannot be constructed with null pointer
+        unsafe { &(*self.table_) }
+    }
+
+    pub(crate) fn new_from_table(populations: &ll_bindings::tsk_population_table_t) -> Self {
+        PopulationTable {
+            table_: populations,
+        }
+    }
+
+    pub(crate) fn new_null() -> Self {
+        Self {
+            table_: std::ptr::null(),
+        }
+    }
+
+    pub(crate) fn set_ptr(&mut self, ptr: *const ll_bindings::tsk_population_table_t) {
+        assert!(!ptr.is_null());
+        self.table_ = ptr;
     }
 
     /// Return the number of rows.
-    pub fn num_rows(&'a self) -> SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> SizeType {
+        self.as_ll_ref().num_rows.into()
     }
 
     pub fn metadata<T: metadata::MetadataRoundtrip>(
-        &'a self,
+        &self,
         row: PopulationId,
     ) -> Result<Option<T>, TskitError> {
-        let table_ref = self.table_;
+        // SAFETY: cannot be constructed with null pointer
+        let table_ref = unsafe { *self.table_ };
         let buffer = metadata_to_vector!(table_ref, row.0)?;
         decode_metadata_row!(T, buffer)
     }
@@ -91,7 +109,7 @@ impl<'a> PopulationTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`PopulationTableRow`].
     pub fn iter(&self) -> impl Iterator<Item = PopulationTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&PopulationTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&PopulationTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/provenance.rs b/src/provenance.rs
index 2f0eb2eed..0d31c1511 100644
--- a/src/provenance.rs
+++ b/src/provenance.rs
@@ -59,8 +59,8 @@ fn make_provenance_row(table: &ProvenanceTable, pos: tsk_id_t) -> Option<Provena
     }
 }
 
-type ProvenanceTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a ProvenanceTable<'a>>;
-type ProvenanceTableIterator<'a> = crate::table_iterator::TableIterator<ProvenanceTable<'a>>;
+type ProvenanceTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a ProvenanceTable>;
+type ProvenanceTableIterator<'a> = crate::table_iterator::TableIterator<ProvenanceTable>;
 
 impl<'a> Iterator for ProvenanceTableRefIterator<'a> {
     type Item = ProvenanceTableRow;
@@ -92,20 +92,36 @@ impl<'a> Iterator for ProvenanceTableIterator<'a> {
 ///
 /// * The type is enabled by the `"provenance"` feature.
 ///
-pub struct ProvenanceTable<'a> {
-    table_: &'a ll_bindings::tsk_provenance_table_t,
+pub struct ProvenanceTable {
+    table_: *const ll_bindings::tsk_provenance_table_t,
 }
 
-impl<'a> ProvenanceTable<'a> {
-    pub(crate) fn new_from_table(provenances: &'a ll_bindings::tsk_provenance_table_t) -> Self {
+impl ProvenanceTable {
+    fn as_ll_ref(&self) -> &ll_bindings::tsk_provenance_table_t {
+        // SAFETY: cannot be constructed with null pointer
+        unsafe { &(*self.table_) }
+    }
+
+    pub(crate) fn new_from_table(provenances: &ll_bindings::tsk_provenance_table_t) -> Self {
         ProvenanceTable {
             table_: provenances,
         }
     }
 
+    pub(crate) fn new_null() -> Self {
+        Self {
+            table_: std::ptr::null(),
+        }
+    }
+
+    pub(crate) fn set_ptr(&mut self, ptr: *const ll_bindings::tsk_provenance_table_t) {
+        assert!(!ptr.is_null());
+        self.table_ = ptr;
+    }
+
     /// Return the number of rows
-    pub fn num_rows(&'a self) -> SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> SizeType {
+        self.as_ll_ref().num_rows.into()
     }
 
     /// Get the ISO-formatted time stamp for row `row`.
@@ -113,14 +129,14 @@ impl<'a> ProvenanceTable<'a> {
     /// # Errors
     ///
     /// [`TskitError::IndexError`] if `r` is out of range.
-    pub fn timestamp<P: Into<ProvenanceId> + Copy>(&'a self, row: P) -> Result<String, TskitError> {
+    pub fn timestamp<P: Into<ProvenanceId> + Copy>(&self, row: P) -> Result<String, TskitError> {
         match unsafe_tsk_ragged_char_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_.timestamp,
-            self.table_.timestamp_offset,
-            self.table_.timestamp_length
+            self.as_ll_ref().timestamp,
+            self.as_ll_ref().timestamp_offset,
+            self.as_ll_ref().timestamp_length
         ) {
             Ok(Some(string)) => Ok(string),
             Ok(None) => Err(crate::TskitError::ValueError {
@@ -136,14 +152,14 @@ impl<'a> ProvenanceTable<'a> {
     /// # Errors
     ///
     /// [`TskitError::IndexError`] if `r` is out of range.
-    pub fn record<P: Into<ProvenanceId> + Copy>(&'a self, row: P) -> Result<String, TskitError> {
+    pub fn record<P: Into<ProvenanceId> + Copy>(&self, row: P) -> Result<String, TskitError> {
         match unsafe_tsk_ragged_char_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_.record,
-            self.table_.record_offset,
-            self.table_.record_length
+            self.as_ll_ref().record,
+            self.as_ll_ref().record_offset,
+            self.as_ll_ref().record_length
         ) {
             Ok(Some(string)) => Ok(string),
             Ok(None) => Ok(String::from("")),
@@ -157,7 +173,7 @@ impl<'a> ProvenanceTable<'a> {
     ///
     /// [`TskitError::IndexError`] if `r` is out of range.
     pub fn row<P: Into<ProvenanceId> + Copy>(
-        &'a self,
+        &self,
         row: P,
     ) -> Result<ProvenanceTableRow, TskitError> {
         if row.into() < 0 {
@@ -173,7 +189,7 @@ impl<'a> ProvenanceTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`ProvenanceTableRow`].
     pub fn iter(&self) -> impl Iterator<Item = ProvenanceTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&ProvenanceTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&ProvenanceTable>(self)
     }
 }
 
@@ -190,13 +206,25 @@ mod test_provenances {
         let s = String::from("");
         let row_id = tables.add_provenance(&s).unwrap();
         let _ = tables.provenances().row(row_id).unwrap();
+        assert_eq!(tables.provenances().num_rows(), 1);
+        let _ = tables.provenances().row(row_id).unwrap();
 
         // and for tree sequences...
         tables.build_index().unwrap();
         let mut ts = tables
             .tree_sequence(crate::TreeSequenceFlags::default())
             .unwrap();
+        assert_eq!(ts.provenances().num_rows(), 1);
+        assert_eq!(row_id, 0);
+        let _ = ts.provenances().timestamp(row_id).unwrap();
+        // let _ = ts.provenances().record(row_id).unwrap();
+        // let _ = ts.provenances().row(row_id).unwrap();
+        assert_eq!(ts.provenances().num_rows(), 1);
         let row_id = ts.add_provenance(&s).unwrap();
+        assert_eq!(row_id, 1);
+        assert_eq!(ts.provenances().num_rows(), 2);
+        let _ = ts.provenances().timestamp(row_id).unwrap();
+        let _ = ts.provenances().record(row_id).unwrap();
         let _ = ts.provenances().row(row_id).unwrap();
     }
 
diff --git a/src/site_table.rs b/src/site_table.rs
index cfd98d45f..868e3a99b 100644
--- a/src/site_table.rs
+++ b/src/site_table.rs
@@ -29,7 +29,7 @@ fn make_site_table_row(table: &SiteTable, pos: tsk_id_t) -> Option<SiteTableRow>
     // set up the iterator
     let p = crate::SizeType::try_from(pos).unwrap();
     if p < table.num_rows() {
-        let table_ref = table.table_;
+        let table_ref = &unsafe { *table.table_ };
         let rv = SiteTableRow {
             id: pos.into(),
             position: table.position(pos).unwrap(),
@@ -42,8 +42,8 @@ fn make_site_table_row(table: &SiteTable, pos: tsk_id_t) -> Option<SiteTableRow>
     }
 }
 
-pub(crate) type SiteTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a SiteTable<'a>>;
-pub(crate) type SiteTableIterator<'a> = crate::table_iterator::TableIterator<SiteTable<'a>>;
+pub(crate) type SiteTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a SiteTable>;
+pub(crate) type SiteTableIterator<'a> = crate::table_iterator::TableIterator<SiteTable>;
 
 impl<'a> Iterator for SiteTableRefIterator<'a> {
     type Item = SiteTableRow;
@@ -70,18 +70,34 @@ impl<'a> Iterator for SiteTableIterator<'a> {
 /// These are not created directly.
 /// Instead, use [`TableAccess::sites`](crate::TableAccess::sites)
 /// to get a reference to an existing site table;
-pub struct SiteTable<'a> {
-    table_: &'a ll_bindings::tsk_site_table_t,
+pub struct SiteTable {
+    table_: *const ll_bindings::tsk_site_table_t,
 }
 
-impl<'a> SiteTable<'a> {
-    pub(crate) fn new_from_table(sites: &'a ll_bindings::tsk_site_table_t) -> Self {
+impl SiteTable {
+    fn as_ll_ref(&self) -> &ll_bindings::tsk_site_table_t {
+        // SAFETY: cannot be constructed with null pointer
+        unsafe { &(*self.table_) }
+    }
+
+    pub(crate) fn new_from_table(sites: &ll_bindings::tsk_site_table_t) -> Self {
         SiteTable { table_: sites }
     }
 
+    pub(crate) fn new_null() -> Self {
+        Self {
+            table_: std::ptr::null(),
+        }
+    }
+
+    pub(crate) fn set_ptr(&mut self, ptr: *const ll_bindings::tsk_site_table_t) {
+        assert!(!ptr.is_null());
+        self.table_ = ptr;
+    }
+
     /// Return the number of rows
-    pub fn num_rows(&'a self) -> SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> SizeType {
+        self.as_ll_ref().num_rows.into()
     }
 
     /// Return the ``position`` value from row ``row`` of the table.
@@ -90,8 +106,9 @@ impl<'a> SiteTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn position<S: Into<SiteId> + Copy>(&'a self, row: S) -> Result<Position, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.position) {
+    pub fn position<S: Into<SiteId> + Copy>(&self, row: S) -> Result<Position, TskitError> {
+        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.as_ll_ref().position)
+        {
             Ok(p) => Ok(p.into()),
             Err(e) => Err(e),
         }
@@ -107,24 +124,21 @@ impl<'a> SiteTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn ancestral_state<S: Into<SiteId>>(
-        &'a self,
-        row: S,
-    ) -> Result<Option<Vec<u8>>, TskitError> {
+    pub fn ancestral_state<S: Into<SiteId>>(&self, row: S) -> Result<Option<Vec<u8>>, TskitError> {
         crate::metadata::char_column_to_vector(
-            self.table_.ancestral_state,
-            self.table_.ancestral_state_offset,
+            self.as_ll_ref().ancestral_state,
+            self.as_ll_ref().ancestral_state_offset,
             row.into().0,
-            self.table_.num_rows,
-            self.table_.ancestral_state_length,
+            self.as_ll_ref().num_rows,
+            self.as_ll_ref().ancestral_state_length,
         )
     }
 
     pub fn metadata<T: metadata::MetadataRoundtrip>(
-        &'a self,
+        &self,
         row: SiteId,
     ) -> Result<Option<T>, TskitError> {
-        let table_ref = self.table_;
+        let table_ref = &unsafe { *self.table_ };
         let buffer = metadata_to_vector!(table_ref, row.0)?;
         decode_metadata_row!(T, buffer)
     }
@@ -132,7 +146,7 @@ impl<'a> SiteTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`SiteTableRow`].
     pub fn iter(&self) -> impl Iterator<Item = SiteTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&SiteTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&SiteTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/table_collection.rs b/src/table_collection.rs
index ec34c20f1..1aa44a16b 100644
--- a/src/table_collection.rs
+++ b/src/table_collection.rs
@@ -65,15 +65,40 @@ use mbox::MBox;
 /// assert_eq!(nodes.num_rows(), 1);
 /// ```
 ///
+/// ```compile_fail
+/// use tskit::TableAccess;
+/// let tables = tskit::TableCollection::new(100.).unwrap();
+/// let populations = tables.populations();
+/// drop(tables);
+/// assert_eq!(populations.num_rows(), 0);
+/// ```
 pub struct TableCollection {
     pub(crate) inner: MBox<ll_bindings::tsk_table_collection_t>,
+    table_references: crate::util::TableReferences,
 }
 
-build_tskit_type!(
-    TableCollection,
-    ll_bindings::tsk_table_collection_t,
-    tsk_table_collection_free
-);
+impl crate::ffi::WrapTskitType<ll_bindings::tsk_table_collection_t> for TableCollection {
+    fn wrap() -> Self {
+        let temp = unsafe {
+            libc::malloc(std::mem::size_of::<ll_bindings::tsk_table_collection_t>())
+                as *mut ll_bindings::tsk_table_collection_t
+        };
+        let nonnull = match std::ptr::NonNull::<ll_bindings::tsk_table_collection_t>::new(temp) {
+            Some(x) => x,
+            None => panic!("out of memory"),
+        };
+        let mbox = unsafe { MBox::from_non_null_raw(nonnull) };
+        let table_references = crate::util::TableReferences::default();
+
+        Self {
+            inner: mbox,
+            table_references,
+        }
+    }
+}
+
+drop_for_tskit_type!(TableCollection, tsk_table_collection_free);
+tskit_type_access!(TableCollection, ll_bindings::tsk_table_collection_t);
 
 impl TableCollection {
     /// Create a new table collection with a sequence length.
@@ -105,6 +130,41 @@ impl TableCollection {
         unsafe {
             (*tables.as_mut_ptr()).sequence_length = sequence_length.0;
         }
+        tables
+            .table_references
+            .populations
+            .set_ptr(&(*tables.inner).populations);
+        tables
+            .table_references
+            .sites
+            .set_ptr(&(*tables.inner).sites);
+        tables
+            .table_references
+            .edges
+            .set_ptr(&(*tables.inner).edges);
+        tables
+            .table_references
+            .migrations
+            .set_ptr(&(*tables.inner).migrations);
+        tables
+            .table_references
+            .individuals
+            .set_ptr(&(*tables.inner).individuals);
+        tables
+            .table_references
+            .mutations
+            .set_ptr(&(*tables.inner).mutations);
+        tables
+            .table_references
+            .nodes
+            .set_ptr(&(*tables.inner).nodes);
+
+        #[cfg(feature = "provenance")]
+        tables
+            .table_references
+            .provenances
+            .set_ptr(&(*tables.inner).provenances);
+
         Ok(tables)
     }
 
@@ -1198,37 +1258,37 @@ impl TableCollection {
 }
 
 impl TableAccess for TableCollection {
-    fn edges(&self) -> EdgeTable {
-        EdgeTable::new_from_table(&(*self.inner).edges)
+    fn edges(&self) -> &EdgeTable {
+        &self.table_references.edges
     }
 
-    fn individuals(&self) -> IndividualTable {
-        IndividualTable::new_from_table(&(*self.inner).individuals)
+    fn individuals(&self) -> &IndividualTable {
+        &self.table_references.individuals
     }
 
-    fn migrations(&self) -> MigrationTable {
-        MigrationTable::new_from_table(&(*self.inner).migrations)
+    fn migrations(&self) -> &MigrationTable {
+        &self.table_references.migrations
     }
 
-    fn nodes(&self) -> NodeTable {
-        NodeTable::new_from_table(&(*self.inner).nodes)
+    fn nodes(&self) -> &NodeTable {
+        &self.table_references.nodes
     }
 
-    fn sites(&self) -> SiteTable {
-        SiteTable::new_from_table(&(*self.inner).sites)
+    fn sites(&self) -> &SiteTable {
+        &self.table_references.sites
     }
 
-    fn mutations(&self) -> MutationTable {
-        MutationTable::new_from_table(&(*self.inner).mutations)
+    fn mutations(&self) -> &MutationTable {
+        &self.table_references.mutations
     }
 
-    fn populations(&self) -> PopulationTable {
-        PopulationTable::new_from_table(&(*self.inner).populations)
+    fn populations(&self) -> &PopulationTable {
+        &self.table_references.populations
     }
 
     #[cfg(any(feature = "provenance", doc))]
-    fn provenances(&self) -> crate::provenance::ProvenanceTable {
-        crate::provenance::ProvenanceTable::new_from_table(&(*self.inner).provenances)
+    fn provenances(&self) -> &crate::provenance::ProvenanceTable {
+        &self.table_references.provenances
     }
 }
 
@@ -1286,25 +1346,6 @@ mod test {
         }
     }
 
-    #[test]
-    fn test_mutable_node_access() {
-        let tables = TableCollection::new(1000.).unwrap();
-        let mut nodes = tables.nodes();
-        let f = nodes.flags_array_mut();
-        for i in f {
-            *i = NodeFlags::from(11);
-        }
-
-        for t in nodes.time_array_mut() {
-            *t = Time::from(-33.0);
-        }
-
-        for i in tables.nodes_iter() {
-            assert_eq!(i.flags.bits(), 11);
-            assert_eq!(f64::from(i.time) as i64, -33);
-        }
-    }
-
     #[test]
     fn test_node_iteration() {
         let tables = make_small_table_collection();
diff --git a/src/traits.rs b/src/traits.rs
index 2e59dbc6c..1dc7c752e 100644
--- a/src/traits.rs
+++ b/src/traits.rs
@@ -50,72 +50,72 @@ pub trait TskitTypeAccess<T> {
 /// ```
 pub trait TableAccess {
     /// Get reference to the [``EdgeTable``](crate::EdgeTable).
-    fn edges(&self) -> EdgeTable;
+    fn edges(&self) -> &EdgeTable;
 
     /// Return an iterator over the edges.
     fn edges_iter(&self) -> Box<dyn Iterator<Item = crate::edge_table::EdgeTableRow> + '_> {
-        Box::new(make_table_iterator::<EdgeTable>(self.edges()))
+        Box::new(make_table_iterator::<&EdgeTable>(self.edges()))
     }
 
     /// Get reference to the [``NodeTable``](crate::NodeTable).
-    fn nodes(&self) -> NodeTable;
+    fn nodes(&self) -> &NodeTable;
 
     /// Return an iterator over the nodes.
     fn nodes_iter(&self) -> Box<dyn Iterator<Item = crate::node_table::NodeTableRow> + '_> {
-        Box::new(make_table_iterator::<NodeTable>(self.nodes()))
+        Box::new(make_table_iterator::<&NodeTable>(self.nodes()))
     }
 
     /// Get reference to the [``MutationTable``](crate::MutationTable).
-    fn mutations(&self) -> MutationTable;
+    fn mutations(&self) -> &MutationTable;
 
     /// Return an iterator over the mutations.
     fn mutations_iter(
         &self,
     ) -> Box<dyn Iterator<Item = crate::mutation_table::MutationTableRow> + '_> {
-        Box::new(make_table_iterator::<MutationTable>(self.mutations()))
+        Box::new(make_table_iterator::<&MutationTable>(self.mutations()))
     }
 
     /// Get reference to the [``SiteTable``](crate::SiteTable).
-    fn sites(&self) -> SiteTable;
+    fn sites(&self) -> &SiteTable;
 
     /// Return an iterator over the sites.
     fn sites_iter(&self) -> Box<dyn Iterator<Item = crate::site_table::SiteTableRow> + '_> {
-        Box::new(make_table_iterator::<SiteTable>(self.sites()))
+        Box::new(make_table_iterator::<&SiteTable>(self.sites()))
     }
 
     /// Get reference to the [``PopulationTable``](crate::PopulationTable).
-    fn populations(&self) -> PopulationTable;
+    fn populations(&self) -> &PopulationTable;
 
     /// Return an iterator over the populations.
     fn populations_iter(
         &self,
     ) -> Box<dyn Iterator<Item = crate::population_table::PopulationTableRow> + '_> {
-        Box::new(make_table_iterator::<PopulationTable>(self.populations()))
+        Box::new(make_table_iterator::<&PopulationTable>(self.populations()))
     }
 
     /// Get reference to the [``MigrationTable``](crate::MigrationTable).
-    fn migrations(&self) -> MigrationTable;
+    fn migrations(&self) -> &MigrationTable;
 
     /// Return an iterator over the migration events.
     fn migrations_iter(
         &self,
     ) -> Box<dyn Iterator<Item = crate::migration_table::MigrationTableRow> + '_> {
-        Box::new(make_table_iterator::<MigrationTable>(self.migrations()))
+        Box::new(make_table_iterator::<&MigrationTable>(self.migrations()))
     }
 
     /// Get reference to the [``IndividualTable``](crate::IndividualTable).
-    fn individuals(&self) -> IndividualTable;
+    fn individuals(&self) -> &IndividualTable;
 
     /// Return an iterator over the individuals.
     fn individuals_iter(
         &self,
     ) -> Box<dyn Iterator<Item = crate::individual_table::IndividualTableRow> + '_> {
-        Box::new(make_table_iterator::<IndividualTable>(self.individuals()))
+        Box::new(make_table_iterator::<&IndividualTable>(self.individuals()))
     }
 
     #[cfg(any(feature = "provenance", doc))]
     /// Get reference to the [``ProvenanceTable``](crate::provenance::ProvenanceTable)
-    fn provenances(&self) -> crate::provenance::ProvenanceTable;
+    fn provenances(&self) -> &crate::provenance::ProvenanceTable;
 
     #[cfg(any(feature = "provenance", doc))]
     /// Return an iterator over provenances
@@ -123,7 +123,7 @@ pub trait TableAccess {
         &self,
     ) -> Box<dyn Iterator<Item = crate::provenance::ProvenanceTableRow> + '_> {
         Box::new(crate::table_iterator::make_table_iterator::<
-            crate::provenance::ProvenanceTable,
+            &crate::provenance::ProvenanceTable,
         >(self.provenances()))
     }
 }
diff --git a/src/trees.rs b/src/trees.rs
index 7f66e5faf..d4c21541a 100644
--- a/src/trees.rs
+++ b/src/trees.rs
@@ -33,6 +33,7 @@ pub struct Tree {
     num_nodes: tsk_size_t,
     array_len: tsk_size_t,
     flags: TreeFlags,
+    nodes: NodeTable,
 }
 
 // Trait defining iteration over nodes.
@@ -54,6 +55,7 @@ impl Tree {
             panic!("out of memory");
         }
         let mbox = unsafe { MBox::from_raw(temp.cast::<ll_bindings::tsk_tree_t>()) };
+        let nodes = NodeTable::new_null();
         Self {
             inner: mbox,
             current_tree: 0,
@@ -61,6 +63,7 @@ impl Tree {
             num_nodes,
             array_len: num_nodes + 1,
             flags,
+            nodes,
         }
     }
 
@@ -83,6 +86,9 @@ impl Tree {
             };
         }
 
+        tree.nodes
+            .set_ptr(unsafe { &(*(*(*tree.inner).tree_sequence).tables).nodes });
+
         handle_tsk_return_value!(rv, tree)
     }
 
@@ -524,10 +530,8 @@ impl Tree {
     /// (and the tree sequence from which it came).
     ///
     /// This is a convenience function for accessing node times, etc..
-    pub fn node_table<'a>(&'a self) -> crate::NodeTable<'a> {
-        crate::NodeTable::<'a>::new_from_table(unsafe {
-            &(*(*(*self.inner).tree_sequence).tables).nodes
-        })
+    pub fn node_table(&self) -> crate::NodeTable {
+        crate::NodeTable::new_from_table(unsafe { &(*(*(*self.inner).tree_sequence).tables).nodes })
     }
 
     /// Calculate the total length of the tree via a preorder traversal.
@@ -959,9 +963,31 @@ iterator_for_nodeiterator!(SamplesIterator<'_>);
 /// ```
 pub struct TreeSequence {
     pub(crate) inner: MBox<ll_bindings::tsk_treeseq_t>,
+    table_references: crate::util::TableReferences,
+}
+
+impl crate::ffi::WrapTskitType<ll_bindings::tsk_treeseq_t> for TreeSequence {
+    fn wrap() -> Self {
+        let temp = unsafe {
+            libc::malloc(std::mem::size_of::<ll_bindings::tsk_treeseq_t>())
+                as *mut ll_bindings::tsk_treeseq_t
+        };
+        let nonnull = match std::ptr::NonNull::<ll_bindings::tsk_treeseq_t>::new(temp) {
+            Some(x) => x,
+            None => panic!("out of memory"),
+        };
+        let mbox = unsafe { MBox::from_non_null_raw(nonnull) };
+        let table_references = crate::util::TableReferences::default();
+
+        Self {
+            inner: mbox,
+            table_references,
+        }
+    }
 }
 
-build_tskit_type!(TreeSequence, ll_bindings::tsk_treeseq_t, tsk_treeseq_free);
+drop_for_tskit_type!(TreeSequence, tsk_treeseq_free);
+tskit_type_access!(TreeSequence, ll_bindings::tsk_treeseq_t);
 
 impl TreeSequence {
     /// Create a tree sequence from a [`TableCollection`].
@@ -1017,6 +1043,42 @@ impl TreeSequence {
         let raw_tables_ptr = tables.into_raw()?;
         let rv =
             unsafe { ll_bindings::tsk_treeseq_init(treeseq.as_mut_ptr(), raw_tables_ptr, flags) };
+        treeseq
+            .table_references
+            .populations
+            .set_ptr(unsafe { &(*(*treeseq.inner).tables).populations });
+        treeseq
+            .table_references
+            .sites
+            .set_ptr(unsafe { &(*(*treeseq.inner).tables).sites });
+        treeseq
+            .table_references
+            .edges
+            .set_ptr(unsafe { &(*(*treeseq.inner).tables).edges });
+        treeseq
+            .table_references
+            .migrations
+            .set_ptr(unsafe { &(*(*treeseq.inner).tables).migrations });
+        treeseq
+            .table_references
+            .individuals
+            .set_ptr(unsafe { &(*(*treeseq.inner).tables).individuals });
+        treeseq
+            .table_references
+            .mutations
+            .set_ptr(unsafe { &(*(*treeseq.inner).tables).mutations });
+        treeseq
+            .table_references
+            .nodes
+            .set_ptr(unsafe { &(*(*treeseq.inner).tables).nodes });
+        #[cfg(feature = "provenance")]
+        {
+            treeseq
+                .table_references
+                .provenances
+                .set_ptr(unsafe { &(*(*treeseq.inner).tables).provenances });
+        }
+
         handle_tsk_return_value!(rv, treeseq)
     }
 
@@ -1284,39 +1346,37 @@ impl TryFrom<TableCollection> for TreeSequence {
 }
 
 impl TableAccess for TreeSequence {
-    fn edges(&self) -> EdgeTable {
-        EdgeTable::new_from_table(unsafe { &(*(*self.inner).tables).edges })
+    fn edges(&self) -> &EdgeTable {
+        &self.table_references.edges
     }
 
-    fn individuals(&self) -> IndividualTable {
-        IndividualTable::new_from_table(unsafe { &(*(*self.inner).tables).individuals })
+    fn individuals(&self) -> &IndividualTable {
+        &self.table_references.individuals
     }
 
-    fn migrations(&self) -> MigrationTable {
-        MigrationTable::new_from_table(unsafe { &(*(*self.inner).tables).migrations })
+    fn migrations(&self) -> &MigrationTable {
+        &self.table_references.migrations
     }
 
-    fn nodes(&self) -> NodeTable {
-        NodeTable::new_from_table(unsafe { &(*(*self.inner).tables).nodes })
+    fn nodes(&self) -> &NodeTable {
+        &self.table_references.nodes
     }
 
-    fn sites(&self) -> SiteTable {
-        SiteTable::new_from_table(unsafe { &(*(*self.inner).tables).sites })
+    fn sites(&self) -> &SiteTable {
+        &self.table_references.sites
     }
 
-    fn mutations(&self) -> MutationTable {
-        MutationTable::new_from_table(unsafe { &(*(*self.inner).tables).mutations })
+    fn mutations(&self) -> &MutationTable {
+        &self.table_references.mutations
     }
 
-    fn populations(&self) -> PopulationTable {
-        PopulationTable::new_from_table(unsafe { &(*(*self.inner).tables).populations })
+    fn populations(&self) -> &PopulationTable {
+        &self.table_references.populations
     }
 
     #[cfg(any(feature = "provenance", doc))]
-    fn provenances(&self) -> crate::provenance::ProvenanceTable {
-        crate::provenance::ProvenanceTable::new_from_table(unsafe {
-            &(*(*self.inner).tables).provenances
-        })
+    fn provenances(&self) -> &crate::provenance::ProvenanceTable {
+        &self.table_references.provenances
     }
 }
 
@@ -1359,6 +1419,7 @@ pub(crate) mod test_trees {
             ntrees += 1;
             assert_eq!(tree.current_tree, ntrees);
             let samples = tree.sample_nodes();
+            let _ = tree.node_table();
             assert_eq!(samples.len(), 2);
             for i in 1..3 {
                 assert_eq!(samples[i - 1], NodeId::from(i as tsk_id_t));
diff --git a/src/util.rs b/src/util.rs
index 9470354bc..59c3d3073 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -1,3 +1,36 @@
+use crate::{
+    EdgeTable, IndividualTable, MigrationTable, MutationTable, NodeTable, PopulationTable,
+    SiteTable,
+};
+
 pub(crate) fn partial_cmp_equal<T: PartialOrd>(lhs: &T, rhs: &T) -> bool {
     matches!(lhs.partial_cmp(rhs), Some(std::cmp::Ordering::Equal))
 }
+
+pub(crate) struct TableReferences {
+    pub edges: EdgeTable,
+    pub nodes: NodeTable,
+    pub sites: SiteTable,
+    pub mutations: MutationTable,
+    pub individuals: IndividualTable,
+    pub migrations: MigrationTable,
+    pub populations: PopulationTable,
+    #[cfg(feature = "provenance")]
+    pub provenances: crate::provenance::ProvenanceTable,
+}
+
+impl Default for TableReferences {
+    fn default() -> Self {
+        Self {
+            edges: EdgeTable::new_null(),
+            nodes: NodeTable::new_null(),
+            sites: SiteTable::new_null(),
+            mutations: MutationTable::new_null(),
+            individuals: IndividualTable::new_null(),
+            migrations: MigrationTable::new_null(),
+            populations: PopulationTable::new_null(),
+            #[cfg(feature = "provenance")]
+            provenances: crate::provenance::ProvenanceTable::new_null(),
+        }
+    }
+}