Finish inner join function

Author: Aperjump

include/boost/numeric/ublas/data_frame.hpp

@@ -6,6 +6,7 @@
 #include <list>
 #include <string>
 #include <unordered_map>
+#include <map>
 #include <vector>
 #include <initializer_list>
 #include <tuple>
@@ -260,12 +261,6 @@ class data_frame {
     void for_each_in_tuple(std::tuple<Ts...> const& t, F f, const std::vector<std::string>& names) {
         for_each(t, f, std::index_sequence_for<Ts...>{}, names);
     }
-
-    // auto get_tuple_types() {
-    //     for (const auto& p: type_map) {
-            
-    //     }
-    // }
     int cur_rows;
     store_t vals;
     /* col_names_map and type_map should maintain consistent */
@@ -416,7 +411,7 @@ template<typename T,
                     typename... Types2, 
                     template<class...> class TypeLists1, typename... InnerTypes1, 
                     template<class...> class TypeLists2, typename... InnerTypes2>
-auto combine(const data_frame<Types1...>& l, const data_frame<Types2...>& r, 
+auto combine_inner(const data_frame<Types1...>& l, const data_frame<Types2...>& r, 
     const std::string& col_name, 
     TypeLists1<InnerTypes1...>, const std::vector<std::string>& colnamesl, 
     TypeLists2<InnerTypes2...>, const std::vector<std::string>& colnamesr) {
@@ -429,8 +424,8 @@ auto combine(const data_frame<Types1...>& l, const data_frame<Types2...>& r,
     auto merge_type_collection = merge_types(type_collection_l{}, type_collection_r{});
     int llen = l.get_cur_rows();
     int rlen = r.get_cur_rows();
-    std::unordered_multimap<T, size_t> valueTopos1;
-    std::unordered_multimap<T, size_t> valueTopos2;
+    std::multimap<T, size_t> valueTopos1;
+    std::multimap<T, size_t> valueTopos2;
     // Must iterate twice to get the number of rows in result data frame
     for (int i = 0; i < llen; i++)
         valueTopos1.insert({l.data_frame<Types1...>::template get_c<T>(col_name, i), i});
@@ -439,16 +434,38 @@ auto combine(const data_frame<Types1...>& l, const data_frame<Types2...>& r,
         if (valueTopos1.count(val))
             valueTopos2.insert({val, j});
     }
-    int rows = valueTopos2.size();
-    auto* new_df = new data_frame(rows, merge_type_collection);
-    using new_df_type = typename std::remove_pointer<decltype(new_df)>::type;
-    // init columns
-    new_df->init_columns(std::tuple<InnerTypes1...>{}, colnamesl, rows);
-    new_df->init_columns(std::tuple<InnerTypes2...>{}, colnamesr, rows);
-    // need to iterate through one the 
-    std::cout << "New df rows: " << new_df->get_cur_rows() << std::endl;
+    // get concated tuple type and names
+    auto tuple_cat_val = std::tuple_cat(std::tuple<InnerTypes1...>{}, std::tuple<InnerTypes2...>{});
+    std::vector<std::string> col_names;
+    for (const auto& l_name: colnamesl) { col_names.push_back(l_name); }
+    for (const auto& r_name: colnamesr) { col_names.push_back(r_name); }
+    // need to iterate through valueTopos2 to get common data
+    std::vector<decltype(tuple_cat_val)> new_tuple_vec;
+    for (const auto& iter: valueTopos2) {
+        T key = iter.first;
+        size_t pos = iter.second;
+        std::tuple<InnerTypes2...> right_tuple = for_each_in_tuple(std::tuple<InnerTypes2...>{}, &r, colnamesr, pos);
+        auto tmp_range = valueTopos1.equal_range(key);
+        for (auto i = tmp_range.first; i != tmp_range.second; ++i) {
+            size_t l_pos = i->second;
+            std::tuple<InnerTypes1...> left_tuple = for_each_in_tuple(std::tuple<InnerTypes1...>{}, &l, colnamesl, l_pos);
+            auto combined_tuple = std::tuple_cat(left_tuple, right_tuple);
+            new_tuple_vec.push_back(combined_tuple);
+        }
+    }
+    auto new_df = make_from_tuples(new_tuple_vec, col_names, tuple_cat_val);
     return new_df;
 }
+template<typename... Ts, typename... Types, std::size_t ... Is>
+auto for_each(const std::tuple<Ts...>& t, const data_frame<Types...>* df, 
+                const std::vector<std::string>& names, size_t pos, std::index_sequence<Is...>) {
+    return std::make_tuple(df->data_frame<Types...>::template get_c<Ts>(names[Is], pos)...);
+}
+template<typename... Types, typename... Ts>
+auto for_each_in_tuple(const std::tuple<Ts...>& t, const data_frame<Types...>* df, 
+                        const std::vector<std::string>& names, size_t pos) {
+    return for_each(t, df, names, pos, std::index_sequence_for<Ts...>{});
+}
 template<class... Types>
 class data_frame_view {
 public:

test/data_frame_test.cpp

@@ -181,8 +181,10 @@ TEST(Data_frame, combine_data_frames) {
                                 std::make_tuple(2.2, "world"s, 40),  
                                 std::make_tuple(1.1, "bili"s, 50)}, 
                                 {"double_vec", "str_vec", "int_vec"});
-    auto df3 = combine<double>(df1, df2, "double_vec", std::tuple<double, long>{}, {"double_vec", "long_vec"},
-                                                    std::tuple<double, std::string, int>{}, {"double_vec", "str_vec", "int_vec"});
+    auto df3 = combine_inner<double>(df1, df2, "double_vec", 
+                                    std::tuple<double, long>{}, {"double_vec", "long_vec"},
+                                    std::tuple<double, std::string, int>{}, {"double_vec", "str_vec", "int_vec"});
     EXPECT_EQ(df3->get_cur_rows(), 4);
     EXPECT_EQ(df3->get_cur_cols(), 4);
+    df3->print_with_index({0, 1, 2, 3});
 }