From 3635ec569d474d4256c9ade192cc697f8d40a5f6 Mon Sep 17 00:00:00 2001
From: Judith Silverman <judith@ipac.caltech.edu>
Date: Mon, 9 Jun 2025 19:14:48 -0700
Subject: [PATCH 1/8] IRSA-6936: tablator: provide high-level accessors II

Add Table::retain_only_selected_rows() to support query_server's mcen option
---
 src/Table.hxx                                 | 14 ++++--
 src/Table/Column_Row_Accessors.cxx            |  1 -
 src/Utils/Table_Utils.hxx                     | 10 +++-
 .../Table_Utils/retain_only_selected_rows.cxx | 46 +++++++++++++++++++
 src/tablator/main.cxx                         | 31 ++++++++++++-
 test/convert.sh                               | 15 ++++++
 test/multi_formatted.tbl                      | 11 +++++
 wscript                                       |  4 +-
 8 files changed, 123 insertions(+), 9 deletions(-)
 create mode 100644 src/Utils/Table_Utils/retain_only_selected_rows.cxx
 create mode 100644 test/multi_formatted.tbl

diff --git a/src/Table.hxx b/src/Table.hxx
index 9dae9f57..2f8a79ca 100644
--- a/src/Table.hxx
+++ b/src/Table.hxx
@@ -241,7 +241,6 @@ public:
     }
 
     size_t get_column_offset(size_t col_idx) const {
-        const auto &columns = get_columns();
         validate_column_index(col_idx);
         return get_offsets().at(col_idx);
     }
@@ -677,6 +676,11 @@ public:
                                         get_columns().at(col_idx).get_array_size());
     }
 
+    void retain_only_selected_rows(const std::set<size_t> &selected_row_idx_list) {
+        tablator::retain_only_selected_rows(get_data(), selected_row_idx_list,
+                                            get_num_rows(), get_row_size());
+    }
+
     // accessors
 
     size_t get_row_size() const { return tablator::get_row_size(get_offsets()); }
@@ -686,12 +690,14 @@ public:
     size_t get_num_columns() const { return get_columns().size(); }
 
     // called by query_server to trim result set
