Add Data_Detail class

Author: judith-ipac

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_;

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");

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

src/Data_Element.hxx

@@ -1,26 +1,30 @@
 #pragma once
 
 #include "Column.hxx"
+#include "Data_Details.hxx"
 #include "Field_Framework.hxx"
 
 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_; }
 
     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

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);

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() {

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_;
 };

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,15 +22,15 @@ 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;
         }
     } else {
         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");

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()");
     }
 }