#include <windows.h>
#include <sqlext.h>
#include <iostream>
#include <iomanip>
#include <string>
#include <assert.h>

using namespace std;

const string conn_str= "driver={MySQL ODBC 3.51 driver};user=root;port=7007";

#define odbc_ok(Call) \
  do { \
    SQLRETURN ret= Call; \
    assert(SQL_SUCCEEDED(ret)); \
  } while (false)


class Bug39878_test 
{
  SQLHENV  henv;
  SQLHDBC  hdbc;
  SQLHSTMT hstmt;

  unsigned int m_row_count;
  unsigned int m_row;
  bool         m_more_rows;
  char         m_col_a[128];
  char         m_col_b[128];

public:

  Bug39878_test(const string&);
  ~Bug39878_test();

  bool load_data(void);
  bool set_timeout(unsigned);
  unsigned long row_count(void);

  void start_scan(void);
  bool next_row(void);
  bool more_rows(void);
  unsigned long row(void);
  void show_row(ostream&);

private:

  bool exec_sql(const string&);
};


Bug39878_test::Bug39878_test(const string&)
{
  odbc_ok(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv));
  odbc_ok(SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER*)SQL_OV_ODBC3, 0)); 

  SQLCHAR      out_conn_str[255]= "";
  SQLSMALLINT  out_conn_str_length;

  odbc_ok(SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc));
  odbc_ok(SQLDriverConnect(
            hdbc, 
            NULL, 
            (SQLCHAR*)conn_str.c_str(), 
            conn_str.length(),
            out_conn_str,
            sizeof(out_conn_str), 
            &out_conn_str_length,
            SQL_DRIVER_NOPROMPT
         ));

  odbc_ok(SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt));
}


Bug39878_test::~Bug39878_test()
{
  exec_sql("DROP TABLE bug39878.t");
  exec_sql("DROP DATABASE bug39878"); 
  SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
  SQLDisconnect(hdbc);
  SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
  SQLFreeHandle(SQL_HANDLE_ENV, henv);
}


bool Bug39878_test::exec_sql(const string &stmt)
{
  SQLRETURN ret= SQLExecDirect(hstmt,(SQLCHAR*)stmt.c_str(),stmt.length());
  
  if (SQL_SUCCEEDED(ret))
    return true;

  cout <<"!Error when executing SQL: " <<stmt <<endl;

  SQLCHAR state[10], error[1024];
  SQLINTEGER native=0; 
  SQLSMALLINT error_length=0;

  for (int rec=1; 
       SQL_SUCCEEDED(ret= SQLGetDiagRec(SQL_HANDLE_STMT, hstmt, rec, 
                                        state, &native, 
                                        error, sizeof(error), &error_length));
      ++rec)
  {
	 cout <<error <<endl;
  }
 
  return false;
}


bool Bug39878_test::load_data(void)
{
  assert(exec_sql("DROP DATABASE IF EXISTS bug39878"));
  assert(exec_sql("CREATE DATABASE bug39878"));

  odbc_ok(SQLSetConnectAttr(hdbc, SQL_ATTR_CURRENT_CATALOG, (SQLCHAR*)"bug39878", SQL_NTS));

  assert(exec_sql("DROP TABLE IF EXISTS t"));
  assert(exec_sql("CREATE TABLE t (a int, b float) ENGINE=myisam"));

  assert(exec_sql("INSERT INTO t VALUES (0,0.1), (1,1.2)"));
  m_row_count=2;
  for (int i=1; i < 14; ++i)
  {
    char count[10];
    sprintf_s(count, sizeof(count), "%d", m_row_count);
    assert(exec_sql(string("INSERT INTO t SELECT a+")+ count 
                    + string(", b+") + count + string(" FROM t")));
    m_row_count *= 2;
    cout <<"Inserted " <<m_row_count <<" rows" <<endl;
  }

  return true;
}


bool Bug39878_test::set_timeout(unsigned sec)
{
  char timeout[10];
  sprintf_s(timeout, sizeof(timeout), "%d", sec);
  assert(exec_sql(string("SET net_write_timeout=") + timeout));
  return true;
}


unsigned long 
Bug39878_test::row_count(void)
{
  return m_row_count;
}


void Bug39878_test::start_scan(void)
{
  odbc_ok(SQLSetConnectAttr(hdbc, SQL_ATTR_CURRENT_CATALOG, (SQLCHAR*)"bug39878", SQL_NTS));
  assert(exec_sql("SELECT a, b FROM t"));
  odbc_ok(SQLBindCol(hstmt, 1, SQL_C_CHAR, m_col_a, sizeof(m_col_a), NULL));
  odbc_ok(SQLBindCol(hstmt, 2, SQL_C_CHAR, m_col_b, sizeof(m_col_b), NULL));

  m_row= 0;
  next_row();
}

void Bug39878_test::show_row(ostream &s)
{
  s <<"row " << setw(5) << right << row() <<": ";
  s << setw(3) << m_col_a <<", " <<m_col_b <<endl;
}

bool Bug39878_test::next_row(void)
{
  SQLRETURN ret= SQLFetch(hstmt);
  m_more_rows= SQL_SUCCEEDED(ret);
  if (m_more_rows)
    m_row++;
  return m_more_rows;
}


bool Bug39878_test::more_rows(void)
{
  return m_more_rows;
}


unsigned long Bug39878_test::row(void)
{
  return m_row;
}


int main()
{  
  cout << "== BUG#39878 test ==" <<endl;

  Bug39878_test test(conn_str);

  cout << "Connected! " <<endl;

  test.load_data();
  test.set_timeout(10);

  for (test.start_scan(); test.more_rows(); test.next_row())
  {
    if (0 == test.row() % 100)
      cout <<"Got " <<test.row() <<" rows" <<endl;

    test.show_row(cout);

    if (8000 == test.row())
    {
      cout <<"Sleeping 30sec ...";
      cout.flush();
      Sleep(30*1000);
      cout <<" continuing" <<endl;
    }

  }

  cout <<"There are " <<test.row_count() <<" rows in the table" <<endl;
  cout <<"Got total of " <<test.row() <<" rows" <<endl;

  cout << "== Done! ==" <<endl;
}