-    void resize_data(const size_t &new_num_rows) {
-        tablator::resize_data(get_data(), new_num_rows, get_row_size());
+    void adjust_num_rows(const size_t &new_num_rows) {
+        tablator::adjust_num_rows(get_data(), new_num_rows, get_row_size());
     }
 
     // deprecated
-    inline void resize_rows(const size_t &new_num_rows) { resize_data(new_num_rows); }
+    inline void resize_rows(const size_t &new_num_rows) {
+        adjust_num_rows(new_num_rows);
+    }
     size_t row_size() const { return get_row_size(); }
     size_t num_rows() const { return get_num_rows(); }
 
diff --git a/src/Table/Column_Row_Accessors.cxx b/src/Table/Column_Row_Accessors.cxx
index 36eae894..ee88a1c3 100644
--- a/src/Table/Column_Row_Accessors.cxx
+++ b/src/Table/Column_Row_Accessors.cxx
@@ -138,7 +138,6 @@ void tablator::Table::insert_array_element_into_row(tablator::Row &row, size_t c
                                                     size_t elt_idx,
                                                     const uint8_t *data_ptr) const {
     validate_parameters(row, *this, col_idx, elt_idx, 1 /* num_elements_to_insert */);
-    const auto &column = get_columns().at(col_idx);
     insert_blob_to_row_internal(row, *this, col_idx, elt_idx, data_ptr, 1);
 }
 //===============================================================
diff --git a/src/Utils/Table_Utils.hxx b/src/Utils/Table_Utils.hxx
index 736d88e4..95fa1bcf 100644
--- a/src/Utils/Table_Utils.hxx
+++ b/src/Utils/Table_Utils.hxx
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <set>
+
 #include "../Column.hxx"
 #include "../Row.hxx"
 
@@ -58,7 +60,7 @@ inline void append_rows(std::vector<uint8_t> &data, const std::vector<uint8_t> &
 }
 
 
-inline void resize_data(std::vector<uint8_t> &data, const size_t &new_num_rows,
+inline void adjust_num_rows(std::vector<uint8_t> &data, const size_t &new_num_rows,
                         uint row_size) {
     data.resize(new_num_rows * row_size);
 }
@@ -73,4 +75,10 @@ void insert_ascii_in_row(Row &row, const Data_Type &data_type, const size_t &arr
                          const size_t &column, const std::string &element,
                          const size_t &offset, const size_t &offset_end);
 
+
+void retain_only_selected_rows(std::vector<uint8_t> &data,
+                               const std::set<size_t> &selected_row_idx_list,
+                               size_t num_rows, size_t row_size);
+
+
 }  // namespace tablator
diff --git a/src/Utils/Table_Utils/retain_only_selected_rows.cxx b/src/Utils/Table_Utils/retain_only_selected_rows.cxx
new file mode 100644
index 00000000..239dddf0
--- /dev/null
+++ b/src/Utils/Table_Utils/retain_only_selected_rows.cxx
@@ -0,0 +1,46 @@
+#include "../Table_Utils.hxx"
+
+void tablator::retain_only_selected_rows(std::vector<uint8_t> &data,
+                                         const std::set<size_t> &selected_row_idx_list,
+                                         size_t num_rows, size_t row_size) {
+    if (data.size() != num_rows * row_size) {
+        // JTODO relax this condition?
+        throw std::runtime_error(
+                "Mismatch between data.size(), num_rows, and row_size.");
+    }
+    size_t num_selected_rows = selected_row_idx_list.size();
+    if (num_selected_rows > num_rows) {
+        throw std::runtime_error("Number of selected rows must not exceed " +
+                                 std::to_string(num_rows));
+    }
+    if (*selected_row_idx_list.rbegin() >= num_rows) {
+        throw std::runtime_error("invalid row index: " +
+                                 std::to_string(*selected_row_idx_list.rbegin()));
+    }
+    if (num_selected_rows == num_rows) {
+        return;
+    }
+
+    const auto data_start_ptr = data.data();
+    auto read_ptr = data_start_ptr;
+    auto write_ptr = data_start_ptr;
+    size_t write_idx = 0;
+    size_t prev_row_idx = 0;
+
+    for (auto row_idx : selected_row_idx_list) {
+        if (row_idx >= write_idx) {
+            if (row_idx > write_idx) {
+                // Copy row_idx-th row to begin immediately after the end of the
+                // previous copied row.
+                read_ptr += ((row_idx - prev_row_idx) * row_size);
+                std::copy(read_ptr, read_ptr + row_size, write_ptr);
+            }
+            ++write_idx;
+            write_ptr += row_size;
+            prev_row_idx = row_idx;
+        }
+    }
+
+    // Delete all data past the last row copied.
+    data.resize(std::distance(data_start_ptr, write_ptr));
+}
diff --git a/src/tablator/main.cxx b/src/tablator/main.cxx
index f04f2428..55785c77 100644
--- a/src/tablator/main.cxx
+++ b/src/tablator/main.cxx
@@ -244,8 +244,10 @@ int main(int argc, char *argv[]) {
     size_t row_id = SIZE_T_MAX;
     size_t start_row = SIZE_T_MAX;
     size_t row_count = SIZE_T_MAX;
-    std::vector<size_t> row_list;
+    std::vector<size_t> row_list;      // for writing ipac_table
+    std::set<size_t> retain_row_list;  // for modifying table in place
     std::string row_string;
+    std::string retain_row_string;
     bool call_static_f = false;
     bool exclude_cols_f = false;
     bool skip_comments_f = false;
@@ -260,7 +262,8 @@ int main(int argc, char *argv[]) {
     std::string trim_decimal_runs = "1";
     std::string counter_column_name = "";
     bool combine_tables_f = false;
-    bool append_rows_f = true;
+    bool append_rows_f = false;
+
 
     // Declare the supported options.
     boost::program_options::options_description visible_options("Options");
@@ -298,6 +301,9 @@ int main(int argc, char *argv[]) {
             "number of consecutive rows to write (output-format ipac_table only)")(
             "row-list", boost::program_options::value<std::string>(&row_string),
             "list of rows to write (output-format ipac_table only)")(
+            "retain-row-list",
+            boost::program_options::value<std::string>(&retain_row_string),
+            "list of rows to retain, dropping others")(
             "static", boost::program_options::value<bool>(&call_static_f),
             "call static function, not Table class member")(
             "column-to-extract",
@@ -401,6 +407,19 @@ int main(int argc, char *argv[]) {
                       std::istream_iterator<size_t>(), std::back_inserter(row_list));
         }
 
+        if (option_variables.count("retain-row-list")) {
+            if (option_variables.count("row-list")) {
+                std::cerr << "The parameters 'row-list' and 'retain-row-list' are "
+                             "mutually "
+                             "incompatible.\n";
+                return 1;
+            }
+            std::stringstream retain_row_stream(retain_row_string);
+            std::copy(std::istream_iterator<size_t>(retain_row_stream),
+                      std::istream_iterator<size_t>(),
+                      std::inserter(retain_row_list, retain_row_list.begin()));
+        }
+
         if (!option_variables.count("column-to-extract") &&
             option_variables.count("as-string")) {
             std::cerr << "The parameter 'as-string' is valid only if "
@@ -649,6 +668,14 @@ int main(int argc, char *argv[]) {
             boost::filesystem::ofstream output_stream(output_path);
             in_table1.write(output_stream, output_path.stem().native(), output_format,
                             options);
+        } else if (!retain_row_list.empty()) {
+            // JTODO make this option incompatible with other options
+            boost::filesystem::ifstream input_stream(input_path);
+            tablator::Table in_table(input_stream, input_format);
+            in_table.retain_only_selected_rows(retain_row_list);
+            boost::filesystem::ofstream output_stream(output_path);
+            in_table.write(output_stream, output_path.stem().native(), output_format,
+                           options);
         } else {
             tablator::Table table(input_path, input_format);
             table.write(output_path, output_format, options);
diff --git a/test/convert.sh b/test/convert.sh
index b685e2e0..e7f19616 100644
--- a/test/convert.sh
+++ b/test/convert.sh
@@ -182,6 +182,14 @@ else
     rm -f temp.json5
 fi
 
+${tablator_bin} --retain-row-list "1 4" test/multi temp.vot 2> /dev/null
+if [ $? -eq 0 ]; then
+    echo "FAIL: invalid argument to retain-row-list"
+else
+    echo "PASS: invalid argument to retain-row-list"
+    rm -f temp.tbl
+fi
+
 
 ###########################################################
 
@@ -1418,3 +1426,10 @@ else
     echo "FAIL: append json5 table"
 fi
 
+${tablator_bin} --retain-row-list "1 2 3" test/multi_formatted.tbl temp.tbl && diff test/back_and_forth_tables/multi_row_123.tbl temp.tbl
+if [ $? -eq 0 ]; then
+    echo "PASS: retain rows"
+    rm -f temp.json5
+else
+    echo "FAIL: retain rows"
+fi
diff --git a/test/multi_formatted.tbl b/test/multi_formatted.tbl
new file mode 100644
index 00000000..8a2cb9d4
--- /dev/null
+++ b/test/multi_formatted.tbl
@@ -0,0 +1,11 @@
+\fixlen = T
+\RowsRetrieved = 4
+\type = 'results'
+|                                  object|       ra|      dec|               htm20|      htm7| htm3|              shtm20|      shtm7| shtm3|flags| SSO|
+|                                    char|   double|   double|                char|      long|  int|                long|        int|   int|  int| int|
+|                                        |         |         |                    |          |     |                    |           |      |     |    |
+|                                    null|     null|     null|                null|      null| null|                null|       null|  null| null|null|
+ 118289arstratraetratratsrastratsrastrats 359.88703  50.83257 16446744073709551616 3294967296 12000  8223372036854775808  1147483648  12000   122    0 
+                                   113368 344.41273 -29.62225  8446744073709551616  294967296 43002 -7223372036854775808 -2047483648  13002   242    1 
+                                   113368 344.41273 -29.62225  8446744073709551616  294967296 43002 -7223372036854775808 -2047483648 -23002   211    0 
+                                   113368 344.41273 -29.62225  8446744073709551616  294967296 43002 -7223372036854775808 -2047483648 -31002   211    1 
diff --git a/wscript b/wscript
index ed14e27e..f716e2ad 100644
--- a/wscript
+++ b/wscript
@@ -6,7 +6,7 @@ def options(opt):
 
 def configure(conf):
     conf.load('compiler_cxx gnu_dirs cxx14 hdf5_cxx cfitsio CCfits boost json5_parser sqlite3 vsqlitepp')
-    conf.check_boost(lib='filesystem system program_options regex')
+    conf.check_boost(lib='filesystem system program_options regex thread')
 
 def build(bld):
 
@@ -14,6 +14,7 @@ def build(bld):
         default_flags=['-Wall', '-Wextra', '-g']
     else:
         default_flags=['-Wall', '-Wextra', '-g', '-Ofast', '-fno-finite-math-only', '-DNDEBUG']
+    default_flags.append("-DBOOST_SPIRIT_THREADSAFE")
 
     use_packages=['cxx14', 'hdf5', 'hdf5_cxx', 'cfitsio', 'CCfits', 'BOOST',
                   'json5_parser', 'sqlite3', 'vsqlitepp']
@@ -71,6 +72,7 @@ def build(bld):
              'src/Ipac_Table_Writer/Ipac_Table_Writer.cxx',
              'src/Utils/Table_Utils/insert_ascii_in_row.cxx',
              'src/Utils/Table_Utils/append_column.cxx',
+             'src/Utils/Table_Utils/retain_only_selected_rows.cxx',
              'src/ptree_readers/ptree_readers.cxx',
              'src/ptree_readers/Utils.cxx',
              'src/ptree_readers/extract_attributes.cxx',

From cfc400082d3e6224789bae1340912215d9b26c36 Mon Sep 17 00:00:00 2001
From: Judith Silverman <judith@ipac.caltech.edu>
Date: Thu, 19 Jun 2025 10:23:13 -0700
Subject: [PATCH 2/8] IRSA-6967: tablator: store row-level size of
 variable-length arrays I

Column: Add dynamic_array_flag class member
ptree_readers: Retire Field_And_Flag helper class
---
 src/Column.hxx                                |  45 ++++++--
 src/Table.hxx                                 |  21 +++-
 .../add_to_property_tree.cxx                  |   1 +
 src/Table/write_tabledata/write_tabledata.cxx |   2 +-
 src/Table_Ops.cxx                             |  16 +--
 src/Utils/Table_Utils.hxx                     |  30 ++++-
 .../Table_Utils/retain_only_selected_rows.cxx |   1 -
 src/ptree_readers.hxx                         |  23 +---
 src/ptree_readers/Utils.cxx                   |   2 +-
 src/ptree_readers/ptree_readers.cxx           |   2 +-
 .../read_field/read_field.cxx                 |   9 +-
 .../append_data_from_stream.cxx               | 105 ++++++++++--------
 .../insert_swapped.cxx                        |  61 +++++-----
 .../compute_column_array_sizes.cxx            |  29 +++--
 .../read_binary2/read_binary2.cxx             |  42 +++----
 .../read_data_element/read_data_element.cxx   |   6 +-
 .../read_tabledata/read_tabledata.cxx         |  20 ++--
 .../read_table_element/read_table_element.cxx |  48 ++------
 18 files changed, 244 insertions(+), 219 deletions(-)

diff --git a/src/Column.hxx b/src/Column.hxx
index 56d8db67..c193be8d 100644
--- a/src/Column.hxx
+++ b/src/Column.hxx
@@ -7,28 +7,47 @@ namespace tablator {
 
 class Column {
 public:
+    // These constexprs are used by HDF5-support code.
     static constexpr char const *COL_ARRAY_SIZE = "array_size";
     static constexpr char const *COL_FIELD_PROPERTIES = "field_properties";
     static constexpr char const *COL_NAME = "name";
     static constexpr char const *COL_TYPE = "type";
+    static constexpr char const *COL_DYNAMIC_ARRAY_FLAG = "dynamic_array_flag";
 
-    Column(const std::string &Name, const Data_Type &Type, const size_t &Array_size)
-            : Column(Name, Type, Array_size, Field_Properties()) {}
+    Column(const std::string &name, const Data_Type &type, const size_t &array_size,
+           const Field_Properties &field_properties, bool dynamic_array_flag)
+            : name_(name),
+              type_(type),
+              array_size_(array_size),
+              field_properties_(field_properties),
+              dynamic_array_flag_(dynamic_array_flag) {}
+
+    Column(const std::string &name, const Data_Type &type, const size_t &array_size,
+           const Field_Properties &field_properties)
+            : Column(name, type, array_size, field_properties,
+                     ((type == Data_Type::CHAR) ||
+                      (array_size == std::numeric_limits<size_t>::max()))) {}
+
+    Column(const std::string &name, const Data_Type &type, const size_t &array_size,
+           bool dynamic_array_flag)
+            : Column(name, type, array_size, Field_Properties(), dynamic_array_flag) {}
+
+
+    Column(const std::string &name, const Data_Type &type, const size_t &array_size)
+            : Column(name, type, array_size, Field_Properties()) {}
+
+
+    Column(const std::string &name, const Data_Type &type,
+           const Field_Properties &field_properties)
+            : Column(name, type, 1, field_properties) {}
+
+    Column(const std::string &name, const Data_Type &type) : Column(name, type, 1) {}
 
-    Column(const std::string &Name, const Data_Type &Type, const size_t &Array_size,
-           const Field_Properties &Field_properties)
-            : name_(Name),
-              type_(Type),
-              array_size_(Array_size),
-              field_properties_(Field_properties) {}
 
     inline size_t get_data_size() const {
         return tablator::data_size(type_) * array_size_;
     }
 
-    // deprecated
-    inline size_t data_size() const { return get_data_size(); }
-
     // accessors
     inline const std::string &get_name() const { return name_; }
     inline const Data_Type &get_type() const { return type_; }
@@ -63,7 +82,8 @@ public:
     inline ATTRIBUTES &get_field_property_attributes() {
         return get_field_properties().get_attributes();
     }
-
+    inline bool get_dynamic_array_flag() const { return dynamic_array_flag_; }
+    inline void set_dynamic_array_flag(bool b) { dynamic_array_flag_ = b; }
 
 private:
     std::string name_;
@@ -72,6 +92,7 @@ private:
     // Actual array_size for fixed-length arrays; maximum array_size otherwise.
     size_t array_size_;
     Field_Properties field_properties_;
+    bool dynamic_array_flag_;
 };
 
 
diff --git a/src/Table.hxx b/src/Table.hxx
index 2f8a79ca..c8260934 100644
--- a/src/Table.hxx
+++ b/src/Table.hxx
@@ -992,12 +992,15 @@ private:
     // WARNING: The private append_column() routines do not increase
     // the size of the null column.  The expectation is that the
     // number of columns is known before adding columns.
-    void append_column(const std::string &name, const Data_Type &type) {
-        append_column(name, type, 1);
+    void append_column(const std::string &name, const Data_Type &type,
+                       const size_t &size, const Field_Properties &field_properties,
+                       bool dynamic_array_flag) {
+        append_column(Column(name, type, size, field_properties, dynamic_array_flag));
     }
+
     void append_column(const std::string &name, const Data_Type &type,
-                       const size_t &size) {
-        append_column(name, type, size, Field_Properties());
+                       const size_t &size, bool dynamic_array_flag) {
+        append_column(Column(name, type, size, dynamic_array_flag));
     }
 
     void append_column(const std::string &name, const Data_Type &type,
@@ -1005,11 +1008,19 @@ private:
         append_column(Column(name, type, size, field_properties));
     }
 
+    void append_column(const std::string &name, const Data_Type &type,
+                       const size_t &size) {
+        append_column(name, type, size);
+    }
+
+    void append_column(const std::string &name, const Data_Type &type) {
+        append_column(name, type);
+    }
+
     void append_column(const Column &column) {
         tablator::append_column(get_columns(), get_offsets(), column);
     }
 
-
     size_t read_ipac_header(std::istream &ipac_file,
                             std::array<std::vector<std::string>, 4> &Columns,
                             std::vector<size_t> &ipac_table_offsets,
diff --git a/src/Table/generate_property_tree/add_to_property_tree.cxx b/src/Table/generate_property_tree/add_to_property_tree.cxx
index 50f725b7..a5736c2c 100644
--- a/src/Table/generate_property_tree/add_to_property_tree.cxx
+++ b/src/Table/generate_property_tree/add_to_property_tree.cxx
@@ -20,6 +20,7 @@ void Min_Max_to_xml(boost::property_tree::ptree &tree, const std::string &min_ma
 
 // If json_prep is true, find (or, if none exists, create) a tree with
 // label <label>_ARRAY, add an un-labeled subtree to that, and return
+
 // the subtree.  Otherwise, add and return a subtree with label
 // <label> whether or not a subtree already exists with that label.
 boost::property_tree::ptree &find_or_add_tree(boost::property_tree::ptree &parent_tree,
diff --git a/src/Table/write_tabledata/write_tabledata.cxx b/src/Table/write_tabledata/write_tabledata.cxx
index eb6d81d2..67b3b7c1 100644
--- a/src/Table/write_tabledata/write_tabledata.cxx
+++ b/src/Table/write_tabledata/write_tabledata.cxx
@@ -56,7 +56,7 @@ void Table::write_tabledata(std::ostream &os, const Format::Enums &output_format
     const auto &data = get_data();
 
     for (size_t row_idx = 0, row_offset = 0; row_idx < num_rows;
-         ++row_idx, row_offset += row_size()) {
+         ++row_idx, row_offset += get_row_size()) {
         os << tr_prefix;
 
         // Skip the null bitfield flag
diff --git a/src/Table_Ops.cxx b/src/Table_Ops.cxx
index 1fee0f3b..a04b644a 100644
--- a/src/Table_Ops.cxx
+++ b/src/Table_Ops.cxx
@@ -33,8 +33,8 @@ Table add_counter_column(const Table &src_table, const std::string &col_name) {
 
     size_t src_nulls_size(src_offsets.at(1));
     size_t dest_nulls_size(dest_offsets.at(1));
-    size_t src_row_size = src_table.row_size();
-    size_t dest_row_size = dest_table.row_size();
+    size_t src_row_size = src_table.get_row_size();
+    size_t dest_row_size = dest_table.get_row_size();
 
     const auto &src_data = src_table.get_data();
 
@@ -68,9 +68,9 @@ Table add_counter_column(const Table &src_table, const std::string &col_name) {
 // Src tables must have the same number of rows.
 // Dest table's set of columns consists of src1's columns followed by src2's columns.
 Table combine_tables(const Table &src1_table, const Table &src2_table) {
-    size_t num_rows = src1_table.num_rows();
-    if (src2_table.num_rows() != num_rows) {
-        throw std::runtime_error("src tables have different numbers of ros.");
+    size_t num_rows = src1_table.get_num_rows();
+    if (src2_table.get_num_rows() != num_rows) {
+        throw std::runtime_error("src tables have different numbers of rows.");
     }
 
     const std::vector<Column> &src1_columns = src1_table.get_columns();
@@ -137,9 +137,9 @@ Table combine_tables(const Table &src1_table, const Table &src2_table) {
     size_t dest_null_flags_size = dest_offsets.at(1);
 
 
-    size_t src1_row_size = src1_table.row_size();
-    size_t src2_row_size = src2_table.row_size();
-    size_t dest_row_size = dest_table.row_size();
+    size_t src1_row_size = src1_table.get_row_size();
+    size_t src2_row_size = src2_table.get_row_size();
+    size_t dest_row_size = dest_table.get_row_size();
 
     const uint8_t *src1_data_ptr = src1_table.get_data().data();
     const uint8_t *src2_data_ptr = src2_table.get_data().data();
diff --git a/src/Utils/Table_Utils.hxx b/src/Utils/Table_Utils.hxx
index 95fa1bcf..42146742 100644
--- a/src/Utils/Table_Utils.hxx
+++ b/src/Utils/Table_Utils.hxx
@@ -13,20 +13,42 @@ void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
 
 inline void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
                           const std::string &name, const Data_Type &type,
-                          const size_t &size,
+                          const size_t &array_size,
+                          const Field_Properties &field_properties,
+                          bool dynamic_array_flag) {
+    append_column(columns, offsets,
+                  Column(name, type, array_size, field_properties, dynamic_array_flag));
+}
+
+inline void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
+                          const std::string &name, const Data_Type &type,
+                          const size_t &array_size,
                           const Field_Properties &field_properties) {
-    append_column(columns, offsets, Column(name, type, size, field_properties));
+    append_column(columns, offsets, Column(name, type, array_size, field_properties));
+}
+
+inline void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
+                          const std::string &name, const Data_Type &type,
+                          const size_t &array_size, bool dynamic_array_flag) {
+    append_column(columns, offsets, Column(name, type, array_size, dynamic_array_flag));
 }
 
 inline void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
                           const std::string &name, const Data_Type &type,
                           const size_t &size) {
-    append_column(columns, offsets, Column(name, type, size, Field_Properties()));
+    append_column(columns, offsets, Column(name, type, size));
 }
 
+inline void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
+                          const std::string &name, const Data_Type &type,
+                          const Field_Properties &field_properties) {
+    append_column(columns, offsets, Column(name, type, field_properties));
+}
+
+
 inline void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
                           const std::string &name, const Data_Type &type) {
-    append_column(columns, offsets, name, type, 1, Field_Properties());
+    append_column(columns, offsets, Column(name, type));
 }
 
 
diff --git a/src/Utils/Table_Utils/retain_only_selected_rows.cxx b/src/Utils/Table_Utils/retain_only_selected_rows.cxx
index 239dddf0..7c7f5c8f 100644
--- a/src/Utils/Table_Utils/retain_only_selected_rows.cxx
+++ b/src/Utils/Table_Utils/retain_only_selected_rows.cxx
@@ -4,7 +4,6 @@ void tablator::retain_only_selected_rows(std::vector<uint8_t> &data,
                                          const std::set<size_t> &selected_row_idx_list,
                                          size_t num_rows, size_t row_size) {
     if (data.size() != num_rows * row_size) {
-        // JTODO relax this condition?
         throw std::runtime_error(
                 "Mismatch between data.size(), num_rows, and row_size.");
     }
diff --git a/src/ptree_readers.hxx b/src/ptree_readers.hxx
index db6e53b8..5c5b0d39 100644
--- a/src/ptree_readers.hxx
+++ b/src/ptree_readers.hxx
@@ -30,18 +30,6 @@ namespace ptree_readers {
 
 ATTRIBUTES extract_attributes(const boost::property_tree::ptree &node);
 
-class Field_And_Flag {
-public:
-    Field_And_Flag(const tablator::Field &field, bool flag)
-            : field_(field), flag_(flag) {}
-    const tablator::Field &get_field() const { return field_; }
-    bool get_dynamic_array_flag() const { return flag_; }
-
-private:
-    tablator::Field field_;
-    bool flag_;
-};
-
 // The motivation for the "_element" business is distinguishing
 // Table from Table_Element.
 
@@ -52,22 +40,21 @@ Resource_Element read_resource_element(const boost::property_tree::ptree &resour
                                        bool &is_results_resource);
 Group_Element read_group_element(const boost::property_tree::ptree &node);
 Table_Element read_table_element(const boost::property_tree::ptree &table);
-Field_And_Flag read_field(const boost::property_tree::ptree &field);
+Field read_field(const boost::property_tree::ptree &field);
 Property read_property(const boost::property_tree::ptree &prop);
 
 Data_Element read_data_element(const boost::property_tree::ptree &data,
-                               const std::vector<Field_And_Flag> &field_flag_pairs);
+                               const std::vector<Field> &fields);
 Data_Element read_tabledata(const boost::property_tree::ptree &tabledata,
-                            const std::vector<Field_And_Flag> &field_flag_pairs);
+                            const std::vector<Field> &fields);
 Data_Element read_binary2(const boost::property_tree::ptree &binary2,
-                          const std::vector<Field_And_Flag> &field_flag_pairs);
+                          const std::vector<Field> &fields);
 
 void append_data_from_stream(std::vector<uint8_t> &data,
                              const std::vector<Column> &columns,
                              const std::vector<size_t> &offsets,
                              const std::vector<uint8_t> &stream,
-                             const std::vector<Field_And_Flag> &field_flag_pairs,
-                             size_t num_rows);
+                             const std::vector<Field> &fields, size_t num_rows);
 
 boost::property_tree::ptree read_xml_string_as_property_tree(
         const std::string &ptree_xml);
diff --git a/src/ptree_readers/Utils.cxx b/src/ptree_readers/Utils.cxx
index bc8bb857..600ddc1e 100644
--- a/src/ptree_readers/Utils.cxx
+++ b/src/ptree_readers/Utils.cxx
@@ -80,7 +80,7 @@ boost::property_tree::ptree::const_iterator read_links_section(
 
 void load_field_singleton(std::vector<tablator::Field> &params,
                           const boost::property_tree::ptree &node) {
-    params.emplace_back(tablator::ptree_readers::read_field(node).get_field());
+    params.emplace_back(tablator::ptree_readers::read_field(node));
 }
 
 void load_field_array(std::vector<tablator::Field> &params,
diff --git a/src/ptree_readers/ptree_readers.cxx b/src/ptree_readers/ptree_readers.cxx
index b1fdf246..05906bc6 100644
--- a/src/ptree_readers/ptree_readers.cxx
+++ b/src/ptree_readers/ptree_readers.cxx
@@ -21,7 +21,7 @@ void tablator::ptree_readers::add_params_from_xml_string(
     boost::property_tree::ptree::const_iterator end = params_tree.end();
     while (child != end) {
         if (child->first == PARAM) {
-            params.emplace_back(read_field(child->second).get_field());
+            params.emplace_back(read_field(child->second));
         }
         ++child;
     }
diff --git a/src/ptree_readers/read_resource_element/read_field/read_field.cxx b/src/ptree_readers/read_resource_element/read_field/read_field.cxx
index bcff1031..3e108532 100644
--- a/src/ptree_readers/read_resource_element/read_field/read_field.cxx
+++ b/src/ptree_readers/read_resource_element/read_field/read_field.cxx
@@ -86,7 +86,7 @@ boost::property_tree::ptree::const_iterator read_links_section(
 
 }  // namespace
 
-tablator::ptree_readers::Field_And_Flag tablator::ptree_readers::read_field(
+tablator::Field tablator::ptree_readers::read_field(
         const boost::property_tree::ptree &field_tree) {
     // Set default values for Field class members and adjust as we read the ptree.
     std::string name = "";
@@ -94,7 +94,7 @@ tablator::ptree_readers::Field_And_Flag tablator::ptree_readers::read_field(
     size_t array_size = 1;
     Field_Properties field_properties;
 
-    bool is_array_dynamic_f = false;
+    bool dynamic_array_flag = false;
 
     auto child = field_tree.begin();
     auto end = field_tree.end();
@@ -112,7 +112,7 @@ tablator::ptree_readers::Field_And_Flag tablator::ptree_readers::read_field(
                 std::string array_size_str = attribute.second.get_value<std::string>();
                 if (array_size_str == "*") {
                     array_size = std::numeric_limits<size_t>::max();
-                    is_array_dynamic_f = true;
+                    dynamic_array_flag = true;
                 } else {
                     array_size = boost::lexical_cast<size_t>(array_size_str);
                 }
@@ -137,6 +137,5 @@ tablator::ptree_readers::Field_And_Flag tablator::ptree_readers::read_field(
     std::vector<STRING_PAIR> &hdf5_links = field_properties.get_hdf5_links();
     child = read_links_section(links, hdf5_links, child, end, TABLE);
 
-    return Field_And_Flag(Field(name, type, array_size, field_properties),
-                          is_array_dynamic_f);
+    return Field(name, type, array_size, field_properties, dynamic_array_flag);
 }
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx
index a61f1bf8..4882ed54 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx
@@ -6,65 +6,78 @@
 #include "../../../../../../Utils/Table_Utils.hxx"
 
 namespace tablator {
-void insert_swapped(const size_t &column_offset, const Data_Type &data_type,
-                    const size_t &array_size, const std::vector<uint8_t> &stream,
-                    const size_t &old_position, Row &row);
-inline void insert_swapped(const size_t &column_offset, const Column &column,
-                           const std::vector<uint8_t> &stream,
-                           const size_t &old_position, Row &row) {
-    return insert_swapped(column_offset, column.get_type(), column.get_array_size(),
-                          stream, old_position, row);
+
+void insert_swapped(Row &row, size_t column_offset, const Data_Type &data_type,
+                    size_t array_size, const std::vector<uint8_t> &stream,
+                    size_t old_position);
+inline void insert_swapped(Row &row, size_t column_offset, const Column &column,
+                           const std::vector<uint8_t> &stream, size_t old_position) {
+    return insert_swapped(row, column_offset, column.get_type(),
+                          column.get_array_size(), stream, old_position);
 }
 
-void ptree_readers::append_data_from_stream(
-        std::vector<uint8_t> &data, const std::vector<Column> &columns,
-        const std::vector<size_t> &offsets, const std::vector<uint8_t> &stream,
-        const std::vector<ptree_readers::Field_And_Flag> &field_flag_pairs,
-        size_t num_rows) {
+void ptree_readers::append_data_from_stream(std::vector<uint8_t> &data,
+                                            const std::vector<Column> &columns,
+                                            const std::vector<size_t> &offsets,
+                                            const std::vector<uint8_t> &stream,
+                                            const std::vector<Field> &fields,
+                                            size_t num_rows) {
     const size_t null_flags_size((columns.size() + 6) / 8);
-    size_t position(0);
+    size_t src_pos(0);
+
     Row row(get_row_size(offsets));
     for (size_t r = 0; r < num_rows; ++r) {
         row.fill_with_zeros();
-        size_t row_offset(position);
-        position += null_flags_size;
+        size_t row_offset(src_pos);
+        src_pos += null_flags_size;
         for (size_t col_idx = 1; col_idx < columns.size(); ++col_idx) {
-            bool dynamic_array_flag =
-                    field_flag_pairs[col_idx].get_dynamic_array_flag();
+            auto column = columns.at(col_idx);
+            auto col_array_size = column.get_array_size();
+            auto col_type = column.get_type();
+
+            bool dynamic_array_flag = fields[col_idx].get_dynamic_array_flag();
             if (is_null_MSB(stream, row_offset, col_idx)) {
-                row.set_null(columns[col_idx].get_type(),
-                             columns[col_idx].get_array_size(), col_idx,
-                             offsets[col_idx], offsets[col_idx + 1]);
-                if (dynamic_array_flag)
-                    position += sizeof(uint32_t);
-                else
-                    position += data_size(columns[col_idx].get_type()) *
-                                columns[col_idx].get_array_size();
-            } else {
+                row.set_null(col_type, col_array_size, col_idx, offsets[col_idx],
+                             offsets[col_idx + 1]);
                 if (dynamic_array_flag) {
-                    auto begin = stream.begin();
-                    std::advance(begin, position);
-                    auto end = stream.begin();
-                    position += sizeof(uint32_t);
-                    std::advance(end, position);
-                    uint32_t dynamic_array_size(0);
-                    boost::spirit::qi::parse(begin, end, boost::spirit::qi::big_dword,
-                                             dynamic_array_size);
-                    insert_swapped(offsets[col_idx], columns[col_idx].get_type(),
-                                   dynamic_array_size, stream, position, row);
-                    position +=
-                            data_size(columns[col_idx].get_type()) * dynamic_array_size;
+				  src_pos += sizeof(uint32_t);
                 } else {
-                    insert_swapped(offsets[col_idx], columns[col_idx], stream, position,
-                                   row);
-                    position += columns[col_idx].get_array_size() *
-                                data_size(columns[col_idx].get_type());
+                    src_pos += data_size(col_type) * col_array_size;
                 }
+            } else if (dynamic_array_flag) {
+                auto begin = stream.begin();
+                std::advance(begin, src_pos);
+                auto end = stream.begin();
+                src_pos += sizeof(uint32_t);
+                std::advance(end, src_pos);
+                uint32_t dynamic_array_size(0);
+
+                // Parse big-ended dynamic_array_size and write it
+                // to <row> (and eventually to <data>)
+                // little-endedly, since <data> is for internal
+                // use only.  We'll swap back if we later write
+                // this table in binary2 format.
+
+                boost::spirit::qi::parse(begin, end, boost::spirit::qi::big_dword,
+                                         dynamic_array_size);
+
+                memcpy(row.get_data().data() + offsets[col_idx], &dynamic_array_size,
+                       sizeof(uint32_t));
+
+                // Now write the array itself, again swapping from
+                // big-ended to little-ended for internal use.
+                insert_swapped(row, offsets[col_idx] + sizeof(uint32_t), col_type,
+                               dynamic_array_size, stream, src_pos);
+                src_pos += data_size(col_type) * dynamic_array_size;
+            } else {
+                insert_swapped(row, offsets[col_idx], column, stream, src_pos);
+                src_pos += col_array_size * data_size(col_type);
             }
-        }
-        if (position <= stream.size()) {
+
+        }  // end loop through columns
+        if (src_pos <= stream.size()) {
             append_row(data, row);
         }
-    }
+    }  // end loop through rows
 }
 }  // namespace tablator
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/insert_swapped.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/insert_swapped.cxx
index c1ef7616..008f813e 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/insert_swapped.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/insert_swapped.cxx
@@ -6,50 +6,49 @@
 
 namespace {
 template <class T, class Rule>
-void parse_and_insert_element(const Rule &rule,
-                              std::vector<uint8_t>::const_iterator &begin,
-                              std::vector<uint8_t>::const_iterator &end,
-                              const size_t &offset, tablator::Row &row) {
+void parse_and_insert_element(tablator::Row &row, size_t offset, const Rule &rule,
+                              std::vector<uint8_t>::const_iterator &src_begin,
+                              std::vector<uint8_t>::const_iterator &src_end) {
     T result;
-    boost::spirit::qi::parse(begin, end, rule, result);
+    boost::spirit::qi::parse(src_begin, src_end, rule, result);
     row.insert(result, offset);
 }
 
-void insert_swapped_element(std::vector<uint8_t>::const_iterator &begin,
-                            std::vector<uint8_t>::const_iterator &end,
-                            const size_t &data_type_size, const size_t &offset,
-                            const bool &is_bool, tablator::Row &row) {
+void insert_swapped_element(tablator::Row &row, size_t offset,
+                            std::vector<uint8_t>::const_iterator &src_begin,
+                            std::vector<uint8_t>::const_iterator &src_end,
+                            size_t data_type_size, const bool &is_bool) {
     switch (data_type_size) {
         case 1:
             // boolean serialization is a little different from just using 0
             // or 1.  Instead, it uses a serialization of the character
             // representation of true or false
             if (is_bool) {
-                if (*begin != 't' && *begin != 'T' && *begin != '1' && *begin != 'f' &&
-                    *begin != 'F' && *begin != '0')
+                if (*src_begin != 't' && *src_begin != 'T' && *src_begin != '1' &&
+                    *src_begin != 'f' && *src_begin != 'F' && *src_begin != '0')
                     throw std::runtime_error(
                             "Invalid value for boolean.  The "
                             "integer representation is " +
-                            std::to_string(*begin));
-                row.insert((*begin == 't' || *begin == 'T' || *begin == '1')
+                            std::to_string(*src_begin));
+                row.insert((*src_begin == 't' || *src_begin == 'T' || *src_begin == '1')
                                    ? static_cast<uint8_t>(1)
                                    : static_cast<uint8_t>(0),
                            offset);
             } else {
-                row.insert(*begin, offset);
+                row.insert(*src_begin, offset);
             }
             break;
         case 2:
-            parse_and_insert_element<uint16_t>(boost::spirit::qi::big_word, begin, end,
-                                               offset, row);
+            parse_and_insert_element<uint16_t>(row, offset, boost::spirit::qi::big_word,
+                                               src_begin, src_end);
             break;
         case 4:
-            parse_and_insert_element<uint32_t>(boost::spirit::qi::big_dword, begin, end,
-                                               offset, row);
+            parse_and_insert_element<uint32_t>(
+                    row, offset, boost::spirit::qi::big_dword, src_begin, src_end);
             break;
         case 8:
-            parse_and_insert_element<uint64_t>(boost::spirit::qi::big_qword, begin, end,
-                                               offset, row);
+            parse_and_insert_element<uint64_t>(
+                    row, offset, boost::spirit::qi::big_qword, src_begin, src_end);
             break;
         default:
             throw std::runtime_error("Invalid value for data_type_size: " +
@@ -60,21 +59,21 @@ void insert_swapped_element(std::vector<uint8_t>::const_iterator &begin,
 }  // namespace
 
 namespace tablator {
-void insert_swapped(const size_t &column_offset, const Data_Type &data_type,
-                    const size_t &array_size, const std::vector<uint8_t> &stream,
-                    const size_t &starting_position, Row &row) {
+void insert_swapped(Row &row, size_t column_offset, const Data_Type &data_type,
+                    size_t array_size, const std::vector<uint8_t> &stream,
+                    size_t starting_src_pos) {
     const size_t data_type_size(data_size(data_type));
     const bool is_bool(data_type == Data_Type::INT8_LE);
-    size_t position = starting_position;
+    size_t src_pos = starting_src_pos;
     for (size_t index = 0; index != array_size; ++index) {
-        auto begin = stream.begin();
-        std::advance(begin, position);
-        auto end = stream.begin();
-        position += data_type_size;
-        std::advance(end, position);
+        auto src_begin = stream.begin();
+        std::advance(src_begin, src_pos);
+        auto src_end = stream.begin();
+        src_pos += data_type_size;
+        std::advance(src_end, src_pos);
 
-        insert_swapped_element(begin, end, data_type_size,
-                               column_offset + index * data_type_size, is_bool, row);
+        insert_swapped_element(row, column_offset + index * data_type_size, src_begin,
+                               src_end, data_type_size, is_bool);
     }
 }
 }  // namespace tablator
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/compute_column_array_sizes.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/compute_column_array_sizes.cxx
index 9598beb5..00d071e2 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/compute_column_array_sizes.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/compute_column_array_sizes.cxx
@@ -7,31 +7,28 @@
 
 
 namespace tablator {
-void compute_column_array_sizes(
-        const std::vector<uint8_t> &stream,
-        const std::vector<ptree_readers::Field_And_Flag> &field_flag_pairs,
-        std::vector<size_t> &column_array_sizes, size_t &num_rows) {
+void compute_column_array_sizes(const std::vector<uint8_t> &stream,
+                                const std::vector<Field> &fields,
+                                std::vector<size_t> &column_array_sizes,
+                                size_t &num_rows) {
     num_rows = 0;
-    if (field_flag_pairs.size() < 2) return;
+    if (fields.size() < 2) return;
 
-    const size_t null_flags_size((field_flag_pairs.size() + 6) / 8);
+    const size_t null_flags_size((fields.size() + 6) / 8);
     size_t position(0);
     while (position + null_flags_size < stream.size()) {
         size_t row_offset(position);
         position += null_flags_size;
         for (size_t field_idx = 1;
-             field_idx < field_flag_pairs.size() && position <= stream.size();
-             ++field_idx) {
-            const auto &field = field_flag_pairs[field_idx].get_field();
-            bool is_array_dynamic =
-                    field_flag_pairs[field_idx].get_dynamic_array_flag();
-
-            if (!is_array_dynamic) {
+             field_idx < fields.size() && position <= stream.size(); ++field_idx) {
+            const auto &field = fields[field_idx];
+            if (!field.get_dynamic_array_flag()) {
+                column_array_sizes[field_idx] = field.get_array_size();
                 position += data_size(field.get_type()) * field.get_array_size();
 
             } else {
                 if (is_null_MSB(stream, row_offset, field_idx)) {
-                    position += sizeof(uint32_t);
+				  position += sizeof(uint32_t);
                 } else {
                     // FIXME: This feels like the hard way to do things.
                     // But I can not use plain old pointers, because I
@@ -61,7 +58,9 @@ void compute_column_array_sizes(
                 }
             }
         }  // end of loop through fields
-        if (position <= stream.size()) ++num_rows;
+        if (position <= stream.size()) {
+            ++num_rows;
+        }
     }
 }
 }  // namespace tablator
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx
index c96d73fc..e965e58f 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx
@@ -5,30 +5,29 @@
 
 namespace tablator {
 std::vector<uint8_t> decode_base64_stream(const std::string &val);
-void compute_column_array_sizes(
-        const std::vector<uint8_t> &stream,
-        const std::vector<ptree_readers::Field_And_Flag> &field_flag_pairs,
-        std::vector<size_t> &column_array_sizes, size_t &num_rows);
+void compute_column_array_sizes(const std::vector<uint8_t> &stream,
+                                const std::vector<Field> &fields,
+                                std::vector<size_t> &column_array_sizes,
+                                size_t &num_rows);
 
 
 //==============================================================
 
-Data_Element ptree_readers::read_binary2(
-        const boost::property_tree::ptree &binary2,
-        const std::vector<ptree_readers::Field_And_Flag> &field_flag_pairs) {
-    std::vector<size_t> column_array_sizes(field_flag_pairs.size(), 1);
-    const size_t null_flags_size((field_flag_pairs.size() + 6) / 8);
+Data_Element ptree_readers::read_binary2(const boost::property_tree::ptree &binary2,
+                                         const std::vector<Field> &fields) {
+    static const std::string STREAM("STREAM");
+
+    std::vector<size_t> column_array_sizes(fields.size(), 1);
+    const size_t null_flags_size((fields.size() + 6) / 8);
     column_array_sizes.at(0) = null_flags_size;
     std::vector<std::vector<uint8_t> > streams;
     for (auto &stream : binary2) {
         if (stream.first == XMLCOMMENT) {
             continue;
         }
-        if (stream.first != "STREAM")
-            throw std::runtime_error(
-                    "Unknown element in BINARY2.  Expected "
-                    "STREAM, but found: " +
-                    stream.first);
+        if (stream.first != STREAM)
+            throw std::runtime_error("Unknown element in BINARY2.  Expected " + STREAM +
+                                     ", but found: " + stream.first);
         std::string encoding;
         for (auto &stream_child : stream.second) {
             if (stream_child.first == XMLATTR) {
@@ -52,11 +51,11 @@ Data_Element ptree_readers::read_binary2(
         streams.emplace_back(
                 decode_base64_stream(stream.second.get_value<std::string>()));
     }
+
     std::vector<size_t> rows_per_stream;
     for (auto &stream : streams) {
         size_t num_rows;
-        compute_column_array_sizes(stream, field_flag_pairs, column_array_sizes,
-                                   num_rows);
+        compute_column_array_sizes(stream, fields, column_array_sizes, num_rows);
         rows_per_stream.push_back(num_rows);
     }
 
@@ -64,14 +63,15 @@ Data_Element ptree_readers::read_binary2(
     std::vector<size_t> offsets = {0};
     std::vector<uint8_t> data;
 
-    for (std::size_t c = 0; c < field_flag_pairs.size(); ++c) {
-        const auto &field = field_flag_pairs.at(c).get_field();
+    for (std::size_t c = 0; c < fields.size(); ++c) {
+        const auto &field = fields.at(c);
         append_column(columns, offsets, field.get_name(), field.get_type(),
-                      column_array_sizes[c], field.get_field_properties());
+                      column_array_sizes[c], field.get_field_properties(),
+                      field.get_dynamic_array_flag());
     }
     for (std::size_t stream = 0; stream < streams.size(); ++stream) {
-        append_data_from_stream(data, columns, offsets, streams[stream],
-                                field_flag_pairs, rows_per_stream[stream]);
+        append_data_from_stream(data, columns, offsets, streams[stream], fields,
+                                rows_per_stream[stream]);
     }
     return Data_Element(columns, offsets, data);
 }
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_data_element.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_data_element.cxx
index d136e3ec..fb8464f0 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_data_element.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_data_element.cxx
@@ -17,7 +17,7 @@ void validate_tail(boost::property_tree::ptree::const_iterator &tail_begin,
 
 tablator::Data_Element tablator::ptree_readers::read_data_element(
         const boost::property_tree::ptree &data,
-        const std::vector<ptree_readers::Field_And_Flag> &field_flag_pairs) {
+        const std::vector<tablator::Field> &fields) {
     auto child = data.begin();
     auto end = data.end();
 
@@ -26,7 +26,7 @@ tablator::Data_Element tablator::ptree_readers::read_data_element(
     }
 
     if (child->first == TABLEDATA) {
-        auto result = read_tabledata(child->second, field_flag_pairs);
+        auto result = read_tabledata(child->second, fields);
         validate_tail(++child, end);
         return result;
     } else if (child->first == BINARY) {
@@ -34,7 +34,7 @@ tablator::Data_Element tablator::ptree_readers::read_data_element(
                 "BINARY serialization inside a VOTable not "
                 "supported.");
     } else if (child->first == BINARY2) {
-        auto result = read_binary2(child->second, field_flag_pairs);
+        auto result = read_binary2(child->second, fields);
         validate_tail(++child, end);
         return result;
     } else if (child->first == FITS) {
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
index 51a08a8c..03fa2a8e 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
@@ -11,9 +11,9 @@ size_t count_elements(const std::string &entry, const Data_Type &type);
 
 tablator::Data_Element tablator::ptree_readers::read_tabledata(
         const boost::property_tree::ptree &tabledata,
-        const std::vector<Field_And_Flag> &field_flag_pairs) {
+        const std::vector<Field> &fields) {
     std::vector<std::vector<std::string> > element_lists_by_row;
-    size_t num_fields = field_flag_pairs.size();
+    size_t num_fields = fields.size();
 
     // Need to set the size to at least 1, because H5::StrType can not
     // handle zero sized strings.
@@ -25,6 +25,7 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
         if (tr.first == "TR" || tr.first.empty()) {
             // Add something for the null_bitfields_flag
             element_lists_by_row.push_back({});
+
             auto td = tr.second.begin();
             while (td != tr.second.end() && td->first == XMLATTR_DOT + ID) {
                 ++td;
@@ -37,7 +38,7 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
                             ".  Expected " + std::to_string(num_fields - 1) +
                             ", but only got " + std::to_string(c - 1) + ".");
                 }
-                const auto &field = field_flag_pairs.at(c).get_field();
+                const auto &field = fields.at(c);
                 if (td->first == "TD" || td->first.empty()) {
                     std::string temp = td->second.get_value<std::string>();
                     if (field.get_array_size() != 1) {
@@ -58,7 +59,7 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
             if (td != tr.second.end()) {
                 throw std::runtime_error("Too many elements in row " +
                                          std::to_string(element_lists_by_row.size()) +
-                                         ".  Only expected " +
+                                         ".  Expected only " +
                                          std::to_string(num_fields - 1) + ".");
             }
         } else if (tr.first != XMLATTR_DOT + "encoding" && tr.first != XMLCOMMENT) {
@@ -73,13 +74,16 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
     std::vector<uint8_t> data;
 
     for (std::size_t c = 0; c < num_fields; ++c) {
-        const auto &field = field_flag_pairs.at(c).get_field();
+        const auto &field = fields.at(c);
         append_column(columns, offsets, field.get_name(), field.get_type(),
-                      column_array_sizes[c], field.get_field_properties());
+                      column_array_sizes[c], field.get_field_properties(),
+                      field.get_dynamic_array_flag());
     }
 
     Row row_string(*offsets.rbegin());
 
+    // JTODO Are we allowing for non-CHAR dynamic arrays?  Should all arrays end in
+    // '\0'?
     for (size_t row_idx = 0; row_idx < element_lists_by_row.size(); ++row_idx) {
         auto &element_list = element_lists_by_row[row_idx];
         row_string.fill_with_zeros();
@@ -96,9 +100,7 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
                                         offsets[col_idx], offsets[col_idx + 1]);
                 } catch (std::exception &error) {
                     throw std::runtime_error(
-                            "Invalid " +
-                            to_string(
-                                    field_flag_pairs[col_idx].get_field().get_type()) +
+                            "Invalid " + to_string(fields[col_idx].get_type()) +
                             " value " + element + " in element_list " +
                             std::to_string(row_idx + 1) + ", field " +
                             std::to_string(col_idx) +
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_table_element.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_table_element.cxx
index 9121786e..e5840b2e 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_table_element.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_table_element.cxx
@@ -9,39 +9,23 @@
 #include "../../../Utils/Vector_Utils.hxx"
 #include "../../Utils.hxx"
 
-namespace {
-
-void load_field_and_flag_singleton(
-        std::vector<tablator::ptree_readers::Field_And_Flag> &field_flag_pairs,
-        const boost::property_tree::ptree &node) {
-    field_flag_pairs.emplace_back(tablator::ptree_readers::read_field(node));
-}
-
-void load_field_and_flag_array(
-        std::vector<tablator::ptree_readers::Field_And_Flag> &field_flag_pairs,
-        const boost::property_tree::ptree &array_tree) {
-    for (const auto &elt : array_tree) {
-        load_field_and_flag_singleton(field_flag_pairs, elt.second);
-    }
-}
 
+namespace {
 
 // Helper function which handles the part of the property_tree corresponding to
 // the section of a VOTable TABLE element preceding its DATA element per the IVOA spec.
 
 boost::property_tree::ptree::const_iterator load_pre_data_section(
-        std::vector<tablator::ptree_readers::Field_And_Flag> &field_flag_pairs,
-        std::vector<tablator::Field> &params,
+        std::vector<tablator::Field> &fields, std::vector<tablator::Field> &params,
         std::vector<tablator::Group_Element> &group_elements,
         boost::property_tree::ptree::const_iterator &start,
         boost::property_tree::ptree::const_iterator &end) {
     boost::property_tree::ptree::const_iterator &iter = start;
     while (iter != end) {
         if (iter->first == tablator::FIELD) {
-            load_field_and_flag_singleton(field_flag_pairs, iter->second);
+            tablator::ptree_readers::load_field_singleton(fields, iter->second);
         } else if (iter->first == tablator::FIELD_ARRAY) {
-            load_field_and_flag_array(field_flag_pairs, iter->second);
-
+            tablator::ptree_readers::load_field_array(fields, iter->second);
         } else if (iter->first == tablator::PARAM) {
             tablator::ptree_readers::load_field_singleton(params, iter->second);
         } else if (iter->first == tablator::PARAM_ARRAY) {
@@ -93,38 +77,26 @@ tablator::Table_Element read_table_element(
         ++child;
     }
 
-    std::vector<Field_And_Flag> field_flag_pairs;
+    std::vector<Field> fields;
     // Register null column
-    field_flag_pairs.emplace_back(
-            Field(null_bitfield_flags_name, Data_Type::UINT8_LE, true,
-                  Field_Properties(null_bitfield_flags_description, {})),
-            false);
+    fields.emplace_back(null_bitfield_flags_name, Data_Type::UINT8_LE, true,
+                        Field_Properties(null_bitfield_flags_description, {}));
 
     std::vector<Group_Element> group_elements;
     std::vector<Field> params;
-    child = load_pre_data_section(field_flag_pairs, params, group_elements, child, end);
-
-    if (field_flag_pairs.size() < 2) {
+    child = load_pre_data_section(fields, params, group_elements, child, end);
+    if (fields.size() < 2) {
         throw std::runtime_error("This VOTable is empty.");
     }
 
     std::vector<Data_Element> data_elements;
     if (child != end && child->first == DATA) {
-        data_elements.emplace_back(read_data_element(child->second, field_flag_pairs));
+        data_elements.emplace_back(read_data_element(child->second, fields));
         ++child;
     }
-
     std::vector<Property> trailing_info_list;
     child = read_trailing_info_section(trailing_info_list, child, end);
 
-    // wrap up
-    std::vector<Field> fields;
-    std::transform(field_flag_pairs.begin(), field_flag_pairs.end(),
-                   std::back_inserter(fields),
-                   [&](const Field_And_Flag &field_flag) -> Field {
-                       return field_flag.get_field();
-                   });
-
     return tablator::Table_Element::Builder(data_elements)
             .add_attributes(attributes)
             .add_description(description)

From 0e55940fe055fc9b32a1d9d019789ad9c95b4b80 Mon Sep 17 00:00:00 2001
From: Judith Silverman <judith@ipac.caltech.edu>
Date: Wed, 25 Jun 2025 21:35:08 -0700
Subject: [PATCH 3/8] Table-related cleanup

Table.hxx: moved functions to "private" section where appropriate
retired flatten_properties()
---
 src/Property.hxx                              |  10 --
 src/Table.hxx                                 | 150 +++++++++---------
 src/Table/Column_Row_Accessors.cxx            |   4 +-
 src/Table/flatten_properties.cxx              |  12 --
 src/Table/write_dsv.cxx                       |   2 +-
 src/Table/write_tabledata/write_tabledata.cxx |   2 +-
 wscript                                       |   1 -
 7 files changed, 76 insertions(+), 105 deletions(-)
 delete mode 100644 src/Table/flatten_properties.cxx

diff --git a/src/Property.hxx b/src/Property.hxx
index 8c375541..e4d98745 100644
--- a/src/Property.hxx
+++ b/src/Property.hxx
@@ -21,16 +21,6 @@ public:
     Property(const std::string &Value, const ATTRIBUTES &Attributes)
             : attributes_(Attributes), value_(Value) {}
 
-    // Called internally, directly or otherwise, only by flatten_properties().
-    std::vector<STRING_PAIR> flatten(const std::string &key) const {
-        std::vector<STRING_PAIR> result;
-        result.push_back(std::make_pair(key, value_));
-        for (auto &a : attributes_)
-            result.push_back(
-                    std::make_pair(key + "." + XMLATTR_DOT + a.first, a.second));
-        return result;
-    }
-
     const ATTRIBUTES &get_attributes() const { return attributes_; }
     ATTRIBUTES &get_attributes() { return attributes_; }
 
diff --git a/src/Table.hxx b/src/Table.hxx
index c8260934..8208c96c 100644
--- a/src/Table.hxx
+++ b/src/Table.hxx
@@ -301,11 +301,6 @@ public:
         tablator::append_row(get_data(), row);
     }
 
-    void unsafe_append_row(const char *row) {
-        tablator::unsafe_append_row(get_data(), row, get_row_size());
-    }
-
-
     void append_rows(const Table &table2);
 
     // write functions
@@ -318,8 +313,8 @@ public:
                const Command_Line_Options &options = default_options) const {
         write(path, Format(path), options);
     }
-    void write_hdf5(std::ostream &os) const;
-    void write_hdf5(const boost::filesystem::path &p) const;
+
+    // JTODO Some of these write_XXX() functions could be made private.
 
     void write_ipac_table(std::ostream &os,
                           const Command_Line_Options &options = default_options) const {
@@ -364,7 +359,7 @@ public:
             std::ostream &os, const std::vector<size_t> &column_ids,
             const Command_Line_Options options = default_options) const {
         Ipac_Table_Writer::write_subtable_by_column_and_row(*this, os, column_ids, 0,
-                                                            num_rows(), options);
+                                                            get_num_rows(), options);
     }
 
     void write_single_ipac_record(std::ostream &os, size_t row_idx,
@@ -410,10 +405,6 @@ public:
                                                   requested_row_ids, options);
     }
 
-
-    void write_dsv(std::ostream &os, const char &separator,
-                   const Command_Line_Options &options = default_options) const;
-
     void write_sql_create_table(std::ostream &os, const std::string &table_name,
                                 const Format::Enums &sql_type) const {
         using namespace std::string_literals;
@@ -461,64 +452,6 @@ public:
     void write_sqlite_db(const boost::filesystem::path &path,
                          const Command_Line_Options &options) const;
 
-    void write_fits(std::ostream &os) const;
-
-    void write_fits(const boost::filesystem::path &filename) const;
-
-    void write_fits(fitsfile *fits_file) const;
-
-    void write_tabledata(std::ostream &os, const Format::Enums &output_format,
-                         const Command_Line_Options &options) const;
-
-    void write_html(std::ostream &os, const Command_Line_Options &options) const;
-
-    boost::property_tree::ptree generate_property_tree() const;
-
-    void read_unknown(const boost::filesystem::path &path);
-    void read_unknown(std::istream &input_stream);
-    void read_ipac_table(std::istream &input_stream);
-    void read_ipac_table(const boost::filesystem::path &path) {
-        boost::filesystem::ifstream input_stream(path);
-        read_ipac_table(input_stream);
-    }
-    void read_fits(const boost::filesystem::path &path);
-    void read_hdf5(const boost::filesystem::path &path);
-    void read_json5(std::istream &input_stream);
-    void read_json5(const boost::filesystem::path &path) {
-        boost::filesystem::ifstream input_stream(path);
-        read_json5(input_stream);
-    }
-    void read_json(std::istream &input_stream);
-    void read_json(const boost::filesystem::path &path) {
-        boost::filesystem::ifstream input_stream(path);
-        read_json(input_stream);
-    }
-
-    void read_votable(std::istream &input_stream);
-    void read_votable(const boost::filesystem::path &path) {
-        boost::filesystem::ifstream input_stream(path);
-        read_votable(input_stream);
-    }
-
-    void read_dsv(std::istream &input_stream, const Format &format);
-    void read_dsv(const boost::filesystem::path &path, const Format &format) {
-        if (path == "-") {
-            read_dsv(std::cin, format);
-        } else {
-            boost::filesystem::ifstream input_stream(path);
-            read_dsv(input_stream, format);
-        }
-    }
-
-    void read_dsv_rows(const std::list<std::vector<std::string>> &dsv) {
-        set_data(read_dsv_rows(get_columns(), get_offsets(), dsv));
-    }
-
-    void set_column_info(std::list<std::vector<std::string>> &dsv) {
-        set_column_info(get_columns(), get_offsets(), dsv);
-    };
-
-
     // Following the VOTable convention, we use the most significant
     // bit for the first column.
     bool is_null_value(size_t row_idx, size_t col_idx) const {
@@ -544,7 +477,6 @@ public:
         return get_data().at(pos) & (128 >> ((col_idx - 1) % 8));
     }
 
-
     // extractors
 
     std::string extract_value_as_string(
@@ -620,7 +552,7 @@ public:
 
         const auto &columns = get_columns();
         auto &column = columns[col_idx];
-        size_t row_count = num_rows();
+        size_t row_count = get_num_rows();
         std::vector<T> col_vec;
         col_vec.reserve(row_count * column.get_array_size());
         for (size_t curr_row_idx = 0; curr_row_idx < row_count; ++curr_row_idx) {
@@ -650,8 +582,6 @@ public:
                                   get_columns().at(col_idx).get_array_size());
     }
 
-
-public:
     void insert_string_column_value_into_row(Row &row, size_t col_idx,
                                              const uint8_t *data_ptr,
                                              uint32_t curr_array_size) const;
@@ -938,6 +868,74 @@ public:
 
 
 private:
+    void unsafe_append_row(const char *row) {
+        tablator::unsafe_append_row(get_data(), row, get_row_size());
+    }
+
+    void write_hdf5(std::ostream &os) const;
+    void write_hdf5(const boost::filesystem::path &p) const;
+
+    void write_dsv(std::ostream &os, const char &separator,
+                   const Command_Line_Options &options = default_options) const;
+
+    void write_fits(std::ostream &os) const;
+
+    void write_fits(const boost::filesystem::path &filename) const;
+
+    void write_fits(fitsfile *fits_file) const;
+
+    void write_tabledata(std::ostream &os, const Format::Enums &output_format,
+                         const Command_Line_Options &options) const;
+
+    void write_html(std::ostream &os, const Command_Line_Options &options) const;
+
+    boost::property_tree::ptree generate_property_tree() const;
+
+    void read_unknown(const boost::filesystem::path &path);
+    void read_unknown(std::istream &input_stream);
+    void read_ipac_table(std::istream &input_stream);
+    void read_ipac_table(const boost::filesystem::path &path) {
+        boost::filesystem::ifstream input_stream(path);
+        read_ipac_table(input_stream);
+    }
+    void read_fits(const boost::filesystem::path &path);
+    void read_hdf5(const boost::filesystem::path &path);
+    void read_json5(std::istream &input_stream);
+    void read_json5(const boost::filesystem::path &path) {
+        boost::filesystem::ifstream input_stream(path);
+        read_json5(input_stream);
+    }
+    void read_json(std::istream &input_stream);
+    void read_json(const boost::filesystem::path &path) {
+        boost::filesystem::ifstream input_stream(path);
+        read_json(input_stream);
+    }
+
+    void read_votable(std::istream &input_stream);
+    void read_votable(const boost::filesystem::path &path) {
+        boost::filesystem::ifstream input_stream(path);
+        read_votable(input_stream);
+    }
+
+    void read_dsv(std::istream &input_stream, const Format &format);
+    void read_dsv(const boost::filesystem::path &path, const Format &format) {
+        if (path == "-") {
+            read_dsv(std::cin, format);
+        } else {
+            boost::filesystem::ifstream input_stream(path);
+            read_dsv(input_stream, format);
+        }
+    }
+
+    void read_dsv_rows(const std::list<std::vector<std::string>> &dsv) {
+        set_data(read_dsv_rows(get_columns(), get_offsets(), dsv));
+    }
+
+    void set_column_info(std::list<std::vector<std::string>> &dsv) {
+        set_column_info(get_columns(), get_offsets(), dsv);
+    };
+
+
     std::vector<size_t> get_column_widths(const Command_Line_Options &options) const {
         return Ipac_Table_Writer::get_column_widths(*this, options);
     }
@@ -1074,10 +1072,6 @@ private:
                                 std::list<std::vector<std::string>> &dsv);
 
 
-    // This function is not used internally.
-    static std::vector<STRING_PAIR> flatten_properties(
-            const Labeled_Properties &properties);
-
     Table(const std::vector<Resource_Element> &resource_elements,
           const Options &options)
             : resource_elements_(resource_elements), options_(options) {
diff --git a/src/Table/Column_Row_Accessors.cxx b/src/Table/Column_Row_Accessors.cxx
index ee88a1c3..ba2f7542 100644
--- a/src/Table/Column_Row_Accessors.cxx
+++ b/src/Table/Column_Row_Accessors.cxx
@@ -14,7 +14,7 @@ const uint8_t *tablator::Table::extract_value_ptr(size_t col_idx,
     if (col_idx >= columns.size()) {
         throw std::runtime_error("Invalid column index: " + std::to_string(col_idx));
     }
-    if (row_idx >= num_rows()) {
+    if (row_idx >= get_num_rows()) {
         throw std::runtime_error("Invalid row index: " + std::to_string(row_idx));
     }
 
@@ -41,7 +41,7 @@ std::string tablator::Table::extract_value_as_string(
         throw std::runtime_error("Invalid row index: " + std::to_string(row_idx));
     }
 
-    size_t curr_row_offset = row_idx * row_size();
+    size_t curr_row_offset = row_idx * get_row_size();
     auto &column = columns[col_idx];
     if (is_null_value(row_idx, col_idx)) {
         auto &null_value = column.get_field_properties().get_values().null;
diff --git a/src/Table/flatten_properties.cxx b/src/Table/flatten_properties.cxx
deleted file mode 100644
index f1788434..00000000
--- a/src/Table/flatten_properties.cxx
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "../Table.hxx"
-
-std::vector<tablator::STRING_PAIR> tablator::Table::flatten_properties(
-        const std::vector<Labeled_Property> &label_and_property_list) {
-    std::vector<tablator::STRING_PAIR> result;
-    for (auto &label_and_prop : label_and_property_list) {
-        std::vector<tablator::STRING_PAIR> flattened_prop(
-                label_and_prop.second.flatten(label_and_prop.first));
-        result.insert(result.end(), flattened_prop.begin(), flattened_prop.end());
-    }
-    return result;
-}
diff --git a/src/Table/write_dsv.cxx b/src/Table/write_dsv.cxx
index aeb6f326..d88da517 100644
--- a/src/Table/write_dsv.cxx
+++ b/src/Table/write_dsv.cxx
@@ -57,7 +57,7 @@ void tablator::Table::write_dsv(std::ostream &os, const char &separator,
     }
 
     for (size_t row_idx = 0, row_offset = 0; row_idx < num_rows;
-         ++row_idx, row_offset += row_size()) {
+         ++row_idx, row_offset += get_row_size()) {
         for (size_t col_idx = 1; col_idx < num_columns; ++col_idx) {
             const auto &column = columns[col_idx];
             size_t offset = offsets[col_idx] + row_offset;
diff --git a/src/Table/write_tabledata/write_tabledata.cxx b/src/Table/write_tabledata/write_tabledata.cxx
index 67b3b7c1..2e7efc0b 100644
--- a/src/Table/write_tabledata/write_tabledata.cxx
+++ b/src/Table/write_tabledata/write_tabledata.cxx
@@ -94,7 +94,7 @@ void Table::write_tabledata(std::ostream &os, const Format::Enums &output_format
             os << '\n';
         }
         os << tr_suffix;
-        if (is_json && row_offset < data.size() - row_size()) {
+        if (is_json && row_offset < data.size() - get_row_size()) {
             os << ',';
         }
         os << '\n';
diff --git a/wscript b/wscript
index f716e2ad..e200bcb7 100644
--- a/wscript
+++ b/wscript
@@ -27,7 +27,6 @@ def build(bld):
              'src/H5_to_Data_Type.cxx',
              'src/quote_sql_string.cxx',
              'src/Table/Table.cxx',
-             'src/Table/flatten_properties.cxx',
              'src/Table/Column_Row_Accessors.cxx',
              'src/Table/read_unknown/read_unknown.cxx',
              'src/Table/read_unknown/is_fits.cxx',

From ba75704666b623c8d273193c988fc2b89e7e76eb Mon Sep 17 00:00:00 2001
From: Judith Silverman <judith@ipac.caltech.edu>
Date: Sat, 21 Jun 2025 20:38:28 -0700
Subject: [PATCH 4/8] Row-related cleanup

---
 src/Row.hxx                                   | 44 ++++++++-----------
 src/Row/set_null.cxx                          | 16 +++----
 src/Table.hxx                                 | 21 +++------
 src/Table/Column_Row_Accessors.cxx            |  8 ++--
 src/Table/read_dsv/read_dsv_rows.cxx          |  6 +--
 src/Table/read_fits.cxx                       | 20 ++++-----
 src/Table/read_ipac_table/read_ipac_table.cxx |  6 +--
 src/Table_Ops.cxx                             |  2 +-
 src/Utils/Table_Utils.hxx                     |  5 ---
 src/Utils/Table_Utils/insert_ascii_in_row.cxx |  2 +-
 .../append_data_from_stream.cxx               |  6 +--
 .../read_tabledata/read_tabledata.cxx         |  4 +-
 src/tablator/main.cxx                         |  2 +-
 13 files changed, 61 insertions(+), 81 deletions(-)

diff --git a/src/Row.hxx b/src/Row.hxx
index 6c1fffdc..e662d513 100644
--- a/src/Row.hxx
+++ b/src/Row.hxx
@@ -9,54 +9,48 @@
 namespace tablator {
 class Row {
 public:
-    // JTODO Update tablator clients to call get_data() and then make data a private
-    // class member.
-    std::vector<char> data;
+    Row(const size_t &size) : data_(size) {}
 
-    Row(const size_t &size) : data(size) {}
+    void fill_with_zeros() { std::fill(data_.begin(), data_.end(), 0); }
 
-    void fill_with_zeros() { std::fill(data.begin(), data.end(), 0); }
-
-    // backward compatibility
-    void set_zero() { fill_with_zeros(); }
-
-    void set_null(const Data_Type &type, const size_t &array_size,
-                  const size_t &col_idx, const size_t &offset,
-                  const size_t &offset_end);
+    void insert_null(const Data_Type &type, const size_t &array_size,
+                     const size_t &col_idx, const size_t &offset,
+                     const size_t &offset_end);
 
     template <typename T>
     void insert(const T &element, const size_t &offset) {
-        assert(offset + sizeof(T) <= data.size());
-        unsafe_copy_to_row(element, offset, data.data());
+        assert(offset + sizeof(T) <= data_.size());
+        unsafe_copy_to_row(element, offset, data_.data());
     }
 
     template <typename T>
     void insert(const T &begin, const T &end, const size_t &offset) {
-        assert(offset + std::distance(begin, end) <= data.size());
-        std::copy(begin, end, data.data() + offset);
+        assert(offset + std::distance(begin, end) <= data_.size());
+        std::copy(begin, end, data_.data() + offset);
     }
 
     void insert(const std::string &element, const size_t &offset_begin,
                 const size_t &offset_end) {
         std::string element_copy(element);
         element_copy.resize(offset_end - offset_begin, '\0');
-        std::copy(element_copy.begin(), element_copy.end(), data.data() + offset_begin);
+        std::copy(element_copy.begin(), element_copy.end(),
+                  data_.data() + offset_begin);
     }
 
+    size_t get_size() const { return data_.size(); }
+
+    const std::vector<char> &get_data() const { return data_; }
+    std::vector<char> &get_data() { return data_; }
+
+private:
     template <typename T>
     void insert_null(const size_t &offset) {
         insert(tablator::get_null<T>(), offset);
     }
 
-    size_t get_size() const { return data.size(); }
-    // Deprecated
-    size_t size() const { return get_size(); }
-
-    const std::vector<char> &get_data() const { return data; }
-    std::vector<char> &get_data() { return data; }
+    void insert_null_by_type(const Data_Type &data_type, const size_t &offset);
 
-private:
-    void set_null_internal(const Data_Type &data_type, const size_t &offset);
+    std::vector<char> data_;
 };
 
 
diff --git a/src/Row/set_null.cxx b/src/Row/set_null.cxx
index 76696bd1..4d50eca1 100644
--- a/src/Row/set_null.cxx
+++ b/src/Row/set_null.cxx
@@ -3,21 +3,21 @@
 #include "../Row.hxx"
 #include "../data_size.hxx"
 
-void tablator::Row::set_null(const Data_Type &data_type, const size_t &array_size,
-                             const size_t &col_idx, const size_t &offset,
-                             const size_t &offset_end) {
+void tablator::Row::insert_null(const Data_Type &data_type, const size_t &array_size,
+                                const size_t &col_idx, const size_t &offset,
+                                const size_t &offset_end) {
     const int byte = (col_idx - 1) / 8;
     const char mask = (128 >> ((col_idx - 1) % 8));
 
     // Update the null_bitfield_flag's bit for this column.
-    data[byte] = data[byte] | mask;
+    data_[byte] = data_[byte] | mask;
 
     size_t curr_offset = offset;
     size_t data_type_size = data_size(data_type);
 
     // Mark the indicated array elements as null.
     for (size_t i = 0; i < array_size; ++i) {
-        set_null_internal(data_type, curr_offset);
+        insert_null_by_type(data_type, curr_offset);
         curr_offset += data_type_size;
         if (curr_offset >= offset_end) {
             // Shouldn't happen.
@@ -26,8 +26,8 @@ void tablator::Row::set_null(const Data_Type &data_type, const size_t &array_siz
     }
 }
 
-void tablator::Row::set_null_internal(const Data_Type &data_type,
-                                      const size_t &offset) {
+void tablator::Row::insert_null_by_type(const Data_Type &data_type,
+                                        const size_t &offset) {
     switch (data_type) {
         case Data_Type::INT8_LE:
             insert_null<int8_t>(offset);
@@ -64,6 +64,6 @@ void tablator::Row::set_null_internal(const Data_Type &data_type,
             break;
         default:
             throw std::runtime_error(
-                    "Unexpected data type in tablator::Row::set_null()");
+                    "Unexpected data type in insert_null_by_type()");
     }
 }
diff --git a/src/Table.hxx b/src/Table.hxx
index 8208c96c..adb257fe 100644
--- a/src/Table.hxx
+++ b/src/Table.hxx
@@ -246,14 +246,10 @@ public:
     }
 
     size_t get_column_offset(const std::string &name) const {
-        auto col_idx = column_index(name);
+        auto col_idx = get_column_index(name);
         return get_offsets().at(col_idx);
     }
 
-    // JTODO deprecated
-    size_t column_index(const std::string &name) const {
-        return get_column_index(name);
-    }
     size_t column_offset(size_t col_idx) const { return get_column_offset(col_idx); }
     size_t column_offset(const std::string &name) const {
         return get_column_offset(name);
@@ -264,7 +260,7 @@ public:
         std::vector<size_t> col_ids;
 
         for (const std::string &col_name : col_names) {
-            size_t col_id = column_index(col_name);
+            size_t col_id = get_column_index(col_name);
             col_ids.emplace_back(col_id);
         }
         return col_ids;
@@ -297,7 +293,7 @@ public:
     // table modifiers
 
     void append_row(const Row &row) {
-        assert(row.data.size() == get_row_size());
+	  assert(row.get_data().size() == get_row_size());
         tablator::append_row(get_data(), row);
     }
 
@@ -314,8 +310,6 @@ public:
         write(path, Format(path), options);
     }
 
-    // JTODO Some of these write_XXX() functions could be made private.
-
     void write_ipac_table(std::ostream &os,
                           const Command_Line_Options &options = default_options) const {
         Ipac_Table_Writer::write(*this, os, options);
@@ -493,7 +487,7 @@ public:
 
     template <typename T>
     std::vector<T> extract_value(const std::string &col_name, size_t row_idx) const {
-        auto col_idx = column_index(col_name);
+        auto col_idx = get_column_index(col_name);
         return extract_value<T>(col_idx, row_idx);
     }
 
@@ -539,7 +533,7 @@ public:
 
     template <typename T>
     std::vector<T> extract_column(const std::string &col_name) const {
-        auto col_idx = column_index(col_name);
+        auto col_idx = get_column_index(col_name);
         return extract_column<T>(col_idx);
     }
 
@@ -563,6 +557,7 @@ public:
 
 
     // inserters
+    // JTODO calls set_null()
     void insert_null_into_row(tablator::Row &row, size_t col_idx,
                               uint32_t array_size) const;
 
@@ -868,10 +863,6 @@ public:
 
 
 private:
-    void unsafe_append_row(const char *row) {
-        tablator::unsafe_append_row(get_data(), row, get_row_size());
-    }
-
     void write_hdf5(std::ostream &os) const;
     void write_hdf5(const boost::filesystem::path &p) const;
 
diff --git a/src/Table/Column_Row_Accessors.cxx b/src/Table/Column_Row_Accessors.cxx
index ba2f7542..c80a8088 100644
--- a/src/Table/Column_Row_Accessors.cxx
+++ b/src/Table/Column_Row_Accessors.cxx
@@ -24,7 +24,7 @@ const uint8_t *tablator::Table::extract_value_ptr(size_t col_idx,
 std::string tablator::Table::extract_value_as_string(
         const std::string &col_name, size_t row_idx,
         const Command_Line_Options &options) const {
-    size_t col_idx = column_index(col_name);  // throws if col_name is invalid
+    size_t col_idx = get_column_index(col_name);  // throws if col_name is invalid
     return extract_value_as_string(col_idx, row_idx, options);
 }
 
@@ -61,7 +61,7 @@ std::string tablator::Table::extract_value_as_string(
 
 std::vector<std::string> tablator::Table::extract_column_values_as_strings(
         const std::string &col_name, const Command_Line_Options &options) const {
-    size_t col_idx = column_index(col_name);  // throws if col_name is invalid
+    size_t col_idx = get_column_index(col_name);  // throws if col_name is invalid
 
     std::vector<std::string> col_vals;
 
@@ -127,8 +127,8 @@ void tablator::Table::insert_null_into_row(tablator::Row &row, size_t col_idx,
                                            uint32_t array_size) const {
     validate_parameters(row, *this, col_idx, 0 /* elt_idx */, array_size);
     const auto &column = get_columns().at(col_idx);
-    row.set_null(column.get_type(), sizeof(uint32_t), col_idx,
-                 get_offsets().at(col_idx), get_offsets().at(col_idx + 1));
+    row.insert_null(column.get_type(), sizeof(uint32_t), col_idx,
+                    get_offsets().at(col_idx), get_offsets().at(col_idx + 1));
 }
 
 
diff --git a/src/Table/read_dsv/read_dsv_rows.cxx b/src/Table/read_dsv/read_dsv_rows.cxx
index eecefe4f..354059b3 100644
--- a/src/Table/read_dsv/read_dsv_rows.cxx
+++ b/src/Table/read_dsv/read_dsv_rows.cxx
@@ -16,9 +16,9 @@ std::vector<uint8_t> tablator::Table::read_dsv_rows(
         for (size_t col_idx = 1; col_idx < columns.size(); ++col_idx) {
             const std::string &element(dsv_row[col_idx - 1]);
             if (element.empty() || element == "null") {
-                row_string.set_null(columns[col_idx].get_type(),
-                                    columns[col_idx].get_array_size(), col_idx,
-                                    offsets[col_idx], offsets[col_idx + 1]);
+                row_string.insert_null(columns[col_idx].get_type(),
+                                       columns[col_idx].get_array_size(), col_idx,
+                                       offsets[col_idx], offsets[col_idx + 1]);
             } else {
                 insert_ascii_in_row(row_string, columns[col_idx].get_type(),
                                     columns[col_idx].get_array_size(), col_idx, element,
diff --git a/src/Table/read_fits.cxx b/src/Table/read_fits.cxx
index 437b1267..642b0fde 100644
--- a/src/Table/read_fits.cxx
+++ b/src/Table/read_fits.cxx
@@ -723,16 +723,16 @@ class Row_Column_Element_Reader {
             // Indicate that all array_size values are null.
 
             // Note: As of 13Oct23, the only value I have seen for anynul is 0.
-            row.set_null(tab_data_type, array_size, tab_col_idx, col_offset,
-                         next_col_offset);
+            row.insert_null(tab_data_type, array_size, tab_col_idx, col_offset,
+                            next_col_offset);
         } else {
             for (size_t array_offset = 0; array_offset < array_size; ++array_offset) {
                 T array_elt = temp_array[array_offset];
                 if (got_null && array_elt == null_value) {
                     // Indicate that a single value in the array is null.
-                    row.set_null(tab_data_type, 1 /* array_size */, tab_col_idx,
-                                 col_offset + (array_offset * sizeof(T)),
-                                 next_col_offset);
+                    row.insert_null(tab_data_type, 1 /* array_size */, tab_col_idx,
+                                    col_offset + (array_offset * sizeof(T)),
+                                    next_col_offset);
                 } else if ((tab_data_type == tablator::Data_Type::FLOAT32_LE ||
                             tab_data_type == tablator::Data_Type::FLOAT64_LE) &&
                            std::isnan(array_elt)) {
@@ -740,9 +740,9 @@ class Row_Column_Element_Reader {
                     // allow columns of these types to specify a NULL signal and because
                     // equality check doesn't work with NaN, which appears to be the
                     // default NULL signal for these types, at least for Euclid files.
-                    row.set_null(tab_data_type, 1 /* array_size */, tab_col_idx,
-                                 col_offset + (array_offset * sizeof(T)),
-                                 next_col_offset);
+                    row.insert_null(tab_data_type, 1 /* array_size */, tab_col_idx,
+                                    col_offset + (array_offset * sizeof(T)),
+                                    next_col_offset);
                 } else {
                     *reinterpret_cast<T *>(curr_ptr) = array_elt;
                     curr_ptr += sizeof(T);
@@ -802,8 +802,8 @@ class Row_Column_Element_Reader {
                           &status);
 
         if (anynul) {
-            row.set_null(tab_col_type, fits_col.repeat(), tab_col_idx, col_offset,
-                         next_col_offset);
+            row.insert_null(tab_col_type, fits_col.repeat(), tab_col_idx, col_offset,
+                            next_col_offset);
         } else {
             char *current = row.get_data().data() + col_offset;
             for (size_t i = 0; i < num_substrings; ++i) {
diff --git a/src/Table/read_ipac_table/read_ipac_table.cxx b/src/Table/read_ipac_table/read_ipac_table.cxx
index 46b73bd3..5083b935 100644
--- a/src/Table/read_ipac_table/read_ipac_table.cxx
+++ b/src/Table/read_ipac_table/read_ipac_table.cxx
@@ -72,9 +72,9 @@ void tablator::Table::read_ipac_table(std::istream &input_stream) {
                      element == ipac_columns[COL_NULL_IDX][col_idx]) ||
                     (ipac_columns[COL_NULL_IDX][col_idx].empty() &&
                      tab_column.get_type() != Data_Type::CHAR && element.empty())) {
-                    row_string.set_null(tab_column.get_type(),
-                                        tab_column.get_array_size(), col_idx,
-                                        offsets[col_idx], offsets[col_idx + 1]);
+                    row_string.insert_null(tab_column.get_type(),
+                                           tab_column.get_array_size(), col_idx,
+                                           offsets[col_idx], offsets[col_idx + 1]);
                 } else {
                     try {
                         insert_ascii_in_row(row_string, tab_column.get_type(),
diff --git a/src/Table_Ops.cxx b/src/Table_Ops.cxx
index a04b644a..eb20e842 100644
--- a/src/Table_Ops.cxx
+++ b/src/Table_Ops.cxx
@@ -44,7 +44,7 @@ Table add_counter_column(const Table &src_table, const std::string &col_name) {
     for (const auto *row_pointer = src_data.data();
          row_pointer < src_data.data() + src_data.size();
          row_pointer += src_row_size, ++cntr) {
-        row.set_zero();
+        row.fill_with_zeros();
         // Copy null_bitflag column valuefrom src_table.
         // The dest_column's null_bitfield flag is never set.
         row.insert(row_pointer, row_pointer + src_nulls_size, 0);
diff --git a/src/Utils/Table_Utils.hxx b/src/Utils/Table_Utils.hxx
index 42146742..f76b4c53 100644
--- a/src/Utils/Table_Utils.hxx
+++ b/src/Utils/Table_Utils.hxx
@@ -72,11 +72,6 @@ inline void append_row(std::vector<uint8_t> &data, const Row &row) {
     data.insert(data.end(), row.get_data().begin(), row.get_data().end());
 }
 
-inline void unsafe_append_row(std::vector<uint8_t> &data, const char *row,
-                              uint row_size) {
-    data.insert(data.end(), row, row + row_size);
-}
-
 inline void append_rows(std::vector<uint8_t> &data, const std::vector<uint8_t> &data2) {
     data.insert(data.end(), data2.begin(), data2.end());
 }
diff --git a/src/Utils/Table_Utils/insert_ascii_in_row.cxx b/src/Utils/Table_Utils/insert_ascii_in_row.cxx
index ff5033c6..c985521e 100644
--- a/src/Utils/Table_Utils/insert_ascii_in_row.cxx
+++ b/src/Utils/Table_Utils/insert_ascii_in_row.cxx
@@ -30,7 +30,7 @@ void insert_ascii_in_row(Row &row, const Data_Type &data_type, const size_t &arr
         switch (data_type) {
             case Data_Type::INT8_LE:
                 if (element == "?" || element == " " || element[0] == '\0') {
-                    row.set_null(data_type, array_size, column, offset, offset_end);
+                    row.insert_null(data_type, array_size, column, offset, offset_end);
                 } else {
                     bool result = (boost::iequals(element, "true") ||
                                    boost::iequals(element, "t") || element == "1");
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx
index 4882ed54..44f31c0d 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx
@@ -37,10 +37,10 @@ void ptree_readers::append_data_from_stream(std::vector<uint8_t> &data,
 
             bool dynamic_array_flag = fields[col_idx].get_dynamic_array_flag();
             if (is_null_MSB(stream, row_offset, col_idx)) {
-                row.set_null(col_type, col_array_size, col_idx, offsets[col_idx],
-                             offsets[col_idx + 1]);
+                row.insert_null(col_type, col_array_size, col_idx, offsets[col_idx],
+                                offsets[col_idx + 1]);
                 if (dynamic_array_flag) {
-				  src_pos += sizeof(uint32_t);
+                    src_pos += sizeof(uint32_t);
                 } else {
                     src_pos += data_size(col_type) * col_array_size;
                 }
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
index 03fa2a8e..6091136a 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
@@ -91,8 +91,8 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
             const auto &column = columns[col_idx];
             auto &element = element_list[col_idx - 1];
             if (element.empty()) {
-                row_string.set_null(column.get_type(), column.get_array_size(), col_idx,
-                                    offsets[col_idx], offsets[col_idx + 1]);
+                row_string.insert_null(column.get_type(), column.get_array_size(),
+                                       col_idx, offsets[col_idx], offsets[col_idx + 1]);
             } else
                 try {
                     insert_ascii_in_row(row_string, column.get_type(),
diff --git a/src/tablator/main.cxx b/src/tablator/main.cxx
index 55785c77..a87e6db3 100644
--- a/src/tablator/main.cxx
+++ b/src/tablator/main.cxx
@@ -106,7 +106,7 @@ void handle_extract_column(const boost::filesystem::path &input_path,
     boost::filesystem::ifstream input_stream(input_path);
     tablator::Table table(input_stream, input_format);
     boost::filesystem::ofstream output_stream(output_path);
-    auto column_id = table.column_index(column_name);
+    auto column_id = table.get_column_index(column_name);
     auto array_size = table.get_columns().at(column_id).get_array_size();
     auto num_rows = table.get_num_rows();
 

From 7231e849099fc188c6c60e4d620ddd8ffdace090 Mon Sep 17 00:00:00 2001
From: Judith Silverman <judith@ipac.caltech.edu>
Date: Sat, 21 Jun 2025 21:28:22 -0700
Subject: [PATCH 5/8] Move/rename Row-related functions

Null::insert_null() to Null::insert_null_internal()
Null::set_null.cxx to Null::insert_null.cxx
Table_Utils::insert_ascii_to_row() to Row::insert_from_ascii()
Table::retain_only_selected_rows() to Table::winnow_rows()
---
 src/Row.hxx                                   |  8 +++-
 .../insert_from_ascii.cxx}                    | 43 +++++++++----------
 src/Row/{set_null.cxx => insert_null.cxx}     | 20 ++++-----
 src/Table.hxx                                 |  5 +--
 src/Table/read_dsv/read_dsv_rows.cxx          | 16 ++++---
 src/Table/read_ipac_table/read_ipac_table.cxx | 17 ++++----
 src/Utils/Table_Utils.hxx                     | 14 ++----
 ...only_selected_rows.cxx => winnow_rows.cxx} |  2 +-
 .../read_tabledata/read_tabledata.cxx         | 14 +++---
 src/tablator/main.cxx                         | 24 +++++------
 test/convert.sh                               | 12 +++---
 wscript                                       |  6 +--
 12 files changed, 90 insertions(+), 91 deletions(-)
 rename src/{Utils/Table_Utils/insert_ascii_in_row.cxx => Row/insert_from_ascii.cxx} (69%)
 rename src/Row/{set_null.cxx => insert_null.cxx} (77%)
 rename src/Utils/Table_Utils/{retain_only_selected_rows.cxx => winnow_rows.cxx} (96%)

diff --git a/src/Row.hxx b/src/Row.hxx
index e662d513..2840c043 100644
--- a/src/Row.hxx
+++ b/src/Row.hxx
@@ -37,6 +37,12 @@ public:
                   data_.data() + offset_begin);
     }
 
+
+    void insert_from_ascii(const std::string &element, const Data_Type &data_type,
+                           const size_t &array_size, const size_t &column,
+                           const size_t &offset, const size_t &offset_end);
+
+
     size_t get_size() const { return data_.size(); }
 
     const std::vector<char> &get_data() const { return data_; }
@@ -44,7 +50,7 @@ public:
 
 private:
     template <typename T>
-    void insert_null(const size_t &offset) {
+    void insert_null_internal(const size_t &offset) {
         insert(tablator::get_null<T>(), offset);
     }
 
diff --git a/src/Utils/Table_Utils/insert_ascii_in_row.cxx b/src/Row/insert_from_ascii.cxx
similarity index 69%
rename from src/Utils/Table_Utils/insert_ascii_in_row.cxx
rename to src/Row/insert_from_ascii.cxx
index c985521e..45ed585a 100644
--- a/src/Utils/Table_Utils/insert_ascii_in_row.cxx
+++ b/src/Row/insert_from_ascii.cxx
@@ -3,13 +3,13 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/lexical_cast.hpp>
 
-#include "../../data_size.hxx"
-#include "../Table_Utils.hxx"
+#include "../Row.hxx"
+#include "../data_size.hxx"
 
 namespace tablator {
-void insert_ascii_in_row(Row &row, const Data_Type &data_type, const size_t &array_size,
-                         const size_t &column, const std::string &element,
-                         const size_t &offset, const size_t &offset_end) {
+void Row::insert_from_ascii(const std::string &element, const Data_Type &data_type,
+                            const size_t &array_size, const size_t &column,
+                            const size_t &offset, const size_t &offset_end) {
     if (array_size != 1 && data_type != Data_Type::CHAR) {
         std::vector<std::string> elements;
         boost::split(elements, element, boost::is_any_of(" "));
@@ -22,15 +22,15 @@ void insert_ascii_in_row(Row &row, const Data_Type &data_type, const size_t &arr
         auto element_offset = offset;
         auto element_size = data_size(data_type);
         for (auto &e : elements) {
-            insert_ascii_in_row(row, data_type, 1, column, e, element_offset,
-                                element_offset + element_size);
+            insert_from_ascii(e, data_type, 1, column, element_offset,
+                              element_offset + element_size);
             element_offset += element_size;
         }
     } else {
         switch (data_type) {
             case Data_Type::INT8_LE:
                 if (element == "?" || element == " " || element[0] == '\0') {
-                    row.insert_null(data_type, array_size, column, offset, offset_end);
+                    insert_null(data_type, array_size, column, offset, offset_end);
                 } else {
                     bool result = (boost::iequals(element, "true") ||
                                    boost::iequals(element, "t") || element == "1");
@@ -38,7 +38,7 @@ void insert_ascii_in_row(Row &row, const Data_Type &data_type, const size_t &arr
                                      boost::iequals(element, "f") || element == "0")) {
                         throw std::exception();
                     }
-                    row.insert(static_cast<uint8_t>(result), offset);
+                    insert(static_cast<uint8_t>(result), offset);
                 }
                 break;
             case Data_Type::UINT8_LE: {
@@ -47,55 +47,54 @@ void insert_ascii_in_row(Row &row, const Data_Type &data_type, const size_t &arr
                 if (result > std::numeric_limits<uint8_t>::max() ||
                     result < std::numeric_limits<uint8_t>::lowest())
                     throw std::exception();
-                row.insert(static_cast<uint8_t>(result), offset);
+                insert(static_cast<uint8_t>(result), offset);
             } break;
             case Data_Type::INT16_LE: {
                 int result = boost::lexical_cast<int>(element);
                 if (result > std::numeric_limits<int16_t>::max() ||
                     result < std::numeric_limits<int16_t>::lowest())
                     throw std::exception();
-                row.insert(static_cast<int16_t>(result), offset);
+                insert(static_cast<int16_t>(result), offset);
             } break;
             case Data_Type::UINT16_LE: {
                 int result = boost::lexical_cast<int>(element);
                 if (result > std::numeric_limits<uint16_t>::max() ||
                     result < std::numeric_limits<uint16_t>::lowest())
                     throw std::exception();
-                row.insert(static_cast<uint16_t>(result), offset);
+                insert(static_cast<uint16_t>(result), offset);
             } break;
             case Data_Type::INT32_LE: {
                 long result = boost::lexical_cast<long>(element);
                 if (result > std::numeric_limits<int32_t>::max() ||
                     result < std::numeric_limits<int32_t>::lowest())
                     throw std::exception();
-                row.insert(static_cast<int32_t>(result), offset);
+                insert(static_cast<int32_t>(result), offset);
             } break;
             case Data_Type::UINT32_LE: {
                 long result = boost::lexical_cast<long>(element);
                 if (result > std::numeric_limits<uint32_t>::max() ||
                     result < std::numeric_limits<uint32_t>::lowest())
                     throw std::exception();
-                row.insert(static_cast<uint32_t>(result), offset);
+                insert(static_cast<uint32_t>(result), offset);
             } break;
             case Data_Type::INT64_LE:
-                row.insert(boost::lexical_cast<int64_t>(element), offset);
+                insert(boost::lexical_cast<int64_t>(element), offset);
                 break;
             case Data_Type::UINT64_LE:
-                row.insert(boost::lexical_cast<uint64_t>(element), offset);
+                insert(boost::lexical_cast<uint64_t>(element), offset);
                 break;
             case Data_Type::FLOAT32_LE:
-                row.insert(boost::lexical_cast<float>(element), offset);
+                insert(boost::lexical_cast<float>(element), offset);
                 break;
             case Data_Type::FLOAT64_LE:
-                row.insert(boost::lexical_cast<double>(element), offset);
+                insert(boost::lexical_cast<double>(element), offset);
                 break;
             case Data_Type::CHAR:
-                row.insert(element, offset, offset_end);
+                insert(element, offset, offset_end);
                 break;
             default:
-                throw std::runtime_error(
-                        "Unknown data type in insert_ascii_in_row(): " +
-                        to_string(data_type));
+                throw std::runtime_error("Unknown data type in insert_from_ascii(): " +
+                                         to_string(data_type));
         }
     }
 }
diff --git a/src/Row/set_null.cxx b/src/Row/insert_null.cxx
similarity index 77%
rename from src/Row/set_null.cxx
rename to src/Row/insert_null.cxx
index 4d50eca1..2a5b1c53 100644
--- a/src/Row/set_null.cxx
+++ b/src/Row/insert_null.cxx
@@ -30,34 +30,34 @@ void tablator::Row::insert_null_by_type(const Data_Type &data_type,
                                         const size_t &offset) {
     switch (data_type) {
         case Data_Type::INT8_LE:
-            insert_null<int8_t>(offset);
+            insert_null_internal<int8_t>(offset);
             break;
         case Data_Type::UINT8_LE:
-            insert_null<uint8_t>(offset);
+            insert_null_internal<uint8_t>(offset);
             break;
         case Data_Type::INT16_LE:
-            insert_null<int16_t>(offset);
+            insert_null_internal<int16_t>(offset);
             break;
         case Data_Type::UINT16_LE:
-            insert_null<uint16_t>(offset);
+            insert_null_internal<uint16_t>(offset);
             break;
         case Data_Type::INT32_LE:
-            insert_null<int32_t>(offset);
+            insert_null_internal<int32_t>(offset);
             break;
         case Data_Type::UINT32_LE:
-            insert_null<uint32_t>(offset);
+            insert_null_internal<uint32_t>(offset);
             break;
         case Data_Type::INT64_LE:
-            insert_null<int64_t>(offset);
+            insert_null_internal<int64_t>(offset);
             break;
         case Data_Type::UINT64_LE:
-            insert_null<uint64_t>(offset);
+            insert_null_internal<uint64_t>(offset);
             break;
         case Data_Type::FLOAT32_LE:
-            insert_null<float>(offset);
+            insert_null_internal<float>(offset);
             break;
         case Data_Type::FLOAT64_LE:
-            insert_null<double>(offset);
+            insert_null_internal<double>(offset);
             break;
         case Data_Type::CHAR:
             insert('\0', offset);
diff --git a/src/Table.hxx b/src/Table.hxx
index adb257fe..ff2b0f8b 100644
--- a/src/Table.hxx
+++ b/src/Table.hxx
@@ -557,7 +557,6 @@ public:
 
 
     // inserters
-    // JTODO calls set_null()
     void insert_null_into_row(tablator::Row &row, size_t col_idx,
                               uint32_t array_size) const;
 
@@ -601,8 +600,8 @@ public:
                                         get_columns().at(col_idx).get_array_size());
     }
 
-    void retain_only_selected_rows(const std::set<size_t> &selected_row_idx_list) {
-        tablator::retain_only_selected_rows(get_data(), selected_row_idx_list,
+    void winnow_rows(const std::set<size_t> &selected_row_idx_list) {
+        tablator::winnow_rows(get_data(), selected_row_idx_list,
                                             get_num_rows(), get_row_size());
     }
 
diff --git a/src/Table/read_dsv/read_dsv_rows.cxx b/src/Table/read_dsv/read_dsv_rows.cxx
index 354059b3..2c510956 100644
--- a/src/Table/read_dsv/read_dsv_rows.cxx
+++ b/src/Table/read_dsv/read_dsv_rows.cxx
@@ -5,27 +5,29 @@ std::vector<uint8_t> tablator::Table::read_dsv_rows(
         const std::list<std::vector<std::string> > &dsv) {
     bool skipped(false);
 
-    Row row_string(tablator::get_row_size(offsets));
     std::vector<uint8_t> data;
+
+    Row single_row(tablator::get_row_size(offsets));
+
     for (auto &dsv_row : dsv) {
         if (!skipped) {
             skipped = true;
             continue;
         }
-        row_string.fill_with_zeros();
+        single_row.fill_with_zeros();
         for (size_t col_idx = 1; col_idx < columns.size(); ++col_idx) {
             const std::string &element(dsv_row[col_idx - 1]);
             if (element.empty() || element == "null") {
-                row_string.insert_null(columns[col_idx].get_type(),
+                single_row.insert_null(columns[col_idx].get_type(),
                                        columns[col_idx].get_array_size(), col_idx,
                                        offsets[col_idx], offsets[col_idx + 1]);
             } else {
-                insert_ascii_in_row(row_string, columns[col_idx].get_type(),
-                                    columns[col_idx].get_array_size(), col_idx, element,
-                                    offsets[col_idx], offsets[col_idx + 1]);
+                single_row.insert_from_ascii(element, columns[col_idx].get_type(),
+                                             columns[col_idx].get_array_size(), col_idx,
+                                             offsets[col_idx], offsets[col_idx + 1]);
             }
         }
-        tablator::append_row(data, row_string);
+        tablator::append_row(data, single_row);
     }
     return data;
 }
diff --git a/src/Table/read_ipac_table/read_ipac_table.cxx b/src/Table/read_ipac_table/read_ipac_table.cxx
index 5083b935..f51df72c 100644
--- a/src/Table/read_ipac_table/read_ipac_table.cxx
+++ b/src/Table/read_ipac_table/read_ipac_table.cxx
@@ -45,12 +45,13 @@ void tablator::Table::read_ipac_table(std::istream &input_stream) {
     std::vector<size_t> minimum_column_widths(num_tablator_columns, 1);
     std::string line;
     std::getline(input_stream, line);
-    Row row_string(tablator::get_row_size(offsets));
+
+    Row single_row(tablator::get_row_size(offsets));
 
     std::vector<uint8_t> data;
     while (input_stream) {
         if (line.find_first_not_of(" \t") != std::string::npos) {
-            row_string.fill_with_zeros();
+            single_row.fill_with_zeros();
             for (size_t col_idx = 1; col_idx < num_tablator_columns; ++col_idx) {
                 const auto &tab_column = tab_columns[col_idx];
                 if (line[ipac_column_offsets[col_idx - 1]] != ' ')
@@ -72,15 +73,15 @@ void tablator::Table::read_ipac_table(std::istream &input_stream) {
                      element == ipac_columns[COL_NULL_IDX][col_idx]) ||
                     (ipac_columns[COL_NULL_IDX][col_idx].empty() &&
                      tab_column.get_type() != Data_Type::CHAR && element.empty())) {
-                    row_string.insert_null(tab_column.get_type(),
+                    single_row.insert_null(tab_column.get_type(),
                                            tab_column.get_array_size(), col_idx,
                                            offsets[col_idx], offsets[col_idx + 1]);
                 } else {
                     try {
-                        insert_ascii_in_row(row_string, tab_column.get_type(),
-                                            tab_column.get_array_size(), col_idx,
-                                            element, offsets[col_idx],
-                                            offsets[col_idx + 1]);
+                        single_row.insert_from_ascii(element, tab_column.get_type(),
+                                                     tab_column.get_array_size(),
+                                                     col_idx, offsets[col_idx],
+                                                     offsets[col_idx + 1]);
                     } catch (std::exception &error) {
                         throw std::runtime_error(
                                 "Invalid " + to_string(tab_column.get_type()) +
@@ -99,7 +100,7 @@ void tablator::Table::read_ipac_table(std::istream &input_stream) {
                                          ": '" + line.substr(bad_char) +
                                          "'.\n\t  Is the header not wide enough?");
 
-            tablator::append_row(data, row_string);
+            tablator::append_row(data, single_row);
         }
         ++current_line_num;
         std::getline(input_stream, line);
diff --git a/src/Utils/Table_Utils.hxx b/src/Utils/Table_Utils.hxx
index f76b4c53..f298d033 100644
--- a/src/Utils/Table_Utils.hxx
+++ b/src/Utils/Table_Utils.hxx
@@ -87,15 +87,7 @@ inline void reserve_data(std::vector<uint8_t> &data, const size_t &new_num_rows,
     data.reserve(new_num_rows * row_size);
 }
 
-
-void insert_ascii_in_row(Row &row, const Data_Type &data_type, const size_t &array_size,
-                         const size_t &column, const std::string &element,
-                         const size_t &offset, const size_t &offset_end);
-
-
-void retain_only_selected_rows(std::vector<uint8_t> &data,
-                               const std::set<size_t> &selected_row_idx_list,
-                               size_t num_rows, size_t row_size);
-
-
+void winnow_rows(std::vector<uint8_t> &data,
+				 const std::set<size_t> &selected_row_idx_list,
+				 size_t num_rows, size_t row_size);
 }  // namespace tablator
diff --git a/src/Utils/Table_Utils/retain_only_selected_rows.cxx b/src/Utils/Table_Utils/winnow_rows.cxx
similarity index 96%
rename from src/Utils/Table_Utils/retain_only_selected_rows.cxx
rename to src/Utils/Table_Utils/winnow_rows.cxx
index 7c7f5c8f..543ae55e 100644
--- a/src/Utils/Table_Utils/retain_only_selected_rows.cxx
+++ b/src/Utils/Table_Utils/winnow_rows.cxx
@@ -1,6 +1,6 @@
 #include "../Table_Utils.hxx"
 
-void tablator::retain_only_selected_rows(std::vector<uint8_t> &data,
+void tablator::winnow_rows(std::vector<uint8_t> &data,
                                          const std::set<size_t> &selected_row_idx_list,
                                          size_t num_rows, size_t row_size) {
     if (data.size() != num_rows * row_size) {
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
index 6091136a..fa83a4df 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
@@ -80,24 +80,24 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
                       field.get_dynamic_array_flag());
     }
 
-    Row row_string(*offsets.rbegin());
+    Row single_row(*offsets.rbegin());
 
     // JTODO Are we allowing for non-CHAR dynamic arrays?  Should all arrays end in
     // '\0'?
     for (size_t row_idx = 0; row_idx < element_lists_by_row.size(); ++row_idx) {
         auto &element_list = element_lists_by_row[row_idx];
-        row_string.fill_with_zeros();
+        single_row.fill_with_zeros();
         for (size_t col_idx = 1; col_idx < num_fields; ++col_idx) {
             const auto &column = columns[col_idx];
             auto &element = element_list[col_idx - 1];
             if (element.empty()) {
-                row_string.insert_null(column.get_type(), column.get_array_size(),
+                single_row.insert_null(column.get_type(), column.get_array_size(),
                                        col_idx, offsets[col_idx], offsets[col_idx + 1]);
             } else
                 try {
-                    insert_ascii_in_row(row_string, column.get_type(),
-                                        column.get_array_size(), col_idx, element,
-                                        offsets[col_idx], offsets[col_idx + 1]);
+                    single_row.insert_from_ascii(
+                            element, column.get_type(), column.get_array_size(),
+                            col_idx, offsets[col_idx], offsets[col_idx + 1]);
                 } catch (std::exception &error) {
                     throw std::runtime_error(
                             "Invalid " + to_string(fields[col_idx].get_type()) +
@@ -108,7 +108,7 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
                             ". Error message: " + error.what());
                 }
         }
-        append_row(data, row_string);
+        append_row(data, single_row);
     }
     return Data_Element(columns, offsets, data);
 }
diff --git a/src/tablator/main.cxx b/src/tablator/main.cxx
index a87e6db3..62a684c8 100644
--- a/src/tablator/main.cxx
+++ b/src/tablator/main.cxx
@@ -244,10 +244,10 @@ int main(int argc, char *argv[]) {
     size_t row_id = SIZE_T_MAX;
     size_t start_row = SIZE_T_MAX;
     size_t row_count = SIZE_T_MAX;
-    std::vector<size_t> row_list;      // for writing ipac_table
-    std::set<size_t> retain_row_list;  // for modifying table in place
+    std::vector<size_t> row_list;       // for writing ipac_table
+    std::set<size_t> winnow_rows_list;  // for modifying table in place
     std::string row_string;
-    std::string retain_row_string;
+    std::string winnow_rows_string;
     bool call_static_f = false;
     bool exclude_cols_f = false;
     bool skip_comments_f = false;
@@ -301,8 +301,8 @@ int main(int argc, char *argv[]) {
             "number of consecutive rows to write (output-format ipac_table only)")(
             "row-list", boost::program_options::value<std::string>(&row_string),
             "list of rows to write (output-format ipac_table only)")(
-            "retain-row-list",
-            boost::program_options::value<std::string>(&retain_row_string),
+            "winnow-rows-list",
+            boost::program_options::value<std::string>(&winnow_rows_string),
             "list of rows to retain, dropping others")(
             "static", boost::program_options::value<bool>(&call_static_f),
             "call static function, not Table class member")(
@@ -407,17 +407,17 @@ int main(int argc, char *argv[]) {
                       std::istream_iterator<size_t>(), std::back_inserter(row_list));
         }
 
-        if (option_variables.count("retain-row-list")) {
+        if (option_variables.count("winnow-rows-list")) {
             if (option_variables.count("row-list")) {
-                std::cerr << "The parameters 'row-list' and 'retain-row-list' are "
+                std::cerr << "The parameters 'row-list' and 'winnow-rows-list' are "
                              "mutually "
                              "incompatible.\n";
                 return 1;
             }
-            std::stringstream retain_row_stream(retain_row_string);
-            std::copy(std::istream_iterator<size_t>(retain_row_stream),
+            std::stringstream winnow_rows_stream(winnow_rows_string);
+            std::copy(std::istream_iterator<size_t>(winnow_rows_stream),
                       std::istream_iterator<size_t>(),
-                      std::inserter(retain_row_list, retain_row_list.begin()));
+                      std::inserter(winnow_rows_list, winnow_rows_list.begin()));
         }
 
         if (!option_variables.count("column-to-extract") &&
@@ -668,11 +668,11 @@ int main(int argc, char *argv[]) {
             boost::filesystem::ofstream output_stream(output_path);
             in_table1.write(output_stream, output_path.stem().native(), output_format,
                             options);
-        } else if (!retain_row_list.empty()) {
+        } else if (!winnow_rows_list.empty()) {
             // JTODO make this option incompatible with other options
             boost::filesystem::ifstream input_stream(input_path);
             tablator::Table in_table(input_stream, input_format);
-            in_table.retain_only_selected_rows(retain_row_list);
+            in_table.winnow_rows(winnow_rows_list);
             boost::filesystem::ofstream output_stream(output_path);
             in_table.write(output_stream, output_path.stem().native(), output_format,
                            options);
diff --git a/test/convert.sh b/test/convert.sh
index e7f19616..7bfdd3b7 100644
--- a/test/convert.sh
+++ b/test/convert.sh
@@ -182,11 +182,11 @@ else
     rm -f temp.json5
 fi
 
-${tablator_bin} --retain-row-list "1 4" test/multi temp.vot 2> /dev/null
+${tablator_bin} --winnow-rows-list "1 4" test/multi temp.vot 2> /dev/null
 if [ $? -eq 0 ]; then
-    echo "FAIL: invalid argument to retain-row-list"
+    echo "FAIL: invalid argument to winnow-rows-list"
 else
-    echo "PASS: invalid argument to retain-row-list"
+    echo "PASS: invalid argument to winnow-rows-list"
     rm -f temp.tbl
 fi
 
@@ -1426,10 +1426,10 @@ else
     echo "FAIL: append json5 table"
 fi
 
-${tablator_bin} --retain-row-list "1 2 3" test/multi_formatted.tbl temp.tbl && diff test/back_and_forth_tables/multi_row_123.tbl temp.tbl
+${tablator_bin} --winnow-rows-list "1 2 3" test/multi_formatted.tbl temp.tbl && diff test/back_and_forth_tables/multi_row_123.tbl temp.tbl
 if [ $? -eq 0 ]; then
-    echo "PASS: retain rows"
+    echo "PASS: winnow rows"
     rm -f temp.json5
 else
-    echo "FAIL: retain rows"
+    echo "FAIL: winnow rows"
 fi
diff --git a/wscript b/wscript
index e200bcb7..1b39bb2c 100644
--- a/wscript
+++ b/wscript
@@ -23,7 +23,8 @@ def build(bld):
              'src/Data_Type_Adjuster.cxx',
              'src/Format/set_from_extension.cxx',
              'src/Format/content_type.cxx',
-             'src/Row/set_null.cxx',
+             'src/Row/insert_null.cxx',
+             'src/Row/insert_from_ascii.cxx',
              'src/H5_to_Data_Type.cxx',
              'src/quote_sql_string.cxx',
              'src/Table/Table.cxx',
@@ -69,9 +70,8 @@ def build(bld):
              'src/Table_Ops.cxx',
              'src/Ipac_Table_Writer/internals.cxx',
              'src/Ipac_Table_Writer/Ipac_Table_Writer.cxx',
-             'src/Utils/Table_Utils/insert_ascii_in_row.cxx',
              'src/Utils/Table_Utils/append_column.cxx',
-             'src/Utils/Table_Utils/retain_only_selected_rows.cxx',
+             'src/Utils/Table_Utils/winnow_rows.cxx',
              'src/ptree_readers/ptree_readers.cxx',
              'src/ptree_readers/Utils.cxx',
              'src/ptree_readers/extract_attributes.cxx',

From f0e6852f79800a8bc354fe7c5581f3a8c8401e0f Mon Sep 17 00:00:00 2001
From: Judith Silverman <judith@ipac.caltech.edu>
Date: Thu, 3 Jul 2025 16:22:53 -0700
Subject: [PATCH 6/8] Consistently call reserve() before append_row()

---
 src/Table/Table.cxx                                      | 3 +--
 src/Table/read_dsv/read_dsv_rows.cxx                     | 5 +++--
 src/Table/read_ipac_table/read_ipac_table.cxx            | 2 +-
 src/Table_Ops.cxx                                        | 8 +++++---
 .../read_data_element/read_binary2/read_binary2.cxx      | 6 ++++++
 .../read_data_element/read_tabledata/read_tabledata.cxx  | 9 ++++++---
 6 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/src/Table/Table.cxx b/src/Table/Table.cxx
index 6cbfe2f5..3884219b 100644
--- a/src/Table/Table.cxx
+++ b/src/Table/Table.cxx
@@ -65,7 +65,6 @@ void Table::append_rows(const Table &table2) {
     const auto &offsets = get_offsets();
     const auto &table2_offsets = table2.get_offsets();
 
-
     for (size_t col_idx = 0; col_idx < num_columns; ++col_idx) {
         const auto &column = columns.at(col_idx);
         const auto &table2_column = table2_columns.at(col_idx);
@@ -89,7 +88,7 @@ void Table::append_rows(const Table &table2) {
             }
         }
     }
-
+	get_data().reserve(get_data().size() + table2.get_data().size());
     tablator::append_rows(get_data(), table2.get_data());
 }
 
diff --git a/src/Table/read_dsv/read_dsv_rows.cxx b/src/Table/read_dsv/read_dsv_rows.cxx
index 2c510956..72d685b9 100644
--- a/src/Table/read_dsv/read_dsv_rows.cxx
+++ b/src/Table/read_dsv/read_dsv_rows.cxx
@@ -5,9 +5,10 @@ std::vector<uint8_t> tablator::Table::read_dsv_rows(
         const std::list<std::vector<std::string> > &dsv) {
     bool skipped(false);
 
+	size_t row_size = tablator::get_row_size(offsets);
+    Row single_row(row_size);
     std::vector<uint8_t> data;
-
-    Row single_row(tablator::get_row_size(offsets));
+	data.reserve(row_size * dsv.size());
 
     for (auto &dsv_row : dsv) {
         if (!skipped) {
diff --git a/src/Table/read_ipac_table/read_ipac_table.cxx b/src/Table/read_ipac_table/read_ipac_table.cxx
index f51df72c..67be0523 100644
--- a/src/Table/read_ipac_table/read_ipac_table.cxx
+++ b/src/Table/read_ipac_table/read_ipac_table.cxx
@@ -45,10 +45,10 @@ void tablator::Table::read_ipac_table(std::istream &input_stream) {
     std::vector<size_t> minimum_column_widths(num_tablator_columns, 1);
     std::string line;
     std::getline(input_stream, line);
-
     Row single_row(tablator::get_row_size(offsets));
 
     std::vector<uint8_t> data;
+	// JTODO reserve()?
     while (input_stream) {
         if (line.find_first_not_of(" \t") != std::string::npos) {
             single_row.fill_with_zeros();
diff --git a/src/Table_Ops.cxx b/src/Table_Ops.cxx
index eb20e842..fccc806b 100644
--- a/src/Table_Ops.cxx
+++ b/src/Table_Ops.cxx
@@ -32,12 +32,14 @@ Table add_counter_column(const Table &src_table, const std::string &col_name) {
 
 
     size_t src_nulls_size(src_offsets.at(1));
-    size_t dest_nulls_size(dest_offsets.at(1));
     size_t src_row_size = src_table.get_row_size();
-    size_t dest_row_size = dest_table.get_row_size();
-
+	size_t num_rows = src_table.get_num_rows();
     const auto &src_data = src_table.get_data();
 
+    size_t dest_nulls_size(dest_offsets.at(1));
+    size_t dest_row_size = dest_table.get_row_size();
+	dest_table.reserve_data(num_rows);
+
     tablator::Row row(dest_row_size);
     uint64_t cntr(1);
 
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx
index e965e58f..33d9ffcc 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx
@@ -53,10 +53,12 @@ Data_Element ptree_readers::read_binary2(const boost::property_tree::ptree &bina
     }
 
     std::vector<size_t> rows_per_stream;
+	size_t total_num_rows = 0;
     for (auto &stream : streams) {
         size_t num_rows;
         compute_column_array_sizes(stream, fields, column_array_sizes, num_rows);
         rows_per_stream.push_back(num_rows);
+		total_num_rows += num_rows;
     }
 
     std::vector<Column> columns;
@@ -69,6 +71,10 @@ Data_Element ptree_readers::read_binary2(const boost::property_tree::ptree &bina
                       column_array_sizes[c], field.get_field_properties(),
                       field.get_dynamic_array_flag());
     }
+
+	size_t row_size = *offsets.rbegin();
+	data.reserve(row_size * total_num_rows);
+
     for (std::size_t stream = 0; stream < streams.size(); ++stream) {
         append_data_from_stream(data, columns, offsets, streams[stream], fields,
                                 rows_per_stream[stream]);
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
index fa83a4df..d795052a 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
@@ -71,7 +71,6 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
 
     std::vector<Column> columns;
     std::vector<size_t> offsets = {0};
-    std::vector<uint8_t> data;
 
     for (std::size_t c = 0; c < num_fields; ++c) {
         const auto &field = fields.at(c);
@@ -80,11 +79,15 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
                       field.get_dynamic_array_flag());
     }
 
-    Row single_row(*offsets.rbegin());
+	size_t row_size = *offsets.rbegin();
+	size_t num_rows = element_lists_by_row.size();
+    std::vector<uint8_t> data;
+	data.reserve(row_size * num_rows);
 
+    Row single_row(row_size);
     // JTODO Are we allowing for non-CHAR dynamic arrays?  Should all arrays end in
     // '\0'?
-    for (size_t row_idx = 0; row_idx < element_lists_by_row.size(); ++row_idx) {
+    for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {
         auto &element_list = element_lists_by_row[row_idx];
         single_row.fill_with_zeros();
         for (size_t col_idx = 1; col_idx < num_fields; ++col_idx) {

From 015594d13a8f49133688061881cb17882cffae43 Mon Sep 17 00:00:00 2001
From: Judith Silverman <judith@ipac.caltech.edu>
Date: Fri, 27 Jun 2025 09:00:12 -0700
Subject: [PATCH 7/8] Add Field_Framework class

---
 src/Data_Element.hxx                          |  58 +++++--
 src/Field_Framework.hxx                       |  96 +++++++++++
 src/Resource_Element.hxx                      |  24 ++-
 src/Table.hxx                                 | 150 +++++-------------
 src/Table/Table.cxx                           | 129 +++++++--------
 src/Table/read_dsv/read_dsv.cxx               |  11 +-
 src/Table/read_dsv/read_dsv_rows.cxx          |  14 +-
 .../set_column_info/set_column_info.cxx       |  23 +--
 src/Table/read_fits.cxx                       | 120 ++++++--------
 src/Table/read_hdf5/read_hdf5.cxx             |  26 +--
 .../append_ipac_data_member.cxx               |  40 ++---
 .../create_types_from_ipac_headers.cxx        |  29 ++--
 src/Table/read_ipac_table/read_ipac_table.cxx |  29 ++--
 .../shrink_ipac_string_columns_to_fit.cxx     |  11 +-
 src/Table_Element.hxx                         |  32 +++-
 src/Utils/Table_Utils.hxx                     |  73 +--------
 src/Utils/Table_Utils/append_column.cxx       |   8 +-
 src/ptree_readers.hxx                         |   4 +-
 .../append_data_from_stream.cxx               |   8 +-
 .../read_binary2/read_binary2.cxx             |  29 ++--
 .../read_tabledata/read_tabledata.cxx         |  22 +--
 test/back_and_forth_tables/fits_medium.vot    |  24 +--
 test/fits_medium.fits                         |  34 ++--
 23 files changed, 517 insertions(+), 477 deletions(-)
 create mode 100644 src/Field_Framework.hxx

diff --git a/src/Data_Element.hxx b/src/Data_Element.hxx
index 21c85a46..c23d04ca 100644
--- a/src/Data_Element.hxx
+++ b/src/Data_Element.hxx
@@ -1,36 +1,68 @@
 #pragma once
 
-#include <boost/property_tree/ptree.hpp>
-#include <boost/property_tree/xml_parser.hpp>
-
 #include "Column.hxx"
-
-// JTODO: Create struct to hold commonly used (columns, offsets) pair?
+#include "Field_Framework.hxx"
 
 namespace tablator {
 
 class Data_Element {
 public:
-    Data_Element(const std::vector<Column> &columns, const std::vector<size_t> &offsets,
+    Data_Element(const Field_Framework &field_framework,
                  const std::vector<uint8_t> &data)
-            : columns_(columns), offsets_(offsets), data_(data) {}
+            : field_framework_(field_framework), data_(data) {}
+
+    Data_Element(const Field_Framework &field_framework)
+            : Data_Element(field_framework, std::vector<uint8_t>()) {}
+
 
     // accessors
-    inline const std::vector<Column> &get_columns() const { return columns_; }
-    inline std::vector<Column> &get_columns() { return columns_; }
+    const Field_Framework &get_field_framework() const { return field_framework_; }
+
+    Field_Framework &get_field_framework() { return field_framework_; }
+
+
+    inline const std::vector<Column> &get_columns() const {
+        return field_framework_.get_columns();
+    }
 
-    inline const std::vector<size_t> &get_offsets() const { return offsets_; }
-    inline std::vector<size_t> &get_offsets() { return offsets_; }
+    // Non-const to allow query_server to modify field_properties.
+    inline std::vector<Column> &get_columns() { return field_framework_.get_columns(); }
+
+    inline const std::vector<size_t> &get_offsets() const {
+        return field_framework_.get_offsets();
+    }
+
+    size_t get_row_size() const { return field_framework_.get_row_size(); }
+
+    size_t get_num_rows() const {
+        if (get_row_size() == 0) {
+            return 0;
+        }
+        return data_.size() / get_row_size();
+    }
+
+    // called by query_server to trim result set
+    void resize_data(size_t &new_num_rows) {
+        data_.resize(get_row_size() * new_num_rows);
+    }
+
+    void reserve_data(size_t &new_num_rows) {
+        data_.reserve(get_row_size() * new_num_rows);
+    }
 
 
     inline const std::vector<uint8_t> &get_data() const { return data_; }
+
+    // Non-const to support append_rows().
     inline std::vector<uint8_t> &get_data() { return data_; }
 
     inline void set_data(const std::vector<uint8_t> &d) { data_ = d; }
 
 private:
-    std::vector<Column> columns_;
-    std::vector<size_t> offsets_ = {0};
+    // Non-const to allow query_server to update column's field_properties.
+    Field_Framework field_framework_;
+
+    // Non-const because of append_rows().
     std::vector<uint8_t> data_;
 };
 
diff --git a/src/Field_Framework.hxx b/src/Field_Framework.hxx
new file mode 100644
index 00000000..b112fd11
--- /dev/null
+++ b/src/Field_Framework.hxx
@@ -0,0 +1,96 @@
+#pragma once
+
+#include "Column.hxx"
+#include "Utils/Null_Utils.hxx"
+
+namespace tablator {
+
+class Field_Framework {
+public:
+    Field_Framework(const std::vector<Column> &incoming_columns,
+                    bool got_null_bitfields_column = false)
+            : offsets_({0}) {
+        if ((got_null_bitfields_column && incoming_columns.size() == 1) ||
+            incoming_columns.empty()) {
+            throw std::runtime_error(
+                    "Field_Framework constructor: <visible_columns> must be "
+                    "non-empty.");
+        }
+        // JTODO avoid copies
+        if (!got_null_bitfields_column) {
+            const size_t null_flags_size = bits_to_bytes(incoming_columns.size() + 1);
+            append_column(null_bitfield_flags_name, Data_Type::UINT8_LE,
+                          null_flags_size,
+                          Field_Properties::Builder()
+                                  .add_description(null_bitfield_flags_description)
+                                  .build());
+        }
+
+        for (auto &col : incoming_columns) {
+            append_column(col);
+        }
+    }
+
+    // accessors
+
+    inline size_t get_row_size() const {
+        if (offsets_.empty()) {
+            throw std::runtime_error("<offsets> is empty");
+        }
+        return offsets_.back();
+    }
+
+    inline const std::vector<Column> &get_columns() const { return columns_; }
+    inline std::vector<Column> &get_columns() { return columns_; }
+
+    inline const std::vector<size_t> &get_offsets() const { return offsets_; }
+    inline std::vector<size_t> &get_offsets() { return offsets_; }
+
+
+private:
+    void append_column(const Column &column) {
+        columns_.emplace_back(column);
+        size_t old_row_size = *offsets_.rbegin();
+        size_t new_row_size = old_row_size + columns_.rbegin()->get_data_size();
+        offsets_.push_back(new_row_size);
+    }
+
+    inline void append_column(const std::string &name, const Data_Type &type,
+                              const size_t &array_size,
+                              const Field_Properties &field_properties,
+                              bool dynamic_array_flag) {
+        append_column(
+                Column(name, type, array_size, field_properties, dynamic_array_flag));
+    }
+
+    inline void append_column(const std::string &name, const Data_Type &type,
+                              const size_t &array_size,
+                              const Field_Properties &field_properties) {
+        append_column(Column(name, type, array_size, field_properties));
+    }
+
+    inline void append_column(const std::string &name, const Data_Type &type,
+                              const size_t &array_size, bool dynamic_array_flag) {
+        append_column(Column(name, type, array_size, dynamic_array_flag));
+    }
+
+    inline void append_column(const std::string &name, const Data_Type &type,
+                              const size_t &size) {
+        append_column(Column(name, type, size));
+    }
+
+    inline void append_column(const std::string &name, const Data_Type &type,
+                              const Field_Properties &field_properties) {
+        append_column(Column(name, type, field_properties));
+    }
+
+
+    inline void append_column(const std::string &name, const Data_Type &type) {
+        append_column(Column(name, type));
+    }
+
+    std::vector<Column> columns_;
+    std::vector<size_t> offsets_;
+};
+
+}  // namespace tablator
diff --git a/src/Resource_Element.hxx b/src/Resource_Element.hxx
index 159c1b99..f6ce8472 100644
--- a/src/Resource_Element.hxx
+++ b/src/Resource_Element.hxx
@@ -373,9 +373,18 @@ public:
         return get_table_elements().at(MAIN_TABLE_ELEMENT_IDX);
     }
 
+    const Field_Framework &get_field_framework() const {
+        return get_main_table_element().get_field_framework();
+    }
+
+    Field_Framework &get_field_framework() {
+        return get_main_table_element().get_field_framework();
+    }
+
     const std::vector<Column> &get_columns() const {
         return get_main_table_element().get_columns();
     }
+
     std::vector<Column> &get_columns() {
         return get_main_table_element().get_columns();
     }
@@ -383,13 +392,24 @@ public:
     const std::vector<size_t> &get_offsets() const {
         return get_main_table_element().get_offsets();
     }
-    std::vector<size_t> &get_offsets() {
-        return get_main_table_element().get_offsets();
+
+    size_t get_row_size() const { return get_main_table_element().get_row_size(); }
+    size_t get_num_rows() const { return get_main_table_element().get_num_rows(); }
+
+    // called by query_server to trim result set
+    void resize_data(size_t &new_num_rows) {
+        get_main_table_element().resize_data(new_num_rows);
+    }
+
+    // called by query_server to trim result set
+    void reserve_data(size_t &new_num_rows) {
+        get_main_table_element().reserve_data(new_num_rows);
     }
 
     std::vector<Field> &get_table_element_params() {
         return get_main_table_element().get_params();
     }
+
     const std::vector<Field> &get_table_element_params() const {
         return get_main_table_element().get_params();
     }
diff --git a/src/Table.hxx b/src/Table.hxx
index ff2b0f8b..281e31a3 100644
--- a/src/Table.hxx
+++ b/src/Table.hxx
@@ -195,12 +195,17 @@ public:
 
     // constructors
     Table(const std::vector<Column> &Columns,
-          const std::map<std::string, std::string> &property_map);
+          const std::map<std::string, std::string> &property_map,
+          bool got_null_bitfields_column = false);
 
     Table(const std::vector<Column> &Columns,
-          const tablator::Labeled_Properties &property_pair_vec);
-    Table(const std::vector<Column> &Columns)
-            : Table(Columns, std::map<std::string, std::string>()) {}
+          const tablator::Labeled_Properties &property_pair_vec,
+          bool got_null_bitfields_column = false);
+
+    Table(const std::vector<Column> &Columns, bool got_null_bitfields_column = false)
+            : Table(Columns, std::map<std::string, std::string>(),
+                    got_null_bitfields_column) {}
+
 
     Table(const boost::filesystem::path &input_path, const Format &format);
     Table(const boost::filesystem::path &input_path) { read_unknown(input_path); }
@@ -293,7 +298,7 @@ public:
     // table modifiers
 
     void append_row(const Row &row) {
-	  assert(row.get_data().size() == get_row_size());
+        assert(row.get_data().size() == get_row_size());
         tablator::append_row(get_data(), row);
     }
 
@@ -607,26 +612,6 @@ public:
 
     // accessors
 
-    size_t get_row_size() const { return tablator::get_row_size(get_offsets()); }
-    size_t get_num_rows() const {
-        return tablator::get_num_rows(get_offsets(), get_data());
-    }
-    size_t get_num_columns() const { return get_columns().size(); }
-
-    // called by query_server to trim result set
-    void adjust_num_rows(const size_t &new_num_rows) {
-        tablator::adjust_num_rows(get_data(), new_num_rows, get_row_size());
-    }
-
-    // deprecated
-    inline void resize_rows(const size_t &new_num_rows) {
-        adjust_num_rows(new_num_rows);
-    }
-    size_t row_size() const { return get_row_size(); }
-    size_t num_rows() const { return get_num_rows(); }
-
-    //===========================================================
-
     // getters for Optional elements
 
     ATTRIBUTES &get_attributes() { return options_.attributes_; }
@@ -687,6 +672,25 @@ public:
         return get_resource_elements().at(get_results_resource_idx());
     }
 
+    Field_Framework &get_field_framework() {
+        return get_results_resource_element().get_field_framework();
+    }
+
+    const Field_Framework &get_field_framework() const {
+        return get_results_resource_element().get_field_framework();
+    }
+
+    // called by query_server to trim result set
+    void resize_data(size_t &new_num_rows) {
+        get_results_resource_element().resize_data(new_num_rows);
+    }
+
+    // called by query_server to trim result set
+    void reserve_data(size_t &new_num_rows) {
+        get_results_resource_element().reserve_data(new_num_rows);
+    }
+
+    // Non-const to allow query_server to modify Field_Properties.
     std::vector<Column> &get_columns() {
         return get_results_resource_element().get_columns();
     }
@@ -694,14 +698,20 @@ public:
         return get_results_resource_element().get_columns();
     }
 
-    std::vector<size_t> &get_offsets() {
-        return get_results_resource_element().get_offsets();
-    }
+    size_t get_num_columns() const { return get_columns().size(); }
 
     const std::vector<size_t> &get_offsets() const {
         return get_results_resource_element().get_offsets();
     }
 
+    size_t get_row_size() const {
+        return get_results_resource_element().get_row_size();
+    }
+    size_t get_num_rows() const {
+        return get_results_resource_element().get_num_rows();
+    }
+
+
     Labeled_Properties &get_resource_element_labeled_properties() {
         return get_results_resource_element().get_labeled_properties();
     }
@@ -728,6 +738,7 @@ public:
         return get_results_resource_element().get_table_element_fields();
     }
 
+    // Non-const to support append_row().
     std::vector<uint8_t> &get_data() {
         return get_results_resource_element().get_data();
     }
@@ -917,15 +928,6 @@ private:
         }
     }
 
-    void read_dsv_rows(const std::list<std::vector<std::string>> &dsv) {
-        set_data(read_dsv_rows(get_columns(), get_offsets(), dsv));
-    }
-
-    void set_column_info(std::list<std::vector<std::string>> &dsv) {
-        set_column_info(get_columns(), get_offsets(), dsv);
-    };
-
-
     std::vector<size_t> get_column_widths(const Command_Line_Options &options) const {
         return Ipac_Table_Writer::get_column_widths(*this, options);
     }
@@ -970,97 +972,33 @@ private:
                 options);
     }
 
-
-    void reserve_data(const size_t &new_num_rows) {
-        tablator::reserve_data(get_data(), new_num_rows, get_row_size());
-    }
-
     // helpers for reading
 
-    // WARNING: The private append_column() routines do not increase
-    // the size of the null column.  The expectation is that the
-    // number of columns is known before adding columns.
-    void append_column(const std::string &name, const Data_Type &type,
-                       const size_t &size, const Field_Properties &field_properties,
-                       bool dynamic_array_flag) {
-        append_column(Column(name, type, size, field_properties, dynamic_array_flag));
-    }
-
-    void append_column(const std::string &name, const Data_Type &type,
-                       const size_t &size, bool dynamic_array_flag) {
-        append_column(Column(name, type, size, dynamic_array_flag));
-    }
-
-    void append_column(const std::string &name, const Data_Type &type,
-                       const size_t &size, const Field_Properties &field_properties) {
-        append_column(Column(name, type, size, field_properties));
-    }
-
-    void append_column(const std::string &name, const Data_Type &type,
-                       const size_t &size) {
-        append_column(name, type, size);
-    }
-
-    void append_column(const std::string &name, const Data_Type &type) {
-        append_column(name, type);
-    }
-
-    void append_column(const Column &column) {
-        tablator::append_column(get_columns(), get_offsets(), column);
-    }
-
     size_t read_ipac_header(std::istream &ipac_file,
                             std::array<std::vector<std::string>, 4> &Columns,
                             std::vector<size_t> &ipac_table_offsets,
                             Labeled_Properties &labeled_resource_properties);
 
-    void create_types_from_ipac_headers(
-            std::array<std::vector<std::string>, 4> &Columns,
-            const std::vector<size_t> &ipac_column_widths) {
-        create_types_from_ipac_headers(get_columns(), get_offsets(), Columns,
-                                       ipac_column_widths);
-    }
-
-    void append_ipac_data_member(const std::string &name, const std::string &data_type,
-                                 const size_t &size) {
-        append_ipac_data_member(get_columns(), get_offsets(), name, data_type, size);
-    }
-
-    void shrink_ipac_string_columns_to_fit(const std::vector<size_t> &column_widths) {
-        shrink_ipac_string_columns_to_fit(get_columns(), get_offsets(), get_data(),
-                                          column_widths);
-    };
-
-
     static void append_ipac_data_member(std::vector<Column> &columns,
-                                        std::vector<size_t> &offsets,
                                         const std::string &name,
                                         const std::string &data_type,
                                         const size_t &size);
 
-    static void create_types_from_ipac_headers(
-            std::vector<Column> &columns, std::vector<size_t> &offsets,
+    static Field_Framework create_types_from_ipac_headers(
             const std::array<std::vector<std::string>, 4> &ipac_columns,
             const std::vector<size_t> &ipac_column_widths);
 
     static void shrink_ipac_string_columns_to_fit(
-            std::vector<Column> &columns, std::vector<size_t> &offsets,
-            std::vector<uint8_t> &data, const std::vector<size_t> &column_widths);
-
-
-    // miscellaneous helpers for reading
-
+            Field_Framework &field_framework, std::vector<uint8_t> &data,
+            const std::vector<size_t> &column_widths);
 
     static std::vector<uint8_t> read_dsv_rows(
-            std::vector<Column> &columns, std::vector<size_t> &offsets,
+            Field_Framework &field_framework,
             const std::list<std::vector<std::string>> &dsv);
 
 
     // used only for read_dsv()?
-    static void set_column_info(std::vector<Column> &columns,
-                                std::vector<size_t> &offsets,
-                                std::list<std::vector<std::string>> &dsv);
-
+    static Field_Framework set_column_info(std::list<std::vector<std::string>> &dsv);
 
     Table(const std::vector<Resource_Element> &resource_elements,
           const Options &options)
diff --git a/src/Table/Table.cxx b/src/Table/Table.cxx
index 3884219b..b20f8950 100644
--- a/src/Table/Table.cxx
+++ b/src/Table/Table.cxx
@@ -53,75 +53,16 @@ void append_column_attributes_with_label(
 
 namespace tablator {
 
-void Table::append_rows(const Table &table2) {
-    assert(table2.get_row_size() == get_row_size());
-
-    size_t num_columns = get_num_columns();
-    assert(table2.get_num_columns() == num_columns);
-
-    const auto &columns = get_columns();
-    const auto &table2_columns = table2.get_columns();
-
-    const auto &offsets = get_offsets();
-    const auto &table2_offsets = table2.get_offsets();
-
-    for (size_t col_idx = 0; col_idx < num_columns; ++col_idx) {
-        const auto &column = columns.at(col_idx);
-        const auto &table2_column = table2_columns.at(col_idx);
-        if (column.get_name() != table2_column.get_name()) {
-            throw std::runtime_error("Column names differ at index " +
-                                     std::to_string(col_idx));
-        }
-        if (column.get_type() != table2_column.get_type()) {
-            throw std::runtime_error("Column types differ at index " +
-                                     std::to_string(col_idx));
-        }
-
-        if (offsets.at(col_idx) != table2_offsets.at(col_idx)) {
-            throw std::runtime_error("Offsets differ at index " +
-                                     std::to_string(col_idx));
-        }
-        if (col_idx == num_columns - 1) {
-            // Check final offset value
-            if (offsets.at(col_idx + 1) != table2_offsets.at(col_idx + 1)) {
-                throw std::runtime_error("Final offset values differ.");
-            }
-        }
-    }
-	get_data().reserve(get_data().size() + table2.get_data().size());
-    tablator::append_rows(get_data(), table2.get_data());
-}
-
-
-Table_Element load_columns_and_offsets(const std::vector<Column> &columns) {
-    if (columns.empty()) {
-        throw std::runtime_error("This table has no columns");
-    }
-
-    std::vector<Column> tabledata_columns;
-    std::vector<size_t> tabledata_offsets = {0};
-
-    const size_t null_flags_size = bits_to_bytes(columns.size());
-    tablator::append_column(tabledata_columns, tabledata_offsets,
-                            null_bitfield_flags_name, Data_Type::UINT8_LE,
-                            null_flags_size,
-                            Field_Properties::Builder()
-                                    .add_description(null_bitfield_flags_description)
-                                    .build());
-
-    for (auto &c : columns) {
-        tablator::append_column(tabledata_columns, tabledata_offsets, c);
-    }
-
-    return Table_Element::Builder(tabledata_columns, tabledata_offsets,
-                                  std::vector<uint8_t>() /*  data */)
-            .build();
-}
-
+// =========================================================
+// Implementation of Table member functions
+// =========================================================
 
 Table::Table(const std::vector<Column> &columns,
-             const std::map<std::string, std::string> &property_map) {
-    add_resource_element(load_columns_and_offsets(columns));
+             const std::map<std::string, std::string> &property_map,
+             bool got_null_bitfields_column) {
+    add_resource_element(
+            Table_Element::Builder(Field_Framework(columns, got_null_bitfields_column))
+                    .build());
 
     for (auto &p : property_map) {
         add_labeled_property(p.first, Property(p.second));
@@ -130,9 +71,12 @@ Table::Table(const std::vector<Column> &columns,
 
 
 Table::Table(const std::vector<Column> &columns,
-             const Labeled_Properties &property_pair_vec)
+             const Labeled_Properties &property_pair_vec,
+             bool got_null_bitfields_column)
         : results_resource_idx_(0) {
-    add_resource_element(load_columns_and_offsets(columns));
+    add_resource_element(
+            Table_Element::Builder(Field_Framework(columns, got_null_bitfields_column))
+                    .build());
 
     for (const auto &label_and_prop : property_pair_vec) {
         if (boost::starts_with(label_and_prop.first, VOTABLE_RESOURCE_DOT)) {
@@ -434,5 +378,52 @@ void Table::stash_resource_element_labeled_property(
     }
 }
 
+//===========================================================
+
+// Helper function
+
+bool close_enough_to_append_rows(const Field_Framework &ff1,
+                                 const Field_Framework &ff2) {
+    if (ff1.get_row_size() != ff2.get_row_size()) {
+        return false;
+    }
+    const auto &ff1_columns = ff1.get_columns();
+    const auto &ff2_columns = ff2.get_columns();
+
+    if (ff1_columns.size() != ff2_columns.size()) {
+        return false;
+    }
+    const auto &ff1_offsets = ff1.get_offsets();
+    const auto &ff2_offsets = ff2.get_offsets();
+
+
+    for (size_t col_idx = 0; col_idx < ff1_columns.size(); ++col_idx) {
+        const auto &ff1_column = ff1_columns.at(col_idx);
+        const auto &ff2_column = ff2_columns.at(col_idx);
+
+        if ((ff1_column.get_name() != ff2_column.get_name()) ||
+            (ff1_column.get_type() != ff2_column.get_type()) ||
+            (ff1_column.get_array_size() != ff2_column.get_array_size()) ||
+            (ff1_column.get_dynamic_array_flag() !=
+             ff2_column.get_dynamic_array_flag()) ||
+            (ff1_offsets.at(col_idx) != ff2_offsets.at(col_idx))) {
+            // Never mind comparing field_properties for now. 01Jul25
+            return false;
+        }
+    }
+    // Check final offset value.
+    return (ff1_offsets.back() == ff2_offsets.back());
+}
+
+
+void Table::append_rows(const Table &table2) {
+    if (!close_enough_to_append_rows(get_field_framework(),
+                                     table2.get_field_framework())) {
+        throw std::runtime_error("The tables are not similar enough to append rows.");
+    }
+    get_data().reserve(get_data().size() + table2.get_data().size());
+    tablator::append_rows(get_data(), table2.get_data());
+}
+
 
 };  // namespace tablator
diff --git a/src/Table/read_dsv/read_dsv.cxx b/src/Table/read_dsv/read_dsv.cxx
index 047b4f49..7fa2e189 100644
--- a/src/Table/read_dsv/read_dsv.cxx
+++ b/src/Table/read_dsv/read_dsv.cxx
@@ -35,12 +35,9 @@ void Table::read_dsv(std::istream &input_stream, const Format &format) {
             parse_dsv(input_stream, format.is_csv() ? ',' : '\t'));
 
     // Construct main resource element from table data.
-
-    std::vector<Column> columns;
-    std::vector<size_t> offsets = {0};
-    set_column_info(columns, offsets, dsv);
-    add_resource_element(Table_Element::Builder(columns, offsets,
-                                                read_dsv_rows(columns, offsets, dsv))
-                                 .build());
+    Field_Framework field_framework = set_column_info(dsv);
+    add_resource_element(
+            Table_Element::Builder(field_framework, read_dsv_rows(field_framework, dsv))
+                    .build());
 }
 }  // namespace tablator
diff --git a/src/Table/read_dsv/read_dsv_rows.cxx b/src/Table/read_dsv/read_dsv_rows.cxx
index 72d685b9..92242027 100644
--- a/src/Table/read_dsv/read_dsv_rows.cxx
+++ b/src/Table/read_dsv/read_dsv_rows.cxx
@@ -1,15 +1,19 @@
 #include "../../Table.hxx"
 
 std::vector<uint8_t> tablator::Table::read_dsv_rows(
-        std::vector<Column> &columns, std::vector<size_t> &offsets,
+        Field_Framework &field_framework,
         const std::list<std::vector<std::string> > &dsv) {
-    bool skipped(false);
+    // JTODO this function should not be a Table class member.
+    auto &columns = field_framework.get_columns();
+    auto &offsets = field_framework.get_offsets();
+    size_t row_size = field_framework.get_row_size();
 
-	size_t row_size = tablator::get_row_size(offsets);
-    Row single_row(row_size);
     std::vector<uint8_t> data;
-	data.reserve(row_size * dsv.size());
+    data.reserve(row_size * dsv.size());
+
 
+    Row single_row(row_size);
+    bool skipped(false);
     for (auto &dsv_row : dsv) {
         if (!skipped) {
             skipped = true;
diff --git a/src/Table/read_dsv/set_column_info/set_column_info.cxx b/src/Table/read_dsv/set_column_info/set_column_info.cxx
index 7459d91b..ee854da6 100644
--- a/src/Table/read_dsv/set_column_info/set_column_info.cxx
+++ b/src/Table/read_dsv/set_column_info/set_column_info.cxx
@@ -1,14 +1,13 @@
 #include "../../../Table.hxx"
 
 namespace tablator {
+
 Data_Type get_best_data_type(const Data_Type &current_type, const std::string &element);
-}
+
 
 // FIXME: A bit icky.  This modifies the dsv document (trims
 // whitespace) while extracting metadata.
-void tablator::Table::set_column_info(std::vector<Column> &columns,
-                                      std::vector<size_t> &offsets,
-                                      std::list<std::vector<std::string> > &dsv) {
+Field_Framework Table::set_column_info(std::list<std::vector<std::string> > &dsv) {
     auto row(dsv.begin());
     std::vector<std::string> names;
     for (auto &name : *row) {
@@ -20,9 +19,12 @@ void tablator::Table::set_column_info(std::vector<Column> &columns,
         }
         names.push_back(trimmed_name);
     }
-    tablator::append_column(columns, offsets, null_bitfield_flags_name,
-                            Data_Type::UINT8_LE, (names.size() + 7) / 8,
-                            Field_Properties(null_bitfield_flags_description));
+
+    std::vector<Column> columns;
+
+    columns.emplace_back(null_bitfield_flags_name, Data_Type::UINT8_LE,
+                         (names.size() + 7) / 8,
+                         Field_Properties(null_bitfield_flags_description));
 
     // Try to infer the types of the columns.  Supported are INT8_LE
     // (bool), INT64_LE, UINT64_LE, FLOAT64_LE, and CHAR.
@@ -51,7 +53,10 @@ void tablator::Table::set_column_info(std::vector<Column> &columns,
     }
 
     for (size_t elem = 0; elem < names.size(); ++elem) {
-        tablator::append_column(columns, offsets, names[elem], types[elem],
-                                types[elem] == Data_Type::CHAR ? sizes[elem] : 1);
+        columns.emplace_back(names[elem], types[elem],
+                             types[elem] == Data_Type::CHAR ? sizes[elem] : 1);
     }
+    return Field_Framework(columns, true /* got_null_bitfields_column */);
 }
+
+}  // namespace tablator
diff --git a/src/Table/read_fits.cxx b/src/Table/read_fits.cxx
index 642b0fde..f3f349c8 100644
--- a/src/Table/read_fits.cxx
+++ b/src/Table/read_fits.cxx
@@ -15,6 +15,8 @@
 //(We can't yet convert to FITS format VOTables with more than one RESOURCE.
 // 07Dec20)
 
+// As of 28Jun25, all columns are created with dynamic_array_flag value <false>.
+
 namespace {
 
 
@@ -497,6 +499,7 @@ class Keyword_Reader {
 //====================================================
 
 // There is more than one way to indicate the array_size of a FITS column.
+// JTODO We don't yet support dynamic array columns in FITS format.  28Jun25
 size_t get_array_size(const CCfits::Column &fits_col) {
     size_t array_size = 1;
     if (std::isdigit(fits_col.format().at(0))) {
@@ -886,27 +889,12 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
     // Read and store binary data
     //*********************************
 
-    std::vector<Column> columns;
-    std::vector<size_t> offsets = {0};
+    std::vector<Column> orig_columns;
 
     // Create null_bitfield_flags column for internal use.
-    tablator::append_column(columns, offsets, null_bitfield_flags_name,
-                            Data_Type::UINT8_LE,
-                            bits_to_bytes(ccfits_table->column().size()),
-                            Field_Properties(null_bitfield_flags_description, {}));
-
-
-    // Check whether the FITS file already has a null_bitfield_flag
-    // column and if so, prepare to skip it; we'll populate the column
-    // we just created instead.  (The FITS file would have this column
-    // only if the file had been generated by an earlier (misguided)
-    // version of tablator.)
-
-    const bool has_null_bitfield_flags(ccfits_table->column().size() > 0 &&
-                                       ccfits_table->column(1).name() ==
-                                               null_bitfield_flags_name &&
-                                       ccfits_table->column(1).type() == CCfits::Tbyte);
-
+    orig_columns.emplace_back(null_bitfield_flags_name, Data_Type::UINT8_LE,
+                              bits_to_bytes(ccfits_table->column().size()),
+                              Field_Properties(null_bitfield_flags_description, {}));
 
     Column_Info_Manager col_info_manager;
 
@@ -922,10 +910,6 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
          ++fits_col_idx) {
         CCfits::Column &fits_col = ccfits_table->column(fits_col_idx);
 
-        if (fits_col_idx == 1 && has_null_bitfield_flags) {
-            // Skip the null_bitfield_flags column, if it exists.
-            continue;
-        }
         size_t array_size = get_array_size(fits_col);
         bool got_null = false;
 
@@ -935,8 +919,8 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
         switch (abs_fits_type) {
             case CCfits::Tlogical: {
                 // std::cout << "Tlogical: " << CCfits::Tlogical << std::endl;
-                tablator::append_column(columns, offsets, fits_col.name(),
-                                        Data_Type::INT8_LE, array_size);
+                orig_columns.emplace_back(fits_col.name(), Data_Type::INT8_LE,
+                                          array_size);
                 col_info_manager.store_data_type_info_for_column(Data_Type::UINT8_LE,
                                                                  array_size);
             } break;
@@ -949,8 +933,8 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
                 Field_Properties null_prop;
                 null_prop.get_values().null =
                         got_null ? std::to_string(null_value) : DEFAULT_NULL_VALUE;
-                tablator::append_column(columns, offsets, fits_col.name(),
-                                        Data_Type::UINT8_LE, array_size, null_prop);
+                orig_columns.emplace_back(fits_col.name(), Data_Type::UINT8_LE,
+                                          array_size, null_prop);
             } break;
             case CCfits::Tshort: {
                 // std::cout << "Tshort: " << CCfits::Tshort << std::endl;
@@ -961,8 +945,8 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
                 Field_Properties null_prop;
                 null_prop.get_values().null =
                         got_null ? std::to_string(null_value) : DEFAULT_NULL_VALUE;
-                tablator::append_column(columns, offsets, fits_col.name(),
-                                        Data_Type::INT16_LE, array_size, null_prop);
+                orig_columns.emplace_back(fits_col.name(), Data_Type::INT16_LE,
+                                          array_size, null_prop);
             } break;
             case CCfits::Tushort: {
                 // std::cout << "Tushort: " << CCfits::Tushort << std::endl;
@@ -973,8 +957,8 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
                 Field_Properties null_prop;
                 null_prop.get_values().null =
                         got_null ? std::to_string(null_value) : DEFAULT_NULL_VALUE;
-                tablator::append_column(columns, offsets, fits_col.name(),
-                                        Data_Type::UINT16_LE, array_size, null_prop);
+                orig_columns.emplace_back(fits_col.name(), Data_Type::UINT16_LE,
+                                          array_size, null_prop);
             } break;
             case CCfits::Tint: {
                 int32_t null_value = 0;
@@ -984,8 +968,8 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
                 Field_Properties null_prop;
                 null_prop.get_values().null =
                         got_null ? std::to_string(null_value) : DEFAULT_NULL_VALUE;
-                tablator::append_column(columns, offsets, fits_col.name(),
-                                        Data_Type::INT32_LE, array_size, null_prop);
+                orig_columns.emplace_back(fits_col.name(), Data_Type::INT32_LE,
+                                          array_size, null_prop);
             } break;
             case CCfits::Tuint: {
                 uint32_t null_value = 0;
@@ -995,8 +979,8 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
                 Field_Properties null_prop;
                 null_prop.get_values().null =
                         got_null ? std::to_string(null_value) : DEFAULT_NULL_VALUE;
-                tablator::append_column(columns, offsets, fits_col.name(),
-                                        Data_Type::UINT32_LE, array_size, null_prop);
+                orig_columns.emplace_back(fits_col.name(), Data_Type::UINT32_LE,
+                                          array_size, null_prop);
             } break;
             case CCfits::Tlong: {
                 // The Tlong type code is used for 32-bit integer columns when reading.
@@ -1007,8 +991,8 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
                 Field_Properties null_prop;
                 null_prop.get_values().null =
                         got_null ? std::to_string(null_value) : DEFAULT_NULL_VALUE;
-                tablator::append_column(columns, offsets, fits_col.name(),
-                                        Data_Type::INT32_LE, array_size, null_prop);
+                orig_columns.emplace_back(fits_col.name(), Data_Type::INT32_LE,
+                                          array_size, null_prop);
             } break;
             case CCfits::Tulong: {
                 // The Tulong type code is used for 32-bit unsigned integer columns when
@@ -1020,8 +1004,8 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
                 Field_Properties null_prop;
                 null_prop.get_values().null =
                         got_null ? std::to_string(null_value) : DEFAULT_NULL_VALUE;
-                tablator::append_column(columns, offsets, fits_col.name(),
-                                        Data_Type::UINT32_LE, array_size, null_prop);
+                orig_columns.emplace_back(fits_col.name(), Data_Type::UINT32_LE,
+                                          array_size, null_prop);
             } break;
             case CCfits::Tlonglong: {
                 int64_t null_value = 0;
@@ -1031,15 +1015,15 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
                 Field_Properties null_prop;
                 null_prop.get_values().null =
                         got_null ? std::to_string(null_value) : DEFAULT_NULL_VALUE;
-                tablator::append_column(columns, offsets, fits_col.name(),
-                                        Data_Type::INT64_LE, array_size, null_prop);
+                orig_columns.emplace_back(fits_col.name(), Data_Type::INT64_LE,
+                                          array_size, null_prop);
             } break;
             case CCfits::Tfloat: {
                 // std::cout << "Tfloat" << std::endl;
                 Field_Properties null_prop;
                 null_prop.get_values().null = DEFAULT_NULL_VALUE;
-                tablator::append_column(columns, offsets, fits_col.name(),
-                                        Data_Type::FLOAT32_LE, array_size, null_prop);
+                orig_columns.emplace_back(fits_col.name(), Data_Type::FLOAT32_LE,
+                                          array_size, null_prop);
                 col_info_manager.store_data_type_info_for_column(Data_Type::FLOAT32_LE,
                                                                  array_size);
             } break;
@@ -1047,14 +1031,14 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
                 // std::cout << "Tdouble" << std::endl;
                 Field_Properties null_prop;
                 null_prop.get_values().null = DEFAULT_NULL_VALUE;
-                tablator::append_column(columns, offsets, fits_col.name(),
-                                        Data_Type::FLOAT64_LE, array_size, null_prop);
+                orig_columns.emplace_back(fits_col.name(), Data_Type::FLOAT64_LE,
+                                          array_size, null_prop);
                 col_info_manager.store_data_type_info_for_column(Data_Type::FLOAT64_LE,
                                                                  array_size);
             } break;
             case CCfits::Tstring:
-                tablator::append_column(columns, offsets, fits_col.name(),
-                                        Data_Type::CHAR, fits_col.width());
+                orig_columns.emplace_back(fits_col.name(), Data_Type::CHAR,
+                                          fits_col.width());
                 col_info_manager.store_data_type_info_for_column(Data_Type::CHAR,
                                                                  array_size);
                 break;
@@ -1068,13 +1052,18 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
         // Check whether keywords contained encoded attributes for this column.
         auto attr_iter = table_element_field_attributes.find(fits_col.name());
         if (attr_iter != table_element_field_attributes.end()) {
-            columns.back().get_field_properties().add_attributes(attr_iter->second);
+            orig_columns.back().get_field_properties().add_attributes(
+                    attr_iter->second);
         }
     }
 
+    Field_Framework field_framework(orig_columns, true /* got_null_bitfields_column */);
+    auto &columns = field_framework.get_columns();
+    auto &offsets = field_framework.get_offsets();
+
     Row_Column_Element_Reader element_reader(col_info_manager, offsets);
 
-    size_t row_size = tablator::get_row_size(offsets);
+    size_t row_size = field_framework.get_row_size();
     size_t num_rows = ccfits_table->rows();
 
     std::vector<uint8_t> data;
@@ -1086,24 +1075,12 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
     if (row_size > 0 && num_rows > 0) {
         fitsfile *fits_pointer = fits.fitsPointer();
 
-        // Tablator columns are 0-based and FITS columns are 1-based.
-        // The tablator table has a null_bitfield_flags column in the
-        // 0th place.  That column will be populated as a side effect
-        // of populating the other columns of the tablator table.
-
-        // If the FITS file was generated by a previous (misguided)
-        // version of tablator, it has its own null_bitfield_flags
-        // column in the 1st place.  In that case, the index of each
-        // column of the FITS file is 1 more than the index of its
-        // counterpart in the tablator table.  if the FITS file does
-        // not have a null_bitfield_flags column, then the indices of
-        // corresponding columns in the two tables are the same.
-
-        // The FITS file's null_bitfield_flags column, if it exists,
-        // is skipped by the code below which retrieves and stores
-        // data from the actual data-bearing columns of the FITS file.
-
-        size_t col_idx_adjuster = (has_null_bitfield_flags) ? 0 : 1;
+        // Tablator columns are 0-based and FITS columns are 1-based,
+        // but the tablator table has a null_bitfield_flags column in
+        // the 0th place, which will be populated as a side effect of
+        // populating the other columns of the tablator table.  All
+        // columns but the 0th of the tablator table have the same
+        // index as their counterpart in the FITS file.
 
         for (size_t j = 0; j < num_rows; ++j) {
             size_t fits_row_idx = j + 1;
@@ -1115,13 +1092,8 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
 
             for (size_t i = 0; i < ccfits_table->column().size(); ++i) {
                 size_t fits_col_idx = i + 1;
+                size_t tab_col_idx = fits_col_idx;
 
-                if (fits_col_idx == 1 && has_null_bitfield_flags) {
-                    // Skip the null_bitfield_flags column, if it exists.
-                    continue;
-                }
-
-                size_t tab_col_idx = fits_col_idx - 1 + col_idx_adjuster;
                 CCfits::Column &fits_col = ccfits_table->column(fits_col_idx);
                 switch (abs(fits_col.type())) {
                     case CCfits::Tlogical: {
@@ -1212,7 +1184,7 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
     //*********************************************************
 
     const auto table_element =
-            Table_Element::Builder(columns, offsets, data)
+            Table_Element::Builder(field_framework, data)
                     .add_trailing_info_list(table_element_trailing_infos)
                     .add_attributes(table_element_attributes)
                     .add_params(table_element_params)
diff --git a/src/Table/read_hdf5/read_hdf5.cxx b/src/Table/read_hdf5/read_hdf5.cxx
index 25daca72..85dbb28b 100644
--- a/src/Table/read_hdf5/read_hdf5.cxx
+++ b/src/Table/read_hdf5/read_hdf5.cxx
@@ -5,6 +5,8 @@
 #include "../HDF5_Attribute.hxx"
 #include "../HDF5_Property.hxx"
 
+// As of 28Jun25, all columns are created with dynamic_array_flag value <false>.
+
 namespace {
 const std::string read_description(const H5::DataSet &dataset,
                                    const std::string desc_label) {
@@ -79,15 +81,13 @@ void tablator::Table::read_hdf5(const boost::filesystem::path &path) {
     }
 
     std::vector<Column> columns;
-    std::vector<size_t> offsets = {0};
 
     for (int i = 0; i < compound.getNmembers(); ++i) {
         H5::DataType datatype(compound.getMemberDataType(i));
         std::string name(compound.getMemberName(i));
         if (datatype.getClass() == H5T_STRING) {
-            tablator::append_column(columns, offsets, name, Data_Type::CHAR,
-                                    datatype.getSize(),
-                                    column_metadata[i].get_field_properties());
+            columns.emplace_back(name, Data_Type::CHAR, datatype.getSize(),
+                                 column_metadata[i].get_field_properties());
         } else if (datatype.getClass() == H5T_ARRAY) {
             auto array_type = compound.getMemberArrayType(i);
             hsize_t ndims = array_type.getArrayNDims();
@@ -99,21 +99,25 @@ void tablator::Table::read_hdf5(const boost::filesystem::path &path) {
                         std::to_string(ndims));
             }
             array_type.getArrayDims(&ndims);
-            tablator::append_column(columns, offsets, name, H5_to_Data_Type(datatype),
-                                    ndims, column_metadata[i].get_field_properties());
+            columns.emplace_back(name, H5_to_Data_Type(datatype), ndims,
+                                 column_metadata[i].get_field_properties());
         } else {
-            tablator::append_column(columns, offsets, name, H5_to_Data_Type(datatype),
-                                    1, column_metadata[i].get_field_properties());
+            columns.emplace_back(name, H5_to_Data_Type(datatype), 1,
+                                 column_metadata[i].get_field_properties());
         }
     }
+
+    Field_Framework field_framework(columns, true /* got_null_bitfields_column */);
     std::vector<uint8_t> data;
-    data.resize(tablator::get_row_size(offsets) *
-                dataset.getSpace().getSimpleExtentNpoints());
+
+    // Resize, don't just reserve.
+    size_t num_rows = dataset.getSpace().getSimpleExtentNpoints();
+    data.resize(field_framework.get_row_size() * num_rows);
     dataset.read(data.data(), compound);
 
     std::vector<Table_Element> table_elements;
     const auto table_element =
-            Table_Element::Builder(columns, offsets, data)
+            Table_Element::Builder(field_framework, data)
                     .add_params(table_element_params)
                     .add_description(table_element_description)
                     .add_trailing_info_list(table_element_trailing_infos)
diff --git a/src/Table/read_ipac_table/create_types_from_ipac_headers/append_ipac_data_member.cxx b/src/Table/read_ipac_table/create_types_from_ipac_headers/append_ipac_data_member.cxx
index 319fcada..f058d991 100644
--- a/src/Table/read_ipac_table/create_types_from_ipac_headers/append_ipac_data_member.cxx
+++ b/src/Table/read_ipac_table/create_types_from_ipac_headers/append_ipac_data_member.cxx
@@ -1,40 +1,44 @@
 #include "../../../Table.hxx"
 
-void tablator::Table::append_ipac_data_member(std::vector<Column> &columns,
-                                              std::vector<size_t> &offsets,
-                                              const std::string &name,
-                                              const std::string &data_type,
-                                              const size_t &num_elements) {
-    /// We use "string".compare (0,size,t) because it is valid to
-    /// abbreviate the type name
+namespace tablator {
+// JTODO rename
+
+void Table::append_ipac_data_member(std::vector<Column> &columns,
+                                    const std::string &name,
+                                    const std::string &data_type,
+                                    const size_t &num_elements) {
+    // We use "string".compare (0,size,t) because it is valid to
+    // abbreviate the type name
     std::string type_str = boost::to_lower_copy(data_type);
     const size_t type_str_len(type_str.size());
 
     if (std::string("boolean").compare(0, type_str_len, type_str) == 0) {
-        tablator::append_column(columns, offsets, name, Data_Type::INT8_LE);
+        columns.emplace_back(name, Data_Type::INT8_LE);
     } else if (std::string("byte").compare(0, type_str_len, type_str) == 0) {
-        tablator::append_column(columns, offsets, name, Data_Type::UINT8_LE);
+        columns.emplace_back(name, Data_Type::UINT8_LE);
     } else if (std::string("short").compare(0, type_str_len, type_str) == 0) {
-        tablator::append_column(columns, offsets, name, Data_Type::INT16_LE);
+        columns.emplace_back(name, Data_Type::INT16_LE);
     } else if (std::string("ushort").compare(0, type_str_len, type_str) == 0) {
-        tablator::append_column(columns, offsets, name, Data_Type::UINT16_LE);
+        columns.emplace_back(name, Data_Type::UINT16_LE);
     } else if (std::string("int").compare(0, type_str_len, type_str) == 0) {
-        tablator::append_column(columns, offsets, name, Data_Type::INT32_LE);
+        columns.emplace_back(name, Data_Type::INT32_LE);
     } else if (std::string("uint").compare(0, type_str_len, type_str) == 0) {
-        tablator::append_column(columns, offsets, name, Data_Type::UINT32_LE);
+        columns.emplace_back(name, Data_Type::UINT32_LE);
     } else if (std::string("long").compare(0, type_str_len, type_str) == 0) {
-        tablator::append_column(columns, offsets, name, Data_Type::INT64_LE);
+        columns.emplace_back(name, Data_Type::INT64_LE);
     } else if (std::string("ulong").compare(0, type_str_len, type_str) == 0) {
-        tablator::append_column(columns, offsets, name, Data_Type::UINT64_LE);
+        columns.emplace_back(name, Data_Type::UINT64_LE);
     } else if (std::string("float").compare(0, type_str_len, type_str) == 0) {
-        tablator::append_column(columns, offsets, name, Data_Type::FLOAT32_LE);
+        columns.emplace_back(name, Data_Type::FLOAT32_LE);
     } else if (std::string("double").compare(0, type_str_len, type_str) == 0 ||
                std::string("real").compare(0, type_str_len, type_str) == 0) {
-        tablator::append_column(columns, offsets, name, Data_Type::FLOAT64_LE);
+        columns.emplace_back(name, Data_Type::FLOAT64_LE);
     } else if (std::string("char").compare(0, type_str_len, type_str) == 0 ||
                std::string("date").compare(0, type_str_len, type_str) == 0) {
-        tablator::append_column(columns, offsets, name, Data_Type::CHAR, num_elements);
+        columns.emplace_back(name, Data_Type::CHAR, num_elements);
     } else {
         throw std::runtime_error("Unknown data type in IPAC table: " + data_type);
     }
 }
+
+}  // namespace tablator
diff --git a/src/Table/read_ipac_table/create_types_from_ipac_headers/create_types_from_ipac_headers.cxx b/src/Table/read_ipac_table/create_types_from_ipac_headers/create_types_from_ipac_headers.cxx
index 503cd037..8c1f5bfb 100644
--- a/src/Table/read_ipac_table/create_types_from_ipac_headers/create_types_from_ipac_headers.cxx
+++ b/src/Table/read_ipac_table/create_types_from_ipac_headers/create_types_from_ipac_headers.cxx
@@ -2,23 +2,29 @@
 
 #include "../../read_ipac_table.hxx"
 
-void tablator::Table::create_types_from_ipac_headers(
-        std::vector<Column> &columns, std::vector<size_t> &offsets,
+// As of 28Jun25, all columns are created with dynamic_array_flag value <false>.
+// JTODO rename function and ipac_columns parameter.
+namespace tablator {
+
+Field_Framework Table::create_types_from_ipac_headers(
         const std::array<std::vector<std::string>, 4> &ipac_columns,
         const std::vector<size_t> &ipac_column_widths) {
-    tablator::append_column(columns, offsets, ipac_columns.at(COL_NAME_IDX).at(0),
-                            Data_Type::UINT8_LE, ipac_column_widths.at(0),
-                            Field_Properties(null_bitfield_flags_description));
+    std::vector<Column> orig_columns;
+    orig_columns.emplace_back(ipac_columns.at(COL_NAME_IDX).at(0), Data_Type::UINT8_LE,
+                              ipac_column_widths.at(0),
+                              Field_Properties(null_bitfield_flags_description));
 
-    size_t num_columns = ipac_columns[0].size();
-    for (size_t col_idx = 1; col_idx < num_columns; ++col_idx) {
-        append_ipac_data_member(columns, offsets,
-                                ipac_columns.at(COL_NAME_IDX).at(col_idx),
+    // ipac_columns, like orig_columns, includes a null column.
+    size_t num_ipac_columns = ipac_columns[0].size();
+    for (size_t col_idx = 1; col_idx < num_ipac_columns; ++col_idx) {
+        append_ipac_data_member(orig_columns, ipac_columns.at(COL_NAME_IDX).at(col_idx),
                                 ipac_columns.at(COL_TYPE_IDX).at(col_idx),
                                 ipac_column_widths.at(col_idx));
     }
 
-    for (size_t col_idx = 1; col_idx < num_columns; ++col_idx) {
+    Field_Framework field_framework(orig_columns, true /* got_null_bitfields_column */);
+    auto &columns = field_framework.get_columns();
+    for (size_t col_idx = 1; col_idx < num_ipac_columns; ++col_idx) {
         Field_Properties field_props({});
         if (!ipac_columns[COL_UNIT_IDX].at(col_idx).empty()) {
             field_props.add_attribute("unit",
@@ -31,4 +37,7 @@ void tablator::Table::create_types_from_ipac_headers(
         }
         columns.at(col_idx).set_field_properties(field_props);
     }
+    return field_framework;
 }
+
+}  // namespace tablator
diff --git a/src/Table/read_ipac_table/read_ipac_table.cxx b/src/Table/read_ipac_table/read_ipac_table.cxx
index 67be0523..c9f5b786 100644
--- a/src/Table/read_ipac_table/read_ipac_table.cxx
+++ b/src/Table/read_ipac_table/read_ipac_table.cxx
@@ -8,6 +8,8 @@
 #include "../../to_string.hxx"
 #include "../read_ipac_table.hxx"
 
+// As of 28Jun25, all columns are created with dynamic_array_flag value <false>.
+
 namespace {
 
 std::vector<size_t> get_ipac_column_widths(
@@ -35,24 +37,25 @@ void tablator::Table::read_ipac_table(std::istream &input_stream) {
 
     const auto ipac_column_widths = get_ipac_column_widths(ipac_column_offsets);
 
-    std::vector<Column> tab_columns;
-    std::vector<size_t> offsets = {0};
-    create_types_from_ipac_headers(tab_columns, offsets, ipac_columns,
-                                   ipac_column_widths);
+    Field_Framework field_framework =
+            create_types_from_ipac_headers(ipac_columns, ipac_column_widths);
 
-    size_t num_tablator_columns = ipac_columns[COL_NAME_IDX].size();
+    size_t num_tab_columns = ipac_columns[COL_NAME_IDX].size();
+    std::vector<Column> &tab_columns = field_framework.get_columns();
+    std::vector<size_t> &offsets = field_framework.get_offsets();
 
-    std::vector<size_t> minimum_column_widths(num_tablator_columns, 1);
+    std::vector<size_t> minimum_column_widths(num_tab_columns, 1);
     std::string line;
     std::getline(input_stream, line);
-    Row single_row(tablator::get_row_size(offsets));
 
     std::vector<uint8_t> data;
-	// JTODO reserve()?
+    // JTODO reserve()
+
+    Row single_row(field_framework.get_row_size());
     while (input_stream) {
         if (line.find_first_not_of(" \t") != std::string::npos) {
             single_row.fill_with_zeros();
-            for (size_t col_idx = 1; col_idx < num_tablator_columns; ++col_idx) {
+            for (size_t col_idx = 1; col_idx < num_tab_columns; ++col_idx) {
                 const auto &tab_column = tab_columns[col_idx];
                 if (line[ipac_column_offsets[col_idx - 1]] != ' ')
                     throw std::runtime_error(
@@ -92,7 +95,7 @@ void tablator::Table::read_ipac_table(std::istream &input_stream) {
                 }
             }
             std::size_t bad_char(line.find_first_not_of(
-                    " \t\r", ipac_column_offsets[num_tablator_columns - 1]));
+                    " \t\r", ipac_column_offsets[num_tab_columns - 1]));
             if (bad_char != std::string::npos)
                 throw std::runtime_error("Non-whitespace found at the end of line " +
                                          std::to_string(current_line_num) +
@@ -105,11 +108,9 @@ void tablator::Table::read_ipac_table(std::istream &input_stream) {
         ++current_line_num;
         std::getline(input_stream, line);
     }
-    shrink_ipac_string_columns_to_fit(tab_columns, offsets, data,
-                                      minimum_column_widths);
+    shrink_ipac_string_columns_to_fit(field_framework, data, minimum_column_widths);
 
-    Table_Element table_element =
-            Table_Element::Builder(tab_columns, offsets, data).build();
+    Table_Element table_element = Table_Element::Builder(field_framework, data).build();
     add_resource_element(Resource_Element::Builder(table_element)
                                  .add_labeled_properties(labeled_resource_properties)
                                  .build());
diff --git a/src/Table/read_ipac_table/shrink_ipac_string_columns_to_fit.cxx b/src/Table/read_ipac_table/shrink_ipac_string_columns_to_fit.cxx
index 69715376..1d548829 100644
--- a/src/Table/read_ipac_table/shrink_ipac_string_columns_to_fit.cxx
+++ b/src/Table/read_ipac_table/shrink_ipac_string_columns_to_fit.cxx
@@ -4,13 +4,14 @@
 #include <utility>
 
 void tablator::Table::shrink_ipac_string_columns_to_fit(
-        std::vector<Column> &columns, std::vector<size_t> &offsets,
-        std::vector<uint8_t> &data,
+        Field_Framework &field_framework, std::vector<uint8_t> &data,
         const std::vector<size_t> &minimum_column_data_widths) {
-    std::vector<size_t> new_offsets = {0};
-    std::vector<Column> new_columns(columns);
+    auto &columns = field_framework.get_columns();
+    auto &offsets = field_framework.get_offsets();
+    size_t old_row_size(field_framework.get_row_size());
 
-    size_t old_row_size(tablator::get_row_size(offsets));
+    std::vector<Column> new_columns(columns);
+    std::vector<size_t> new_offsets = {0};
     size_t new_row_size(0);
 
     for (size_t col_idx = 0; col_idx < columns.size(); ++col_idx) {
diff --git a/src/Table_Element.hxx b/src/Table_Element.hxx
index d5567cd2..4a9279ca 100644
--- a/src/Table_Element.hxx
+++ b/src/Table_Element.hxx
@@ -96,9 +96,13 @@ public:
         Builder(const std::vector<Data_Element> &data_elements)
                 : data_elements_(data_elements) {}
 
-        Builder(const std::vector<Column> &columns, const std::vector<size_t> &offsets,
+        Builder(const Field_Framework &field_framework,
                 const std::vector<uint8_t> &data) {
-            data_elements_.emplace_back(Data_Element(columns, offsets, data));
+            data_elements_.emplace_back(Data_Element(field_framework, data));
+        }
+
+        Builder(const Field_Framework &field_framework) {
+            data_elements_.emplace_back(Data_Element(field_framework));
         }
 
         Table_Element build() { return Table_Element(data_elements_, options_); }
@@ -250,6 +254,14 @@ public:
         return data_elements_.at(DEFAULT_DATA_ELEMENT_IDX);
     }
 
+    const Field_Framework &get_field_framework() const {
+        return get_main_data_element().get_field_framework();
+    }
+
+    Field_Framework &get_field_framework() {
+        return get_main_data_element().get_field_framework();
+    }
+
     const std::vector<Column> &get_columns() const {
         return get_main_data_element().get_columns();
     }
@@ -259,7 +271,21 @@ public:
         return get_main_data_element().get_offsets();
     }
 
-    std::vector<size_t> &get_offsets() { return get_main_data_element().get_offsets(); }
+    //    std::vector<size_t> &get_offsets() { return
+    //    get_main_data_element().get_offsets(); }
+
+    size_t get_row_size() const { return get_main_data_element().get_row_size(); }
+    size_t get_num_rows() const { return get_main_data_element().get_num_rows(); }
+
+    // called by query_server to trim result set
+    void resize_data(size_t &new_num_rows) {
+        get_main_data_element().resize_data(new_num_rows);
+    }
+
+    // called by query_server to trim result set
+    void reserve_data(size_t &new_num_rows) {
+        get_main_data_element().reserve_data(new_num_rows);
+    }
 
     const std::vector<uint8_t> &get_data() const {
         return get_main_data_element().get_data();
diff --git a/src/Utils/Table_Utils.hxx b/src/Utils/Table_Utils.hxx
index f298d033..4f16ac3f 100644
--- a/src/Utils/Table_Utils.hxx
+++ b/src/Utils/Table_Utils.hxx
@@ -3,71 +3,12 @@
 #include <set>
 
 #include "../Column.hxx"
+#include "../Field_Framework.hxx"
 #include "../Row.hxx"
 
 namespace tablator {
 
-// column-related functions
-void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
-                   const Column &column);
-
-inline void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
-                          const std::string &name, const Data_Type &type,
-                          const size_t &array_size,
-                          const Field_Properties &field_properties,
-                          bool dynamic_array_flag) {
-    append_column(columns, offsets,
-                  Column(name, type, array_size, field_properties, dynamic_array_flag));
-}
-
-inline void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
-                          const std::string &name, const Data_Type &type,
-                          const size_t &array_size,
-                          const Field_Properties &field_properties) {
-    append_column(columns, offsets, Column(name, type, array_size, field_properties));
-}
-
-inline void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
-                          const std::string &name, const Data_Type &type,
-                          const size_t &array_size, bool dynamic_array_flag) {
-    append_column(columns, offsets, Column(name, type, array_size, dynamic_array_flag));
-}
-
-inline void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
-                          const std::string &name, const Data_Type &type,
-                          const size_t &size) {
-    append_column(columns, offsets, Column(name, type, size));
-}
-
-inline void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
-                          const std::string &name, const Data_Type &type,
-                          const Field_Properties &field_properties) {
-    append_column(columns, offsets, Column(name, type, field_properties));
-}
-
-
-inline void append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
-                          const std::string &name, const Data_Type &type) {
-    append_column(columns, offsets, Column(name, type));
-}
-
-
 // row-related functions
-
-inline size_t get_row_size(const std::vector<size_t> &offsets) {
-    if (offsets.empty()) {
-        throw std::runtime_error("<offsets> is empty");
-    }
-    return offsets.back();
-}
-
-inline size_t get_num_rows(const std::vector<size_t> &offsets,
-                           const std::vector<uint8_t> &data) {
-    if (offsets.empty()) {
-        throw std::runtime_error("<offsets> is empty");
-    }
-    return data.size() / get_row_size(offsets);
-}
 inline void append_row(std::vector<uint8_t> &data, const Row &row) {
     data.insert(data.end(), row.get_data().begin(), row.get_data().end());
 }
@@ -76,18 +17,8 @@ inline void append_rows(std::vector<uint8_t> &data, const std::vector<uint8_t> &
     data.insert(data.end(), data2.begin(), data2.end());
 }
 
-
-inline void adjust_num_rows(std::vector<uint8_t> &data, const size_t &new_num_rows,
-                        uint row_size) {
-    data.resize(new_num_rows * row_size);
-}
-
-inline void reserve_data(std::vector<uint8_t> &data, const size_t &new_num_rows,
-                         uint row_size) {
-    data.reserve(new_num_rows * row_size);
-}
-
 void winnow_rows(std::vector<uint8_t> &data,
 				 const std::set<size_t> &selected_row_idx_list,
 				 size_t num_rows, size_t row_size);
+
 }  // namespace tablator
diff --git a/src/Utils/Table_Utils/append_column.cxx b/src/Utils/Table_Utils/append_column.cxx
index 1b54db3d..617c5241 100644
--- a/src/Utils/Table_Utils/append_column.cxx
+++ b/src/Utils/Table_Utils/append_column.cxx
@@ -1,10 +1,13 @@
 #include "../Table_Utils.hxx"
+#if 0
+void tablator::append_column(Field_Framework &field_framework, const Column &column) {
+    auto &offsets = field_framework.get_offsets();
 
-void tablator::append_column(std::vector<Column> &columns, std::vector<size_t> &offsets,
-                             const Column &column) {
     if (offsets.empty()) {
         throw std::runtime_error("<offsets> is empty");
     }
+    auto &columns = field_framework.get_columns();
+
     auto new_columns(columns);
     new_columns.push_back(column);
     size_t old_row_size = *offsets.rbegin();
@@ -17,3 +20,4 @@ void tablator::append_column(std::vector<Column> &columns, std::vector<size_t> &
     swap(columns, new_columns);
     swap(offsets, new_offsets);
 }
+#endif
diff --git a/src/ptree_readers.hxx b/src/ptree_readers.hxx
index 5c5b0d39..bc0ab470 100644
--- a/src/ptree_readers.hxx
+++ b/src/ptree_readers.hxx
@@ -8,6 +8,7 @@
 
 #include "Column.hxx"
 #include "Common.hxx"
+#include "Field_Framework.hxx"
 
 namespace tablator {
 
@@ -51,8 +52,7 @@ Data_Element read_binary2(const boost::property_tree::ptree &binary2,
                           const std::vector<Field> &fields);
 
 void append_data_from_stream(std::vector<uint8_t> &data,
-                             const std::vector<Column> &columns,
-                             const std::vector<size_t> &offsets,
+                             const Field_Framework &field_framework,
                              const std::vector<uint8_t> &stream,
                              const std::vector<Field> &fields, size_t num_rows);
 
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx
index 44f31c0d..6fa0e8cb 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx
@@ -17,15 +17,17 @@ inline void insert_swapped(Row &row, size_t column_offset, const Column &column,
 }
 
 void ptree_readers::append_data_from_stream(std::vector<uint8_t> &data,
-                                            const std::vector<Column> &columns,
-                                            const std::vector<size_t> &offsets,
+                                            const Field_Framework &field_framework,
                                             const std::vector<uint8_t> &stream,
                                             const std::vector<Field> &fields,
                                             size_t num_rows) {
+    auto &columns = field_framework.get_columns();
+    auto &offsets = field_framework.get_offsets();
+
     const size_t null_flags_size((columns.size() + 6) / 8);
     size_t src_pos(0);
 
-    Row row(get_row_size(offsets));
+    Row row(field_framework.get_row_size());
     for (size_t r = 0; r < num_rows; ++r) {
         row.fill_with_zeros();
         size_t row_offset(src_pos);
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx
index 33d9ffcc..9a0f45b7 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx
@@ -53,32 +53,31 @@ Data_Element ptree_readers::read_binary2(const boost::property_tree::ptree &bina
     }
 
     std::vector<size_t> rows_per_stream;
-	size_t total_num_rows = 0;
+    size_t total_num_rows = 0;
     for (auto &stream : streams) {
-        size_t num_rows;
-        compute_column_array_sizes(stream, fields, column_array_sizes, num_rows);
-        rows_per_stream.push_back(num_rows);
-		total_num_rows += num_rows;
+        size_t curr_num_rows;
+        compute_column_array_sizes(stream, fields, column_array_sizes, curr_num_rows);
+        rows_per_stream.push_back(curr_num_rows);
+        total_num_rows += curr_num_rows;
     }
 
     std::vector<Column> columns;
-    std::vector<size_t> offsets = {0};
-    std::vector<uint8_t> data;
-
     for (std::size_t c = 0; c < fields.size(); ++c) {
         const auto &field = fields.at(c);
-        append_column(columns, offsets, field.get_name(), field.get_type(),
-                      column_array_sizes[c], field.get_field_properties(),
-                      field.get_dynamic_array_flag());
+        columns.emplace_back(field.get_name(), field.get_type(), column_array_sizes[c],
+                             field.get_field_properties(),
+                             field.get_dynamic_array_flag());
     }
+    Field_Framework field_framework(columns, true /* got_null_bitfields_column */);
 
-	size_t row_size = *offsets.rbegin();
-	data.reserve(row_size * total_num_rows);
+    size_t row_size = field_framework.get_row_size();
+    std::vector<uint8_t> data;
+    data.reserve(row_size * total_num_rows);
 
     for (std::size_t stream = 0; stream < streams.size(); ++stream) {
-        append_data_from_stream(data, columns, offsets, streams[stream], fields,
+        append_data_from_stream(data, field_framework, streams[stream], fields,
                                 rows_per_stream[stream]);
     }
-    return Data_Element(columns, offsets, data);
+    return Data_Element(field_framework, data);
 }
 }  // namespace tablator
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
index d795052a..b53ebd38 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
@@ -69,20 +69,24 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
         }
     }
 
-    std::vector<Column> columns;
-    std::vector<size_t> offsets = {0};
+    std::vector<Column> orig_columns;
 
     for (std::size_t c = 0; c < num_fields; ++c) {
         const auto &field = fields.at(c);
-        append_column(columns, offsets, field.get_name(), field.get_type(),
-                      column_array_sizes[c], field.get_field_properties(),
-                      field.get_dynamic_array_flag());
+        orig_columns.emplace_back(field.get_name(), field.get_type(),
+                                  column_array_sizes[c], field.get_field_properties(),
+                                  field.get_dynamic_array_flag());
     }
 
-	size_t row_size = *offsets.rbegin();
-	size_t num_rows = element_lists_by_row.size();
+    Field_Framework field_framework(orig_columns, true /* got_null_bitfields_column */);
+    std::vector<Column> &columns = field_framework.get_columns();
+    std::vector<size_t> &offsets = field_framework.get_offsets();
+
+    size_t num_rows = element_lists_by_row.size();
+    size_t row_size = *offsets.rbegin();
+
     std::vector<uint8_t> data;
-	data.reserve(row_size * num_rows);
+    data.reserve(row_size * num_rows);
 
     Row single_row(row_size);
     // JTODO Are we allowing for non-CHAR dynamic arrays?  Should all arrays end in
@@ -113,5 +117,5 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
         }
         append_row(data, single_row);
     }
-    return Data_Element(columns, offsets, data);
+    return Data_Element(field_framework, data);
 }
diff --git a/test/back_and_forth_tables/fits_medium.vot b/test/back_and_forth_tables/fits_medium.vot
index 63679e0c..7d7486ec 100644
--- a/test/back_and_forth_tables/fits_medium.vot
+++ b/test/back_and_forth_tables/fits_medium.vot
@@ -2,18 +2,18 @@
 <VOTABLE version="1.3" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.ivoa.net/xml/VOTable/v1.3" xmlns:stc="http://www.ivoa.net/xml/STC/v1.30" xsi:schemaLocation="http://www.ivoa.net/xml/VOTable/v1.3 http://www.ivoa.net/xml/VOTable/v1.3 http://www.ivoa.net/xml/STC/v1.30 http://www.ivoa.net/xml/STC/v1.30">
   <RESOURCE>
     <INFO name="ADQL" ucd="meta.adql" value="SELECT * FROM planck_toi_044 WHERE CONTAINS(POINT(&apos;J2000 GEOCENTER&apos;,ra,dec),CIRCLE(&apos;J2000 GEOCENTER&apos;,121.17440000000001,-21.572939999999999,0.01))=1 AND (mjd &gt;= 55550.0 AND mjd &lt;= 65650.5)"/>
-    <INFO name="DATE" comment="File Creation Date" ucd="time.creation" value="2016-03-18T22:02:44"/>
-    <INFO name="FREQ" comment="GHz" ucd="em.freq" value="044"/>
-    <INFO name="INSTRUME" comment="Instrument Name" ucd="instr" value="LFI"/>
-    <INFO name="OBJDEC" comment="Search Target DEC degrees" ucd="pos.eq.dec" value="-21.572939999999999"/>
-    <INFO name="OBJECT" comment="Target Name" ucd="src" value="CIRCLE(&apos;&apos;J2000 GEOCENTER&apos;&apos;,121.174,-21.5729,0.01)"/>
-    <INFO name="OBJGLAT" comment="Search Target GLAT degrees" ucd="pos.galactic.lat" value="5.3028541265890539"/>
-    <INFO name="OBJGLON" comment="Search Target GLON degrees" ucd="pos.galactic.lon" value="240.47825496346866"/>
-    <INFO name="OBJRA" comment="Search Target RA degrees" ucd="pos.eq.ra" value="121.17440000000001"/>
-    <INFO name="OBJ_TYPE" comment="Fixed or Moving" ucd="src.class" value="Fixed"/>
-    <INFO name="PROCVER" comment="Processing Version" ucd="meta.version" value="DX11D"/>
-    <INFO name="RADIUS" comment="Search Radius degrees" ucd="pos.radius" value="0.01"/>
-    <INFO name="TELESCOP" comment="Telescope Name" ucd="instr.obsty" value="PLANCK"/>
+    <INFO comment="File Creation Date" name="DATE" ucd="time.creation" value="2016-03-18T22:02:44"/>
+    <INFO comment="GHz" name="FREQ" ucd="em.freq" value="044"/>
+    <INFO comment="Instrument Name" name="INSTRUME" ucd="instr" value="LFI"/>
+    <INFO comment="Search Target DEC degrees" name="OBJDEC" ucd="pos.eq.dec" value="-21.572939999999999"/>
+    <INFO comment="Target Name" name="OBJECT" ucd="src" value="CIRCLE(&apos;&apos;&apos;&apos;J2000 GEOCENTER&apos;&apos;&apos;&apos;,121.174,-21.5729,0.01)"/>
+    <INFO comment="Search Target GLAT degrees" name="OBJGLAT" ucd="pos.galactic.lat" value="5.3028541265890539"/>
+    <INFO comment="Search Target GLON degrees" name="OBJGLON" ucd="pos.galactic.lon" value="240.47825496346866"/>
+    <INFO comment="Search Target RA degrees" name="OBJRA" ucd="pos.eq.ra" value="121.17440000000001"/>
+    <INFO comment="Fixed or Moving" name="OBJ_TYPE" ucd="src.class" value="Fixed"/>
+    <INFO comment="Processing Version" name="PROCVER" ucd="meta.version" value="DX11D"/>
+    <INFO comment="Search Radius degrees" name="RADIUS" ucd="pos.radius" value="0.01"/>
+    <INFO comment="Telescope Name" name="TELESCOP" ucd="instr.obsty" value="PLANCK"/>
     <TABLE>
       <FIELD name="ra" datatype="double" unit="degrees"/>
       <FIELD name="dec" datatype="double" unit="degrees"/>
diff --git a/test/fits_medium.fits b/test/fits_medium.fits
index 69bea23a..29b88d6a 100644
--- a/test/fits_medium.fits
+++ b/test/fits_medium.fits
@@ -1,17 +1,17 @@
-SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   16 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   54 / width of table in bytes                        NAXIS2  =                  146 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                   10 / number of fields in each row                   TTYPE1  = 'null_bitfield_flags' / label for field   1                           TFORM1  = '2B      '           / data format of field: BYTE                     TTYPE2  = 'ra      '           / label for field   2                            TFORM2  = 'D       '           / data format of field: 8-byte DOUBLE            TUNIT2  = 'degrees '           / physical unit of field                         TTYPE3  = 'dec     '           / label for field   3                            TFORM3  = 'D       '           / data format of field: 8-byte DOUBLE            TUNIT3  = 'degrees '           / physical unit of field                         TTYPE4  = 'psi     '           / label for field   4                            TFORM4  = 'E       '           / data format of field: 4-byte REAL              TUNIT4  = 'degrees '           / physical unit of field                         TTYPE5  = 'mjd     '           / label for field   5                            TFORM5  = 'D       '           / data format of field: 8-byte DOUBLE            TUNIT5  = 'days    '           / physical unit of field                         TTYPE6  = 'signal  '           / label for field   6                            TFORM6  = 'E       '           / data format of field: 4-byte REAL              TUNIT6  = 'K_CMB   '           / physical unit of field                         TTYPE7  = 'glon    '           / label for field   7                            TFORM7  = 'D       '           / data format of field: 8-byte DOUBLE            TUNIT7  = 'degrees '           / physical unit of field                         TTYPE8  = 'glat    '           / label for field   8                            TFORM8  = 'D       '           / data format of field: 8-byte DOUBLE            TUNIT8  = 'degrees '           / physical unit of field                         TTYPE9  = 'sso     '           / label for field   9                            TFORM9  = 'L       '           / data format of field: 1-byte LOGICAL           TTYPE10 = 'detector'           / label for field  10                            TFORM10 = '3A      '           / data format of field: ASCII Character          EXTNAME = 'Table   '           / name of this binary table extension            LONGSTRN= 'OGIP 1.0'           / The HEASARC Long String Convention may be used.COMMENT   This FITS file may contain long string keyword values that are        COMMENT   continued over multiple keywords.  The HEASARC convention uses the &  COMMENT   character at the end of each substring which is then continued        COMMENT   on the next keyword which has the name CONTINUE.                      ADQL    = 'SELECT * FROM planck_toi_044 WHERE CONTAINS(POINT(''J2000 GEOCENTE&' CONTINUE  'R'',ra,dec),CIRCLE(''J2000 GEOCENTER'',121.17440000000001,-21.57293&'CONTINUE  '9999999999,0.01))=1 AND (mjd >= 55550.0 AND mjd <= 65650.5)'         DATE    = '2016-03-18T22:02:44' / File Creation Date                            OBJECT  = 'CIRCLE(''J2000 GEOCENTER'',121.174,-21.5729,0.01)' / Target Name     OBJ_TYPE= 'Fixed   '           / Fixed or Moving                                OBJRA   = '121.17440000000001' / Search Target RA degrees                       OBJDEC  = '-21.572939999999999' / Search Target DEC degrees                     OBJGLON = '240.47825496346866' / Search Target GLON degrees                     OBJGLAT = '5.3028541265890539' / Search Target GLAT degrees                     RADIUS  = '0.01    '           / Search Radius degrees                          PROCVER = 'DX11D   '           / Processing Version                             TELESCOP= 'PLANCK  '           / Telescope Name                                 INSTRUME= 'LFI     '           / Instrument Name                                FREQ    = '044     '           / GHz                                            END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             @^J�g��g�5�~U3'yBA�@�v�9+e):��P@nb_v6�@,syd�pF24M@^K��?:X�5����BH@�Hڐ�&z;	3@n���;S@:�'��~F24M@^K�P��0�5�eN�sfB�@�H�;�b޻0��@n�>mM
-@8Wf�$F24M@^K7��'��5����|�BD[@�v���ET:��@n!?�OJ@:�Q�F24M@^KK�
�%�5�o(
BBD�@�v��dp�y��@nO�&d@<�!FF24M@^K�a� ��5��2�wCiB�@�<|��N��G@n,b�'�@>�n��/F24M@^J�PLז�5���W�Ci??@�\���,�]j@nP/�@-�b��F24M@^J�?�t�5�0�/!Ci?h@�\�A���:�ې@nW�/�z@,�����F24M@^J��mJ�5�ӓ�yBE(@�v�(D;19�@n=^�
m@4#�+�F24M@^J�-Sޞ�5��к4BC@�v�r�~:R�b@n?���@3�6��GF24M@^J���b��5��2�Z�Ci?�@�\�6I��|B@n � �@2��%�F24M@^J�*"��5�<��x�Ci?�@�\�իB ���;@n,��m�@2����F24M@^JŒ@��5�S`��BD�@�v��|a:�x�@nYo�Q>@..�r&F24M@^J�p;�.�5���g�#BB�@�v�U��;$`s@nUb��d@/�9��F24M@^K����5��	��BC�@�v���~8�ԭ�@n3^��Z@6�+>�[F24M@^Kp*����5�(��2qCiC@�<�
�����@nl��lf@8��ȯ�F24M@^Kz�Љ�5��Qp�CiB�@�<,���:���@ny��Ų@8HW )F24M@^Kq�hP��5��y\�CiB�@�<ky�>��I�@n|J7@7~k
-�F24M@^Kpv8Ib�5�׭�r�CiC.@�<�	�9փ�@nd?s�@9D�ㄎF24M@^Ka�;���5�dk�+CiC�@�=e��ɺ*|@nT0��`@9�,�SiF24M@^Kk�x<�5�y���`CiC_@�='M���\{�@nX��[@9�80Q�F24M@^J��}���5���3�Ci?�@�\��%a:�I:�@n��@1�K��F24M@^J�����5���<iCi?�@�\���Jx�
-U!@n�>�@1�7��F24M@^J�&�=��5���!�rCi?s@�\��J���7@nM���@7<��v�F24M@^J�g��g�5�~U3'y�e�@�v�9+e);�Z@nb_v6�@,syd�pF24S@^K��?:X�5�����e�@�Hڐ�&z�I2@n���;S@:�'��~F24S@^K�P��0�5�eN�sf�e�&@�H�;�b޺�U}@n�>mM
-@8Wf�$F24S@^K7��'��5����|��e��@�v���ET;��@n!?�OJ@:�Q�F24S@^KK�
�%�5�o(
B�e�3@�v��dp:�j�@nO�&d@<�!FF24S@^K�a� ��5��2�wCB�@�<|��N;Lc@n,b�'�@>�n��/F24S@^J�PLז�5���W�C??@�\���,���@nP/�@-�b��F24S@^J�?�t�5�0�/!C?h@�\�A��Ļ���@nW�/�z@,�����F24S@^J��mJ�5�ӓ�y�e��@�v�(D:�<1@n=^�
m@4#�+�F24S@^J�-Sޞ�5��к4�e��@�v�r�~;gĖ@n?���@3�6��GF24S@^J���b��5��2�Z�C?�@�\�6I�:�:�@n � �@2��%�F24S@^J�*"��5�<��x�C?�@�\�իB ;�R}@n,��m�@2����F24S@^JŒ@��5�S`���e�z@�v��|a�*/�@nYo�Q>@..�r&F24S@^J�p;�.�5���g�#�e�@�v�U�Իd�_@nUb��d@/�9��F24S@^K����5��	���e�h@�v���~8;��@n3^��Z@6�+>�[F24S@^Kp*����5�(��2qCC@�<�
��:e�@nl��lf@8��ȯ�F24S@^Kz�Љ�5��Qp�CB�@�<,���9i�@ny��Ų@8HW )F24S@^Kq�hP��5��y\�CB�@�<ky�>�Wd�@n|J7@7~k
-�F24S@^Kpv8Ib�5�׭�r�CC.@�<�	�8�EV@nd?s�@9D�ㄎF24S@^Ka�;���5�dk�+CC�@�=e���;��@nT0��`@9�,�SiF24S@^Kk�x<�5�y���`CC_@�='M��:��@nX��[@9�80Q�F24S@^J��}���5���3�C?�@�\��%a:���@n��@1�K��F24S@^J�����5���<iC?�@�\���Jx��0�@n�>�@1�7��F24S@^J�&�=��5���!�rC?s@�\��J�;r l@nM���@7<��v�F24S@^K?6���5��c�ڻB�(R@�[>�x�:�e�@n�_0U@0S�,_=F25M@^K!���5���>"B�'@@�[=���Ժ��.@n��7�@0޻�~�F25M@^KĤ72��5�����B�l�@�.0�@�:�t@n|��@=�6>!F25M@^K������5��qd��B�0@���l�s;�7@n�@+��@7Rı�F25M@^K�'K#�5��"Ӥ�B�lf@�.0t�^X:
-�@n���@:"}�KKF25M@^K�E�r��5����NB�/e@��db��W��@n��)�@9'��(XF25M@^K��")��5�S`���B�m�@�.1+0d;��t@n�`d�@<C�7�F25M@^J�Mr4Y�5��)��C���@�I�eb�;��@n�F�0@6�����F25M@^K�H���5���a�	B�'t@�[=�σ�;�=�@n`у�P@3�n��F25M@^J�
-���5��&ԹXC���@�I����>����@n#
�V�@3�����F25M@^J�E��5�b��C���@�I��k����@n+z�@1V�ށ�F25M@^J�����5�_�LC�̼@�I��4��9�'�@n+`�&A@1~��yqF25M@^KgʕX�5���$@%B�(-@�[>[F�o;C
-@nI��E�@4�m��F25M@^J�i� >�5��6�s�C���@�I���29Ywy@n5
\��@.�����F25M@^K�����5�M/?��B�'x@�[>3t~G:�@nA]�4�@6o��:F25M@^K�y��5�h��L�B�',@�[>�
:H��@nCP�W�@6�zF25M@^K#+�H�5��G�+�B�&�@�[=}P��;_@n1y�!@7�N�yeF25M@^K) C@�5��^��B�'@�[=��Pĸ�?@n7��>�@7��'CF25M@^K�
��;�5�@��B�0@����\~���*@n�0��@9�N���F25M@^KG�0��5��j�j�B�&�@�[=J���/�@nS>d��@4���F25M@^K�Ɗ�^�5�@\�B�l�@�.0�
��:��m@ne�N�k@?��d�F25M@^K�T�Z��5�%�EaB�l�@�.1� ػ�d@ni�9�@?�_FH5F25M@^K�l����5���[aB�0D@���ȕ;�@nMn;��@=憘TF25M@^K�0x���5���U4�B�/@��z�|:��@nL>��@=��)�*F25M@^K�-�t�5�M
-c��B�l�@�.0��ۈ;�||@nh����@>X��o�F25M@^K��’�5����յB�/?@��o|�;��@nqp�'@;�� �F25M@^K�Z��5���`7VB�0<@��	.�;�m�@ng����@;R}�lF25M@^K?6���5��c�ڻBP�@�[>�x�����@n�_0U@0S�,_=F25S@^K!���5���>"BN@�[=���Ի1��@n��7�@0޻�~�F25S@^KĤ72��5�����A��Q@�.0�@�:���@n|��@=�6>!F25S@^K������5��qd��B`@���l�s��6/@n�@+��@7Rı�F25S@^K�'K#�5��"Ӥ�A���@�.0t�^X;\2�@n���@:"}�KKF25S@^K�E�r��5����NB^�@��db���T@n��)�@9'��(XF25S@^K��")��5�S`���A��@�.1+0d:k�@n�`d�@<C�7�F25S@^J�Mr4Y�5��)��C:�@�I�eb��#�p@n�F�0@6�����F25S@^K�H���5���a�	BN�@�[=�σ��-h"@n`у�P@3�n��F25S@^J�
-���5��&ԹXC:�@�I����>�@�@n#
�V�@3�����F25S@^J�E��5�b��C:�@�I��k���@n+z�@1V�ށ�F25S@^J�����5�_�LC:w@�I��4��:
2�@n+`�&A@1~��yqF25S@^KgʕX�5���$@%BPZ@�[>[F�o:�u@nI��E�@4�m��F25S@^J�i� >�5��6�s�C:�@�I���2����@n5
\��@.�����F25S@^K�����5�M/?��BN�@�[>3t~G��&X@nA]�4�@6o��:F25S@^K�y��5�h��L�BNX@�[>�
��n @nCP�W�@6�zF25S@^K#+�H�5��G�+�BM|@�[=}P��;��+@n1y�!@7�N�yeF25S@^K) C@�5��^��BN@�[=��PĻL��@n7��>�@7��'CF25S@^K�
��;�5�@��B`#@����\~�Q�;@n�0��@9�N���F25S@^KG�0��5��j�j�BM@�[=J��;	,�@nS>d��@4���F25S@^K�Ɗ�^�5�@\�A��%@�.0�
���V۷@ne�N�k@?��d�F25S@^K�T�Z��5�%�EaA��*@�.1� ظ���@ni�9�@?�_FH5F25S@^K�l����5���[aB`�@���ȕ:��@nMn;��@=憘TF25S@^K�0x���5���U4�B^@��z�|:%J@nL>��@=��)�*F25S@^K�-�t�5�M
-c��A��f@�.0��ۈ;"K8@nh����@>X��o�F25S@^K��’�5����յB^~@��o|��E�@nqp�'@;�� �F25S@^K�Z��5���`7VB`y@��	.�����@ng����@;R}�lF25S@^K�ST��5���
-[���@��!-w�GG�@nv���I@=P���F26M@^K��5a��5�F�|��@��dp��"@n
w�@;_3�F26M@^K��"���5�ӈ����_@��%oVD9?�@n��L7�@:�8֎�F26M@^K���P;�5����3����@�.1�h%�d[I@n��h� @:���F26M@^K����5�
nW1�C�@�w��[�&:��@n���bz@:o���F26M@^K"B�tU�5�U��޳�A�@�[>�>�~;Y�@n'�j�@8��6�{F26M@^K�9G)�5�$<q���?�@�[?-���:�N
@n q��R@8��¾�F26M@^Kr>�5��`^�8�@�[?����;��O@n��@9��S"F26M@^K(:�^�5���5C�@�I��˃ٺ�\@n@�Q@: ��F26M@^K���Ē�5�S�T�%��
-@������:��b@nKݗ�%@?�)���F26M@^KS0l�5�7��]�>G@�[?'�vT;��@nXix8@4��tF26M@^K,��5���8��B@@�[>Ҏ$�<*Z@nh�u�j@3J&9F26M@^Kΰp�5��ҤFn�:3@�[?���;�q@ng�x��@2�`�b�F26M@^J��
��5��c�C`@�I��$V;�Q<@n?~km�@2�X�`�F26M@^J׊9��5��b��C
-�@�I���6�;*��@nE1R�@10�t�IF26M@^K^����5�_U�@CX@�I����c���@n"@�
�@7??���F26M@^K.�O��5�F1����>@�[?�1tX��/�@n?��t:@6]j�hF26M@^K��>r��5��7K������@�.2y*n�X�\@ns���@<�S�0cF26M@^K�q�G�5���;m8���\@�.1��	�;�w@nm-���@<[fߵF26M@^K����5�2����%@�.2�.�@ne-�h@>\Կ��F26M@^K���`@�5��-�;2��@����;s��@nX�'&@>K/���F26M@^K������5���B���a@��~�2�0�'@n^�k�W@=עRVF26M@^K�ST��5���
-[���@��!-w;�fx@nv���I@=P���F26S@^K��5a��5�F�|���T@��dp�;^ @n
w�@;_3�F26S@^K��"���5�ӈ������@��%oVD�܍S@n��L7�@:�8֎�F26S@^K���P;�5����3�߾�@�.1�h%�f�@n��h� @:���F26S@^K����5�
nW1�BN?<@�w��[�&��E@n���bz@:o���F26S@^K"B�tU�5�U��޳��6@�[>�>�~��+�@n'�j�@8��6�{F26S@^K�9G)�5�$<q�����@�[?-��ܻ���@n q��R@8��¾�F26S@^Kr>�5��`^��@�[?����:��@n��@9��S"F26S@^K(:�^�5���5BN/B@�I��˃ٻ�v�@n@�Q@: ��F26S@^K���Ē�5�S�T�%���A@������;ddQ@nKݗ�%@?�)���F26S@^KS0l�5�7��]���@�[?'�vT��@nXix8@4��tF26S@^K,��5���8���H@�[>Ҏ$�:�<�@nh�u�j@3J&9F26S@^Kΰp�5��ҤFn��F@�[?���;�S�@ng�x��@2�`�b�F26S@^J��
��5��c�BN-~@�I��$V�:�.@n?~km�@2�X�`�F26S@^J׊9��5��b��BN+�@�I���6ں�'�@nE1R�@10�t�IF26S@^K^����5�_U�@BN-^@�I����c;���@n"@�
�@7??���F26S@^K.�O��5�F1������@�[?�1tX���T@n?��t:@6]j�hF26S@^K��>r��5��7K���߿�@�.2y*n:�ޕ@ns���@<�S�0cF26S@^K�q�G�5���;m8�߿�@�.1��	�;4��@nm-���@<[fߵF26S@^K����5�2��߿	@�.2�.���
@ne-�h@>\Կ��F26S@^K���`@�5��-�;2���6@����;�..@nX�'&@>K/���F26S@^K������5���B����l@��~�2�
-H'@n^�k�W@=עRVF26S
\ No newline at end of file
+SIMPLE  =                    T / file does conform to FITS standard             BITPIX  =                   16 / number of bits per data pixel                  NAXIS   =                    0 / number of data axes                            EXTEND  =                    T / FITS dataset may contain extensions            COMMENT   FITS (Flexible Image Transport System) format is defined in 'AstronomyCOMMENT   and Astrophysics', volume 376, page 359; bibcode: 2001A&A...376..359H END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             XTENSION= 'BINTABLE'           / binary table extension                         BITPIX  =                    8 / 8-bit bytes                                    NAXIS   =                    2 / 2-dimensional binary table                     NAXIS1  =                   52 / width of table in bytes                        NAXIS2  =                  146 / number of rows in table                        PCOUNT  =                    0 / size of special data area                      GCOUNT  =                    1 / one data group (required keyword)              TFIELDS =                    9 / number of fields in each row                   TTYPE1  = 'ra      '           / label for field   1                            TFORM1  = '1D      '           / data format of field: 8-byte DOUBLE            TUNIT1  = 'degrees '           / physical unit of field                         TTYPE2  = 'dec     '           / label for field   2                            TFORM2  = '1D      '           / data format of field: 8-byte DOUBLE            TUNIT2  = 'degrees '           / physical unit of field                         TTYPE3  = 'psi     '           / label for field   3                            TFORM3  = '1E      '           / data format of field: 4-byte REAL              TUNIT3  = 'degrees '           / physical unit of field                         TTYPE4  = 'mjd     '           / label for field   4                            TFORM4  = '1D      '           / data format of field: 8-byte DOUBLE            TUNIT4  = 'days    '           / physical unit of field                         TTYPE5  = 'signal  '           / label for field   5                            TFORM5  = '1E      '           / data format of field: 4-byte REAL              TUNIT5  = 'K_CMB   '           / physical unit of field                         TTYPE6  = 'glon    '           / label for field   6                            TFORM6  = '1D      '           / data format of field: 8-byte DOUBLE            TUNIT6  = 'degrees '           / physical unit of field                         TTYPE7  = 'glat    '           / label for field   7                            TFORM7  = '1D      '           / data format of field: 8-byte DOUBLE            TUNIT7  = 'degrees '           / physical unit of field                         TTYPE8  = 'sso     '           / label for field   8                            TFORM8  = '1L      '           / data format of field: 1-byte LOGICAL           TTYPE9  = 'detector'           / label for field   9                            TFORM9  = '3A      '           / data format of field: ASCII Character          EXTNAME = 'Table   '           / name of this binary table extension            LONGSTRN= 'OGIP 1.0'           / The HEASARC Long String Convention may be used.COMMENT   This FITS file may contain long string keyword values that are        COMMENT   continued over multiple keywords.  The HEASARC convention uses the &  COMMENT   character at the end of each substring which is then continued        COMMENT   on the next keyword which has the name CONTINUE.                      TNULL9  = '        '                                                            VOKW0   = 'VOTABLE.RESOURCE.INFO.ADQL.<xmlattr>.name<VOEND>ADQL'                VOKW1   = 'VOTABLE.RESOURCE.INFO.ADQL.<xmlattr>.ucd<VOEND>meta.adql'            VOKW2   = 'VOTABLE.RESOURCE.INFO.ADQL.<xmlattr>.value<VOEND>SELECT * FROM plan&'CONTINUE  'ck_toi_044 WHERE CONTAINS(POINT(''J2000 GEOCENTER'',ra,dec),CIRCLE&' CONTINUE  '(''J2000 GEOCENTER'',121.17440000000001,-21.572939999999999,0.01))=&'CONTINUE  '1 AND (mjd >= 55550.0 AND mjd <= 65650.5)'                           VOKW3   = 'VOTABLE.RESOURCE.INFO.DATE.<xmlattr>.comment<VOEND>File Creation Da&'CONTINUE  'te      '                                                            VOKW4   = 'VOTABLE.RESOURCE.INFO.DATE.<xmlattr>.name<VOEND>DATE'                VOKW5   = 'VOTABLE.RESOURCE.INFO.DATE.<xmlattr>.ucd<VOEND>time.creation'        VOKW6   = 'VOTABLE.RESOURCE.INFO.DATE.<xmlattr>.value<VOEND>2016-03-18T22:02:44'VOKW7   = 'VOTABLE.RESOURCE.INFO.FREQ.<xmlattr>.comment<VOEND>GHz'              VOKW8   = 'VOTABLE.RESOURCE.INFO.FREQ.<xmlattr>.name<VOEND>FREQ'                VOKW9   = 'VOTABLE.RESOURCE.INFO.FREQ.<xmlattr>.ucd<VOEND>em.freq'              VOKW10  = 'VOTABLE.RESOURCE.INFO.FREQ.<xmlattr>.value<VOEND>044'                VOKW11  = 'VOTABLE.RESOURCE.INFO.INSTRUME.<xmlattr>.comment<VOEND>Instrument N&'CONTINUE  'ame     '                                                            VOKW12  = 'VOTABLE.RESOURCE.INFO.INSTRUME.<xmlattr>.name<VOEND>INSTRUME'        VOKW13  = 'VOTABLE.RESOURCE.INFO.INSTRUME.<xmlattr>.ucd<VOEND>instr'            VOKW14  = 'VOTABLE.RESOURCE.INFO.INSTRUME.<xmlattr>.value<VOEND>LFI'            VOKW15  = 'VOTABLE.RESOURCE.INFO.OBJDEC.<xmlattr>.comment<VOEND>Search Target &'CONTINUE  'DEC degrees'                                                         VOKW16  = 'VOTABLE.RESOURCE.INFO.OBJDEC.<xmlattr>.name<VOEND>OBJDEC'            VOKW17  = 'VOTABLE.RESOURCE.INFO.OBJDEC.<xmlattr>.ucd<VOEND>pos.eq.dec'         VOKW18  = 'VOTABLE.RESOURCE.INFO.OBJDEC.<xmlattr>.value<VOEND>-21.572939999999&'CONTINUE  '999     '                                                            VOKW19  = 'VOTABLE.RESOURCE.INFO.OBJECT.<xmlattr>.comment<VOEND>Target Name'    VOKW20  = 'VOTABLE.RESOURCE.INFO.OBJECT.<xmlattr>.name<VOEND>OBJECT'            VOKW21  = 'VOTABLE.RESOURCE.INFO.OBJECT.<xmlattr>.ucd<VOEND>src'                VOKW22  = 'VOTABLE.RESOURCE.INFO.OBJECT.<xmlattr>.value<VOEND>CIRCLE(''''''''J&'CONTINUE  '2000 GEOCENTER'''''''',121.174,-21.5729,0.01)'                       VOKW23  = 'VOTABLE.RESOURCE.INFO.OBJGLAT.<xmlattr>.comment<VOEND>Search Target&'CONTINUE  ' GLAT degrees'                                                       VOKW24  = 'VOTABLE.RESOURCE.INFO.OBJGLAT.<xmlattr>.name<VOEND>OBJGLAT'          VOKW25  = 'VOTABLE.RESOURCE.INFO.OBJGLAT.<xmlattr>.ucd<VOEND>pos.galactic.lat'  VOKW26  = 'VOTABLE.RESOURCE.INFO.OBJGLAT.<xmlattr>.value<VOEND>5.3028541265890&'CONTINUE  '539     '                                                            VOKW27  = 'VOTABLE.RESOURCE.INFO.OBJGLON.<xmlattr>.comment<VOEND>Search Target&'CONTINUE  ' GLON degrees'                                                       VOKW28  = 'VOTABLE.RESOURCE.INFO.OBJGLON.<xmlattr>.name<VOEND>OBJGLON'          VOKW29  = 'VOTABLE.RESOURCE.INFO.OBJGLON.<xmlattr>.ucd<VOEND>pos.galactic.lon'  VOKW30  = 'VOTABLE.RESOURCE.INFO.OBJGLON.<xmlattr>.value<VOEND>240.47825496346&'CONTINUE  '866     '                                                            VOKW31  = 'VOTABLE.RESOURCE.INFO.OBJRA.<xmlattr>.comment<VOEND>Search Target R&'CONTINUE  'A degrees'                                                           VOKW32  = 'VOTABLE.RESOURCE.INFO.OBJRA.<xmlattr>.name<VOEND>OBJRA'              VOKW33  = 'VOTABLE.RESOURCE.INFO.OBJRA.<xmlattr>.ucd<VOEND>pos.eq.ra'           VOKW34  = 'VOTABLE.RESOURCE.INFO.OBJRA.<xmlattr>.value<VOEND>121.17440000000001'VOKW35  = 'VOTABLE.RESOURCE.INFO.OBJ_TYPE.<xmlattr>.comment<VOEND>Fixed or Mov&'CONTINUE  'ing     '                                                            VOKW36  = 'VOTABLE.RESOURCE.INFO.OBJ_TYPE.<xmlattr>.name<VOEND>OBJ_TYPE'        VOKW37  = 'VOTABLE.RESOURCE.INFO.OBJ_TYPE.<xmlattr>.ucd<VOEND>src.class'        VOKW38  = 'VOTABLE.RESOURCE.INFO.OBJ_TYPE.<xmlattr>.value<VOEND>Fixed'          VOKW39  = 'VOTABLE.RESOURCE.INFO.PROCVER.<xmlattr>.comment<VOEND>Processing Ve&'CONTINUE  'rsion   '                                                            VOKW40  = 'VOTABLE.RESOURCE.INFO.PROCVER.<xmlattr>.name<VOEND>PROCVER'          VOKW41  = 'VOTABLE.RESOURCE.INFO.PROCVER.<xmlattr>.ucd<VOEND>meta.version'      VOKW42  = 'VOTABLE.RESOURCE.INFO.PROCVER.<xmlattr>.value<VOEND>DX11D'           VOKW43  = 'VOTABLE.RESOURCE.INFO.RADIUS.<xmlattr>.comment<VOEND>Search Radius &'CONTINUE  'degrees '                                                            VOKW44  = 'VOTABLE.RESOURCE.INFO.RADIUS.<xmlattr>.name<VOEND>RADIUS'            VOKW45  = 'VOTABLE.RESOURCE.INFO.RADIUS.<xmlattr>.ucd<VOEND>pos.radius'         VOKW46  = 'VOTABLE.RESOURCE.INFO.RADIUS.<xmlattr>.value<VOEND>0.01'             VOKW47  = 'VOTABLE.RESOURCE.INFO.TELESCOP.<xmlattr>.comment<VOEND>Telescope Na&'CONTINUE  'me      '                                                            VOKW48  = 'VOTABLE.RESOURCE.INFO.TELESCOP.<xmlattr>.name<VOEND>TELESCOP'        VOKW49  = 'VOTABLE.RESOURCE.INFO.TELESCOP.<xmlattr>.ucd<VOEND>instr.obsty'      VOKW50  = 'VOTABLE.RESOURCE.INFO.TELESCOP.<xmlattr>.value<VOEND>PLANCK'         VOKW51  = 'VOTABLE.RESOURCE.TABLE.FIELD.ra.<xmlattr>.unit<VOEND>degrees'        VOKW52  = 'VOTABLE.RESOURCE.TABLE.FIELD.dec.<xmlattr>.unit<VOEND>degrees'       VOKW53  = 'VOTABLE.RESOURCE.TABLE.FIELD.psi.<xmlattr>.unit<VOEND>degrees'       VOKW54  = 'VOTABLE.RESOURCE.TABLE.FIELD.mjd.<xmlattr>.unit<VOEND>days'          VOKW55  = 'VOTABLE.RESOURCE.TABLE.FIELD.signal.<xmlattr>.unit<VOEND>K_CMB'      VOKW56  = 'VOTABLE.RESOURCE.TABLE.FIELD.glon.<xmlattr>.unit<VOEND>degrees'      VOKW57  = 'VOTABLE.RESOURCE.TABLE.FIELD.glat.<xmlattr>.unit<VOEND>degrees'      END                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             @^J�g��g�5�~U3'yBA�@�v�9+e):��P@nb_v6�@,syd�pF24M@^K��?:X�5����BH@�Hڐ�&z;	3@n���;S@:�'��~F24M@^K�P��0�5�eN�sfB�@�H�;�b޻0��@n�>mM
+@8Wf�$F24M@^K7��'��5����|�BD[@�v���ET:��@n!?�OJ@:�Q�F24M@^KK�
�%�5�o(
BBD�@�v��dp�y��@nO�&d@<�!FF24M@^K�a� ��5��2�wCiB�@�<|��N��G@n,b�'�@>�n��/F24M@^J�PLז�5���W�Ci??@�\���,�]j@nP/�@-�b��F24M@^J�?�t�5�0�/!Ci?h@�\�A���:�ې@nW�/�z@,�����F24M@^J��mJ�5�ӓ�yBE(@�v�(D;19�@n=^�
m@4#�+�F24M@^J�-Sޞ�5��к4BC@�v�r�~:R�b@n?���@3�6��GF24M@^J���b��5��2�Z�Ci?�@�\�6I��|B@n � �@2��%�F24M@^J�*"��5�<��x�Ci?�@�\�իB ���;@n,��m�@2����F24M@^JŒ@��5�S`��BD�@�v��|a:�x�@nYo�Q>@..�r&F24M@^J�p;�.�5���g�#BB�@�v�U��;$`s@nUb��d@/�9��F24M@^K����5��	��BC�@�v���~8�ԭ�@n3^��Z@6�+>�[F24M@^Kp*����5�(��2qCiC@�<�
�����@nl��lf@8��ȯ�F24M@^Kz�Љ�5��Qp�CiB�@�<,���:���@ny��Ų@8HW )F24M@^Kq�hP��5��y\�CiB�@�<ky�>��I�@n|J7@7~k
+�F24M@^Kpv8Ib�5�׭�r�CiC.@�<�	�9փ�@nd?s�@9D�ㄎF24M@^Ka�;���5�dk�+CiC�@�=e��ɺ*|@nT0��`@9�,�SiF24M@^Kk�x<�5�y���`CiC_@�='M���\{�@nX��[@9�80Q�F24M@^J��}���5���3�Ci?�@�\��%a:�I:�@n��@1�K��F24M@^J�����5���<iCi?�@�\���Jx�
+U!@n�>�@1�7��F24M@^J�&�=��5���!�rCi?s@�\��J���7@nM���@7<��v�F24M@^J�g��g�5�~U3'y�e�@�v�9+e);�Z@nb_v6�@,syd�pF24S@^K��?:X�5�����e�@�Hڐ�&z�I2@n���;S@:�'��~F24S@^K�P��0�5�eN�sf�e�&@�H�;�b޺�U}@n�>mM
+@8Wf�$F24S@^K7��'��5����|��e��@�v���ET;��@n!?�OJ@:�Q�F24S@^KK�
�%�5�o(
B�e�3@�v��dp:�j�@nO�&d@<�!FF24S@^K�a� ��5��2�wCB�@�<|��N;Lc@n,b�'�@>�n��/F24S@^J�PLז�5���W�C??@�\���,���@nP/�@-�b��F24S@^J�?�t�5�0�/!C?h@�\�A��Ļ���@nW�/�z@,�����F24S@^J��mJ�5�ӓ�y�e��@�v�(D:�<1@n=^�
m@4#�+�F24S@^J�-Sޞ�5��к4�e��@�v�r�~;gĖ@n?���@3�6��GF24S@^J���b��5��2�Z�C?�@�\�6I�:�:�@n � �@2��%�F24S@^J�*"��5�<��x�C?�@�\�իB ;�R}@n,��m�@2����F24S@^JŒ@��5�S`���e�z@�v��|a�*/�@nYo�Q>@..�r&F24S@^J�p;�.�5���g�#�e�@�v�U�Իd�_@nUb��d@/�9��F24S@^K����5��	���e�h@�v���~8;��@n3^��Z@6�+>�[F24S@^Kp*����5�(��2qCC@�<�
��:e�@nl��lf@8��ȯ�F24S@^Kz�Љ�5��Qp�CB�@�<,���9i�@ny��Ų@8HW )F24S@^Kq�hP��5��y\�CB�@�<ky�>�Wd�@n|J7@7~k
+�F24S@^Kpv8Ib�5�׭�r�CC.@�<�	�8�EV@nd?s�@9D�ㄎF24S@^Ka�;���5�dk�+CC�@�=e���;��@nT0��`@9�,�SiF24S@^Kk�x<�5�y���`CC_@�='M��:��@nX��[@9�80Q�F24S@^J��}���5���3�C?�@�\��%a:���@n��@1�K��F24S@^J�����5���<iC?�@�\���Jx��0�@n�>�@1�7��F24S@^J�&�=��5���!�rC?s@�\��J�;r l@nM���@7<��v�F24S@^K?6���5��c�ڻB�(R@�[>�x�:�e�@n�_0U@0S�,_=F25M@^K!���5���>"B�'@@�[=���Ժ��.@n��7�@0޻�~�F25M@^KĤ72��5�����B�l�@�.0�@�:�t@n|��@=�6>!F25M@^K������5��qd��B�0@���l�s;�7@n�@+��@7Rı�F25M@^K�'K#�5��"Ӥ�B�lf@�.0t�^X:
+�@n���@:"}�KKF25M@^K�E�r��5����NB�/e@��db��W��@n��)�@9'��(XF25M@^K��")��5�S`���B�m�@�.1+0d;��t@n�`d�@<C�7�F25M@^J�Mr4Y�5��)��C���@�I�eb�;��@n�F�0@6�����F25M@^K�H���5���a�	B�'t@�[=�σ�;�=�@n`у�P@3�n��F25M@^J�
+���5��&ԹXC���@�I����>����@n#
�V�@3�����F25M@^J�E��5�b��C���@�I��k����@n+z�@1V�ށ�F25M@^J�����5�_�LC�̼@�I��4��9�'�@n+`�&A@1~��yqF25M@^KgʕX�5���$@%B�(-@�[>[F�o;C
+@nI��E�@4�m��F25M@^J�i� >�5��6�s�C���@�I���29Ywy@n5
\��@.�����F25M@^K�����5�M/?��B�'x@�[>3t~G:�@nA]�4�@6o��:F25M@^K�y��5�h��L�B�',@�[>�
:H��@nCP�W�@6�zF25M@^K#+�H�5��G�+�B�&�@�[=}P��;_@n1y�!@7�N�yeF25M@^K) C@�5��^��B�'@�[=��Pĸ�?@n7��>�@7��'CF25M@^K�
��;�5�@��B�0@����\~���*@n�0��@9�N���F25M@^KG�0��5��j�j�B�&�@�[=J���/�@nS>d��@4���F25M@^K�Ɗ�^�5�@\�B�l�@�.0�
��:��m@ne�N�k@?��d�F25M@^K�T�Z��5�%�EaB�l�@�.1� ػ�d@ni�9�@?�_FH5F25M@^K�l����5���[aB�0D@���ȕ;�@nMn;��@=憘TF25M@^K�0x���5���U4�B�/@��z�|:��@nL>��@=��)�*F25M@^K�-�t�5�M
+c��B�l�@�.0��ۈ;�||@nh����@>X��o�F25M@^K��’�5����յB�/?@��o|�;��@nqp�'@;�� �F25M@^K�Z��5���`7VB�0<@��	.�;�m�@ng����@;R}�lF25M@^K?6���5��c�ڻBP�@�[>�x�����@n�_0U@0S�,_=F25S@^K!���5���>"BN@�[=���Ի1��@n��7�@0޻�~�F25S@^KĤ72��5�����A��Q@�.0�@�:���@n|��@=�6>!F25S@^K������5��qd��B`@���l�s��6/@n�@+��@7Rı�F25S@^K�'K#�5��"Ӥ�A���@�.0t�^X;\2�@n���@:"}�KKF25S@^K�E�r��5����NB^�@��db���T@n��)�@9'��(XF25S@^K��")��5�S`���A��@�.1+0d:k�@n�`d�@<C�7�F25S@^J�Mr4Y�5��)��C:�@�I�eb��#�p@n�F�0@6�����F25S@^K�H���5���a�	BN�@�[=�σ��-h"@n`у�P@3�n��F25S@^J�
+���5��&ԹXC:�@�I����>�@�@n#
�V�@3�����F25S@^J�E��5�b��C:�@�I��k���@n+z�@1V�ށ�F25S@^J�����5�_�LC:w@�I��4��:
2�@n+`�&A@1~��yqF25S@^KgʕX�5���$@%BPZ@�[>[F�o:�u@nI��E�@4�m��F25S@^J�i� >�5��6�s�C:�@�I���2����@n5
\��@.�����F25S@^K�����5�M/?��BN�@�[>3t~G��&X@nA]�4�@6o��:F25S@^K�y��5�h��L�BNX@�[>�
��n @nCP�W�@6�zF25S@^K#+�H�5��G�+�BM|@�[=}P��;��+@n1y�!@7�N�yeF25S@^K) C@�5��^��BN@�[=��PĻL��@n7��>�@7��'CF25S@^K�
��;�5�@��B`#@����\~�Q�;@n�0��@9�N���F25S@^KG�0��5��j�j�BM@�[=J��;	,�@nS>d��@4���F25S@^K�Ɗ�^�5�@\�A��%@�.0�
���V۷@ne�N�k@?��d�F25S@^K�T�Z��5�%�EaA��*@�.1� ظ���@ni�9�@?�_FH5F25S@^K�l����5���[aB`�@���ȕ:��@nMn;��@=憘TF25S@^K�0x���5���U4�B^@��z�|:%J@nL>��@=��)�*F25S@^K�-�t�5�M
+c��A��f@�.0��ۈ;"K8@nh����@>X��o�F25S@^K��’�5����յB^~@��o|��E�@nqp�'@;�� �F25S@^K�Z��5���`7VB`y@��	.�����@ng����@;R}�lF25S@^K�ST��5���
+[���@��!-w�GG�@nv���I@=P���F26M@^K��5a��5�F�|��@��dp��"@n
w�@;_3�F26M@^K��"���5�ӈ����_@��%oVD9?�@n��L7�@:�8֎�F26M@^K���P;�5����3����@�.1�h%�d[I@n��h� @:���F26M@^K����5�
nW1�C�@�w��[�&:��@n���bz@:o���F26M@^K"B�tU�5�U��޳�A�@�[>�>�~;Y�@n'�j�@8��6�{F26M@^K�9G)�5�$<q���?�@�[?-���:�N
@n q��R@8��¾�F26M@^Kr>�5��`^�8�@�[?����;��O@n��@9��S"F26M@^K(:�^�5���5C�@�I��˃ٺ�\@n@�Q@: ��F26M@^K���Ē�5�S�T�%��
+@������:��b@nKݗ�%@?�)���F26M@^KS0l�5�7��]�>G@�[?'�vT;��@nXix8@4��tF26M@^K,��5���8��B@@�[>Ҏ$�<*Z@nh�u�j@3J&9F26M@^Kΰp�5��ҤFn�:3@�[?���;�q@ng�x��@2�`�b�F26M@^J��
��5��c�C`@�I��$V;�Q<@n?~km�@2�X�`�F26M@^J׊9��5��b��C
+�@�I���6�;*��@nE1R�@10�t�IF26M@^K^����5�_U�@CX@�I����c���@n"@�
�@7??���F26M@^K.�O��5�F1����>@�[?�1tX��/�@n?��t:@6]j�hF26M@^K��>r��5��7K������@�.2y*n�X�\@ns���@<�S�0cF26M@^K�q�G�5���;m8���\@�.1��	�;�w@nm-���@<[fߵF26M@^K����5�2����%@�.2�.�@ne-�h@>\Կ��F26M@^K���`@�5��-�;2��@����;s��@nX�'&@>K/���F26M@^K������5���B���a@��~�2�0�'@n^�k�W@=עRVF26M@^K�ST��5���
+[���@��!-w;�fx@nv���I@=P���F26S@^K��5a��5�F�|���T@��dp�;^ @n
w�@;_3�F26S@^K��"���5�ӈ������@��%oVD�܍S@n��L7�@:�8֎�F26S@^K���P;�5����3�߾�@�.1�h%�f�@n��h� @:���F26S@^K����5�
nW1�BN?<@�w��[�&��E@n���bz@:o���F26S@^K"B�tU�5�U��޳��6@�[>�>�~��+�@n'�j�@8��6�{F26S@^K�9G)�5�$<q�����@�[?-��ܻ���@n q��R@8��¾�F26S@^Kr>�5��`^��@�[?����:��@n��@9��S"F26S@^K(:�^�5���5BN/B@�I��˃ٻ�v�@n@�Q@: ��F26S@^K���Ē�5�S�T�%���A@������;ddQ@nKݗ�%@?�)���F26S@^KS0l�5�7��]���@�[?'�vT��@nXix8@4��tF26S@^K,��5���8���H@�[>Ҏ$�:�<�@nh�u�j@3J&9F26S@^Kΰp�5��ҤFn��F@�[?���;�S�@ng�x��@2�`�b�F26S@^J��
��5��c�BN-~@�I��$V�:�.@n?~km�@2�X�`�F26S@^J׊9��5��b��BN+�@�I���6ں�'�@nE1R�@10�t�IF26S@^K^����5�_U�@BN-^@�I����c;���@n"@�
�@7??���F26S@^K.�O��5�F1������@�[?�1tX���T@n?��t:@6]j�hF26S@^K��>r��5��7K���߿�@�.2y*n:�ޕ@ns���@<�S�0cF26S@^K�q�G�5���;m8�߿�@�.1��	�;4��@nm-���@<[fߵF26S@^K����5�2��߿	@�.2�.���
@ne-�h@>\Կ��F26S@^K���`@�5��-�;2���6@����;�..@nX�'&@>K/���F26S@^K������5���B����l@��~�2�
+H'@n^�k�W@=עRVF26S
\ No newline at end of file

From 86e758cc1d5ba9660f2d61afb6758c4a84ef94f6 Mon Sep 17 00:00:00 2001
From: Judith Silverman <judith@ipac.caltech.edu>
Date: Sat, 5 Jul 2025 18:12:38 -0700
Subject: [PATCH 8/8] Add Data_Detail class

---
 src/Column.hxx                                |  9 ++-
 src/Common.hxx                                |  1 +
 src/Data_Details.hxx                          | 72 +++++++++++++++++++
 src/Data_Element.hxx                          | 40 +++++------
 src/Field_Framework.hxx                       |  1 -
 src/Resource_Element.hxx                      | 19 +++--
 src/Row.hxx                                   | 16 +++--
 src/Row/insert_from_ascii.cxx                 |  6 +-
 src/Row/insert_null.cxx                       | 12 ++--
 src/Table.hxx                                 | 63 +++++++++-------
 src/Table/Table.cxx                           | 14 ++--
 src/Table/read_dsv/read_dsv_rows.cxx          | 21 +++---
 .../set_column_info/set_column_info.cxx       |  1 -
 src/Table/read_fits.cxx                       | 10 +--
 src/Table/read_hdf5/read_hdf5.cxx             | 13 ++--
 .../append_ipac_data_member.cxx               |  4 +-
 .../create_types_from_ipac_headers.cxx        |  2 +-
 src/Table/read_ipac_table/read_ipac_table.cxx | 18 ++---
 .../shrink_ipac_string_columns_to_fit.cxx     | 53 ++++++++------
 src/Table_Element.hxx                         | 31 +++++---
 src/Table_Ops.cxx                             | 48 +++++++------
 src/Utils/Table_Utils.hxx                     | 17 ++---
 src/Utils/Table_Utils/append_column.cxx       | 23 ------
 src/Utils/Table_Utils/winnow_rows.cxx         |  3 +
 src/ptree_readers.hxx                         |  3 +-
 .../append_data_from_stream.cxx               | 32 ++++++---
 .../read_binary2/read_binary2.cxx             | 11 ++-
 .../read_tabledata/read_tabledata.cxx         | 10 ++-
 src/unsafe_copy_to_row.hxx                    | 11 ---
 test/convert.sh                               |  8 +--
 wscript                                       |  1 -
 31 files changed, 327 insertions(+), 246 deletions(-)
 create mode 100644 src/Data_Details.hxx
 delete mode 100644 src/Utils/Table_Utils/append_column.cxx
 delete mode 100644 src/unsafe_copy_to_row.hxx

diff --git a/src/Column.hxx b/src/Column.hxx
index c193be8d..9669e954 100644
--- a/src/Column.hxx
+++ b/src/Column.hxx
@@ -43,11 +43,6 @@ public:
 
     Column(const std::string &name, const Data_Type &type) : Column(name, type, 1) {}
 
-
-    inline size_t get_data_size() const {
-        return tablator::data_size(type_) * array_size_;
-    }
-
     // accessors
     inline const std::string &get_name() const { return name_; }
     inline const Data_Type &get_type() const { return type_; }
@@ -85,6 +80,10 @@ public:
     inline bool get_dynamic_array_flag() const { return dynamic_array_flag_; }
     inline void set_dynamic_array_flag(bool b) { dynamic_array_flag_ = b; }
 
+    inline size_t get_data_size() const {
+        return tablator::data_size(type_) * array_size_;
+    }
+
 private:
     std::string name_;
     Data_Type type_;
diff --git a/src/Common.hxx b/src/Common.hxx
index 5c239920..02f63af7 100644
--- a/src/Common.hxx
+++ b/src/Common.hxx
@@ -64,6 +64,7 @@ static const std::string PARAMREF("PARAMref");
 static const std::string QUERY_STATUS("QUERY_STATUS");
 static const std::string REF("ref");
 static const std::string RESOURCE("RESOURCE");
+static const std::string STREAM("STREAM");
 static const std::string TABLE("TABLE");
 static const std::string TABLEDATA("TABLEDATA");
 static const std::string TIMESYS("TIMESYS");
diff --git a/src/Data_Details.hxx b/src/Data_Details.hxx
new file mode 100644
index 00000000..0d61812f
--- /dev/null
+++ b/src/Data_Details.hxx
@@ -0,0 +1,72 @@
+#pragma once
+
+#include "Common.hxx"
+#include "Field_Framework.hxx"
+#include "Row.hxx"
+
+namespace tablator {
+
+class Data_Details {
+public:
+    Data_Details(size_t row_size, size_t num_rows = 0) : row_size_(row_size) {
+        init(num_rows);
+    }
+
+    Data_Details(const Field_Framework &field_framework, size_t num_rows = 0)
+            : Data_Details(field_framework.get_row_size(), num_rows) {}
+
+
+    void append_row(const Row &row) {
+        assert(row.get_data().size() == get_row_size());
+        data_.reserve(data_.size() + row.get_data().size());
+        data_.insert(data_.end(), row.get_data().begin(), row.get_data().end());
+    }
+
+
+    void append_rows(const Data_Details &other) {
+        assert(other.get_row_size() == get_row_size());
+
+        data_.reserve(data_.size() + other.get_data().size());
+        data_.insert(data_.end(), other.get_data().begin(), other.get_data().end());
+    }
+
+    void adjust_num_rows(const size_t new_num_rows) {
+        data_.resize(new_num_rows * get_row_size());
+    }
+
+    void reserve_rows(const size_t &new_num_rows) {
+        data_.reserve(get_row_size() * new_num_rows);
+    }
+
+    // accessors
+
+    size_t get_data_size() const { return data_.size(); }
+
+    size_t get_num_rows() const {
+        if (get_row_size() == 0) {
+            return 0;
+        }
+        return get_data_size() / get_row_size();
+    };
+
+    inline size_t get_row_size() const { return row_size_; }
+
+    inline const std::vector<uint8_t> &get_data() const { return data_; }
+
+    // Non-const to support append_rows().
+    inline std::vector<uint8_t> &get_data() { return data_; }
+
+    inline void set_data(const std::vector<uint8_t> &d) { data_ = d; }
+
+
+private:
+    void init(const size_t &new_num_rows) {
+	  reserve_rows(new_num_rows);
+    }
+
+    // Can't be const because of append_rows().
+    std::vector<uint8_t> data_;
+    size_t row_size_;
+};
+
+}  // namespace tablator
diff --git a/src/Data_Element.hxx b/src/Data_Element.hxx
index c23d04ca..79b96a5f 100644
--- a/src/Data_Element.hxx
+++ b/src/Data_Element.hxx
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Column.hxx"
+#include "Data_Details.hxx"
 #include "Field_Framework.hxx"
 
 namespace tablator {
@@ -8,12 +9,11 @@ namespace tablator {
 class Data_Element {
 public:
     Data_Element(const Field_Framework &field_framework,
-                 const std::vector<uint8_t> &data)
-            : field_framework_(field_framework), data_(data) {}
-
-    Data_Element(const Field_Framework &field_framework)
-            : Data_Element(field_framework, std::vector<uint8_t>()) {}
+                 const Data_Details &data_details)
+            : field_framework_(field_framework), data_details_(data_details) {}
 
+    Data_Element(const Field_Framework &field_framework, size_t num_rows = 0)
+            : Data_Element(field_framework, Data_Details(field_framework, num_rows)) {}
 
     // accessors
     const Field_Framework &get_field_framework() const { return field_framework_; }
@@ -21,6 +21,10 @@ public:
     Field_Framework &get_field_framework() { return field_framework_; }
 
 
+    const Data_Details &get_data_details() const { return data_details_; }
+
+    Data_Details &get_data_details() { return data_details_; }
+
     inline const std::vector<Column> &get_columns() const {
         return field_framework_.get_columns();
     }
@@ -33,37 +37,31 @@ public:
     }
 
     size_t get_row_size() const { return field_framework_.get_row_size(); }
+    size_t get_num_rows() const { return data_details_.get_num_rows(); }
 
-    size_t get_num_rows() const {
-        if (get_row_size() == 0) {
-            return 0;
-        }
-        return data_.size() / get_row_size();
+    void adjust_num_rows(const size_t &new_num_rows) {
+        data_details_.adjust_num_rows(new_num_rows);
     }
 
-    // called by query_server to trim result set
-    void resize_data(size_t &new_num_rows) {
-        data_.resize(get_row_size() * new_num_rows);
+    void reserve_rows(const size_t &new_num_rows) {
+        get_data_details().reserve_rows(new_num_rows);
     }
 
-    void reserve_data(size_t &new_num_rows) {
-        data_.reserve(get_row_size() * new_num_rows);
+    inline const std::vector<uint8_t> &get_data() const {
+        return data_details_.get_data();
     }
 
-
-    inline const std::vector<uint8_t> &get_data() const { return data_; }
-
     // Non-const to support append_rows().
-    inline std::vector<uint8_t> &get_data() { return data_; }
+    inline std::vector<uint8_t> &get_data() { return data_details_.get_data(); }
 
-    inline void set_data(const std::vector<uint8_t> &d) { data_ = d; }
+    inline void set_data(const std::vector<uint8_t> &d) { data_details_.set_data(d); }
 
 private:
     // Non-const to allow query_server to update column's field_properties.
     Field_Framework field_framework_;
 
     // Non-const because of append_rows().
-    std::vector<uint8_t> data_;
+    Data_Details data_details_;
 };
 
 }  // namespace tablator
diff --git a/src/Field_Framework.hxx b/src/Field_Framework.hxx
index b112fd11..0afebdd9 100644
--- a/src/Field_Framework.hxx
+++ b/src/Field_Framework.hxx
@@ -46,7 +46,6 @@ public:
     inline const std::vector<size_t> &get_offsets() const { return offsets_; }
     inline std::vector<size_t> &get_offsets() { return offsets_; }
 
-
 private:
     void append_column(const Column &column) {
         columns_.emplace_back(column);
diff --git a/src/Resource_Element.hxx b/src/Resource_Element.hxx
index f6ce8472..1389c99f 100644
--- a/src/Resource_Element.hxx
+++ b/src/Resource_Element.hxx
@@ -381,6 +381,16 @@ public:
         return get_main_table_element().get_field_framework();
     }
 
+
+    const Data_Details &get_data_details() const {
+        return get_main_table_element().get_data_details();
+    }
+
+    Data_Details &get_data_details() {
+        return get_main_table_element().get_data_details();
+    }
+
+
     const std::vector<Column> &get_columns() const {
         return get_main_table_element().get_columns();
     }
@@ -397,13 +407,12 @@ public:
     size_t get_num_rows() const { return get_main_table_element().get_num_rows(); }
 
     // called by query_server to trim result set
-    void resize_data(size_t &new_num_rows) {
-        get_main_table_element().resize_data(new_num_rows);
+    void adjust_num_rows(const size_t &new_num_rows) {
+        get_main_table_element().adjust_num_rows(new_num_rows);
     }
 
-    // called by query_server to trim result set
-    void reserve_data(size_t &new_num_rows) {
-        get_main_table_element().reserve_data(new_num_rows);
+    void reserve_rows(const size_t &new_num_rows) {
+        get_main_table_element().reserve_rows(new_num_rows);
     }
 
     std::vector<Field> &get_table_element_params() {
diff --git a/src/Row.hxx b/src/Row.hxx
index 2840c043..6d450ee1 100644
--- a/src/Row.hxx
+++ b/src/Row.hxx
@@ -3,24 +3,25 @@
 #include <cassert>
 #include <vector>
 
+#include "Common.hxx"
 #include "Data_Type.hxx"
-#include "unsafe_copy_to_row.hxx"
 
 namespace tablator {
 class Row {
 public:
-    Row(const size_t &size) : data_(size) {}
+    Row(const size_t &data_size) : data_(data_size) {}
 
     void fill_with_zeros() { std::fill(data_.begin(), data_.end(), 0); }
 
-    void insert_null(const Data_Type &type, const size_t &array_size,
-                     const size_t &col_idx, const size_t &offset,
-                     const size_t &offset_end);
+    void insert_null(Data_Type type, const size_t &array_size, const size_t &col_idx,
+                     const size_t &offset, const size_t &offset_end);
 
     template <typename T>
     void insert(const T &element, const size_t &offset) {
         assert(offset + sizeof(T) <= data_.size());
-        unsafe_copy_to_row(element, offset, data_.data());
+        std::copy(reinterpret_cast<const char *>(&element),
+                  reinterpret_cast<const char *>(&element) + sizeof(T),
+                  data_.data() + offset);
     }
 
     template <typename T>
@@ -29,6 +30,7 @@ public:
         std::copy(begin, end, data_.data() + offset);
     }
 
+
     void insert(const std::string &element, const size_t &offset_begin,
                 const size_t &offset_end) {
         std::string element_copy(element);
@@ -54,7 +56,7 @@ private:
         insert(tablator::get_null<T>(), offset);
     }
 
-    void insert_null_by_type(const Data_Type &data_type, const size_t &offset);
+    void insert_null_by_type(Data_Type data_type, const size_t &offset);
 
     std::vector<char> data_;
 };
diff --git a/src/Row/insert_from_ascii.cxx b/src/Row/insert_from_ascii.cxx
index 45ed585a..f732964f 100644
--- a/src/Row/insert_from_ascii.cxx
+++ b/src/Row/insert_from_ascii.cxx
@@ -8,7 +8,7 @@
 
 namespace tablator {
 void Row::insert_from_ascii(const std::string &element, const Data_Type &data_type,
-                            const size_t &array_size, const size_t &column,
+                            const size_t &array_size, const size_t &col_idx,
                             const size_t &offset, const size_t &offset_end) {
     if (array_size != 1 && data_type != Data_Type::CHAR) {
         std::vector<std::string> elements;
@@ -22,7 +22,7 @@ void Row::insert_from_ascii(const std::string &element, const Data_Type &data_ty
         auto element_offset = offset;
         auto element_size = data_size(data_type);
         for (auto &e : elements) {
-            insert_from_ascii(e, data_type, 1, column, element_offset,
+            insert_from_ascii(e, data_type, 1, col_idx, element_offset,
                               element_offset + element_size);
             element_offset += element_size;
         }
@@ -30,7 +30,7 @@ void Row::insert_from_ascii(const std::string &element, const Data_Type &data_ty
         switch (data_type) {
             case Data_Type::INT8_LE:
                 if (element == "?" || element == " " || element[0] == '\0') {
-                    insert_null(data_type, array_size, column, offset, offset_end);
+                    insert_null(data_type, array_size, col_idx, offset, offset_end);
                 } else {
                     bool result = (boost::iequals(element, "true") ||
                                    boost::iequals(element, "t") || element == "1");
diff --git a/src/Row/insert_null.cxx b/src/Row/insert_null.cxx
index 2a5b1c53..ec45a8e4 100644
--- a/src/Row/insert_null.cxx
+++ b/src/Row/insert_null.cxx
@@ -3,9 +3,9 @@
 #include "../Row.hxx"
 #include "../data_size.hxx"
 
-void tablator::Row::insert_null(const Data_Type &data_type, const size_t &array_size,
-                                const size_t &col_idx, const size_t &offset,
-                                const size_t &offset_end) {
+void tablator::Row::insert_null(Data_Type data_type, const size_t& array_size,
+                                const size_t& col_idx, const size_t& offset,
+                                const size_t& offset_end) {
     const int byte = (col_idx - 1) / 8;
     const char mask = (128 >> ((col_idx - 1) % 8));
 
@@ -26,8 +26,7 @@ void tablator::Row::insert_null(const Data_Type &data_type, const size_t &array_
     }
 }
 
-void tablator::Row::insert_null_by_type(const Data_Type &data_type,
-                                        const size_t &offset) {
+void tablator::Row::insert_null_by_type(Data_Type data_type, const size_t& offset) {
     switch (data_type) {
         case Data_Type::INT8_LE:
             insert_null_internal<int8_t>(offset);
@@ -63,7 +62,6 @@ void tablator::Row::insert_null_by_type(const Data_Type &data_type,
             insert('\0', offset);
             break;
         default:
-            throw std::runtime_error(
-                    "Unexpected data type in insert_null_by_type()");
+            throw std::runtime_error("Unexpected data type in insert_null_by_type()");
     }
 }
diff --git a/src/Table.hxx b/src/Table.hxx
index 281e31a3..0936e034 100644
--- a/src/Table.hxx
+++ b/src/Table.hxx
@@ -196,16 +196,15 @@ public:
     // constructors
     Table(const std::vector<Column> &Columns,
           const std::map<std::string, std::string> &property_map,
-          bool got_null_bitfields_column = false);
+          bool got_null_bitfields_column = false, size_t num_rows = 0);
 
     Table(const std::vector<Column> &Columns,
           const tablator::Labeled_Properties &property_pair_vec,
-          bool got_null_bitfields_column = false);
-
-    Table(const std::vector<Column> &Columns, bool got_null_bitfields_column = false)
+          bool got_null_bitfields_column = false, size_t num_rows = 0);
+    Table(const std::vector<Column> &Columns, bool got_null_bitfields_column = false,
+          size_t num_rows = 0)
             : Table(Columns, std::map<std::string, std::string>(),
-                    got_null_bitfields_column) {}
-
+                    got_null_bitfields_column, num_rows) {}
 
     Table(const boost::filesystem::path &input_path, const Format &format);
     Table(const boost::filesystem::path &input_path) { read_unknown(input_path); }
@@ -297,10 +296,8 @@ public:
 
     // table modifiers
 
-    void append_row(const Row &row) {
-        assert(row.get_data().size() == get_row_size());
-        tablator::append_row(get_data(), row);
-    }
+    // query_server and ZTF-mtc-utils call this function.
+    void append_row(const Row &row) { get_data_details().append_row(row); }
 
     void append_rows(const Table &table2);
 
@@ -314,7 +311,6 @@ public:
                const Command_Line_Options &options = default_options) const {
         write(path, Format(path), options);
     }
-
     void write_ipac_table(std::ostream &os,
                           const Command_Line_Options &options = default_options) const {
         Ipac_Table_Writer::write(*this, os, options);
@@ -451,6 +447,7 @@ public:
     void write_sqlite_db(const boost::filesystem::path &path,
                          const Command_Line_Options &options) const;
 
+
     // Following the VOTable convention, we use the most significant
     // bit for the first column.
     bool is_null_value(size_t row_idx, size_t col_idx) const {
@@ -476,6 +473,7 @@ public:
         return get_data().at(pos) & (128 >> ((col_idx - 1) % 8));
     }
 
+
     // extractors
 
     std::string extract_value_as_string(
@@ -612,6 +610,10 @@ public:
 
     // accessors
 
+    size_t get_num_columns() const { return get_columns().size(); }
+
+    //===========================================================
+
     // getters for Optional elements
 
     ATTRIBUTES &get_attributes() { return options_.attributes_; }
@@ -672,6 +674,7 @@ public:
         return get_resource_elements().at(get_results_resource_idx());
     }
 
+
     Field_Framework &get_field_framework() {
         return get_results_resource_element().get_field_framework();
     }
@@ -680,26 +683,34 @@ public:
         return get_results_resource_element().get_field_framework();
     }
 
-    // called by query_server to trim result set
-    void resize_data(size_t &new_num_rows) {
-        get_results_resource_element().resize_data(new_num_rows);
+    Data_Details &get_data_details() {
+        return get_results_resource_element().get_data_details();
+    }
+
+    const Data_Details &get_data_details() const {
+        return get_results_resource_element().get_data_details();
     }
 
+    void adjust_num_rows(const size_t &new_num_rows) {
+        get_results_resource_element().adjust_num_rows(new_num_rows);
+    }
+
+
+    // deprecated
     // called by query_server to trim result set
-    void reserve_data(size_t &new_num_rows) {
-        get_results_resource_element().reserve_data(new_num_rows);
+    void resize_data(const size_t &new_num_rows) {
+        get_results_resource_element().adjust_num_rows(new_num_rows);
     }
 
     // Non-const to allow query_server to modify Field_Properties.
     std::vector<Column> &get_columns() {
         return get_results_resource_element().get_columns();
     }
+
     const std::vector<Column> &get_columns() const {
         return get_results_resource_element().get_columns();
     }
 
-    size_t get_num_columns() const { return get_columns().size(); }
-
     const std::vector<size_t> &get_offsets() const {
         return get_results_resource_element().get_offsets();
     }
@@ -707,6 +718,7 @@ public:
     size_t get_row_size() const {
         return get_results_resource_element().get_row_size();
     }
+
     size_t get_num_rows() const {
         return get_results_resource_element().get_num_rows();
     }
@@ -727,6 +739,7 @@ public:
     std::vector<Field> &get_table_element_params() {
         return get_results_resource_element().get_table_element_params();
     }
+
     const std::vector<Field> &get_table_element_params() const {
         return get_results_resource_element().get_table_element_params();
     }
@@ -734,6 +747,7 @@ public:
     std::vector<Field> &get_table_element_fields() {
         return get_results_resource_element().get_table_element_fields();
     }
+
     const std::vector<Field> &get_table_element_fields() const {
         return get_results_resource_element().get_table_element_fields();
     }
@@ -747,12 +761,10 @@ public:
         return get_results_resource_element().get_data();
     }
 
-
     Table_Element &get_main_table_element() {
         return get_results_resource_element().get_main_table_element();
     }
 
-
     const Table_Element &get_main_table_element() const {
         return get_results_resource_element().get_main_table_element();
     }
@@ -928,6 +940,7 @@ private:
         }
     }
 
+
     std::vector<size_t> get_column_widths(const Command_Line_Options &options) const {
         return Ipac_Table_Writer::get_column_widths(*this, options);
     }
@@ -973,7 +986,6 @@ private:
     }
 
     // helpers for reading
-
     size_t read_ipac_header(std::istream &ipac_file,
                             std::array<std::vector<std::string>, 4> &Columns,
                             std::vector<size_t> &ipac_table_offsets,
@@ -989,15 +1001,14 @@ private:
             const std::vector<size_t> &ipac_column_widths);
 
     static void shrink_ipac_string_columns_to_fit(
-            Field_Framework &field_framework, std::vector<uint8_t> &data,
+            Field_Framework &field_framework, Data_Details &data_details,
             const std::vector<size_t> &column_widths);
 
-    static std::vector<uint8_t> read_dsv_rows(
-            Field_Framework &field_framework,
-            const std::list<std::vector<std::string>> &dsv);
+    static Data_Details read_dsv_rows(Field_Framework &field_framework,
+                                      const std::list<std::vector<std::string>> &dsv);
 
 
-    // used only for read_dsv()?
+    // used only for read_dsv()
     static Field_Framework set_column_info(std::list<std::vector<std::string>> &dsv);
 
     Table(const std::vector<Resource_Element> &resource_elements,
diff --git a/src/Table/Table.cxx b/src/Table/Table.cxx
index b20f8950..b2a057f2 100644
--- a/src/Table/Table.cxx
+++ b/src/Table/Table.cxx
@@ -59,9 +59,10 @@ namespace tablator {
 
 Table::Table(const std::vector<Column> &columns,
              const std::map<std::string, std::string> &property_map,
-             bool got_null_bitfields_column) {
+             bool got_null_bitfields_column, size_t num_rows) {
     add_resource_element(
-            Table_Element::Builder(Field_Framework(columns, got_null_bitfields_column))
+            Table_Element::Builder(Field_Framework(columns, got_null_bitfields_column),
+                                   num_rows)
                     .build());
 
     for (auto &p : property_map) {
@@ -72,10 +73,11 @@ Table::Table(const std::vector<Column> &columns,
 
 Table::Table(const std::vector<Column> &columns,
              const Labeled_Properties &property_pair_vec,
-             bool got_null_bitfields_column)
+             bool got_null_bitfields_column, size_t num_rows)
         : results_resource_idx_(0) {
     add_resource_element(
-            Table_Element::Builder(Field_Framework(columns, got_null_bitfields_column))
+            Table_Element::Builder(Field_Framework(columns, got_null_bitfields_column),
+                                   num_rows)
                     .build());
 
     for (const auto &label_and_prop : property_pair_vec) {
@@ -415,14 +417,12 @@ bool close_enough_to_append_rows(const Field_Framework &ff1,
     return (ff1_offsets.back() == ff2_offsets.back());
 }
 
-
 void Table::append_rows(const Table &table2) {
     if (!close_enough_to_append_rows(get_field_framework(),
                                      table2.get_field_framework())) {
         throw std::runtime_error("The tables are not similar enough to append rows.");
     }
-    get_data().reserve(get_data().size() + table2.get_data().size());
-    tablator::append_rows(get_data(), table2.get_data());
+    get_data_details().append_rows(table2.get_data_details());
 }
 
 
diff --git a/src/Table/read_dsv/read_dsv_rows.cxx b/src/Table/read_dsv/read_dsv_rows.cxx
index 92242027..b0da4dcf 100644
--- a/src/Table/read_dsv/read_dsv_rows.cxx
+++ b/src/Table/read_dsv/read_dsv_rows.cxx
@@ -1,18 +1,17 @@
 #include "../../Table.hxx"
 
-std::vector<uint8_t> tablator::Table::read_dsv_rows(
-        Field_Framework &field_framework,
-        const std::list<std::vector<std::string> > &dsv) {
-    // JTODO this function should not be a Table class member.
+namespace tablator {
+
+// JTODO this function should not be a Table class member.
+Data_Details Table::read_dsv_rows(Field_Framework &field_framework,
+                                  const std::list<std::vector<std::string> > &dsv) {
     auto &columns = field_framework.get_columns();
     auto &offsets = field_framework.get_offsets();
-    size_t row_size = field_framework.get_row_size();
 
-    std::vector<uint8_t> data;
-    data.reserve(row_size * dsv.size());
+    Data_Details data_details(field_framework, dsv.size());
 
+    Row single_row(field_framework.get_row_size());
 
-    Row single_row(row_size);
     bool skipped(false);
     for (auto &dsv_row : dsv) {
         if (!skipped) {
@@ -32,7 +31,9 @@ std::vector<uint8_t> tablator::Table::read_dsv_rows(
                                              offsets[col_idx], offsets[col_idx + 1]);
             }
         }
-        tablator::append_row(data, single_row);
+        data_details.append_row(single_row);
     }
-    return data;
+    return data_details;
 }
+
+}  // namespace tablator
diff --git a/src/Table/read_dsv/set_column_info/set_column_info.cxx b/src/Table/read_dsv/set_column_info/set_column_info.cxx
index ee854da6..475d1f27 100644
--- a/src/Table/read_dsv/set_column_info/set_column_info.cxx
+++ b/src/Table/read_dsv/set_column_info/set_column_info.cxx
@@ -4,7 +4,6 @@ namespace tablator {
 
 Data_Type get_best_data_type(const Data_Type &current_type, const std::string &element);
 
-
 // FIXME: A bit icky.  This modifies the dsv document (trims
 // whitespace) while extracting metadata.
 Field_Framework Table::set_column_info(std::list<std::vector<std::string> > &dsv) {
diff --git a/src/Table/read_fits.cxx b/src/Table/read_fits.cxx
index f3f349c8..5b6fdfbd 100644
--- a/src/Table/read_fits.cxx
+++ b/src/Table/read_fits.cxx
@@ -3,6 +3,9 @@
 
 #include <CCfits/CCfits>
 
+#include "../Common.hxx"
+#include "../Data_Details.hxx"
+#include "../Field_Framework.hxx"
 #include "../Table.hxx"
 #include "../fits_keyword_ucd_mapping.hxx"
 #include "../string_to_Data_Type.hxx"
@@ -1066,8 +1069,7 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
     size_t row_size = field_framework.get_row_size();
     size_t num_rows = ccfits_table->rows();
 
-    std::vector<uint8_t> data;
-    data.reserve(row_size * num_rows);
+    tablator::Data_Details data_details(field_framework, num_rows);
 
     // CCfits dies in read_element_given_column_and_row() if there is no data in the
     // table. :(
@@ -1175,7 +1177,7 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
                             "unit", fits_col.unit());
                 }
             }
-            tablator::append_row(data, curr_row);
+            data_details.append_row(curr_row);
         }
     }
 
@@ -1184,7 +1186,7 @@ void tablator::Table::read_fits(const boost::filesystem::path &path) {
     //*********************************************************
 
     const auto table_element =
-            Table_Element::Builder(field_framework, data)
+            Table_Element::Builder(field_framework, data_details)
                     .add_trailing_info_list(table_element_trailing_infos)
                     .add_attributes(table_element_attributes)
                     .add_params(table_element_params)
diff --git a/src/Table/read_hdf5/read_hdf5.cxx b/src/Table/read_hdf5/read_hdf5.cxx
index 85dbb28b..3c0369ca 100644
--- a/src/Table/read_hdf5/read_hdf5.cxx
+++ b/src/Table/read_hdf5/read_hdf5.cxx
@@ -5,6 +5,7 @@
 #include "../HDF5_Attribute.hxx"
 #include "../HDF5_Property.hxx"
 
+
 // As of 28Jun25, all columns are created with dynamic_array_flag value <false>.
 
 namespace {
@@ -80,6 +81,7 @@ void tablator::Table::read_hdf5(const boost::filesystem::path &path) {
                 std::to_string(compound.getNmembers()));
     }
 
+
     std::vector<Column> columns;
 
     for (int i = 0; i < compound.getNmembers(); ++i) {
@@ -108,16 +110,17 @@ void tablator::Table::read_hdf5(const boost::filesystem::path &path) {
     }
 
     Field_Framework field_framework(columns, true /* got_null_bitfields_column */);
-    std::vector<uint8_t> data;
 
-    // Resize, don't just reserve.
     size_t num_rows = dataset.getSpace().getSimpleExtentNpoints();
-    data.resize(field_framework.get_row_size() * num_rows);
-    dataset.read(data.data(), compound);
+    Data_Details data_details(field_framework, num_rows);
+
+    // Resize, don't just reserve.
+    data_details.adjust_num_rows(num_rows);
+    dataset.read(data_details.get_data().data(), compound);
 
     std::vector<Table_Element> table_elements;
     const auto table_element =
-            Table_Element::Builder(field_framework, data)
+            Table_Element::Builder(field_framework, data_details)
                     .add_params(table_element_params)
                     .add_description(table_element_description)
                     .add_trailing_info_list(table_element_trailing_infos)
diff --git a/src/Table/read_ipac_table/create_types_from_ipac_headers/append_ipac_data_member.cxx b/src/Table/read_ipac_table/create_types_from_ipac_headers/append_ipac_data_member.cxx
index f058d991..f5905e22 100644
--- a/src/Table/read_ipac_table/create_types_from_ipac_headers/append_ipac_data_member.cxx
+++ b/src/Table/read_ipac_table/create_types_from_ipac_headers/append_ipac_data_member.cxx
@@ -1,8 +1,6 @@
 #include "../../../Table.hxx"
-
-namespace tablator {
 // JTODO rename
-
+namespace tablator {
 void Table::append_ipac_data_member(std::vector<Column> &columns,
                                     const std::string &name,
                                     const std::string &data_type,
diff --git a/src/Table/read_ipac_table/create_types_from_ipac_headers/create_types_from_ipac_headers.cxx b/src/Table/read_ipac_table/create_types_from_ipac_headers/create_types_from_ipac_headers.cxx
index 8c1f5bfb..b0837891 100644
--- a/src/Table/read_ipac_table/create_types_from_ipac_headers/create_types_from_ipac_headers.cxx
+++ b/src/Table/read_ipac_table/create_types_from_ipac_headers/create_types_from_ipac_headers.cxx
@@ -1,3 +1,4 @@
+#include "../../../Field_Framework.hxx"
 #include "../../../Table.hxx"
 
 #include "../../read_ipac_table.hxx"
@@ -21,7 +22,6 @@ Field_Framework Table::create_types_from_ipac_headers(
                                 ipac_columns.at(COL_TYPE_IDX).at(col_idx),
                                 ipac_column_widths.at(col_idx));
     }
-
     Field_Framework field_framework(orig_columns, true /* got_null_bitfields_column */);
     auto &columns = field_framework.get_columns();
     for (size_t col_idx = 1; col_idx < num_ipac_columns; ++col_idx) {
diff --git a/src/Table/read_ipac_table/read_ipac_table.cxx b/src/Table/read_ipac_table/read_ipac_table.cxx
index c9f5b786..b94cbb05 100644
--- a/src/Table/read_ipac_table/read_ipac_table.cxx
+++ b/src/Table/read_ipac_table/read_ipac_table.cxx
@@ -5,6 +5,7 @@
 #include <vector>
 
 
+#include "../../Utils/Table_Utils.hxx"
 #include "../../to_string.hxx"
 #include "../read_ipac_table.hxx"
 
@@ -36,21 +37,19 @@ void tablator::Table::read_ipac_table(std::istream &input_stream) {
                              labeled_resource_properties);
 
     const auto ipac_column_widths = get_ipac_column_widths(ipac_column_offsets);
-
     Field_Framework field_framework =
             create_types_from_ipac_headers(ipac_columns, ipac_column_widths);
 
     size_t num_tab_columns = ipac_columns[COL_NAME_IDX].size();
+    std::vector<size_t> minimum_column_widths(num_tab_columns, 1);
+
     std::vector<Column> &tab_columns = field_framework.get_columns();
     std::vector<size_t> &offsets = field_framework.get_offsets();
+    Data_Details data_details(field_framework);
 
-    std::vector<size_t> minimum_column_widths(num_tab_columns, 1);
     std::string line;
     std::getline(input_stream, line);
 
-    std::vector<uint8_t> data;
-    // JTODO reserve()
-
     Row single_row(field_framework.get_row_size());
     while (input_stream) {
         if (line.find_first_not_of(" \t") != std::string::npos) {
@@ -103,14 +102,15 @@ void tablator::Table::read_ipac_table(std::istream &input_stream) {
                                          ": '" + line.substr(bad_char) +
                                          "'.\n\t  Is the header not wide enough?");
 
-            tablator::append_row(data, single_row);
+            data_details.append_row(single_row);
         }
         ++current_line_num;
         std::getline(input_stream, line);
     }
-    shrink_ipac_string_columns_to_fit(field_framework, data, minimum_column_widths);
-
-    Table_Element table_element = Table_Element::Builder(field_framework, data).build();
+    shrink_ipac_string_columns_to_fit(field_framework, data_details,
+                                      minimum_column_widths);
+    Table_Element table_element =
+            Table_Element::Builder(field_framework, data_details).build();
     add_resource_element(Resource_Element::Builder(table_element)
                                  .add_labeled_properties(labeled_resource_properties)
                                  .build());
diff --git a/src/Table/read_ipac_table/shrink_ipac_string_columns_to_fit.cxx b/src/Table/read_ipac_table/shrink_ipac_string_columns_to_fit.cxx
index 1d548829..3a19ad30 100644
--- a/src/Table/read_ipac_table/shrink_ipac_string_columns_to_fit.cxx
+++ b/src/Table/read_ipac_table/shrink_ipac_string_columns_to_fit.cxx
@@ -4,42 +4,51 @@
 #include <utility>
 
 void tablator::Table::shrink_ipac_string_columns_to_fit(
-        Field_Framework &field_framework, std::vector<uint8_t> &data,
+        Field_Framework &old_field_framework, Data_Details &old_data_details,
         const std::vector<size_t> &minimum_column_data_widths) {
-    auto &columns = field_framework.get_columns();
-    auto &offsets = field_framework.get_offsets();
-    size_t old_row_size(field_framework.get_row_size());
+    auto &old_columns = old_field_framework.get_columns();
+    auto &old_offsets = old_field_framework.get_offsets();
+    size_t num_columns = old_columns.size();
+    size_t old_row_size(old_field_framework.get_row_size());
 
-    std::vector<Column> new_columns(columns);
-    std::vector<size_t> new_offsets = {0};
-    size_t new_row_size(0);
+    std::vector<uint8_t> &old_data = old_data_details.get_data();
+    size_t num_rows = old_data_details.get_num_rows();
 
-    for (size_t col_idx = 0; col_idx < columns.size(); ++col_idx) {
+    for (size_t col_idx = 0; col_idx < num_columns; ++col_idx) {
         // Populate new_offsets based on column-level data.
-        if (columns[col_idx].get_type() == Data_Type::CHAR) {
-            new_columns[col_idx].set_array_size(minimum_column_data_widths[col_idx]);
+        if (old_columns[col_idx].get_type() == Data_Type::CHAR) {
+            old_columns[col_idx].set_array_size(minimum_column_data_widths[col_idx]);
         }
-        new_row_size += new_columns[col_idx].get_data_size();
-        new_offsets.push_back(new_row_size);
     }
 
-    size_t num_rows = data.size() / old_row_size;
+    Field_Framework new_field_framework(old_columns,
+                                        true /* got_null_bitfields_column */);
+    std::vector<Column> &new_columns = new_field_framework.get_columns();
+    std::vector<size_t> &new_offsets = new_field_framework.get_offsets();
+
+    size_t new_row_size = new_field_framework.get_row_size();
+
+    if (old_row_size == new_row_size) {
+        // Nothing can be shrunk.
+        return;
+    }
 
     // FIXME: Do this in place.
-    std::vector<uint8_t> new_data(num_rows * new_row_size);
+    Data_Details new_data_details(new_row_size, num_rows);
+    std::vector<uint8_t> &new_data = new_data_details.get_data();
+
     size_t old_row_offset(0), new_row_offset(0);
     for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {
-        for (size_t col_idx = 0; col_idx < offsets.size() - 1; ++col_idx) {
-            std::copy(data.begin() + old_row_offset + offsets[col_idx],
-                      data.begin() + old_row_offset + offsets[col_idx] +
+        for (size_t col_idx = 0; col_idx < num_columns; ++col_idx) {
+            std::copy(old_data.begin() + old_row_offset + old_offsets[col_idx],
+                      old_data.begin() + old_row_offset + old_offsets[col_idx] +
                               new_columns[col_idx].get_data_size(),
-                      new_data.begin() + new_row_offset + new_offsets[col_idx]);
+                      std::back_inserter(new_data));
         }
         old_row_offset += old_row_size;
         new_row_offset += new_row_size;
     }
-    using namespace std;
-    swap(data, new_data);
-    swap(columns, new_columns);
-    swap(offsets, new_offsets);
+
+    std::swap(old_field_framework, new_field_framework);
+    std::swap(old_data_details, new_data_details);
 }
diff --git a/src/Table_Element.hxx b/src/Table_Element.hxx
index 4a9279ca..13c27afe 100644
--- a/src/Table_Element.hxx
+++ b/src/Table_Element.hxx
@@ -97,10 +97,15 @@ public:
                 : data_elements_(data_elements) {}
 
         Builder(const Field_Framework &field_framework,
-                const std::vector<uint8_t> &data) {
-            data_elements_.emplace_back(Data_Element(field_framework, data));
+                const Data_Details &data_details) {
+            data_elements_.emplace_back(Data_Element(field_framework, data_details));
         }
 
+        Builder(const Field_Framework &field_framework, size_t num_rows) {
+            data_elements_.emplace_back(Data_Element(field_framework, num_rows));
+        }
+
+
         Builder(const Field_Framework &field_framework) {
             data_elements_.emplace_back(Data_Element(field_framework));
         }
@@ -262,6 +267,15 @@ public:
         return get_main_data_element().get_field_framework();
     }
 
+    const Data_Details &get_data_details() const {
+        return get_main_data_element().get_data_details();
+    }
+
+    Data_Details &get_data_details() {
+        return get_main_data_element().get_data_details();
+    }
+
+
     const std::vector<Column> &get_columns() const {
         return get_main_data_element().get_columns();
     }
@@ -271,22 +285,19 @@ public:
         return get_main_data_element().get_offsets();
     }
 
-    //    std::vector<size_t> &get_offsets() { return
-    //    get_main_data_element().get_offsets(); }
-
     size_t get_row_size() const { return get_main_data_element().get_row_size(); }
     size_t get_num_rows() const { return get_main_data_element().get_num_rows(); }
 
     // called by query_server to trim result set
-    void resize_data(size_t &new_num_rows) {
-        get_main_data_element().resize_data(new_num_rows);
+    void adjust_num_rows(const size_t &new_num_rows) {
+        get_main_data_element().adjust_num_rows(new_num_rows);
     }
 
-    // called by query_server to trim result set
-    void reserve_data(size_t &new_num_rows) {
-        get_main_data_element().reserve_data(new_num_rows);
+    void reserve_rows(const size_t &new_num_rows) {
+        get_main_data_element().reserve_rows(new_num_rows);
     }
 
+
     const std::vector<uint8_t> &get_data() const {
         return get_main_data_element().get_data();
     }
diff --git a/src/Table_Ops.cxx b/src/Table_Ops.cxx
index fccc806b..f613f2af 100644
--- a/src/Table_Ops.cxx
+++ b/src/Table_Ops.cxx
@@ -2,6 +2,7 @@
 
 #include <set>
 
+#include "Row.hxx"
 #include "Table.hxx"
 
 //==================================================================
@@ -9,7 +10,6 @@
 namespace tablator {
 //============================================================================
 
-
 Table add_counter_column(const Table &src_table, const std::string &col_name) {
     const auto &src_columns = src_table.get_columns();
     size_t num_src_columns = src_columns.size();
@@ -23,22 +23,27 @@ Table add_counter_column(const Table &src_table, const std::string &col_name) {
         }
         dest_columns.push_back(src_columns[col_idx]);
     }
+    // Append the new column.
+    dest_columns.emplace_back(col_name, Data_Type::UINT64_LE, 1 /* array_size */,
+                              false /* dynamic_array_flag */);
 
-    dest_columns.emplace_back(col_name, Data_Type::UINT64_LE, 1 /* array_size */);
-
-    tablator::Table dest_table(dest_columns);
+    tablator::Table dest_table(dest_columns, false /* got_null_bitfields_column */);
     const auto &src_offsets = src_table.get_offsets();
     const auto &dest_offsets = dest_table.get_offsets();
 
 
     size_t src_nulls_size(src_offsets.at(1));
-    size_t src_row_size = src_table.get_row_size();
-	size_t num_rows = src_table.get_num_rows();
-    const auto &src_data = src_table.get_data();
-
     size_t dest_nulls_size(dest_offsets.at(1));
+    size_t src_row_size = src_table.get_row_size();
     size_t dest_row_size = dest_table.get_row_size();
-	dest_table.reserve_data(num_rows);
+    size_t num_rows = src_table.get_num_rows();
+
+    // JTODO Data_Details function to handle this?
+    const auto &src_data = src_table.get_data_details().get_data();
+
+    auto &dest_data_details = dest_table.get_data_details();
+    dest_data_details.reserve_rows(num_rows);
+    auto &dest_data = dest_data_details.get_data();
 
     tablator::Row row(dest_row_size);
     uint64_t cntr(1);
@@ -56,7 +61,6 @@ Table add_counter_column(const Table &src_table, const std::string &col_name) {
         // end of dest_table's null_bitflag entry.
         row.insert(row_pointer + src_nulls_size, row_pointer + src_row_size,
                    dest_nulls_size);
-
         // Add the new column value.
         row.insert(cntr, dest_offsets[num_src_columns]);
 
@@ -65,6 +69,7 @@ Table add_counter_column(const Table &src_table, const std::string &col_name) {
     return dest_table;
 }
 
+
 //=====================================================================
 
 // Src tables must have the same number of rows.
@@ -74,7 +79,6 @@ Table combine_tables(const Table &src1_table, const Table &src2_table) {
     if (src2_table.get_num_rows() != num_rows) {
         throw std::runtime_error("src tables have different numbers of rows.");
     }
-
     const std::vector<Column> &src1_columns = src1_table.get_columns();
     size_t num_src1_columns = src1_columns.size();
 
@@ -116,18 +120,19 @@ Table combine_tables(const Table &src1_table, const Table &src2_table) {
 
     // Load combined_columns with visible columns (all but null-flag one) of src1
     for (size_t col_idx = 1; col_idx < num_src1_columns; ++col_idx) {
-        combined_columns.push_back(src1_columns[col_idx]);
+        combined_columns.emplace_back(src1_columns[col_idx]);
     }
 
     // Same for columns of src2_table.
     for (size_t col_idx = 1; col_idx < num_src2_columns; ++col_idx) {
-        combined_columns.push_back(src2_columns[col_idx]);
+        combined_columns.emplace_back(src2_columns[col_idx]);
     }
 
-    // Construct dest_table.
-    Table dest_table(combined_columns);
-    std::vector<Column> dest_columns = dest_table.get_columns();
+    // JTODO Add lower-level functions to handle the copying?
 
+    // Construct dest_table.
+    Table dest_table(combined_columns, false /* got_null_bitfields_flag */, num_rows);
+    std::vector<Column> &dest_columns = dest_table.get_columns();
 
     // Prepare to load dest_table data.
     const std::vector<size_t> &src1_offsets = src1_table.get_offsets();
@@ -146,11 +151,10 @@ Table combine_tables(const Table &src1_table, const Table &src2_table) {
     const uint8_t *src1_data_ptr = src1_table.get_data().data();
     const uint8_t *src2_data_ptr = src2_table.get_data().data();
 
-    dest_table.reserve_data(num_rows);
-
     // Load dest_table data.
+
+    Row curr_row(dest_row_size);
     for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {
-        Row curr_row(dest_row_size);
         curr_row.fill_with_zeros();
 
         size_t src1_row_start_offset = row_idx * src1_row_size;
@@ -158,14 +162,13 @@ Table combine_tables(const Table &src1_table, const Table &src2_table) {
 
         uint8_t *row_data_ptr = reinterpret_cast<uint8_t *>(curr_row.get_data().data());
 
-
         // Copy src1's null bitfield data for this row.
         memcpy(row_data_ptr, src1_data_ptr + src1_row_start_offset,
                src1_null_flags_size);
 
         // Starting where previous memcpy left off, copy src2's null bitfield data for
         // this row.
-        if (num_src1_columns % 8 == 1) {
+        if (num_src1_columns % 8 == 1) {  // i.e. (num_visible_columns % 8) == 0
             memcpy(row_data_ptr + src1_null_flags_size,
                    src2_data_ptr + src2_row_start_offset, src2_null_flags_size);
         } else {
@@ -203,10 +206,9 @@ Table combine_tables(const Table &src1_table, const Table &src2_table) {
                src2_row_size - src2_null_flags_size);
 
         // Make curr_row official
-        tablator::append_row(dest_table.get_data(), curr_row);
+        dest_table.get_data_details().append_row(curr_row);
     }
     return dest_table;
 }
 
-
 }  // namespace tablator
diff --git a/src/Utils/Table_Utils.hxx b/src/Utils/Table_Utils.hxx
index 4f16ac3f..88e7971c 100644
--- a/src/Utils/Table_Utils.hxx
+++ b/src/Utils/Table_Utils.hxx
@@ -1,22 +1,13 @@
 #pragma once
 
 #include <set>
-
-#include "../Column.hxx"
-#include "../Field_Framework.hxx"
-#include "../Row.hxx"
+#include <vector>
+#include <cstdint>
+#include <cstddef>
 
 namespace tablator {
 
-// row-related functions
-inline void append_row(std::vector<uint8_t> &data, const Row &row) {
-    data.insert(data.end(), row.get_data().begin(), row.get_data().end());
-}
-
-inline void append_rows(std::vector<uint8_t> &data, const std::vector<uint8_t> &data2) {
-    data.insert(data.end(), data2.begin(), data2.end());
-}
-
+// JTODO Move to Data_Details
 void winnow_rows(std::vector<uint8_t> &data,
 				 const std::set<size_t> &selected_row_idx_list,
 				 size_t num_rows, size_t row_size);
diff --git a/src/Utils/Table_Utils/append_column.cxx b/src/Utils/Table_Utils/append_column.cxx
deleted file mode 100644
index 617c5241..00000000
--- a/src/Utils/Table_Utils/append_column.cxx
+++ /dev/null
@@ -1,23 +0,0 @@
-#include "../Table_Utils.hxx"
-#if 0
-void tablator::append_column(Field_Framework &field_framework, const Column &column) {
-    auto &offsets = field_framework.get_offsets();
-
-    if (offsets.empty()) {
-        throw std::runtime_error("<offsets> is empty");
-    }
-    auto &columns = field_framework.get_columns();
-
-    auto new_columns(columns);
-    new_columns.push_back(column);
-    size_t old_row_size = *offsets.rbegin();
-    size_t new_row_size = old_row_size + new_columns.rbegin()->get_data_size();
-    auto new_offsets(offsets);
-    new_offsets.push_back(new_row_size);
-
-    /// Copy and swap for exception safety.
-    using namespace std;
-    swap(columns, new_columns);
-    swap(offsets, new_offsets);
-}
-#endif
diff --git a/src/Utils/Table_Utils/winnow_rows.cxx b/src/Utils/Table_Utils/winnow_rows.cxx
index 543ae55e..b9fbde4c 100644
--- a/src/Utils/Table_Utils/winnow_rows.cxx
+++ b/src/Utils/Table_Utils/winnow_rows.cxx
@@ -1,5 +1,8 @@
 #include "../Table_Utils.hxx"
 
+#include <string>
+#include <stdexcept>
+
 void tablator::winnow_rows(std::vector<uint8_t> &data,
                                          const std::set<size_t> &selected_row_idx_list,
                                          size_t num_rows, size_t row_size) {
diff --git a/src/ptree_readers.hxx b/src/ptree_readers.hxx
index bc0ab470..317034c2 100644
--- a/src/ptree_readers.hxx
+++ b/src/ptree_readers.hxx
@@ -8,6 +8,7 @@
 
 #include "Column.hxx"
 #include "Common.hxx"
+#include "Data_Details.hxx"
 #include "Field_Framework.hxx"
 
 namespace tablator {
@@ -51,7 +52,7 @@ Data_Element read_tabledata(const boost::property_tree::ptree &tabledata,
 Data_Element read_binary2(const boost::property_tree::ptree &binary2,
                           const std::vector<Field> &fields);
 
-void append_data_from_stream(std::vector<uint8_t> &data,
+void append_data_from_stream(Data_Details &data_details,
                              const Field_Framework &field_framework,
                              const std::vector<uint8_t> &stream,
                              const std::vector<Field> &fields, size_t num_rows);
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx
index 6fa0e8cb..0ea2ca4b 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/append_data_from_stream/append_data_from_stream.cxx
@@ -2,21 +2,29 @@
 
 #include <boost/spirit/include/qi.hpp>
 
+#include "../../../../../../Data_Details.hxx"
+#include "../../../../../../Field_Framework.hxx"
 #include "../../../../../../Utils/Null_Utils.hxx"
 #include "../../../../../../Utils/Table_Utils.hxx"
 
 namespace tablator {
 
+// for dynamic array_size column
 void insert_swapped(Row &row, size_t column_offset, const Data_Type &data_type,
                     size_t array_size, const std::vector<uint8_t> &stream,
                     size_t old_position);
+
+// for fixed array_size column
 inline void insert_swapped(Row &row, size_t column_offset, const Column &column,
                            const std::vector<uint8_t> &stream, size_t old_position) {
     return insert_swapped(row, column_offset, column.get_type(),
                           column.get_array_size(), stream, old_position);
 }
 
-void ptree_readers::append_data_from_stream(std::vector<uint8_t> &data,
+//===========================================================
+
+
+void ptree_readers::append_data_from_stream(Data_Details &data_details,
                                             const Field_Framework &field_framework,
                                             const std::vector<uint8_t> &stream,
                                             const std::vector<Field> &fields,
@@ -24,12 +32,14 @@ void ptree_readers::append_data_from_stream(std::vector<uint8_t> &data,
     auto &columns = field_framework.get_columns();
     auto &offsets = field_framework.get_offsets();
 
+    auto &data = data_details.get_data();
+
     const size_t null_flags_size((columns.size() + 6) / 8);
     size_t src_pos(0);
 
-    Row row(field_framework.get_row_size());
+    Row single_row(field_framework.get_row_size());
     for (size_t r = 0; r < num_rows; ++r) {
-        row.fill_with_zeros();
+        single_row.fill_with_zeros();
         size_t row_offset(src_pos);
         src_pos += null_flags_size;
         for (size_t col_idx = 1; col_idx < columns.size(); ++col_idx) {
@@ -39,8 +49,8 @@ void ptree_readers::append_data_from_stream(std::vector<uint8_t> &data,
 
             bool dynamic_array_flag = fields[col_idx].get_dynamic_array_flag();
             if (is_null_MSB(stream, row_offset, col_idx)) {
-                row.insert_null(col_type, col_array_size, col_idx, offsets[col_idx],
-                                offsets[col_idx + 1]);
+                single_row.insert_null(col_type, col_array_size, col_idx,
+                                       offsets[col_idx], offsets[col_idx + 1]);
                 if (dynamic_array_flag) {
                     src_pos += sizeof(uint32_t);
                 } else {
@@ -63,22 +73,22 @@ void ptree_readers::append_data_from_stream(std::vector<uint8_t> &data,
                 boost::spirit::qi::parse(begin, end, boost::spirit::qi::big_dword,
                                          dynamic_array_size);
 
-                memcpy(row.get_data().data() + offsets[col_idx], &dynamic_array_size,
-                       sizeof(uint32_t));
+                memcpy(single_row.get_data().data() + offsets[col_idx],
+                       &dynamic_array_size, sizeof(uint32_t));
 
                 // Now write the array itself, again swapping from
                 // big-ended to little-ended for internal use.
-                insert_swapped(row, offsets[col_idx] + sizeof(uint32_t), col_type,
-                               dynamic_array_size, stream, src_pos);
+                insert_swapped(single_row, offsets[col_idx] + sizeof(uint32_t),
+                               col_type, dynamic_array_size, stream, src_pos);
                 src_pos += data_size(col_type) * dynamic_array_size;
             } else {
-                insert_swapped(row, offsets[col_idx], column, stream, src_pos);
+                insert_swapped(single_row, offsets[col_idx], column, stream, src_pos);
                 src_pos += col_array_size * data_size(col_type);
             }
 
         }  // end loop through columns
         if (src_pos <= stream.size()) {
-            append_row(data, row);
+            data_details.append_row(single_row);
         }
     }  // end loop through rows
 }
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx
index 9a0f45b7..c7f6654c 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_binary2/read_binary2.cxx
@@ -68,16 +68,15 @@ Data_Element ptree_readers::read_binary2(const boost::property_tree::ptree &bina
                              field.get_field_properties(),
                              field.get_dynamic_array_flag());
     }
-    Field_Framework field_framework(columns, true /* got_null_bitfields_column */);
+    Field_Framework field_framework(columns,
+                                    true /* got_null_bitfields_column */);  // JTODO
+    Data_Details data_details(field_framework, total_num_rows);
 
-    size_t row_size = field_framework.get_row_size();
-    std::vector<uint8_t> data;
-    data.reserve(row_size * total_num_rows);
 
     for (std::size_t stream = 0; stream < streams.size(); ++stream) {
-        append_data_from_stream(data, field_framework, streams[stream], fields,
+        append_data_from_stream(data_details, field_framework, streams[stream], fields,
                                 rows_per_stream[stream]);
     }
-    return Data_Element(field_framework, data);
+    return Data_Element(field_framework, data_details);
 }
 }  // namespace tablator
diff --git a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
index b53ebd38..6e00b587 100644
--- a/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
+++ b/src/ptree_readers/read_resource_element/read_table_element/read_data_element/read_tabledata/read_tabledata.cxx
@@ -83,12 +83,10 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
     std::vector<size_t> &offsets = field_framework.get_offsets();
 
     size_t num_rows = element_lists_by_row.size();
-    size_t row_size = *offsets.rbegin();
 
-    std::vector<uint8_t> data;
-    data.reserve(row_size * num_rows);
+    Data_Details data_details(field_framework, num_rows);
+    Row single_row(*offsets.rbegin());
 
-    Row single_row(row_size);
     // JTODO Are we allowing for non-CHAR dynamic arrays?  Should all arrays end in
     // '\0'?
     for (size_t row_idx = 0; row_idx < num_rows; ++row_idx) {
@@ -115,7 +113,7 @@ tablator::Data_Element tablator::ptree_readers::read_tabledata(
                             ". Error message: " + error.what());
                 }
         }
-        append_row(data, single_row);
+        data_details.append_row(single_row);
     }
-    return Data_Element(field_framework, data);
+    return Data_Element(field_framework, data_details);
 }
diff --git a/src/unsafe_copy_to_row.hxx b/src/unsafe_copy_to_row.hxx
deleted file mode 100644
index 24584b9b..00000000
--- a/src/unsafe_copy_to_row.hxx
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-
-#include <algorithm>
-
-template <typename T>
-inline void unsafe_copy_to_row(const T &element, const size_t &offset, char *row) {
-    // FIXME: This might be undefined, because element+1 is not
-    // guaranteed to be valid
-    std::copy(reinterpret_cast<const char *>(&element),
-              reinterpret_cast<const char *>(&element + 1), row + offset);
-}
diff --git a/test/convert.sh b/test/convert.sh
index 7bfdd3b7..0d312dd3 100644
--- a/test/convert.sh
+++ b/test/convert.sh
@@ -168,17 +168,17 @@ fi
 
 ${tablator_bin} --append-rows=1 test/back_and_forth_tables/two_row_float_array.vot test/back_and_forth_tables/two_row_double_array.vot temp.json5 2> /dev/null
 if [ $? -eq 0 ]; then
-    echo "FAIL: combine tables whose corresponding columns are of different types"
+    echo "FAIL: append rows of table whose corresponding columns are of different types"
 else
-    echo "PASS: combine tables whose corresponding columns are of different types"
+    echo "PASS: append rows of table whose corresponding columns are of different types"
     rm -f temp.json5
 fi
 
 ${tablator_bin} --append-rows=1 test/back_and_forth_tables/two_row_double_array.vot test/back_and_forth_tables/two_row_double_array_II.vot out.tbl 2> /dev/null
 if [ $? -eq 0 ]; then
-    echo "FAIL: combine tables whose corresponding offsets don't match"
+    echo "FAIL: append rows of tables whose corresponding offsets don't match"
 else
-    echo "PASS: combine tables whose corresponding offsets don't match"
+    echo "PASS: append rows of tables whose corresponding offsets don't match"
     rm -f temp.json5
 fi
 
diff --git a/wscript b/wscript
index 1b39bb2c..6461bf8d 100644
--- a/wscript
+++ b/wscript
@@ -70,7 +70,6 @@ def build(bld):
              'src/Table_Ops.cxx',
              'src/Ipac_Table_Writer/internals.cxx',
              'src/Ipac_Table_Writer/Ipac_Table_Writer.cxx',
-             'src/Utils/Table_Utils/append_column.cxx',
              'src/Utils/Table_Utils/winnow_rows.cxx',
              'src/ptree_readers/ptree_readers.cxx',
              'src/ptree_readers/Utils.cxx',