{

typedef int Int;

typedef std::string Text;

typedef Text Any;

struct row_t

{

template<class T> T* alloc(size_t const count) { return (T*)calloc(count,sizeof(T)); }

row_t(MYSQL_STMT* stmt, size_t count) : count(count), stmt(stmt)

{

bind = alloc<MYSQL_BIND>(count);

error = alloc<my_bool>(count);

length = alloc<unsigned long>(count);

is_null = alloc<my_bool>(count);

}

~row_t()

{

free(bind);

free(error);

free(length);

free(is_null);

}

const size_t count;

MYSQL_STMT* stmt;

MYSQL_BIND* bind;

unsigned long* length;

my_bool* error;

my_bool* is_null;

};

typedef row_t& row;

typedef MYSQL* connection;

static void get_column_Int(row r, int index, Int& data)

{

// nothing

}

static void get_column_Text(row r, int index, Text& data)

{

unsigned long const& length = r.length[index];

MYSQL_BIND& bind = r.bind[index];

if (length > 0)

{

data.resize(length);

bind.buffer = (void*)(data.c_str());

bind.buffer_length = length;

mysql_stmt_fetch_column(r.stmt, r.bind, index, 0);

}

//data.resize(length);

}

static void bind_column_Int(row r, int index, Int& data)

{

MYSQL_BIND& bind = r.bind[index];

data = 0;

bind.buffer_type = MYSQL_TYPE_LONG;

bind.buffer = (void*)&data;

bind.is_null = &r.is_null[index];

bind.length = &r.length[index];

bind.error = &r.error[index];

}

static void bind_column_Text(row r, int index, Text& data)

{

MYSQL_BIND& bind = r.bind[index];

bind.buffer_type = MYSQL_TYPE_STRING;

bind.buffer = 0;

bind.buffer_length = 0;

bind.is_null = &r.is_null[index];

bind.length = &r.length[index];

bind.error = &r.error[index];

}

static void set_param(row r, const Text& val, int index)

{

MYSQL_BIND& bind = r.bind[index];

r.length[index] = val.size();

bind.length = &r.length[index];

bind.buffer_length = val.size();

bind.buffer_type = MYSQL_TYPE_STRING;

bind.buffer = (void*)val.c_str();

}

static void set_param(row r, const Int& val, int index)

{

MYSQL_BIND& bind = r.bind[index];

bind.buffer_type = MYSQL_TYPE_LONG;

bind.buffer = (void*)&val;

}

class mysql_stmt

{

public:

mysql_stmt(MYSQL_STMT* stmt) : stmt(stmt)

{

}

void close()

{

if (stmt) mysql_stmt_close(stmt);

stmt = NULL;

}

virtual ~mysql_stmt()

{

close();

}

operator MYSQL_STMT*()

{

return stmt;

}

private:

MYSQL_STMT* stmt;

};

struct no_params

{

void set_params(row) {}

enum { count = 0 };

};

template<class T>

struct no_binder

{

void get(row,T) {}

void bind(row) {}

enum { count = 0 };

};

class statement

{

private:

connection db;

char const* sql;

mysql_stmt stmt;

bool ready;

public:

statement(connection aDb, char const* sql) : db(aDb), sql(sql), stmt(mysql_stmt_init(aDb))

{

ready = false;

}

bool prepare()

{

if (ready)

{

return true;

}

if (!stmt)

{

#if defined(SQLGG_DEBUG)

fprintf(stderr, " mysql_stmt_init(), out of memory\n");

#endif

return false;

}

if (mysql_stmt_prepare(stmt, sql, strlen(sql)))

{

#if defined(SQLGG_DEBUG)

fprintf(stderr, " mysql_stmt_prepare(), failed\n");

fprintf(stderr, " %s\n", mysql_stmt_error(stmt));

#endif

return false;

}

ready = true;

return true;

}

template<class T, class Binder, class Params>

bool select(T result, Binder binder, Params params)

{

prepare();

if (Params::count != mysql_stmt_param_count(stmt))

{

#if defined(SQLGG_DEBUG)

fprintf(stderr, " wrong params count %u != %lu\n",Params::count,mysql_stmt_param_count(stmt));

#endif

return false;

}

if (Binder::count != mysql_stmt_field_count(stmt))

{

#if defined(SQLGG_DEBUG)

fprintf(stderr, " wrong number of columns %u != %u\n",Binder::count,mysql_stmt_field_count(stmt));

#endif

return false;

}

row_t r_params(stmt,Params::count);

params.set_params(r_params);

if (mysql_stmt_bind_param(stmt, r_params.bind))

{

#if defined(SQLGG_DEBUG)

fprintf(stderr, " mysql_stmt_bind_param() failed\n");

fprintf(stderr, " %s\n", mysql_stmt_error(stmt));

#endif

return false;

}

if (mysql_stmt_execute(stmt))

{

#if defined(SQLGG_DEBUG)

fprintf(stderr, " mysql_stmt_execute(), failed\n");

fprintf(stderr, " %s\n", mysql_stmt_error(stmt));

#endif

return false;

}

row_t r(stmt,Binder::count);

if (0 != Binder::count)

{

binder.bind(r);

if (mysql_stmt_bind_result(stmt, r.bind))

{

#if defined(SQLGG_DEBUG)

fprintf(stderr, " mysql_stmt_bind_result() failed\n");

fprintf(stderr, " %s\n", mysql_stmt_error(stmt));

#endif

return false;

}

}

while (true)

{

int res = mysql_stmt_fetch(stmt);

if (0 != res && MYSQL_DATA_TRUNCATED != res) break;

binder.get(r,result);

}

return true;

}

template<class Params>

bool execute(Params params)

{

int dummy = 0;

return select(dummy,no_binder<int>(),params);

}

}; // statement