/*

* Copyright 2017 MapD Technologies, Inc.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

/**

* @file DataGen.cpp

* @brief Sample MapD Client code for generating random data that can be

* inserted into a given MapD table.

*

* Usage: <table> <database> <user> <password> [<num rows>] [hostname[:port]]

* The program executes the following:

* 1. connect to mapd_server at hostname:port (default: localhost:9091)

* with <database> <user> <password>

* 2. get the table descriptor of <table>

* 3. randomly generate tab-delimited data that can be imported to <table>

* 4. disconnect from mapd_server

*

* Copyright (c) 2014 MapD Technologies, Inc. All rights reserved.

**/

#include <cstring>

#include <cstdlib>

#include <string>

#include <iostream>

#include <cstdint>

#include <cfloat>

#include <random>

#include <ctime>

// include files for Thrift and MapD Thrift Services

#include "gen-cpp/MapD.h"

#include <thrift/transport/TSocket.h>

#include <thrift/protocol/TBinaryProtocol.h>

#include <thrift/transport/TBufferTransports.h>

using namespace ::apache::thrift;

using namespace ::apache::thrift::protocol;

using namespace ::apache::thrift::transport;

// Thrift uses boost::shared_ptr instead of std::shared_ptr

using boost::shared_ptr;

namespace {

// anonymous namespace for private functions

std::default_random_engine random_gen(std::random_device{}());

// returns a random int as string

std::string gen_int() {

std::uniform_int_distribution<int> dist(INT_MIN, INT_MAX);

return std::to_string(dist(random_gen));

}

// returns a random float as string

std::string gen_real() {

std::uniform_real_distribution<float> dist(0.0, 1.0);

return std::to_string(dist(random_gen));

}

const int max_str_len = 100;

// returns a random string of length up to max_str_len

std::string gen_string() {

std::string chars("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890");

std::uniform_int_distribution<> char_dist(0, chars.size() - 1);

std::uniform_int_distribution<> len_dist(0, max_str_len);

int len = len_dist(random_gen);

std::string s(len, ' ');

for (int i = 0; i < len; i++)

s[i] = chars[char_dist(random_gen)];

return s;

}

// returns a random boolean as string

std::string gen_bool() {

std::uniform_int_distribution<int> dist(0, 1);

if (dist(random_gen) == 1)

return "t";

return "f";

}

// returns a random time as string

std::string gen_time() {

std::uniform_int_distribution<int> dist(0, INT32_MAX);

time_t t = dist(random_gen);

std::tm* tm_ptr = gmtime(&t);

char buf[9];

strftime(buf, 9, "%T", tm_ptr);

return buf;

}

// returns a random timestamp as string

std::string gen_timestamp() {

std::uniform_int_distribution<int> dist(0, INT32_MAX);

time_t t = dist(random_gen);

std::tm* tm_ptr = gmtime(&t);

char buf[20];

strftime(buf, 20, "%F %T", tm_ptr);

return buf;

}

// returns a random date as string

std::string gen_date() {

std::uniform_int_distribution<int> dist(0, INT32_MAX);

time_t t = dist(random_gen);

std::tm* tm_ptr = gmtime(&t);

char buf[11];

strftime(buf, 11, "%F", tm_ptr);

return buf;

}

// output to std::cout num_rows number of rows conforming to row_desc.

// each column value is separated by delimiter.

void data_gen(const TRowDescriptor& row_desc, const char* delimiter, int num_rows) {

for (int i = 0; i < num_rows; i++) {

bool not_first = false;

for (auto p = row_desc.begin(); p != row_desc.end(); ++p) {

if (not_first)

std::cout << delimiter;

else

not_first = true;

switch (p->col_type.type) {

case TDatumType::SMALLINT:

case TDatumType::INT:

case TDatumType::BIGINT:

std::cout << gen_int();

break;

case TDatumType::FLOAT:

case TDatumType::DOUBLE:

case TDatumType::DECIMAL:

std::cout << gen_real();

break;

case TDatumType::STR:

std::cout << gen_string();

break;

case TDatumType::TIME:

std::cout << gen_time();

break;

case TDatumType::TIMESTAMP:

case TDatumType::INTERVAL_DAY_TIME:

case TDatumType::INTERVAL_YEAR_MONTH:

std::cout << gen_timestamp();

break;

case TDatumType::DATE:

std::cout << gen_date();

break;

case TDatumType::BOOL:

std::cout << gen_bool();

break;

}

}

std::cout << std::endl;

}

}

}

int main(int argc, char** argv) {

std::string server_host("localhost"); // default to localhost

int port = 9091; // default port number

int num_rows = 1000000; // default number of rows to generate

const char* delimiter = "\t"; // only support tab delimiter for now

if (argc < 5) {

std::cout << "Usage: <table> <database> <user> <password> [<num rows>] [hostname[:port]]" << std::endl;

return 1;

}

std::string table_name(argv[1]);

std::string db_name(argv[2]);

std::string user_name(argv[3]);

std::string passwd(argv[4]);

if (argc >= 6) {

num_rows = atoi(argv[5]);

if (argc >= 7) {

char* host = strtok(argv[6], ":");

char* portno = strtok(NULL, ":");

server_host = host;

if (portno != NULL)

port = atoi(portno);

}

}

shared_ptr<TTransport> socket(new TSocket(server_host, port));

shared_ptr<TTransport> transport(new TBufferedTransport(socket));

shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));

MapDClient client(protocol);

TSessionId session;

try {

transport->open(); // open transport

client.connect(session, user_name, passwd, db_name); // connect to mapd_server

TTableDetails table_details;

client.get_table_details(table_details, session, table_name);

data_gen(table_details.row_desc, delimiter, num_rows);

client.disconnect(session); // disconnect from mapd_server

transport->close(); // close transport

} catch (TMapDException& e) {

std::cerr << e.error_msg << std::endl;

return 1;

} catch (TException& te) {

std::cerr << "Thrift error: " << te.what() << std::endl;

return 1;

}

return 0;

}