///////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2010-2011 Artyom Beilis (Tonkikh) <artyomtnk@yahoo.com>
//
// Distributed under:
//
// the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// or (at your opinion) under:
//
// The MIT License
// (See accompanying file MIT.txt or a copy at
// http://www.opensource.org/licenses/mit-license.php)
//
///////////////////////////////////////////////////////////////////////////////
#define CPPDB_DRIVER_SOURCE
#ifdef CPPDB_WITH_MYSQL
# define CPPDB_SOURCE
#endif
#include <mysql.h>
#include <cppdb/backend.h>
#include <cppdb/errors.h>
#include <cppdb/utils.h>
#include <cppdb/numeric_util.h>
#include <sstream>
#include <vector>
#include <limits>
#include <iomanip>
#include <stdlib.h>
#include <string.h>
#include <iostream>
namespace cppdb {
namespace mysql_backend {
class cppdb_myerror : public cppdb_error
{
public:
cppdb_myerror(std::string const &str) :
cppdb_error("cppdb::mysql::" + str)
{
}
};
namespace unprep {
class result : public backend::result {
public:
///
/// Check if the next row in the result exists. If the DB engine can't perform
/// this check without loosing data for current row, it should return next_row_unknown.
///
virtual next_row has_next()
{
if(!res_)
return last_row_reached;
if(current_row_ >= mysql_num_rows(res_))
return last_row_reached;
else
return next_row_exists;
}
///
/// Move to next row. Should be called before first access to any of members. If no rows remain
/// return false, otherwise return true
///
virtual bool next()
{
if(!res_)
return false;
current_row_ ++;
row_ = mysql_fetch_row(res_);
if(!row_)
return false;
return true;
}
///
/// Fetch an integer value for column \a col starting from 0.
///
/// Should throw invalid_column() \a col value is invalid, should throw bad_value_cast() if the underlying data
/// can't be converted to integer or its range is not supported by the integer type.
///
char const *at(int col)
{
if(!res_)
throw empty_row_access();
if(col < 0 || col >= cols_)
throw invalid_column();
return row_[col];
}
char const *at(int col,size_t &len)
{
if(!res_)
throw empty_row_access();
if(col < 0 || col >= cols_)
throw invalid_column();
unsigned long *lengths = mysql_fetch_lengths(res_);
if(lengths==0)
throw cppdb_myerror("Can't get length of column");
len = lengths[col];
return row_[col];
}
template<typename T>
bool do_fetch(int col,T &v)
{
size_t len;
char const *s=at(col,len);
if(!s)
return false;
v = parse_number<T>(std::string(s,len),fmt_);
return true;
}
virtual bool fetch(int col,short &v)
{
return do_fetch(col,v);;
}
virtual bool fetch(int col,unsigned short &v)
{
return do_fetch(col,v);
}
virtual bool fetch(int col,int &v)
{
return do_fetch(col,v);
}
virtual bool fetch(int col,unsigned &v)
{
return do_fetch(col,v);
}
virtual bool fetch(int col,long &v)
{
return do_fetch(col,v);
}
virtual bool fetch(int col,unsigned long &v)
{
return do_fetch(col,v);
}
virtual bool fetch(int col,long long &v)
{
return do_fetch(col,v);
}
///
virtual bool fetch(int col,unsigned long long &v)
{
return do_fetch(col,v);
}
virtual bool fetch(int col,float &v)
{
return do_fetch(col,v);
}
virtual bool fetch(int col,double &v)
{
return do_fetch(col,v);
}
virtual bool fetch(int col,long double &v)
{
return do_fetch(col,v);
}
///
virtual bool fetch(int col,std::string &v)
{
size_t len;
char const *s=at(col,len);
if(!s)
return false;
v.assign(s,len);
return true;
}
virtual bool fetch(int col,std::ostream &v)
{
size_t len;
char const *s=at(col,len);
if(!s)
return false;
v.write(s,len);
return true;
}
///
/// Fetch a date-time value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid. If the data can't be converted
/// to date-time it should throw bad_value_cast()
///
virtual bool fetch(int col,std::tm &v)
{
size_t len;
char const *s=at(col,len);
if(!s)
return false;
std::string tmp(s,len);
v = parse_time(tmp);
return true;
}
///
/// Check if the column \a col is NULL starting from 0, should throw invalid_column() if the index out of range
///
virtual bool is_null(int col)
{
return at(col) == 0;
}
///
/// Return the number of columns in the result. Should be valid even without calling next() first time.
///
virtual int cols()
{
return cols_;
}
virtual std::string column_to_name(int col)
{
if(col < 0 || col >=cols_)
throw invalid_column();
if(!res_)
throw empty_row_access();
MYSQL_FIELD *flds=mysql_fetch_fields(res_);
if(!flds) {
throw cppdb_myerror("Internal error empty fileds");
}
return flds[col].name;
}
virtual int name_to_column(std::string const &name)
{
if(!res_)
throw empty_row_access();
MYSQL_FIELD *flds=mysql_fetch_fields(res_);
if(!flds) {
throw cppdb_myerror("Internal error empty fileds");
}
for(int i=0;i<cols_;i++)
if(name == flds[i].name)
return i;
return -1;
}
// End of API
result(MYSQL *conn) :
res_(0),
cols_(0),
current_row_(0),
row_(0)
{
fmt_.imbue(std::locale::classic());
res_ = mysql_store_result(conn);
if(!res_) {
cols_ = mysql_field_count(conn);
if(cols_ == 0)
throw cppdb_myerror("Seems that the query does not produce any result");
}
else {
cols_ = mysql_num_fields(res_);
}
}
~result()
{
if(res_)
mysql_free_result(res_);
}
private:
std::istringstream fmt_;
MYSQL_RES *res_;
int cols_;
unsigned current_row_;
MYSQL_ROW row_;
};
class statement : public backend::statement {
public:
virtual std::string const &sql_query()
{
return query_;
}
virtual void bind(int col,std::string const &s)
{
bind(col,s.c_str(),s.c_str()+s.size());
}
virtual void bind(int col,char const *s)
{
bind(col,s,s+strlen(s));
}
virtual void bind(int col,char const *b,char const *e)
{
std::vector<char> buf(2*(e-b)+1);
size_t len = mysql_real_escape_string(conn_,&buf.front(),b,e-b);
std::string &s=at(col);
s.clear();
s.reserve(e-b+2);
s+='\'';
s.append(&buf.front(),len);
s+='\'';
}
virtual void bind(int col,std::tm const &v)
{
std::string &s = at(col);
s.clear();
s.reserve(30);
s+='\'';
s+=cppdb::format_time(v);
s+='\'';
}
virtual void bind(int col,std::istream &v)
{
std::ostringstream ss;
ss << v.rdbuf();
std::string tmp=ss.str();
bind(col,tmp);
}
template<typename T>
void do_bind(int col,T v)
{
fmt_.str(std::string());
if(!std::numeric_limits<T>::is_integer)
fmt_ << std::setprecision(std::numeric_limits<T>::digits10+1);
fmt_ << v;
std::string tmp = fmt_.str();
at(col).swap(tmp);
}
virtual void bind(int col,int v)
{
do_bind(col,v);
}
virtual void bind(int col,unsigned v)
{
do_bind(col,v);
}
virtual void bind(int col,long v)
{
do_bind(col,v);
}
virtual void bind(int col,unsigned long v)
{
do_bind(col,v);
}
virtual void bind(int col,long long v)
{
do_bind(col,v);
}
virtual void bind(int col,unsigned long long v)
{
do_bind(col,v);
}
virtual void bind(int col,double v)
{
do_bind(col,v);
}
virtual void bind(int col,long double v)
{
do_bind(col,v);
}
virtual void bind_null(int col)
{
at(col)="NULL";
}
virtual long long sequence_last(std::string const &/*sequence*/)
{
return mysql_insert_id(conn_);
}
virtual unsigned long long affected()
{
return mysql_affected_rows(conn_);
}
void bind_all(std::string &real_query)
{
size_t total = query_.size();
for(unsigned i=0;i<params_.size();i++) {
total+=params_[i].size();
}
real_query.clear();
real_query.reserve(total);
size_t pos_ = 0;
for(unsigned i=0;i<params_.size();i++) {
size_t marker = binders_[i];
real_query.append(query_,pos_,marker-pos_);
pos_ = marker+1;
real_query.append(params_[i]);
}
real_query.append(query_,pos_,std::string::npos);
}
virtual result *query()
{
std::string real_query;
bind_all(real_query);
reset_params();
if(mysql_real_query(conn_,real_query.c_str(),real_query.size())) {
throw cppdb_myerror(mysql_error(conn_));
}
return new result(conn_);
}
virtual void exec()
{
std::string real_query;
bind_all(real_query);
reset_params();
if(mysql_real_query(conn_,real_query.c_str(),real_query.size())) {
throw cppdb_myerror(mysql_error(conn_));
}
MYSQL_RES *r=mysql_store_result(conn_);
if(r){
mysql_free_result(r);
throw cppdb_myerror("Calling exec() on query!");
}
}
std::string &at(int col)
{
if(col < 1 || col > params_no_) {
throw invalid_placeholder();
}
return params_[col-1];
}
void reset_params()
{
params_.clear();
params_.resize(params_no_,"NULL");
}
statement(std::string const &q,MYSQL *conn) :
query_(q),
conn_(conn),
params_no_(0)
{
fmt_.imbue(std::locale::classic());
bool inside_text = false;
for(size_t i=0;i<query_.size();i++) {
if(query_[i]=='\'') {
inside_text=!inside_text;
}
if(query_[i]=='?' && !inside_text) {
params_no_++;
binders_.push_back(i);
}
}
if(inside_text) {
throw cppdb_myerror("Unterminated string found in query");
}
reset_params();
}
virtual ~statement()
{
}
virtual void reset()
{
}
private:
std::ostringstream fmt_;
std::vector<std::string> params_;
std::vector<size_t> binders_;
std::string query_;
MYSQL *conn_;
int params_no_;
};
} // uprep
namespace prep {
class result : public backend::result {
struct bind_data {
bind_data() :
ptr(0),
length(0),
is_null(0),
error(0)
{
memset(&buf,0,sizeof(buf));
}
char buf[128];
std::vector<char> vbuf;
char *ptr;
unsigned long length;
my_bool is_null;
my_bool error;
};
public:
///
/// Check if the next row in the result exists. If the DB engine can't perform
/// this check without loosing data for current row, it should return next_row_unknown.
///
virtual next_row has_next()
{
if(current_row_ >= mysql_stmt_num_rows(stmt_))
return last_row_reached;
else
return next_row_exists;
}
///
/// Move to next row. Should be called before first access to any of members. If no rows remain
/// return false, otherwise return true
///
virtual bool next()
{
current_row_ ++;
reset();
if(cols_ > 0) {
if(mysql_stmt_bind_result(stmt_,&bind_[0])) {
throw cppdb_myerror(mysql_stmt_error(stmt_));
}
}
int r = mysql_stmt_fetch(stmt_);
if(r==MYSQL_NO_DATA) {
return false;
}
if(r==MYSQL_DATA_TRUNCATED) {
for(int i=0;i<cols_;i++) {
if(bind_data_[i].error && !bind_data_[i].is_null && bind_data_[i].length >= sizeof(bind_data_[i].buf)) {
bind_data_[i].vbuf.resize(bind_data_[i].length);
bind_[i].buffer = &bind_data_[i].vbuf.front();
bind_[i].buffer_length = bind_data_[i].length;
if(mysql_stmt_fetch_column(stmt_,&bind_[i],i,0)) {
throw cppdb_myerror(mysql_stmt_error(stmt_));
}
bind_data_[i].ptr = &bind_data_[i].vbuf.front();
}
}
}
return true;
}
///
/// Fetch an integer value for column \a col starting from 0.
///
/// Should throw invalid_column() \a col value is invalid, should throw bad_value_cast() if the underlying data
/// can't be converted to integer or its range is not supported by the integer type.
///
bind_data &at(int col)
{
if(col < 0 || col >= cols_)
throw invalid_column();
if(bind_data_.empty())
throw cppdb_myerror("Attempt to access data without fetching it first");
return bind_data_.at(col);
}
template<typename T>
bool do_fetch(int col,T &v)
{
bind_data &d=at(col);
if(d.is_null)
return false;
v=parse_number<T>(std::string(d.ptr,d.length),fmt_);
return true;
}
virtual bool fetch(int col,short &v)
{
return do_fetch(col,v);;
}
///
/// Fetch an integer value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid, should throw bad_value_cast() if the underlying data
/// can't be converted to integer or its range is not supported by the integer type.
///
virtual bool fetch(int col,unsigned short &v)
{
return do_fetch(col,v);
}
///
/// Fetch an integer value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid, should throw bad_value_cast() if the underlying data
/// can't be converted to integer or its range is not supported by the integer type.
///
virtual bool fetch(int col,int &v)
{
return do_fetch(col,v);
}
///
/// Fetch an integer value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid, should throw bad_value_cast() if the underlying data
/// can't be converted to integer or its range is not supported by the integer type.
///
virtual bool fetch(int col,unsigned &v)
{
return do_fetch(col,v);
}
///
/// Fetch an integer value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid, should throw bad_value_cast() if the underlying data
/// can't be converted to integer or its range is not supported by the integer type.
///
virtual bool fetch(int col,long &v)
{
return do_fetch(col,v);
}
///
/// Fetch an integer value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid, should throw bad_value_cast() if the underlying data
/// can't be converted to integer or its range is not supported by the integer type.
///
virtual bool fetch(int col,unsigned long &v)
{
return do_fetch(col,v);
}
///
/// Fetch an integer value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid, should throw bad_value_cast() if the underlying data
/// can't be converted to integer or its range is not supported by the integer type.
///
virtual bool fetch(int col,long long &v)
{
return do_fetch(col,v);
}
///
/// Fetch an integer value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid, should throw bad_value_cast() if the underlying data
/// can't be converted to integer or its range is not supported by the integer type.
///
virtual bool fetch(int col,unsigned long long &v)
{
return do_fetch(col,v);
}
///
/// Fetch a floating point value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid, should throw bad_value_cast() if the underlying data
/// can't be converted to floating point value.
///
virtual bool fetch(int col,float &v)
{
return do_fetch(col,v);
}
///
/// Fetch a floating point value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid, should throw bad_value_cast() if the underlying data
/// can't be converted to floating point value.
///
virtual bool fetch(int col,double &v)
{
return do_fetch(col,v);
}
///
/// Fetch a floating point value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid, should throw bad_value_cast() if the underlying data
/// can't be converted to floating point value.
///
virtual bool fetch(int col,long double &v)
{
return do_fetch(col,v);
}
///
/// Fetch a string value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid, any data should be convertible to
/// text value (as formatting integer, floating point value or date-time as string).
///
virtual bool fetch(int col,std::string &v)
{
bind_data &d=at(col);
if(d.is_null)
return false;
v.assign(d.ptr,d.length);
return true;
}
///
/// Fetch a BLOB value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid, any data should be convertible to
/// BLOB value as text (as formatting integer, floating point value or date-time as string).
///
virtual bool fetch(int col,std::ostream &v)
{
bind_data &d=at(col);
if(d.is_null)
return false;
v.write(d.ptr,d.length);
return true;
}
///
/// Fetch a date-time value for column \a col starting from 0.
/// Returns true if ok, returns false if the column value is NULL and the referenced object should remain unchanged
///
/// Should throw invalid_column() \a col value is invalid. If the data can't be converted
/// to date-time it should throw bad_value_cast()
///
virtual bool fetch(int col,std::tm &v)
{
std::string tmp;
if(!fetch(col,tmp))
return false;
v = parse_time(tmp);
return true;
}
///
/// Check if the column \a col is NULL starting from 0, should throw invalid_column() if the index out of range
///
virtual bool is_null(int col)
{
return at(col).is_null;
}
///
/// Return the number of columns in the result. Should be valid even without calling next() first time.
///
virtual int cols()
{
return cols_;
}
virtual std::string column_to_name(int col)
{
if(col < 0 || col >=cols_)
throw invalid_column();
MYSQL_FIELD *flds=mysql_fetch_fields(meta_);
if(!flds) {
throw cppdb_myerror("Internal error empty fileds");
}
return flds[col].name;
}
virtual int name_to_column(std::string const &name)
{
MYSQL_FIELD *flds=mysql_fetch_fields(meta_);
if(!flds) {
throw cppdb_myerror("Internal error empty fileds");
}
for(int i=0;i<cols_;i++)
if(name == flds[i].name)
return i;
return -1;
}
// End of API
result(MYSQL_STMT *stmt) :
stmt_(stmt), current_row_(0),meta_(0)
{
fmt_.imbue(std::locale::classic());
cols_ = mysql_stmt_field_count(stmt_);
if(mysql_stmt_store_result(stmt_)) {
throw cppdb_myerror(mysql_stmt_error(stmt_));
}
meta_ = mysql_stmt_result_metadata(stmt_);
if(!meta_) {
throw cppdb_myerror("Seems that the query does not produce any result");
}
}
~result()
{
mysql_free_result(meta_);
}
void reset()
{
bind_.resize(0);
bind_data_.resize(0);
bind_.resize(cols_,MYSQL_BIND());
bind_data_.resize(cols_,bind_data());
for(int i=0;i<cols_;i++) {
bind_[i].buffer_type = MYSQL_TYPE_STRING;
bind_[i].buffer = bind_data_[i].buf;
bind_[i].buffer_length = sizeof(bind_data_[i].buf);
bind_[i].length = &bind_data_[i].length;
bind_[i].is_null = &bind_data_[i].is_null;
bind_[i].error = &bind_data_[i].error;
bind_data_[i].ptr = bind_data_[i].buf;
}
}
private:
std::istringstream fmt_;
int cols_;
MYSQL_STMT *stmt_;
unsigned current_row_;
MYSQL_RES *meta_;
std::vector<MYSQL_BIND> bind_;
std::vector<bind_data> bind_data_;
};
class statement : public backend::statement {
struct param {
my_bool is_null;
bool is_blob;
unsigned long length;
std::string value;
void *buffer;
param() :
is_null(1),
is_blob(false),
length(0),
buffer(0)
{
}
void set(char const *b,char const *e,bool blob=false)
{
length = e - b;
buffer = const_cast<char *>(b);
is_blob = blob;
is_null = 0;
}
void set_str(std::string const &s)
{
value = s;
buffer = const_cast<char *>(value.c_str());
length = value.size();
is_null = 0;
}
void set(std::tm const &t)
{
set_str(cppdb::format_time(t));
}
void bind_it(MYSQL_BIND *b)
{
b->is_null = &is_null;
if(!is_null) {
b->buffer_type = is_blob ? MYSQL_TYPE_BLOB : MYSQL_TYPE_STRING;
b->buffer = buffer;
b->buffer_length = length;
b->length = &length;
}
else {
b->buffer_type = MYSQL_TYPE_NULL;
}
}
};
public:
// Begin of API
///
/// Get the query the statement works with. Return it as is, used as key for statement
/// caching
///
virtual std::string const &sql_query()
{
return query_;
}
///
/// Bind a text value to column \a col (starting from 1). You may assume
/// that the reference remains valid until real call of query() or exec()
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
virtual void bind(int col,std::string const &s)
{
at(col).set(s.c_str(),s.c_str()+s.size());
}
///
/// Bind a text value to column \a col (starting from 1). You may assume
/// that the reference remains valid until real call of query() or exec()
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
virtual void bind(int col,char const *s)
{
at(col).set(s,s+strlen(s));
}
///
/// Bind a text value to column \a col (starting from 1). You may assume
/// that the reference remains valid until real call of query() or exec()
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
virtual void bind(int col,char const *b,char const *e)
{
at(col).set(b,e);
}
///
/// Bind a date-time value to column \a col (starting from 1).
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
virtual void bind(int col,std::tm const &v)
{
at(col).set(v);
}
///
/// Bind a BLOB value to column \a col (starting from 1).
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
virtual void bind(int col,std::istream &v)
{
std::ostringstream ss;
ss << v.rdbuf();
at(col).set_str(ss.str());
at(col).is_blob = true;
}
template<typename T>
void do_bind(int col,T v)
{
fmt_.str(std::string());
if(!std::numeric_limits<T>::is_integer)
fmt_ << std::setprecision(std::numeric_limits<T>::digits10+1);
fmt_ << v;
at(col).set_str(fmt_.str());
}
///
/// Bind an integer value to column \a col (starting from 1).
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
virtual void bind(int col,int v)
{
do_bind(col,v);
}
///
/// Bind an integer value to column \a col (starting from 1).
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
/// May throw bad_value_cast() if the value out of supported range by the DB.
///
virtual void bind(int col,unsigned v)
{
do_bind(col,v);
}
///
/// Bind an integer value to column \a col (starting from 1).
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
/// May throw bad_value_cast() if the value out of supported range by the DB.
///
virtual void bind(int col,long v)
{
do_bind(col,v);
}
///
/// Bind an integer value to column \a col (starting from 1).
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
/// May throw bad_value_cast() if the value out of supported range by the DB.
///
virtual void bind(int col,unsigned long v)
{
do_bind(col,v);
}
///
/// Bind an integer value to column \a col (starting from 1).
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
/// May throw bad_value_cast() if the value out of supported range by the DB.
///
virtual void bind(int col,long long v)
{
do_bind(col,v);
}
///
/// Bind an integer value to column \a col (starting from 1).
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
/// May throw bad_value_cast() if the value out of supported range by the DB.
///
virtual void bind(int col,unsigned long long v)
{
do_bind(col,v);
}
///
/// Bind a floating point value to column \a col (starting from 1).
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
virtual void bind(int col,double v)
{
do_bind(col,v);
}
///
/// Bind a floating point value to column \a col (starting from 1).
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
virtual void bind(int col,long double v)
{
do_bind(col,v);
}
///
/// Bind a NULL value to column \a col (starting from 1).
///
/// Should throw invalid_placeholder() if the value of col is out of range. May
/// ignore if it is impossible to know whether the placeholder exists without special
/// support from back-end.
///
virtual void bind_null(int col)
{
at(col)=param();
}
///
/// Fetch the last sequence generated for last inserted row. May use sequence as parameter
/// if the database uses sequences, should ignore the parameter \a sequence if the last
/// id is fetched without parameter.
///
/// Should be called after exec() for insert statement, otherwise the behavior is undefined.
///
/// MUST throw not_supported_by_backend() if such option is not supported by the DB engine.
///
virtual long long sequence_last(std::string const &/*sequence*/)
{
return mysql_stmt_insert_id(stmt_);
}
///
/// Return the number of affected rows by last statement.
///
/// Should be called after exec(), otherwise behavior is undefined.
///
virtual unsigned long long affected()
{
return mysql_stmt_affected_rows(stmt_);
}
void bind_all()
{
if(!params_.empty()) {
for(unsigned i=0;i<params_.size();i++)
params_[i].bind_it(&bind_[i]);
if(mysql_stmt_bind_param(stmt_,&bind_.front())) {
throw cppdb_myerror(mysql_stmt_error(stmt_));
}
}
}
///
/// Return SQL Query result, MAY throw cppdb_error if the statement is not a query
///
virtual result *query()
{
bind_all();
if(mysql_stmt_execute(stmt_)) {
throw cppdb_myerror(mysql_stmt_error(stmt_));
}
return new result(stmt_);
}
///
/// Execute a statement, MAY throw cppdb_error if the statement returns results.
///
virtual void exec()
{
bind_all();
if(mysql_stmt_execute(stmt_)) {
throw cppdb_myerror(mysql_stmt_error(stmt_));
}
if(mysql_stmt_store_result(stmt_)) {
throw cppdb_myerror(mysql_stmt_error(stmt_));
}
MYSQL_RES *r=mysql_stmt_result_metadata(stmt_);
if(r) {
mysql_free_result(r);
throw cppdb_myerror("Calling exec() on query!");
}
}
// End of API
// Caching support
statement(std::string const &q,MYSQL *conn) :
query_(q),
stmt_(0),
params_count_(0)
{
fmt_.imbue(std::locale::classic());
stmt_ = mysql_stmt_init(conn);
try {
if(!stmt_) {
throw cppdb_myerror(" Failed to create a statement");
}
if(mysql_stmt_prepare(stmt_,q.c_str(),q.size())) {
throw cppdb_myerror(mysql_stmt_error(stmt_));
}
params_count_ = mysql_stmt_param_count(stmt_);
reset_data();
}
catch(...) {
if(stmt_)
mysql_stmt_close(stmt_);
throw;
}
}
virtual ~statement()
{
mysql_stmt_close(stmt_);
}
void reset_data()
{
params_.resize(0);
params_.resize(params_count_);
bind_.resize(0);
bind_.resize(params_count_,MYSQL_BIND());
}
virtual void reset()
{
reset_data();
mysql_stmt_reset(stmt_);
}
private:
param &at(int col)
{
if(col < 1 || col > params_count_)
throw invalid_placeholder();
return params_[col-1];
}
std::ostringstream fmt_;
std::vector<param> params_;
std::vector<MYSQL_BIND> bind_;
std::string query_;
MYSQL_STMT *stmt_;
int params_count_;
};
} // prep
class connection;
class connection : public backend::connection {
public:
connection(connection_info const &ci) :
backend::connection(ci),
conn_(0)
{
conn_ = mysql_init(0);
if(!conn_) {
throw cppdb_error("cppdb::mysql failed to create connection");
}
std::string host = ci.get("host","");
char const *phost = host.empty() ? 0 : host.c_str();
std::string user = ci.get("user","");
char const *puser = user.empty() ? 0 : user.c_str();
std::string password = ci.get("password","");
char const *ppassword = password.empty() ? 0 : password.c_str();
std::string database = ci.get("database","");
char const *pdatabase = database.empty() ? 0 : database.c_str();
int port = ci.get("port",0);
std::string unix_socket = ci.get("unix_socket","");
char const *punix_socket = unix_socket.empty() ? 0 : unix_socket.c_str();
#if MYSQL_VERSION_ID >= 50507
std::string default_auth = ci.get("default_auth","");
if (!default_auth.empty()) {
mysql_set_option(MYSQL_DEFAULT_AUTH, default_auth.c_str());
}
#endif
std::string init_command = ci.get("init_command","");
if(!init_command.empty()) {
mysql_set_option(MYSQL_INIT_COMMAND, init_command.c_str());
}
if(ci.has("opt_compress")) {
if(ci.get("opt_compress", 1)) {
mysql_set_option(MYSQL_OPT_COMPRESS, NULL);
}
}
if(ci.has("opt_connect_timeout")) {
if(unsigned connect_timeout = ci.get("opt_connect_timeout", 0)) {
mysql_set_option(MYSQL_OPT_CONNECT_TIMEOUT, &connect_timeout);
}
}
if(ci.has("opt_guess_connection")) {
if(ci.get("opt_guess_connection", 1)) {
mysql_set_option(MYSQL_OPT_GUESS_CONNECTION, NULL);
}
}
if(ci.has("opt_local_infile")) {
if(unsigned local_infile = ci.get("opt_local_infile", 0)) {
mysql_set_option(MYSQL_OPT_CONNECT_TIMEOUT, &local_infile);
}
}
if(ci.has("opt_named_pipe")) {
if(ci.get("opt_named_pipe", 1)) {
mysql_set_option(MYSQL_OPT_NAMED_PIPE, NULL);
}
}
if(ci.has("opt_protocol")) {
if(unsigned protocol = ci.get("opt_protocol", 0)) {
mysql_set_option(MYSQL_OPT_PROTOCOL, &protocol);
}
}
if(ci.has("opt_read_timeout")) {
if(unsigned read_timeout = ci.get("opt_read_timeout", 0)) {
mysql_set_option(MYSQL_OPT_READ_TIMEOUT, &read_timeout);
}
}
if(ci.has("opt_reconnect")) {
if(unsigned reconnect = ci.get("opt_reconnect", 1)) {
my_bool value = reconnect;
mysql_set_option(MYSQL_OPT_RECONNECT, &value);
}
}
#if MYSQL_VERSION_ID >= 50507
std::string plugin_dir = ci.get("plugin_dir", "");
if(!plugin_dir.empty()) {
mysql_set_option(MYSQL_PLUGIN_DIR, plugin_dir.c_str());
}
#endif
std::string set_client_ip = ci.get("set_client_ip", "");
if(!set_client_ip.empty()) {
mysql_set_option(MYSQL_SET_CLIENT_IP, set_client_ip.c_str());
}
if(ci.has("opt_ssl_verify_server_cert")) {
if(unsigned verify = ci.get("opt_ssl_verify_server_cert", 1)) {
my_bool value = verify;
mysql_set_option(MYSQL_OPT_SSL_VERIFY_SERVER_CERT, &value);
}
}
if(ci.has("opt_use_embedded_connection")) {
if(ci.get("opt_use_embedded_connection", 1)) {
mysql_set_option(MYSQL_OPT_USE_EMBEDDED_CONNECTION, NULL);
}
}
if(ci.has("opt_use_remote_connection")) {
if(ci.get("opt_use_remote_connection", 1)) {
mysql_set_option(MYSQL_OPT_USE_REMOTE_CONNECTION, NULL);
}
}
if(ci.has("opt_write_timeout")) {
if(unsigned write_timeout = ci.get("opt_write_timeout", 0)) {
mysql_set_option(MYSQL_OPT_WRITE_TIMEOUT, &write_timeout);
}
}
std::string read_default_file = ci.get("read_default_file", "");
if(!read_default_file.empty()) {
mysql_set_option(MYSQL_READ_DEFAULT_FILE, read_default_file.c_str());
}
std::string read_default_group = ci.get("read_default_group", "");
if(!read_default_group.empty()) {
mysql_set_option(MYSQL_READ_DEFAULT_GROUP, read_default_group.c_str());
}
if(ci.has("report_data_truncation")) {
if(unsigned report = ci.get("report_data_truncation", 1)) {
my_bool value = report;
mysql_set_option(MYSQL_REPORT_DATA_TRUNCATION, &value);
}
}
#if MYSQL_VERSION_ID >= 40101
if(ci.has("secure_auth")) {
if(unsigned secure = ci.get("secure_auth", 1)) {
my_bool value = secure;
mysql_set_option(MYSQL_SECURE_AUTH, &value);
}
}
#endif
std::string set_charset_dir = ci.get("set_charset_dir", "");
if(!set_charset_dir.empty()) {
mysql_set_option(MYSQL_SET_CHARSET_DIR, set_charset_dir.c_str());
}
std::string set_charset_name = ci.get("set_charset_name", "");
if(!set_charset_name.empty()) {
mysql_set_option(MYSQL_SET_CHARSET_NAME, set_charset_name.c_str());
}
std::string shared_memory_base_name = ci.get("shared_memory_base_name", "");
if(!shared_memory_base_name.empty()) {
mysql_set_option(MYSQL_SHARED_MEMORY_BASE_NAME, shared_memory_base_name.c_str());
}
if(!mysql_real_connect(conn_,phost,puser,ppassword,pdatabase,port,punix_socket,0)) {
std::string err="unknown";
try { err = mysql_error(conn_); }catch(...){}
mysql_close(conn_);
throw cppdb_myerror(err);
}
}
~connection()
{
mysql_close(conn_);
}
// API
void exec(std::string const &s)
{
if(mysql_real_query(conn_,s.c_str(),s.size())) {
throw cppdb_myerror(mysql_error(conn_));
}
}
///
/// Start new isolated transaction. Would not be called
/// withing other transaction on current connection.
///
virtual void begin()
{
exec("BEGIN");
}
///
/// Commit the transaction, you may assume that is called after begin()
/// was called.
///
virtual void commit()
{
exec("COMMIT");
}
///
/// Rollback the transaction. MUST never throw!!!
///
virtual void rollback()
{
try {
exec("ROLLBACK");
}
catch(...) {
}
}
///
/// Create a prepared statement \a q. May throw if preparation had failed.
/// Should never return null value.
///
virtual backend::statement *prepare_statement(std::string const &q)
{
return new prep::statement(q,conn_);
}
virtual backend::statement *create_statement(std::string const &q)
{
return new unprep::statement(q,conn_);
}
///
/// Escape a string for inclusion in SQL query. May throw not_supported_by_backend() if not supported by backend.
///
virtual std::string escape(std::string const &s)
{
return escape(s.c_str(),s.c_str()+s.size());
}
///
/// Escape a string for inclusion in SQL query. May throw not_supported_by_backend() if not supported by backend.
///
virtual std::string escape(char const *s)
{
return escape(s,s+strlen(s));
}
///
/// Escape a string for inclusion in SQL query. May throw not_supported_by_backend() if not supported by backend.
///
virtual std::string escape(char const *b,char const *e)
{
std::vector<char> buf(2*(e-b)+1);
size_t len = mysql_real_escape_string(conn_,&buf.front(),b,e-b);
std::string result;
result.assign(&buf.front(),len);
return result;
}
///
/// Get the name of the driver, for example sqlite3, odbc
///
virtual std::string driver()
{
return "mysql";
}
///
/// Get the name of the SQL Server, for example sqlite3, mssql, oracle, differs from driver() when
/// the backend supports multiple databases like odbc backend.
///
virtual std::string engine()
{
return "mysql";
}
// API
private:
///
/// Set a custom MYSQL option on the connection.
///
///
void mysql_set_option(mysql_option option, const void* arg)
{
// char can be casted to void but not the other way, support older API
if(mysql_options(conn_, option, static_cast<char const *>(arg))) {
throw cppdb_error("cppdb::mysql failed to set option");
}
}
connection_info ci_;
MYSQL *conn_;
};
} // backend
} // cppdb
extern "C" {
CPPDB_DRIVER_API cppdb::backend::connection *cppdb_mysql_get_connection(cppdb::connection_info const &cs)
{
return new cppdb::mysql_backend::connection(cs);
}
}
