Query 1 { SQL DISTINCT }

gistfile2.txt

#include <algorithm>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <sstream>
#include <stdint.h>
#include <thrust/device_vector.h>
#include <thrust/sort.h>
#include <thrust/unique.h>
#include <time.h>

using namespace std;

struct check_records {
  const unsigned int *time6;
  const char *bool5;
  bool *res;
  const unsigned int *time6_from;
  const unsigned int *time6_to;
  const char *bool5_val;

  check_records(const unsigned int *_time6, const char *_bool5, bool *_res,
                const unsigned int *_time6_from, const unsigned int *_time6_to,
                const char *_bool5_val)
      : time6(_time6), bool5(_bool5), res(_res), time6_from(_time6_from),
        time6_to(_time6_to), bool5_val(_bool5_val) {}
  template <typename IndexType>
  __host__ __device__ void operator()(const IndexType &i) {

    if (time6[i] >= time6_from[0] && time6[i] <= time6_to[0] &&
        bool5[i] == bool5_val[0]) {
      res[i] = 1;
    } else
      res[i] = 0;
  }
};

int main(int ac, char **av) {
  unsigned int time6_from = 19000101, time6_to = 20300101;
  char bool5_val = 0;
  string usage = "Usage : query1 [-time6_from TIME6_FROM] [-time6_to TIME6_TO "
                 "] [-bool5 BOOL5]";

  if (ac == 1) {
    cout << usage << endl;
    exit(1);
  };

  for (unsigned int i = 1; i < ac; i++) {
    if (strcmp(av[i], "-time6_from") == 0) {
      if (i + 1 < ac) {
        time6_from = atoi(av[i + 1]);
        i++;
      } else {
        cout << usage << endl;
        exit(1);
      };
    }
    if (strcmp(av[i], "-time6_to") == 0) {
      if (i + 1 < ac) {
        time6_to = atoi(av[i + 1]);
        i++;
      } else {
        cout << usage << endl;
        exit(1);
      };
    } else if (strcmp(av[i], "-bool5") == 0) {
      if (i + 1 < ac) {
        bool5_val = av[i + 1][0];
        i++;
      } else {
        cout << usage << endl;
        exit(1);
      };
    }
  };

  // cout << time6_from << " " << time6_to << " " << bool5_val << endl;

  cout << "Parsing columns " << endl;
  string file_name = "col1.txt";
  std::fstream f(file_name, std::ios_base::in | ios::binary);
  uint64_t key;
  thrust::device_vector<uint64_t> id1;
  std::vector<uint64_t> keys;
  thrust::device_vector<bool> res;
  if (f) {
    while (f >> key) {
      keys.push_back(key);
    };

    id1.resize(keys.size());
    thrust::copy(keys.begin(), keys.end(), id1.begin());
  } else {
    cout << "Could not open file " << file_name << endl;
  };

  file_name = "col6.txt";
  std::fstream f1(file_name, std::ios_base::in | ios::binary);
  string date_string;
  thrust::device_vector<unsigned int> time6;
  std::vector<unsigned int> date_keys;
  if (f1) {
    while (f1 >> date_string) {
      date_keys.push_back(std::stoi(date_string.substr(0, 4) +
                                    date_string.substr(5, 2) +
                                    date_string.substr(8, 2)));
    };

    time6.resize(date_keys.size());
    thrust::copy(date_keys.begin(), date_keys.end(), time6.begin());
  } else {
    cout << "Could not open file " << file_name << endl;
  };

  file_name = "col5.txt";
  std::fstream f2(file_name, std::ios_base::in | ios::binary);
  char bool_char;
  thrust::device_vector<char> bool5;
  std::vector<char> bool_keys;
  if (f2) {
    while (f2 >> bool_char) {
      bool_keys.push_back(bool_char);
    };

    bool5.resize(bool_keys.size());
    thrust::copy(bool_keys.begin(), bool_keys.end(), bool5.begin());
  } else {
    cout << "Could not open file " << file_name << endl;
  };

  // Now we have all 3 arrays in a device memory
  cout << "Done parsing " << endl;
  std::clock_t start1 = std::clock();
  res.resize(bool_keys.size());

  // SQL WHERE condition check
  thrust::device_vector<unsigned int> dev_time6_from(1);
  thrust::device_vector<unsigned int> dev_time6_to(1);
  thrust::device_vector<char> dev_bool5(1);
  dev_time6_from[0] = time6_from;
  dev_time6_to[0] = time6_to;
  dev_bool5[0] = bool5_val;

  thrust::counting_iterator<unsigned int> begin(0);
  check_records ff(
      (const unsigned int *)thrust::raw_pointer_cast(time6.data()),
      (const char *)thrust::raw_pointer_cast(bool5.data()),
      thrust::raw_pointer_cast(res.data()),
      (const unsigned int *)thrust::raw_pointer_cast(dev_time6_from.data()),
      (const unsigned int *)thrust::raw_pointer_cast(dev_time6_to.data()),
      (const char *)thrust::raw_pointer_cast(dev_bool5.data()));
  thrust::for_each(begin, begin + res.size(), ff);

  // copy_if the results
  thrust::device_vector<uint64_t> id1_cpy(res.size());
  auto w_count = thrust::copy_if(id1.begin(), id1.end(), res.begin(),
                                 id1_cpy.begin(), thrust::identity<bool>()) -
                 id1_cpy.begin();
  // SQL DISTINCT
  thrust::sort(id1_cpy.begin(), id1_cpy.begin() + w_count);
  auto distinct_cnt =
      thrust::unique(id1_cpy.begin(), id1_cpy.begin() + w_count) -
      id1_cpy.begin();
  cout << "distinct count " << distinct_cnt << endl;
  std::cout << "time " << ((std::clock() - start1) / (double)CLOCKS_PER_SEC)
            << '\n';

  return 0;
}