//
// g++ -std=c++11 -Wall -g speedtest.cpp -I/usr/local/include
//      -I ${ORACLE_HOME}/rdbms/public -L ${ORACLE_HOME}/lib -lclntsh
//      -o speedtest && ./speedtest
//

#include <iostream>
#include <iomanip>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <ctime>

#define OTL_ORA12C
#define OTL_STL
#define OTL_EXCEPTION_STM_TEXT_SIZE 32767
#define OTL_ORA_UTF8

#if 0
#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)

#define OTL_TRACE_LEVEL 0xff
#define OTL_TRACE_STREAM cerr
#define OTL_TRACE_LINE_PREFIX "MY OTL TRACE " __FILE__ ":" TOSTRING(__LINE__) " ==> "
#endif

using namespace std;

#include <otlv4.h>  // include the OTL 4.0 header file

class data {
    public:
        data(size_t nrows = 1)
            : c_numrows(nrows),
              c_strlen(8)
        {
            genint(id);
            genstr(name);
            gendate(aod);
            gencurr(curr1);
            gendouble(price1);
            gencurr(curr2);
            gendouble(price2);
        }

        void print(void);
        string pdate(struct tm);

        size_t c_numrows;

        vector<int>       id;
        vector<string>    name;
        vector<struct tm> aod;
        vector<string>    curr1;
        vector<double>    price1;
        vector<string>    curr2;
        vector<double>    price2;

    private:
        size_t c_strlen;

        void gencurr(vector<string> &);
        void genstr(vector<string> &);
        void genint(vector<int> &);
        void gendouble(vector<double> &);
        void gendate(vector<struct tm> &);

};

void data::print(void)
{
    cout << "Num of rows: " << c_numrows << '\n';
    for(size_t n=0; n<c_numrows; ++n) {
        cout << setw(8)  << n+1 << " " <<
                setw(10) << id[n]         << " - " <<
                            name[n]       << " - " <<
                            pdate(aod[n]) << " - " <<
                            curr1[n]      << " - " <<
                setw(10) << price1[n]     << " - " <<
                            curr2[n]      << " - " <<
                setw(10) << price2[n]     << '\n';
    }
    cout << "====================================" << endl;
}

void data::gencurr(vector<string> & cvec)
{
    for(size_t n=0; n<c_numrows; ++n) {
        string curr;
        for(size_t i=0; i<3; ++i) {
            char c = rand() % ('Z' - 'A') + 'A';
            curr.push_back(c);
        }
        cvec.push_back(curr);
    }
}

void data::genstr(vector<string> & vstr)
{
    for(size_t n=0; n<c_numrows; ++n) {
        string str;
        for(size_t i=0; i<c_strlen; ++i) {
            char s = rand() % ('Z' - 'A') + 'A';
            str.push_back(s);
        }
        vstr.push_back(str);
    }
}

void data::genint(vector<int> & vint)
{
    for(size_t n=0; n<c_numrows; ++n) {
        int i = rand() % 10000000 - 5000000;
        vint.push_back(i);
    }
}

void data::gendouble(vector<double> & vdouble)
{
    for(size_t n=0; n<c_numrows; ++n) {
        double d = (double)(rand() % 10000000 - 5000000) / 1000000.0;
        vdouble.push_back(d);
    }
}

void data::gendate(vector<struct tm> & vtm)
{
    for(size_t n=0; n<c_numrows; ++n) {
        struct tm *tm;
        time_t t = rand() % time(nullptr);
        tm = localtime(&t);
        vtm.push_back(*tm);
    }
}

string data::pdate(struct tm tm)
{
    char date[20];

    //int tm_sec;    /* Seconds (0-60) */
    //int tm_min;    /* Minutes (0-59) */
    //int tm_hour;   /* Hours (0-23) */
    //int tm_mday;   /* Day of the month (1-31) */
    //int tm_mon;    /* Month (0-11) */
    //int tm_year;   /* Year - 1900 */
    //int tm_wday;   /* Day of the week (0-6, Sunday = 0) */
    //int tm_yday;   /* Day in the year (0-365, 1 Jan = 0) */
    //int tm_isdst;  /* Daylight saving time */

    snprintf(date, 20, "%04d-%02d-%02d %02d:%02d:%02d",
        tm.tm_year+1900,
        tm.tm_mon+1,
        tm.tm_mday,
        tm.tm_hour,
        tm.tm_min,
        tm.tm_sec);

    string dstr(date);

    return dstr;
}

void insert(otl_connect &db, data &data)   // insert rows into table
{
    otl_stream o(
        5000,                                                       // buffer size
            // Performance is controlled by a single parameter -- the stream buffer size.
            // The buffer size is defined in logical rows to be inserted into a table,
            // selected from a table / view in one round-trip to the database
            // (a.k.a. batch size, array size).
        "insert into speedtest "
            "(id, name, aod, curr1, price1, curr2, price2) "
            "values "
            "(:id<int>, :name<char[32]>, :aod<char[20]>, :curr1<char[32]>, :price1<double>, :curr2<char[32]>, :price2<double>)",
        db  // connect object
        );

    for(size_t i=0; i<data.c_numrows; ++i) {
        o << data.id[i]              <<
             data.name[i]            <<
             data.pdate(data.aod[i]) <<
             data.curr1[i]           <<
             data.price1[i]          <<
             data.curr2[i]           <<
             data.price2[i];
    }
}

int main(int argc, char *argv[])
{
    cout << "Progname: " << argv[0] << " " << ((argc >= 2 )? argv[1] : "") << endl;

    //------------------------------------------------

    data d(argc >= 2 ? atoi(argv[1]) : 1);
    //d.print();

    //------------------------------------------------

    int i = argc >= 3 ? atoi(argv[2])-1 : 0;
    cout << setw(8) << i+1 << " " <<
        setw(10) << d.id[i]           << " - " <<
                    d.name[i]         << " - " <<
                    d.pdate(d.aod[i]) << " - " <<
                    d.curr1[i]        << " - " <<
        setw(10) << d.price1[i]       << " - " <<
                    d.curr2[i]        << " - " <<
        setw(10) << d.price2[i]       << endl;

    //------------------------------------------------

    otl_connect db; // connect object
    otl_connect::otl_initialize();

    // initialize OCI environment
    try {
        db.rlogon("???/???@???"); // connect to Oracle

        long rpc;
        rpc = otl_cursor::direct_exec(db, "alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'");
        cout << "Alter session : " << rpc << endl;
        rpc = otl_cursor::direct_exec(db, "truncate table speedtest");
        cout << "Speedtest truncated : " << rpc << endl;

        time_t t1 = time(NULL);
        insert(db, d);
        time_t t2 = time(NULL);
        cout << "Runtime: " << t2 - t1 << endl;

        db.commit();
    } catch(otl_exception& p) {    // intercept OTL exceptions
        cerr << p.msg      <<endl; // print out error message
        cerr << p.stm_text <<endl; // print out SQL that caused the error
        cerr << p.var_info <<endl; // print out the variable that caused the error
    } db.logoff(); // disconnect from Oracle

    return 0;
}