static int
UdmMySQLConnect(UDM_DB *db)
{
const char* DBLog= UdmVarListFindStr(&db->Vars,"sqllog",NULL);
const char* DBLogBin= UdmVarListFindStr(&db->Vars,"sqllogbin",NULL);
const char* DBSock= UdmVarListFindStr(&db->Vars,"socket",NULL);
const char* DBUser= UdmVarListFindStr(&db->Vars,"DBUser",NULL);
const char* DBPass= UdmVarListFindStr(&db->Vars,"DBPass",NULL);
const char* DBHost= UdmVarListFindStr(&db->Vars, "DBHost", "localhost");
const char* mycnfgroup= UdmVarListFindStr(&db->Vars, "mycnfgroup", "client");
int DBPort= UdmVarListFindInt(&db->Vars, "DBPort", 0);
const char* setnames= UdmVarListFindStr(&db->Vars,"setnames", "");
int opt_compress= UdmVarListFindBool(&db->Vars, "compress", 0);
int opt_client_multi_statements= UdmVarListFindBool(&db->Vars, "ClientMultiStatements", 0);
UDM_MYSQL *mydb= (UDM_MYSQL*) UdmMalloc(sizeof(UDM_MYSQL));
unsigned long client_flag= 0;
if (!(db->specific= mydb))
{
db->errcode= 1;
sprintf(db->errstr, "Can't alloc mydb. Not enough memory?");
return UDM_ERROR;
}
bzero((void*) mydb, sizeof(UDM_MYSQL));
if (!mysql_init(&mydb->mysql))
{
db->errcode= 1;
sprintf(db->errstr, "mysql_init() failed. Not enough memory?");
return UDM_ERROR;
}
if (strcasecmp(mycnfgroup, "no"))
mysql_options(&mydb->mysql, MYSQL_READ_DEFAULT_GROUP, mycnfgroup);
if (opt_compress)
mysql_options(&mydb->mysql, MYSQL_OPT_COMPRESS, 0);
#ifdef CLIENT_MULTI_STATEMENTS
client_flag |= opt_client_multi_statements ? CLIENT_MULTI_STATEMENTS : 0;
#endif
if(!(mysql_real_connect(&mydb->mysql, DBHost, DBUser, DBPass,
db->DBName?db->DBName:"mnogosearch",
(unsigned)DBPort, DBSock, client_flag)))
{
db->errcode=1;
sprintf(db->errstr, "MySQL driver: #%d: %s",
mysql_errno(&mydb->mysql), mysql_error(&mydb->mysql));
return UDM_ERROR;
}
db->connected=1;
db->version= udm_mysql_version(&mydb->mysql);
if (db->version >= 40100)
{
db->flags|= UDM_SQL_HAVE_SUBSELECT;
if (setnames[0])
{
int rc;
#if (MYSQL_VERSION_ID > 40100)
rc= mysql_set_character_set(&mydb->mysql, setnames);
#else
{
char qbuf[64];
udm_snprintf(qbuf, sizeof(qbuf), "SET NAMES %s", setnames);
rc= mysql_query(&mydb->mysql, qbuf);
}
#endif
if (rc)
{
db->errcode= 1;
sprintf(db->errstr,"MySQL driver: in SET NAMES: #%d: %s",
mysql_errno(&mydb->mysql), mysql_error(&mydb->mysql));
return UDM_ERROR;
}
}
}
else
{
#ifdef HAVE_MYSQL_PS
/* Switch from native to general PS API */
if (db->sql->SQLPrepare)
{
db->sql->SQLPrepare= UdmSQLPrepareGeneric;
db->sql->SQLBind= UdmSQLBindGeneric;
db->sql->SQLExec= UdmSQLExecGeneric;
db->sql->SQLStmtFree= UdmSQLStmtFreeGeneric;
}
#endif
}
if (DBLog)
{
char qbuf[64];
sprintf(qbuf, "SET SQL_LOG_OFF=%d", atoi(DBLog) ? 0 : 1);
if (mysql_query(&mydb->mysql, qbuf))
{
db->errcode=1;
sprintf(db->errstr,"MySQL driver: in SET SQL_LOG_OFF: #%d: %s",
mysql_errno(&mydb->mysql), mysql_error(&mydb->mysql));
return UDM_ERROR;
}
}
if (DBLogBin)
{
char qbuf[64];
sprintf(qbuf, "SET SQL_LOG_BIN=%d", atoi(DBLogBin) ? 1 : 0);
if (mysql_query(&mydb->mysql, qbuf))
{
db->errcode=1;
sprintf(db->errstr,"MySQL driver: in SET SQL_LOG_BIN: #%d: %s",
mysql_errno(&mydb->mysql), mysql_error(&mydb->mysql));
return UDM_ERROR;
}
}
return UDM_OK;
}
/**
* Monitor an individual server
*
* @param handle The MySQL Monitor object
* @param database The database to probe
*/
static void
monitorDatabase(MONITOR *mon, MONITOR_SERVERS *database)
{
GALERA_MONITOR* handle = (GALERA_MONITOR*)mon->handle;
MYSQL_ROW row;
MYSQL_RES *result,*result2;
int isjoined = 0;
char *uname = mon->user;
char *passwd = mon->password;
unsigned long int server_version = 0;
char *server_string;
if (database->server->monuser != NULL)
{
uname = database->server->monuser;
passwd = database->server->monpw;
}
if (uname == NULL)
return;
/* Don't even probe server flagged as in maintenance */
if (SERVER_IN_MAINT(database->server))
return;
/** Store previous status */
database->mon_prev_status = database->server->status;
if (database->con == NULL || mysql_ping(database->con) != 0)
{
char *dpwd = decryptPassword(passwd);
int connect_timeout = mon->connect_timeout;
int read_timeout = mon->read_timeout;
int write_timeout = mon->write_timeout;
if(database->con)
mysql_close(database->con);
database->con = mysql_init(NULL);
mysql_options(database->con, MYSQL_OPT_CONNECT_TIMEOUT, (void *)&connect_timeout);
mysql_options(database->con, MYSQL_OPT_READ_TIMEOUT, (void *)&read_timeout);
mysql_options(database->con, MYSQL_OPT_WRITE_TIMEOUT, (void *)&write_timeout);
if (mysql_real_connect(database->con, database->server->name,
uname, dpwd, NULL, database->server->port, NULL, 0) == NULL)
{
free(dpwd);
server_clear_status(database->server, SERVER_RUNNING);
/* Also clear Joined, M/S and Stickiness bits */
server_clear_status(database->server, SERVER_JOINED);
server_clear_status(database->server, SERVER_SLAVE);
server_clear_status(database->server, SERVER_MASTER);
server_clear_status(database->server, SERVER_MASTER_STICKINESS);
if (mysql_errno(database->con) == ER_ACCESS_DENIED_ERROR)
{
server_set_status(database->server, SERVER_AUTH_ERROR);
}
database->server->node_id = -1;
if (mon_status_changed(database) && mon_print_fail_status(database))
{
LOGIF(LE, (skygw_log_write_flush(
LOGFILE_ERROR,
"Error : Monitor was unable to connect to "
"server %s:%d : \"%s\"",
database->server->name,
database->server->port,
mysql_error(database->con))));
}
return;
}
else
{
server_clear_status(database->server, SERVER_AUTH_ERROR);
}
free(dpwd);
}
/* If we get this far then we have a working connection */
server_set_status(database->server, SERVER_RUNNING);
/* get server version string */
server_string = (char *)mysql_get_server_info(database->con);
if (server_string) {
database->server->server_string = realloc(database->server->server_string, strlen(server_string)+1);
if (database->server->server_string)
strcpy(database->server->server_string, server_string);
}
/* Check if the the Galera FSM shows this node is joined to the cluster */
if (mysql_query(database->con, "SHOW STATUS LIKE 'wsrep_local_state'") == 0
&& (result = mysql_store_result(database->con)) != NULL)
{
if(mysql_field_count(database->con) < 2)
{
mysql_free_result(result);
skygw_log_write(LE,"Error: Unexpected result for \"SHOW STATUS LIKE 'wsrep_local_state'\". Expected 2 columns."
" MySQL Version: %s",version_str);
return;
}
while ((row = mysql_fetch_row(result)))
{
if (strcmp(row[1], "4") == 0)
isjoined = 1;
/* Check if the node is a donor and is using xtrabackup, in this case it can stay alive */
else if (strcmp(row[1], "2") == 0 && handle->availableWhenDonor == 1) {
if (mysql_query(database->con, "SHOW VARIABLES LIKE 'wsrep_sst_method'") == 0
&& (result2 = mysql_store_result(database->con)) != NULL)
{
if(mysql_field_count(database->con) < 2)
{
mysql_free_result(result);
mysql_free_result(result2);
skygw_log_write(LE,"Error: Unexpected result for \"SHOW VARIABLES LIKE 'wsrep_sst_method'\". Expected 2 columns."
" MySQL Version: %s",version_str);
return;
}
while ((row = mysql_fetch_row(result2)))
{
if (strncmp(row[1], "xtrabackup", 10) == 0)
isjoined = 1;
}
mysql_free_result(result2);
}
}
}
mysql_free_result(result);
}
/* Check the the Galera node index in the cluster */
if (mysql_query(database->con, "SHOW STATUS LIKE 'wsrep_local_index'") == 0
&& (result = mysql_store_result(database->con)) != NULL)
{
long local_index = -1;
if(mysql_field_count(database->con) < 2)
{
mysql_free_result(result);
skygw_log_write(LE,"Error: Unexpected result for \"SHOW STATUS LIKE 'wsrep_local_index'\". Expected 2 columns."
" MySQL Version: %s",version_str);
return;
}
while ((row = mysql_fetch_row(result)))
{
local_index = strtol(row[1], NULL, 10);
if ((errno == ERANGE && (local_index == LONG_MAX
|| local_index == LONG_MIN)) || (errno != 0 && local_index == 0))
{
local_index = -1;
}
database->server->node_id = local_index;
}
mysql_free_result(result);
}
if (isjoined)
server_set_status(database->server, SERVER_JOINED);
else
server_clear_status(database->server, SERVER_JOINED);
}
int OGRMySQLDataSource::Open( const char * pszNewName, char** papszOpenOptionsIn,
int bUpdate )
{
CPLAssert( nLayers == 0 );
/* -------------------------------------------------------------------- */
/* Use options process to get .my.cnf file contents. */
/* -------------------------------------------------------------------- */
int nPort = 0;
char **papszTableNames=NULL;
std::string oHost, oPassword, oUser, oDB;
CPLString osNewName(pszNewName);
const char* apszOpenOptions[] = { "dbname", "port", "user", "password",
"host", "tables"
};
for(int i=0; i <(int)(sizeof(apszOpenOptions)/sizeof(char*)); i++)
{
const char* pszVal = CSLFetchNameValue(papszOpenOptionsIn, apszOpenOptions[i]);
if( pszVal )
{
if( osNewName[osNewName.size()-1] != ':' )
osNewName += ",";
if( i > 0 )
{
osNewName += apszOpenOptions[i];
osNewName += "=";
}
if( EQUAL(apszOpenOptions[i], "tables") )
{
for( ; *pszVal; ++pszVal )
{
if( *pszVal == ',' )
osNewName += ";";
else
osNewName += *pszVal;
}
}
else
osNewName += pszVal;
}
}
/* -------------------------------------------------------------------- */
/* Parse out connection information. */
/* -------------------------------------------------------------------- */
char **papszItems = CSLTokenizeString2( osNewName+6, ",",
CSLT_HONOURSTRINGS );
if( CSLCount(papszItems) < 1 )
{
CSLDestroy( papszItems );
CPLError( CE_Failure, CPLE_AppDefined,
"MYSQL: request missing databasename." );
return FALSE;
}
oDB = papszItems[0];
for( int i = 1; papszItems[i] != NULL; i++ )
{
if( STARTS_WITH_CI(papszItems[i], "user="******"password="******"host=") )
oHost = papszItems[i] + 5;
else if( STARTS_WITH_CI(papszItems[i], "port=") )
nPort = atoi(papszItems[i] + 5);
else if( STARTS_WITH_CI(papszItems[i], "tables=") )
{
CSLDestroy(papszTableNames);
papszTableNames = CSLTokenizeStringComplex(
papszItems[i] + 7, ";", FALSE, FALSE );
}
else
CPLError( CE_Warning, CPLE_AppDefined,
"'%s' in MYSQL datasource definition not recognised and ignored.", papszItems[i] );
}
CSLDestroy( papszItems );
/* -------------------------------------------------------------------- */
/* Try to establish connection. */
/* -------------------------------------------------------------------- */
hConn = mysql_init( NULL );
if( hConn == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"mysql_init() failed." );
}
/* -------------------------------------------------------------------- */
/* Set desired options on the connection: charset and timeout. */
/* -------------------------------------------------------------------- */
if( hConn )
{
const char *pszTimeoutLength =
CPLGetConfigOption( "MYSQL_TIMEOUT", "0" );
unsigned int timeout = atoi(pszTimeoutLength);
mysql_options(hConn, MYSQL_OPT_CONNECT_TIMEOUT, (char*)&timeout);
mysql_options(hConn, MYSQL_SET_CHARSET_NAME, "utf8" );
}
/* -------------------------------------------------------------------- */
/* Perform connection. */
/* -------------------------------------------------------------------- */
if( hConn
&& mysql_real_connect( hConn,
oHost.length() ? oHost.c_str() : NULL,
oUser.length() ? oUser.c_str() : NULL,
oPassword.length() ? oPassword.c_str() : NULL,
oDB.length() ? oDB.c_str() : NULL,
nPort, NULL, CLIENT_INTERACTIVE ) == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"MySQL connect failed for: %s\n%s",
pszNewName + 6, mysql_error( hConn ) );
mysql_close( hConn );
hConn = NULL;
}
if( hConn == NULL )
{
CSLDestroy( papszTableNames );
return FALSE;
}
else
{
// Enable automatic reconnection
// Must be called after mysql_real_connect() on MySQL < 5.0.19
// and at any point on more recent versions.
my_bool reconnect = 1;
mysql_options(hConn, MYSQL_OPT_RECONNECT, &reconnect);
}
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* Get a list of available tables. */
/* -------------------------------------------------------------------- */
if( papszTableNames == NULL )
{
MYSQL_RES *hResultSet;
MYSQL_ROW papszRow;
if( mysql_query( hConn, "SHOW TABLES" ) )
{
ReportError( "SHOW TABLES Failed" );
return FALSE;
}
hResultSet = mysql_store_result( hConn );
if( hResultSet == NULL )
{
ReportError( "mysql_store_result() failed on SHOW TABLES result.");
return FALSE;
}
while( (papszRow = mysql_fetch_row( hResultSet )) != NULL )
{
if( papszRow[0] == NULL )
continue;
if( EQUAL(papszRow[0],"spatial_ref_sys")
|| EQUAL(papszRow[0],"geometry_columns") )
continue;
papszTableNames = CSLAddString(papszTableNames, papszRow[0] );
}
mysql_free_result( hResultSet );
}
/* -------------------------------------------------------------------- */
/* Get the schema of the available tables. */
/* -------------------------------------------------------------------- */
int iRecord;
for( iRecord = 0;
papszTableNames != NULL && papszTableNames[iRecord] != NULL;
iRecord++ )
{
// FIXME: This should be fixed to deal with tables
// for which we can't open because the name is bad/
OpenTable( papszTableNames[iRecord], bUpdate );
}
CSLDestroy( papszTableNames );
return nLayers > 0 || bUpdate;
}
bool MySQLConnection::Initialize(const char *infoString)
{
MYSQL * mysqlInit = mysql_init(NULL);
if (!mysqlInit)
{
sLog.outError( "Could not initialize Mysql connection" );
return false;
}
Tokens tokens = StrSplit(infoString, ";");
Tokens::iterator iter;
std::string host, port_or_socket, user, password, database;
int port;
char const* unix_socket;
iter = tokens.begin();
if(iter != tokens.end())
host = *iter++;
if(iter != tokens.end())
port_or_socket = *iter++;
if(iter != tokens.end())
user = *iter++;
if(iter != tokens.end())
password = *iter++;
if(iter != tokens.end())
database = *iter++;
mysql_options(mysqlInit,MYSQL_SET_CHARSET_NAME,"utf8");
#ifdef WIN32
if(host==".") // named pipe use option (Windows)
{
unsigned int opt = MYSQL_PROTOCOL_PIPE;
mysql_options(mysqlInit,MYSQL_OPT_PROTOCOL,(char const*)&opt);
port = 0;
unix_socket = 0;
}
else // generic case
{
port = atoi(port_or_socket.c_str());
unix_socket = 0;
}
#else
if(host==".") // socket use option (Unix/Linux)
{
unsigned int opt = MYSQL_PROTOCOL_SOCKET;
mysql_options(mysqlInit,MYSQL_OPT_PROTOCOL,(char const*)&opt);
host = "localhost";
port = 0;
unix_socket = port_or_socket.c_str();
}
else // generic case
{
port = atoi(port_or_socket.c_str());
unix_socket = 0;
}
#endif
mMysql = mysql_real_connect(mysqlInit, host.c_str(), user.c_str(),
password.c_str(), database.c_str(), port, unix_socket, 0);
if (mMysql)
{
DETAIL_LOG( "Connected to MySQL database at %s",
host.c_str());
sLog.outString( "MySQL client library: %s", mysql_get_client_info());
sLog.outString( "MySQL server ver: %s ", mysql_get_server_info( mMysql));
/*----------SET AUTOCOMMIT ON---------*/
// It seems mysql 5.0.x have enabled this feature
// by default. In crash case you can lose data!!!
// So better to turn this off
// ---
// This is wrong since mangos use transactions,
// autocommit is turned of during it.
// Setting it to on makes atomic updates work
// ---
// LEAVE 'AUTOCOMMIT' MODE ALWAYS ENABLED!!!
// W/O IT EVEN 'SELECT' QUERIES WOULD REQUIRE TO BE WRAPPED INTO 'START TRANSACTION'<>'COMMIT' CLAUSES!!!
if (!mysql_autocommit(mMysql, 1))
DETAIL_LOG("AUTOCOMMIT SUCCESSFULLY SET TO 1");
else
DETAIL_LOG("AUTOCOMMIT NOT SET TO 1");
/*-------------------------------------*/
// set connection properties to UTF8 to properly handle locales for different
// server configs - core sends data in UTF8, so MySQL must expect UTF8 too
Execute("SET NAMES `utf8`");
Execute("SET CHARACTER SET `utf8`");
return true;
}
else
{
sLog.outError( "Could not connect to MySQL database at %s: %s\n",
host.c_str(),mysql_error(mysqlInit));
mysql_close(mysqlInit);
return false;
}
}
/* {{{ pdo_mysql_handle_factory */
static int pdo_mysql_handle_factory(pdo_dbh_t *dbh, zval *driver_options)
{
pdo_mysql_db_handle *H;
int i, ret = 0;
char *host = NULL, *unix_socket = NULL;
unsigned int port = 3306;
char *dbname;
struct pdo_data_src_parser vars[] = {
{ "charset", NULL, 0 },
{ "dbname", "", 0 },
{ "host", "localhost", 0 },
{ "port", "3306", 0 },
{ "unix_socket", PDO_DEFAULT_MYSQL_UNIX_ADDR, 0 },
};
int connect_opts = 0
#ifdef CLIENT_MULTI_RESULTS
|CLIENT_MULTI_RESULTS
#endif
;
#if defined(PDO_USE_MYSQLND)
int dbname_len = 0;
int password_len = 0;
#endif
#ifdef CLIENT_MULTI_STATEMENTS
if (!driver_options) {
connect_opts |= CLIENT_MULTI_STATEMENTS;
} else if (pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_MULTI_STATEMENTS, 1)) {
connect_opts |= CLIENT_MULTI_STATEMENTS;
}
#endif
PDO_DBG_ENTER("pdo_mysql_handle_factory");
PDO_DBG_INF_FMT("dbh=%p", dbh);
#ifdef CLIENT_MULTI_RESULTS
PDO_DBG_INF("multi results");
#endif
php_pdo_parse_data_source(dbh->data_source, dbh->data_source_len, vars, 5);
H = pecalloc(1, sizeof(pdo_mysql_db_handle), dbh->is_persistent);
H->einfo.errcode = 0;
H->einfo.errmsg = NULL;
/* allocate an environment */
/* handle for the server */
if (!(H->server = pdo_mysql_init(dbh->is_persistent))) {
pdo_mysql_error(dbh);
goto cleanup;
}
dbh->driver_data = H;
#ifndef PDO_USE_MYSQLND
H->max_buffer_size = 1024*1024;
#endif
H->buffered = H->emulate_prepare = 1;
/* handle MySQL options */
if (driver_options) {
zend_long connect_timeout = pdo_attr_lval(driver_options, PDO_ATTR_TIMEOUT, 30);
zend_long local_infile = pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_LOCAL_INFILE, 0);
char *init_cmd = NULL;
#ifndef PDO_USE_MYSQLND
char *default_file = NULL, *default_group = NULL;
#endif
zend_long compress = 0;
char *ssl_key = NULL, *ssl_cert = NULL, *ssl_ca = NULL, *ssl_capath = NULL, *ssl_cipher = NULL;
H->buffered = pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_USE_BUFFERED_QUERY, 1);
H->emulate_prepare = pdo_attr_lval(driver_options,
PDO_MYSQL_ATTR_DIRECT_QUERY, H->emulate_prepare);
H->emulate_prepare = pdo_attr_lval(driver_options,
PDO_ATTR_EMULATE_PREPARES, H->emulate_prepare);
#ifndef PDO_USE_MYSQLND
H->max_buffer_size = pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_MAX_BUFFER_SIZE, H->max_buffer_size);
#endif
if (pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_FOUND_ROWS, 0)) {
connect_opts |= CLIENT_FOUND_ROWS;
}
if (pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_IGNORE_SPACE, 0)) {
connect_opts |= CLIENT_IGNORE_SPACE;
}
if (mysql_options(H->server, MYSQL_OPT_CONNECT_TIMEOUT, (const char *)&connect_timeout)) {
pdo_mysql_error(dbh);
goto cleanup;
}
#if PHP_API_VERSION < 20100412
if ((PG(open_basedir) && PG(open_basedir)[0] != '\0') || PG(safe_mode))
#else
if (PG(open_basedir) && PG(open_basedir)[0] != '\0')
#endif
{
local_infile = 0;
}
#if defined(MYSQL_OPT_LOCAL_INFILE) || defined(PDO_USE_MYSQLND)
if (mysql_options(H->server, MYSQL_OPT_LOCAL_INFILE, (const char *)&local_infile)) {
pdo_mysql_error(dbh);
goto cleanup;
}
#endif
#ifdef MYSQL_OPT_RECONNECT
/* since 5.0.3, the default for this option is 0 if not specified.
* we want the old behaviour
* mysqlnd doesn't support reconnect, thus we don't have "|| defined(PDO_USE_MYSQLND)"
*/
{
zend_long reconnect = 1;
mysql_options(H->server, MYSQL_OPT_RECONNECT, (const char*)&reconnect);
}
#endif
init_cmd = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_INIT_COMMAND, NULL);
if (init_cmd) {
if (mysql_options(H->server, MYSQL_INIT_COMMAND, (const char *)init_cmd)) {
efree(init_cmd);
pdo_mysql_error(dbh);
goto cleanup;
}
efree(init_cmd);
}
#ifndef PDO_USE_MYSQLND
default_file = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_READ_DEFAULT_FILE, NULL);
if (default_file) {
if (mysql_options(H->server, MYSQL_READ_DEFAULT_FILE, (const char *)default_file)) {
efree(default_file);
pdo_mysql_error(dbh);
goto cleanup;
}
efree(default_file);
}
default_group= pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_READ_DEFAULT_GROUP, NULL);
if (default_group) {
if (mysql_options(H->server, MYSQL_READ_DEFAULT_GROUP, (const char *)default_group)) {
efree(default_group);
pdo_mysql_error(dbh);
goto cleanup;
}
efree(default_group);
}
#endif
compress = pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_COMPRESS, 0);
if (compress) {
if (mysql_options(H->server, MYSQL_OPT_COMPRESS, 0)) {
pdo_mysql_error(dbh);
goto cleanup;
}
}
ssl_key = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_SSL_KEY, NULL);
ssl_cert = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_SSL_CERT, NULL);
ssl_ca = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_SSL_CA, NULL);
ssl_capath = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_SSL_CAPATH, NULL);
ssl_cipher = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_SSL_CIPHER, NULL);
if (ssl_key || ssl_cert || ssl_ca || ssl_capath || ssl_cipher) {
mysql_ssl_set(H->server, ssl_key, ssl_cert, ssl_ca, ssl_capath, ssl_cipher);
if (ssl_key) {
efree(ssl_key);
}
if (ssl_cert) {
efree(ssl_cert);
}
if (ssl_ca) {
efree(ssl_ca);
}
if (ssl_capath) {
efree(ssl_capath);
}
if (ssl_cipher) {
efree(ssl_cipher);
}
}
#if MYSQL_VERSION_ID > 50605 || defined(PDO_USE_MYSQLND)
{
char *public_key = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_SERVER_PUBLIC_KEY, NULL);
if (public_key) {
if (mysql_options(H->server, MYSQL_SERVER_PUBLIC_KEY, public_key)) {
pdo_mysql_error(dbh);
efree(public_key);
goto cleanup;
}
efree(public_key);
}
}
#endif
}
#ifdef PDO_MYSQL_HAS_CHARSET
if (vars[0].optval && mysql_options(H->server, MYSQL_SET_CHARSET_NAME, vars[0].optval)) {
pdo_mysql_error(dbh);
goto cleanup;
}
#endif
dbname = vars[1].optval;
host = vars[2].optval;
if(vars[3].optval) {
port = atoi(vars[3].optval);
}
#ifdef PHP_WIN32
if (vars[2].optval && !strcmp(".", vars[2].optval)) {
#else
if (vars[2].optval && !strcmp("localhost", vars[2].optval)) {
#endif
unix_socket = vars[4].optval;
}
/* TODO: - Check zval cache + ZTS */
#ifdef PDO_USE_MYSQLND
if (dbname) {
dbname_len = strlen(dbname);
}
if (dbh->password) {
password_len = strlen(dbh->password);
}
if (mysqlnd_connect(H->server, host, dbh->username, dbh->password, password_len, dbname, dbname_len,
port, unix_socket, connect_opts, MYSQLND_CLIENT_NO_FLAG) == NULL) {
#else
if (mysql_real_connect(H->server, host, dbh->username, dbh->password, dbname, port, unix_socket, connect_opts) == NULL) {
#endif
pdo_mysql_error(dbh);
goto cleanup;
}
if (!dbh->auto_commit) {
mysql_handle_autocommit(dbh);
}
H->attached = 1;
dbh->alloc_own_columns = 1;
dbh->max_escaped_char_length = 2;
dbh->methods = &mysql_methods;
ret = 1;
cleanup:
for (i = 0; i < sizeof(vars)/sizeof(vars[0]); i++) {
if (vars[i].freeme) {
efree(vars[i].optval);
}
}
dbh->methods = &mysql_methods;
PDO_DBG_RETURN(ret);
}
/* }}} */
pdo_driver_t pdo_mysql_driver = {
PDO_DRIVER_HEADER(mysql),
pdo_mysql_handle_factory
};
extern int mysql_db_get_db_connection(mysql_conn_t *mysql_conn, char *db_name,
mysql_db_info_t *db_info)
{
int rc = SLURM_SUCCESS;
bool storage_init = false;
char *db_host = db_info->host;
xassert(mysql_conn);
slurm_mutex_lock(&mysql_conn->lock);
if (!(mysql_conn->db_conn = mysql_init(mysql_conn->db_conn))) {
slurm_mutex_unlock(&mysql_conn->lock);
fatal("mysql_init failed: %s",
mysql_error(mysql_conn->db_conn));
} else {
/* If this ever changes you will need to alter
* src/common/slurmdbd_defs.c function _send_init_msg to
* handle a different timeout when polling for the
* response.
*/
unsigned int my_timeout = 30;
#ifdef MYSQL_OPT_RECONNECT
my_bool reconnect = 1;
/* make sure reconnect is on */
mysql_options(mysql_conn->db_conn, MYSQL_OPT_RECONNECT,
&reconnect);
#endif
mysql_options(mysql_conn->db_conn, MYSQL_OPT_CONNECT_TIMEOUT,
(char *)&my_timeout);
while (!storage_init) {
if (!mysql_real_connect(mysql_conn->db_conn, db_host,
db_info->user, db_info->pass,
db_name, db_info->port, NULL,
CLIENT_MULTI_STATEMENTS)) {
int err = mysql_errno(mysql_conn->db_conn);
if (err == ER_BAD_DB_ERROR) {
debug("Database %s not created. "
"Creating", db_name);
rc = _create_db(db_name, db_info);
} else {
const char *err_str = mysql_error(
mysql_conn->db_conn);
error("mysql_real_connect failed: "
"%d %s",
err, err_str);
if ((db_host == db_info->host)
&& db_info->backup) {
db_host = db_info->backup;
continue;
}
rc = ESLURM_DB_CONNECTION;
mysql_close(mysql_conn->db_conn);
mysql_conn->db_conn = NULL;
break;
}
} else {
storage_init = true;
if (mysql_conn->rollback)
mysql_autocommit(
mysql_conn->db_conn, 0);
rc = _mysql_query_internal(
mysql_conn->db_conn,
"SET session sql_mode='ANSI_QUOTES,"
"NO_ENGINE_SUBSTITUTION';");
}
}
}
slurm_mutex_unlock(&mysql_conn->lock);
errno = rc;
return rc;
}
int main(int argc, char *argv[])
{
MYSQL *connection;
my_bool reconnect = true;
char clientid[24];
struct mosquitto *mosq;
int rc = 0;
signal(SIGINT, handle_signal);
signal(SIGTERM, handle_signal);
mysql_library_init(0, NULL, NULL);
mosquitto_lib_init();
connection = mysql_init(NULL);
if(connection){
mysql_options(connection, MYSQL_OPT_RECONNECT, &reconnect);
connection = mysql_real_connect(connection, db_host, db_username, db_password, db_database, db_port, NULL, 0);
if(connection){
stmt = mysql_stmt_init(connection);
mysql_stmt_prepare(stmt, db_query, strlen(db_query));
memset(clientid, 0, 24);
snprintf(clientid, 23, "mysql_log_%d", getpid());
mosq = mosquitto_new(clientid, true, connection);
if(mosq){
mosquitto_connect_callback_set(mosq, connect_callback);
mosquitto_message_callback_set(mosq, message_callback);
rc = mosquitto_connect(mosq, mqtt_host, mqtt_port, 60);
mosquitto_subscribe(mosq, NULL, "nodes/01/#", 0);
while(run){
rc = mosquitto_loop(mosq, -1, 1);
if(run && rc){
sleep(20);
mosquitto_reconnect(mosq);
}
}
mosquitto_destroy(mosq);
}
mysql_stmt_close(stmt);
mysql_close(connection);
}else{
fprintf(stderr, "Error: Unable to connect to database.\n");
printf("%s\n", mysql_error(connection));
rc = 1;
}
}else{
fprintf(stderr, "Error: Unable to start mysql.\n");
rc = 1;
}
mysql_library_end();
mosquitto_lib_cleanup();
return rc;
}
void *process_queue(struct thread_data *td) {
struct configuration *conf= td->conf;
g_mutex_lock(init_mutex);
MYSQL *thrconn= mysql_init(NULL);
g_mutex_unlock(init_mutex);
if (defaults_file != NULL) {
mysql_options(thrconn,MYSQL_READ_DEFAULT_FILE,defaults_file);
}
mysql_options(thrconn, MYSQL_READ_DEFAULT_GROUP, "myloader");
if (compress_protocol)
mysql_options(thrconn, MYSQL_OPT_COMPRESS, NULL);
if (!mysql_real_connect(thrconn, hostname, username, password, NULL, port, socket_path, 0)) {
g_critical("Failed to connect to MySQL server: %s", mysql_error(thrconn));
exit(EXIT_FAILURE);
}
if (mysql_query(thrconn, "SET SESSION wait_timeout = 2147483")){
g_warning("Failed to increase wait_timeout: %s", mysql_error(thrconn));
}
if (!enable_binlog)
mysql_query(thrconn, "SET SQL_LOG_BIN=0");
mysql_query(thrconn, "/*!40101 SET NAMES binary*/");
mysql_query(thrconn, "/*!40101 SET SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */");
mysql_query(thrconn, "/*!40014 SET UNIQUE_CHECKS=0 */");
mysql_query(thrconn, "SET autocommit=0");
g_async_queue_push(conf->ready, GINT_TO_POINTER(1));
struct job* job= NULL;
struct restore_job* rj= NULL;
for(;;) {
job= (struct job*)g_async_queue_pop(conf->queue);
switch (job->type) {
case JOB_RESTORE:
rj= (struct restore_job *)job->job_data;
g_message("Thread %d restoring `%s`.`%s` part %d", td->thread_id, rj->database, rj->table, rj->part);
restore_data(thrconn, rj->database, rj->table, rj->filename, FALSE, TRUE);
if (rj->database) g_free(rj->database);
if (rj->table) g_free(rj->table);
if (rj->filename) g_free(rj->filename);
g_free(rj);
g_free(job);
break;
case JOB_SHUTDOWN:
g_message("Thread %d shutting down", td->thread_id);
if (thrconn)
mysql_close(thrconn);
g_free(job);
mysql_thread_end();
return NULL;
break;
default:
g_critical("Something very bad happened!");
exit(EXIT_FAILURE);
}
}
if (thrconn)
mysql_close(thrconn);
mysql_thread_end();
return NULL;
}
int main(int argc, char *argv[]) {
struct configuration conf= { NULL, NULL, NULL, 0 };
GError *error= NULL;
GOptionContext *context;
g_thread_init(NULL);
init_mutex= g_mutex_new();
if(db == NULL && source_db != NULL){
db = g_strdup(source_db);
}
context= g_option_context_new("multi-threaded MySQL loader");
GOptionGroup *main_group= g_option_group_new("main", "Main Options", "Main Options", NULL, NULL);
g_option_group_add_entries(main_group, entries);
g_option_group_add_entries(main_group, common_entries);
g_option_context_set_main_group(context, main_group);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_print("option parsing failed: %s, try --help\n", error->message);
exit(EXIT_FAILURE);
}
g_option_context_free(context);
if (program_version) {
g_print("myloader %s, built against MySQL %s\n", VERSION, MYSQL_SERVER_VERSION);
exit(EXIT_SUCCESS);
}
set_verbose(verbose);
if (!directory) {
g_critical("a directory needs to be specified, see --help\n");
exit(EXIT_FAILURE);
} else {
char *p= g_strdup_printf("%s/metadata", directory);
if (!g_file_test(p, G_FILE_TEST_EXISTS)) {
g_critical("the specified directory is not a mydumper backup\n");
exit(EXIT_FAILURE);
}
}
MYSQL *conn;
conn= mysql_init(NULL);
if (defaults_file != NULL) {
mysql_options(conn,MYSQL_READ_DEFAULT_FILE,defaults_file);
}
mysql_options(conn, MYSQL_READ_DEFAULT_GROUP, "myloader");
if (!mysql_real_connect(conn, hostname, username, password, NULL, port, socket_path, 0)) {
g_critical("Error connection to database: %s", mysql_error(conn));
exit(EXIT_FAILURE);
}
if (mysql_query(conn, "SET SESSION wait_timeout = 2147483")){
g_warning("Failed to increase wait_timeout: %s", mysql_error(conn));
}
if (!enable_binlog)
mysql_query(conn, "SET SQL_LOG_BIN=0");
mysql_query(conn, "/*!40014 SET FOREIGN_KEY_CHECKS=0*/");
conf.queue= g_async_queue_new();
conf.ready= g_async_queue_new();
guint n;
GThread **threads= g_new(GThread*, num_threads);
struct thread_data *td= g_new(struct thread_data, num_threads);
for (n= 0; n < num_threads; n++) {
td[n].conf= &conf;
td[n].thread_id= n+1;
threads[n]= g_thread_create((GThreadFunc)process_queue, &td[n], TRUE, NULL);
g_async_queue_pop(conf.ready);
}
g_async_queue_unref(conf.ready);
g_message("%d threads created", num_threads);
restore_databases(&conf, conn);
for (n= 0; n < num_threads; n++) {
struct job *j= g_new0(struct job, 1);
j->type = JOB_SHUTDOWN;
g_async_queue_push(conf.queue, j);
}
for (n= 0; n < num_threads; n++) {
g_thread_join(threads[n]);
}
restore_schema_post(conn);
restore_schema_view(conn);
restore_schema_triggers(conn);
g_async_queue_unref(conf.queue);
mysql_close(conn);
mysql_thread_end();
mysql_library_end();
g_free(directory);
g_free(td);
g_free(threads);
return errors ? EXIT_FAILURE : EXIT_SUCCESS;
}
/* Returns the MYSQL instance (singleton) */
MYSQL * mysql_get_instance() {
my_bool reconnect = 1;
if (APM_MY_G(event_db) == NULL) {
APM_MY_G(event_db) = malloc(sizeof(MYSQL));
mysql_init(APM_MY_G(event_db));
mysql_options(APM_MY_G(event_db), MYSQL_OPT_RECONNECT, &reconnect);
APM_DEBUG("[MySQL driver] Connecting to server...");
if (mysql_real_connect(APM_MY_G(event_db), APM_MY_G(db_host), APM_MY_G(db_user), APM_MY_G(db_pass), APM_MY_G(db_name), APM_MY_G(db_port), NULL, 0) == NULL) {
APM_DEBUG("FAILED! Message: %s\n", mysql_error(APM_MY_G(event_db)));
free(APM_MY_G(event_db));
APM_MY_G(event_db) = NULL;
return NULL;
}
APM_DEBUG("OK\n");
mysql_set_character_set(APM_MY_G(event_db), "utf8");
mysql_query(
APM_MY_G(event_db),
"\
CREATE TABLE IF NOT EXISTS request (\
id INTEGER UNSIGNED PRIMARY KEY auto_increment,\
application VARCHAR(255) NOT NULL,\
ts TIMESTAMP NOT NULL,\
script TEXT NOT NULL,\
uri TEXT NOT NULL,\
host TEXT NOT NULL,\
ip INTEGER UNSIGNED NOT NULL,\
cookies TEXT NOT NULL,\
post_vars TEXT NOT NULL,\
referer TEXT NOT NULL\
)"
);
mysql_query(
APM_MY_G(event_db),
"\
CREATE TABLE IF NOT EXISTS event (\
id INTEGER UNSIGNED PRIMARY KEY auto_increment,\
request_id INTEGER UNSIGNED,\
ts TIMESTAMP NOT NULL,\
type SMALLINT UNSIGNED NOT NULL,\
file TEXT NOT NULL,\
line MEDIUMINT UNSIGNED NOT NULL,\
message TEXT NOT NULL,\
backtrace BLOB NOT NULL,\
KEY request (request_id)\
)"
);
mysql_query(
APM_MY_G(event_db),
"\
CREATE TABLE IF NOT EXISTS stats (\
id INTEGER UNSIGNED PRIMARY KEY auto_increment,\
request_id INTEGER UNSIGNED,\
duration FLOAT UNSIGNED NOT NULL,\
user_cpu FLOAT UNSIGNED NOT NULL,\
sys_cpu FLOAT UNSIGNED NOT NULL,\
mem_peak_usage INTEGER UNSIGNED NOT NULL,\
KEY request (request_id)\
)"
);
}
return APM_MY_G(event_db);
}
BOOL CDataManage::InitDatabase()
{
/*try
{
m_pConnect.CreateInstance("ADODB.Connection");
m_pCommand.CreateInstance("ADODB.Command");
m_pRecord.CreateInstance("ADODB.Recordset");
m_pConnect->ConnectionString = m_ConnectStr.AllocSysString();
m_pConnect->Open("", "", "", -1);
}
catch (_com_error &err)
{
MessageBox(NULL, "数据库初始化失败", "提示", MB_ICONINFORMATION);
return FALSE;
}*/
//mysql
try
{
MYSQL mydata;
if (0 == mysql_library_init(0, NULL, NULL))
{
MessageBox(NULL,"数据库初始化成功!","提示",MB_OK);
}
else
{
MessageBox(NULL, "数据库初始化失败", "提示", MB_ICONINFORMATION);
return -1;
}
//初始化数据结构
if (NULL != mysql_init(&mydata)) {
MessageBox(NULL, "数据结构初始化成功!", "提示", MB_OK);
}
else {
MessageBox(NULL, "数据结构初始化失败", "提示", MB_ICONINFORMATION);
return -1;
}
//在连接数据库之前，设置额外的连接选项
//可以设置的选项很多，这里设置字符集，否则无法处理中文
if (0 == mysql_options(&mydata, MYSQL_SET_CHARSET_NAME, "gbk")) {
MessageBox(NULL, "设置字符集成功!", "提示", MB_OK);
}
else {
MessageBox(NULL, "设置字符集失败", "提示", MB_ICONINFORMATION);
return -1;
}
//连接数据库
if (NULL
!= mysql_real_connect(&mydata, "localhost", "root", "LfAmco1212", "db_Video", 3306, NULL, 0))
{
MessageBox(NULL, "连接数据库成功!", "提示", MB_OK);
}
else {
MessageBox(NULL, "连接数据库失败", "提示", MB_ICONINFORMATION);
return -1;
}
}
catch (_com_error &err)
{
MessageBox(NULL, "数据库初始化失败", "提示", MB_ICONINFORMATION);
return FALSE;
}
return TRUE;
}
int f_mysql_speed(ARG7) {
char temp_pathname[STRING_SIZE];
char sql[1500];
char server[100];
char user[100];
char password[100];
char database[100];
char table[100];
MYSQL_RES *res;
MYSQL_ROW row;
char name[100], desc[100], unit[100], level_buf[100];
int year, month, day, hour, minute, second;
char vt[20],rt[20];
// unsigned char *p;
int i,j;
double longitude,latitude,value;
char new_level[50];
char new_name[50];
char conv[50];
char precision[10];
char last;
char param[50];
int ctr;
int level;
unsigned int load_local_infile;
struct local_struct {
MYSQL *conn;
FILE *temp_fileptr;
unsigned int npts;
char *rows[MAX_NXNY];
char has_value[MAX_NXNY];
char *params;
unsigned int isset;
unsigned int wlon;
unsigned int remove_unlikely;
char runtime[20], validtime[20];
int last_GDS_change_no;
};
struct local_struct *save;
strcpy(server,arg1);
strcpy(user,arg2);
strcpy(password,arg3);
strcpy(database,arg4);
strcpy(table,arg5);
/* initialization phase */
if (mode == -1) {
decode = latlon = 1;
*local = save = (struct local_struct *) malloc( sizeof(struct local_struct));
if (save == NULL) fatal_error("mysql_speed memory allocation ","");
for (i = 0; i < MAX_NXNY; i++) {
save->rows[i] = NULL;
save->has_value[i] = 0;
}
save->last_GDS_change_no = 0;
save->conn = mysql_init(NULL);
save->temp_fileptr= NULL;
save->params = (char *) malloc(1500*sizeof(char));
sprintf(save->params,"%s","");
save->isset = 0;
save->runtime[0] = 0;
save->validtime[0] = 0;
load_local_infile = 1; // 1 = LOAD LOCAL INFILE, 0 = do not LOAD LOCAL INFILE
if (sscanf(arg6,"%d", &save->wlon) != 1) {
fatal_error("Argument 6, use western longitudes, has to be 0 or 1, error parsing %s", arg6);
}
if (sscanf(arg7,"%d", &save->remove_unlikely) != 1) {
fatal_error("Argument 7, remove unlikely values, has to be 0 or 1, error parsing %s", arg7);
}
/* Set options for database */
mysql_options(save->conn,MYSQL_OPT_LOCAL_INFILE, (char *) &load_local_infile);
/* Connect to database */
if (!mysql_real_connect(save->conn, server, user, password, database, 0, NULL, 0)) {
fatal_error("f_mysql_speed: could not connect to %s", mysql_error(save->conn));
}
return 0;
}
/* cleanup phase */
if (mode == -2) {
save = (struct local_struct *) *local;
strcpy(temp_pathname, "/tmp/wgrib2_mysqlXXXXXX");
if ( -1 == (load_local_infile = mkstemp(temp_pathname)) ) {
fatal_error("f_mysql_speed: error making temporary filename","");
}
if ( !(save->temp_fileptr = fdopen(load_local_infile, "w")) ) {
fatal_error("f_mysql_speed: error making temporary filename","");
}
fprintf(stdout, "Columns to insert: rt,vt,lat,lon%s\n", save->params);
fprintf(save->temp_fileptr,"rt,vt,lat,lon%s\n",save->params);
for (j = 0; j < save->npts; j++) {
if (save->has_value[j] == 1) fprintf(save->temp_fileptr,"%s\n",save->rows[j]);
}
fflush(save->temp_fileptr);
sprintf(sql,"LOAD DATA LOCAL INFILE '%s' INTO TABLE %s FIELDS TERMINATED BY ',' ENCLOSED BY '\"' LINES TERMINATED BY '\\n' IGNORE 1 LINES (rt,vt,lat,lon%s)",temp_pathname,table,save->params);
printf("Inserting into database, table=%s \n",table);
printf("%s\n",sql);
/* send SQL query */
if (mysql_query(save->conn, sql)) {
fatal_error("f_mysql_speed: connection error %s", mysql_error(save->conn));
}
fclose(save->temp_fileptr);
remove(temp_pathname);
mysql_close(save->conn);
return 0;
}
/* processing phase */
save = (struct local_struct *) *local;
// if (new_GDS && save->isset == 0 ) {
if ((save->last_GDS_change_no != GDS_change_no) && save->isset == 0 ) {
//save->npts = GB2_Sec3_npts(sec);
save->npts = ndata;
if (ndata > MAX_NXNY) fatal_error_i("f_mysql_speed: MAX_NXNY exceeded %d", MAX_NXNY);
for (i = 0; i < ndata; i++) {
if (save->rows[i] == NULL) {
save->rows[i] = (char *) malloc(1500*sizeof(char));
if (save->rows[i] == NULL) fatal_error("f_mysql_speed: memory allocation problem","");
}
save->rows[i][0] = '\0';
}
save->isset = 1;
// } else if (new_GDS) {
} else if (save->last_GDS_change_no != GDS_change_no) {
fatal_error("f_mysql_speed, grid definition has to be the same for all fields","");
}
save->last_GDS_change_no = GDS_change_no;
/*Collect runtime and validtime into vt and rt*/
reftime(sec, &year, &month, &day, &hour, &minute, &second);
// p = sec[1];
// sprintf(rt, "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d", (p[12]<<8)+p[13], p[14],p[15],p[16],p[17],p[18]);
sprintf(rt, "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d", year,month,day,hour,minute,second);
if (verftime(sec, &year, &month, &day, &hour, &minute, &second) == 0) {
sprintf(vt,"%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d", year,month,day,hour,minute,second);
}
/*Check that runtimes are equal and validtimes are equal*/
if (save->runtime[0] != 0 && strcmp(save->runtime,rt) != 0) {
fprintf(stderr, "Error, runtime has to be equal for all fields\n");
}
strcpy(save->runtime,rt);
if (save->validtime[0] != 0 && strcmp(save->validtime,vt) != 0) {
fprintf(stderr, "Error, validtime has to be equal for all fields\n");
}
strcpy(save->validtime,vt);
/*Get levels, parameter name, description and unit*/
// f_lev(mode, sec, data, ndata, level_buf, local);
f_lev(call_ARG0(level_buf, NULL));
//if (ndata != save->npts && save->npts>0) fprintf(stderr,"ERROR: fields do not contain equally many gridpoints, %d , %d \n",save->npts,ndata);
if (strcmp(level_buf, "reserved") == 0) return(0);
getName(sec, mode, NULL, name, desc, unit);
fprintf(stderr,"Start processing of %s at %s, runtime=%s, validtime=%s \n", name, level_buf,rt,vt);
ctr = GB2_Center(sec);
sprintf(sql,"select * from wgrib2_parameter_mapping where center_id=%d and wgrib_param_name='%s' and wgrib_param_levelname='%s'", ctr, name, level_buf);
fprintf(stderr,"SQL: %s\n", sql);
if (mysql_query(save->conn, sql)) {
fatal_error("f_mysql_speed: mysql error %s", mysql_error(save->conn));
}
sprintf(new_level,"%s", "None");
sprintf(conv,"%s", "None");
sprintf(precision, "%s", "2");
printf("\nCenter_id: %d \n", ctr);
res = mysql_use_result(save->conn);
while ( (row = mysql_fetch_row(res) ) != NULL) {
printf("our_name: %s \n", row[3]);
sprintf(new_name,"%s", row[3]);
sprintf(new_level,"%s", row[4]);
sprintf(conv,"%s", row[5]);
sprintf(precision, "%s", row[6]);
}
printf("val_precision: %s \n", precision);
printf("conversion: %s \n", conv);
printf("our_levelname: %s \n", new_level);
if (strcmp(new_level,"None") != 0) {
fprintf(stderr,"Sets level %s as level %s\n", level_buf, new_level);
sprintf(param, "%s_%s", new_name, new_level);
} else {
if (strcmp(level_buf,"surface") == 0) {
sprintf(param, "%s_0", name);
} else {
sscanf(level_buf,"%d %s", &level, &last);
sprintf(param, "%s_%d", name, level);
}
}
mysql_free_result(res);
strcat(save->params,",");
strcat(save->params,param);
fprintf(stderr,"Gridpoints in data: %d\n", ndata);
fprintf(stderr, "Gridpoints for insert: %d\n", save->npts);
fprintf(stderr, "Remove unlikely: %d\n", save->remove_unlikely);
fprintf(stderr, "Western longitudes: %d\n", save->wlon);
for (j = 0; j < ndata; j++) {
longitude = lon[j];
if (longitude > 180 && save->wlon==1) longitude-=360;
latitude = lat[j];
value = data[j];
if (save->remove_unlikely == 1 && value>0 && value<10e-8) value=0;
if (save->remove_unlikely == 1 && (strcmp(name,"APCP")==0 || strcmp(name,"ASNOW")==0 || strcmp(name,"ACPCP")==0 ) && value==1) value=0;
value = convunit(value, conv);
if (strlen(save->rows[j]) < 2) {
if (!UNDEFINED_VAL(data[j])) {
save->has_value[j] = 1;
sprintf(save->rows[j],"\"%s\",\"%s\",%g,%g,%lg",rt,vt,latitude,longitude,value);
} else {
sprintf(save->rows[j],"\"%s\",\"%s\",%g,%g,NULL",rt,vt,latitude,longitude);
}
} else {
if (!UNDEFINED_VAL(data[j])) {
save->has_value[j] = 1;
sprintf(sql,",%lg",value);
} else {
sprintf(sql,",NULL");
}
strcat(save->rows[j],sql);
}
}
return 0;
}
void *func(void *arg)
{
ThreadArgs *args = (ThreadArgs *)arg;
MYSQL_ROW row;
unsigned int rowCounter = 0;
MYSQL_FIELD *field;
unsigned int i;
unsigned int timeout = 3000;
const char *pStatement = "SELECT * FROM employees";
mysql_thread_init();
MYSQL *mysql = mysql_init(NULL);
MYSQL_STMT *stmt;
MYSQL_BIND bind[6];
MYSQL_RES *prepare_meta_result;
short small_data;
int int_data;
char str_data[STRING_SIZE];
char str_data2[STRING_SIZE];
my_bool is_null[6];
my_bool error[6];
MYSQL_TIME ts;
unsigned long length[6];
if (mysql == NULL)
{
printf("[%ld][%d]mysql init failed: %s\n", *args->thread_id, args->id, mysql_error(mysql));
return (void *)0;
}
mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, &timeout);
if (mysql_real_connect(mysql, DBHOST, DBUSER, DBPASS, DBNAME, DBPORT, DBSOCK, DBPCNT) == NULL)
{
printf("[%ld][%d]connect failed: %s\n", *args->thread_id, args->id, mysql_error(mysql));
mysql_close(mysql);
mysql_thread_end();
return (void *)0;
}
stmt = mysql_stmt_init(mysql);
if (0 != mysql_stmt_prepare(stmt, pStatement, 23))
{
printf("[%ld][%d]prepare statement failed: %s\n", *args->thread_id, args->id, mysql_error(mysql));
mysql_close(mysql);
mysql_thread_end();
return (void *)0;
}
prepare_meta_result = mysql_stmt_result_metadata(stmt);
if (!prepare_meta_result)
{
printf( "mysql_stmt_result_metadata(), returned no meta information\n");
printf(" %s\n", mysql_stmt_error(stmt));
exit(0);
}
if (0 != mysql_stmt_execute(stmt))
{
printf("[%ld][%d]query failed: %s\n", *args->thread_id, args->id, mysql_error(mysql));
mysql_close(mysql);
mysql_thread_end();
return (void *)0;
}
/* Bind the result buffers for all 4 columns before fetching them */
memset(bind, 0, sizeof(bind));
bind[0].buffer_type= MYSQL_TYPE_LONG;
bind[0].buffer= (char *)&int_data;
bind[0].is_null= &is_null[0];
bind[0].length= &length[0];
bind[0].error= &error[0];
/* TIMESTAMP COLUMN */
bind[1].buffer_type= MYSQL_TYPE_DATE;
bind[1].buffer= (char *)&ts;
bind[1].is_null= &is_null[1];
bind[1].length= &length[1];
bind[1].error= &error[1];
/* STRING COLUMN */
bind[2].buffer_type= MYSQL_TYPE_STRING;
bind[2].buffer= (char *)str_data;
bind[2].buffer_length= STRING_SIZE;
bind[2].is_null= &is_null[2];
bind[2].length= &length[2];
bind[2].error= &error[2];
/* STRING COLUMN */
bind[3].buffer_type= MYSQL_TYPE_STRING;
bind[3].buffer= (char *)str_data;
bind[3].buffer_length= STRING_SIZE;
bind[3].is_null= &is_null[3];
bind[3].length= &length[3];
bind[3].error= &error[3];
/* STRING COLUMN */
bind[4].buffer_type= MYSQL_TYPE_STRING;
bind[4].buffer= (char *)str_data;
bind[4].buffer_length= STRING_SIZE;
bind[4].is_null= &is_null[4];
bind[4].length= &length[4];
bind[4].error= &error[4];
/* TIMESTAMP COLUMN */
bind[5].buffer_type= MYSQL_TYPE_DATE;
bind[5].buffer= (char *)&ts;
bind[5].is_null= &is_null[5];
bind[5].length= &length[5];
bind[5].error= &error[5];
/* Bind the result buffers */
if (mysql_stmt_bind_result(stmt, bind))
{
printf( " mysql_stmt_bind_result() failed\n");
printf( " %s\n", mysql_stmt_error(stmt));
exit(0);
}
mysql_stmt_store_result(stmt);
printf("field name: ");
while (NULL != (field = mysql_fetch_field(prepare_meta_result)))
{
printf(" %s, ", field->name);
}
while (!mysql_stmt_fetch(stmt))
{
rowCounter++;
}
printf("loop through result, total %d rows\n", rowCounter);
mysql_free_result(prepare_meta_result);
mysql_close(mysql);
mysql_thread_end();
return (void *)0;
}
short download_blob_data(char *db_module,char *db_file,char *field_list,char *key_values,char *encoding_type,char *filename)
{
#ifdef USE_MYSQL
APPlib *sql_fields=NULL,*sql_values=NULL;
FILE *fp=NULL;
short err=-1;
int x=0,y=0,z=0;
MYSQL *mysql;
MYSQL_ROW mysqlRow;
MYSQL_RES *mysqlResult;
char *temp=NULL,*mytemp;
unsigned long *lengths;
unsigned int num_fields;
unsigned long long rows_returned=0;
unsigned int db_module_length=0;
unsigned int db_file_length=0;
unsigned int field_list_length=0;
unsigned int key_values_length=0;
if(db_module==NULL)
{
prterr("Error: db_module is NULL.\n");
return(-1);
}
if(db_file==NULL)
{
prterr("Error: db_file is NULL.\n");
return(-1);
}
if(field_list==NULL)
{
prterr("Error: field_list is NULL.\n");
return(-1);
}
if(key_values==NULL)
{
prterr("Error: key_values is NULL.\n");
return(-1);
}
if(encoding_type==NULL)
{
prterr("Error: encoding_type is NULL.\n");
return(-1);
}
if(filename==NULL)
{
prterr("Error: filename is NULL.\n");
return(-1);
}
db_module_length=strlen(db_module);
if(db_module_length==0)
{
prterr("Error: db_module is empty.\n");
return(-1);
}
db_file_length=strlen(db_file);
if(db_file_length==0)
{
prterr("Error: db_file is empty.\n");
return(-1);
}
field_list_length=strlen(field_list);
if(field_list_length==0)
{
prterr("Error: field_list is empty.\n");
return(-1);
}
key_values_length=strlen(key_values);
if(key_values_length==0)
{
prterr("Error: key_values is empty.\n");
return(-1);
}
if((strlen(encoding_type))==0)
{
prterr("Error: encoding_type is empty.\n");
return(-1);
}
if((strlen(filename))==0)
{
prterr("Error: filename is empty.\n");
return(-1);
}
mysql=mysql_init(NULL);
if(!mysql)
{
prterr("Error: Couldn't initialize MYSQL structure.");
} else {
#ifdef WIN32
mysql_options(mysql,MYSQL_READ_DEFAULT_FILE,"rda\\my.cnf");
#else
mysql_options(mysql,MYSQL_READ_DEFAULT_FILE,"rda/my.cnf");
#endif
mysql_options(mysql,MYSQL_READ_DEFAULT_GROUP,db_module);
if(!mysql_real_connect(mysql,NULL,NULL,NULL,db_module,0,NULL,0))
{
prterr("Error: mysql_real_connect failed for %s->%s with %s.",db_module,db_file,mysql_error(mysql));
return(err);
}
}
if(mysql!=NULL)
{
mytemp=Rmalloc(field_list_length+key_values_length);
memset(mytemp,0,(field_list_length+key_values_length));
sql_fields=APPlibNEW();
for(x=0;x<field_list_length;x++)
{
if((field_list[x]=='|')&&(y==0))
{
y=1;
} else if((field_list[x]=='|')&&(y==1)) {
strncpy(mytemp,field_list+z,(x-(z+1)));
addAPPlib(sql_fields,mytemp);
y=0;
z=(x+1);
memset(mytemp,0,(field_list_length+key_values_length));
} else if(x==(field_list_length-1)) {
strncpy(mytemp,field_list+z,field_list_length);
addAPPlib(sql_fields,mytemp);
memset(mytemp,0,(field_list_length+key_values_length));
}
}
#ifdef USE_RDA_DIAGNOSTICS
if((diagmix)||(diagnrd)||(diagmisc))
{
SEEAPPlib(sql_fields);
}
#endif /* ifdef USE_RDA_DIAGNOSTICS */
sql_values=APPlibNEW();
z=0;
for(x=0;x<key_values_length;x++)
{
if((key_values[x]=='|')&&(y==0))
{
y=1;
} else if((key_values[x]=='|')&&(y==1)) {
strncpy(mytemp,key_values+z,(x-(z+1)));
addAPPlib(sql_values,mytemp);
y=0;
z=(x+1);
memset(mytemp,0,(field_list_length+key_values_length));
} else if(x==(key_values_length-1)) {
strncpy(mytemp,key_values+z,key_values_length);
addAPPlib(sql_values,mytemp);
memset(mytemp,0,(field_list_length+key_values_length));
}
}
if(mytemp!=NULL) Rfree(mytemp);
#ifdef USE_RDA_DIAGNOSTICS
if((diagmix)||(diagnrd)||(diagmisc))
{
SEEAPPlib(sql_values);
}
#endif /* ifdef USE_RDA_DIAGNOSTICS */
temp=Rmalloc((db_module_length+db_file_length+field_list_length+key_values_length)*2+520);
memset(temp,0,((db_module_length+db_file_length+field_list_length+key_values_length)*2+520));
sprintf(temp,"SELECT ");
for(x=0;x<sql_fields->numlibs;x++)
{
if(x==(sql_fields->numlibs-1))
{
sprintf(temp,"%s%s FROM %s ",temp,sql_fields->libs[x],db_file);
}else{
sprintf(temp,"%s%s,",temp,sql_fields->libs[x]);
}
}
for(x=0;x<sql_values->numlibs;x++)
{
if(x==0)
{
sprintf(temp,"%sWHERE (%s = \"%s\" ",temp,sql_fields->libs[x],sql_values->libs[x]);
}else if(strlen(sql_values->libs[x])!=0) {
sprintf(temp,"%sAND %s = \"%s\" ",temp,sql_fields->libs[x],sql_values->libs[x]);
}
}
sprintf(temp,"%s)",temp);
if(!mysql_real_query(mysql,temp,RDAstrlen(temp)))
{
mysqlResult=mysql_store_result(mysql);
if(mysqlResult!=NULL)
{
rows_returned=mysql_num_rows(mysqlResult);
if(rows_returned>1)
{
prterr("Error: More than one row returned. Returned [%d] rows. Please check your key information to insure only one row is downloaded.\n",rows_returned);
}else{
while((mysqlRow=mysql_fetch_row(mysqlResult)))
{
num_fields=mysql_num_fields(mysqlResult);
lengths = mysql_fetch_lengths(mysqlResult);
/*
printf("num_fields = [%d] x = [%d]\n",num_fields,x);
printf("FILE SIZE = %d\n", lengths[(num_fields-1)]);
printf("FILE DATA: [\n%s\n",mysqlRow[(num_fields-1)]);
*/
#ifdef WIN32
if((stricmp(encoding_type,"RAW"))==0)
#else
if((strcasecmp(encoding_type,"RAW"))==0)
#endif
{
fp=fopen(filename,"w");
if(fp!=NULL)
{
fwrite(mysqlRow[(num_fields-1)],sizeof(char),(lengths[(num_fields-1)]),fp);
} else {
prterr("Error: Cannot open file [%s] for writing.",filename);
}
if(fp!=NULL) fclose(fp);
#ifdef WIN32
}else if((stricmp(encoding_type,"BASE64_DECODE"))==0) {
#else
}else if((strcasecmp(encoding_type,"BASE64_DECODE"))==0) {
#endif
decode_base64_to_file(filename,mysqlRow[(num_fields-1)]);
}else{
fp=fopen(filename,"w");
if(fp!=NULL)
{
fwrite(mysqlRow[(num_fields-1)],sizeof(char),(lengths[(num_fields-1)]),fp);
} else {
prterr("Error: Cannot open file [%s] for writing.",filename);
}
if(fp!=NULL) fclose(fp);
}
}
}
mysql_free_result(mysqlResult);
} else {
mysql_free_result(mysqlResult);
prterr("Error: No results found in table %s.\n",db_file);
}
}else {
prterr("Error: Query Failed.\nQuery: [%s].\n",temp);
}
if(temp!=NULL) Rfree(temp);
} else {
prterr("Error: MySQL Server Connection Lost!");
}
mysql_close(mysql);
mysql_library_end();
freeapplib(sql_fields);
freeapplib(sql_values);
return (err);
#else
return(-1);
#endif
}
void full_connect(VALUE self, MYSQL *db) {
VALUE r_host = rb_iv_get(self, "@host");
const char *host = "localhost";
if (r_host != Qnil) {
host = StringValuePtr(r_host);
}
VALUE r_user = rb_iv_get(self, "@user");
const char *user = "******";
if (r_user != Qnil) {
user = StringValuePtr(r_user);
}
VALUE r_password = rb_iv_get(self, "@password");
char *password = NULL;
if (r_password != Qnil) {
password = StringValuePtr(r_password);
}
VALUE r_port = rb_iv_get(self, "@port");
int port = 3306;
if (r_port != Qnil) {
port = NUM2INT(r_port);
}
VALUE r_path = rb_iv_get(self, "@path");
char *path = NULL;
char *database = NULL;
if (r_path != Qnil) {
path = StringValuePtr(r_path);
database = strtok(path, "/"); // not threadsafe
}
if (!database || !*database) {
rb_raise(eConnectionError, "Database must be specified");
}
VALUE r_query = rb_iv_get(self, "@query");
char *socket = NULL;
// Check to see if we're on the db machine. If so, try to use the socket
if (strcasecmp(host, "localhost") == 0) {
socket = get_uri_option(r_query, "socket");
if (socket) {
rb_iv_set(self, "@using_socket", Qtrue);
}
}
#ifdef HAVE_MYSQL_SSL_SET
char *ssl_client_key, *ssl_client_cert, *ssl_ca_cert, *ssl_ca_path, *ssl_cipher;
VALUE r_ssl;
if (rb_obj_is_kind_of(r_query, rb_cHash)) {
r_ssl = rb_hash_aref(r_query, rb_str_new2("ssl"));
if (rb_obj_is_kind_of(r_ssl, rb_cHash)) {
ssl_client_key = get_uri_option(r_ssl, "client_key");
ssl_client_cert = get_uri_option(r_ssl, "client_cert");
ssl_ca_cert = get_uri_option(r_ssl, "ca_cert");
ssl_ca_path = get_uri_option(r_ssl, "ca_path");
ssl_cipher = get_uri_option(r_ssl, "cipher");
assert_file_exists(ssl_client_key, "client_key doesn't exist");
assert_file_exists(ssl_client_cert, "client_cert doesn't exist");
assert_file_exists(ssl_ca_cert, "ca_cert doesn't exist");
mysql_ssl_set(db, ssl_client_key, ssl_client_cert, ssl_ca_cert, ssl_ca_path, ssl_cipher);
}
else if (r_ssl != Qnil) {
rb_raise(rb_eArgError, "ssl must be passed a hash");
}
}
#endif
unsigned long client_flags = 0;
MYSQL *result = mysql_real_connect(
db,
host,
user,
password,
database,
port,
socket,
client_flags
);
if (!result) {
raise_error(self, db, Qnil);
}
#ifdef HAVE_MYSQL_GET_SSL_CIPHER
const char *ssl_cipher_used = mysql_get_ssl_cipher(db);
if (ssl_cipher_used) {
rb_iv_set(self, "@ssl_cipher", rb_str_new2(ssl_cipher_used));
}
#endif
#ifdef MYSQL_OPT_RECONNECT
my_bool reconnect = 1;
mysql_options(db, MYSQL_OPT_RECONNECT, &reconnect);
#endif
// We only support encoding for MySQL versions providing mysql_set_character_set.
// Without this function there are potential issues with mysql_real_escape_string
// since that doesn't take the character set into consideration when setting it
// using a SET CHARACTER SET query. Since we don't want to stimulate these possible
// issues we simply ignore it and assume the user has configured this correctly.
#ifdef HAVE_MYSQL_SET_CHARACTER_SET
// Set the connections character set
VALUE encoding = rb_iv_get(self, "@encoding");
VALUE my_encoding = rb_hash_aref(do_const_get(mEncoding, "MAP"), encoding);
if (my_encoding != Qnil) {
int encoding_error = mysql_set_character_set(db, rb_str_ptr_readonly(my_encoding));
if (encoding_error != 0) {
raise_error(self, db, Qnil);
}
else {
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index(rb_str_ptr_readonly(encoding))));
#endif
rb_iv_set(self, "@my_encoding", my_encoding);
}
}
else {
rb_warn("Encoding %s is not a known Ruby encoding for MySQL\n", rb_str_ptr_readonly(encoding));
rb_iv_set(self, "@encoding", rb_str_new2("UTF-8"));
#ifdef HAVE_RUBY_ENCODING_H
rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index("UTF-8")));
#endif
rb_iv_set(self, "@my_encoding", rb_str_new2("utf8"));
}
#endif
// Disable sql_auto_is_null
cCommand_execute(Qnil, self, db, rb_str_new2("SET sql_auto_is_null = 0"));
// removed NO_AUTO_VALUE_ON_ZERO because of MySQL bug http://bugs.mysql.com/bug.php?id=42270
// added NO_BACKSLASH_ESCAPES so that backslashes should not be escaped as in other databases
// For really anscient MySQL versions we don't attempt any strictness
#ifdef HAVE_MYSQL_GET_SERVER_VERSION
//4.x versions do not support certain session parameters
if (mysql_get_server_version(db) < 50000) {
cCommand_execute(Qnil, self, db, rb_str_new2("SET SESSION sql_mode = 'ANSI,NO_DIR_IN_CREATE,NO_UNSIGNED_SUBTRACTION'"));
}
else {
cCommand_execute(Qnil, self, db, rb_str_new2("SET SESSION sql_mode = 'ANSI,NO_BACKSLASH_ESCAPES,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,TRADITIONAL'"));
}
#endif
rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));
}
int
main (int argc, char **argv)
{
MYSQL mysql;
MYSQL_RES *res;
MYSQL_ROW row;
double value;
char *error = NULL;
int status;
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
/* Parse extra opts if any */
argv=np_extra_opts (&argc, argv, progname);
if (process_arguments (argc, argv) == ERROR)
usage4 (_("Could not parse arguments"));
/* initialize mysql */
mysql_init (&mysql);
mysql_options(&mysql,MYSQL_READ_DEFAULT_GROUP,"client");
/* establish a connection to the server and error checking */
if (!mysql_real_connect(&mysql,db_host,db_user,db_pass,db,db_port,db_socket,0)) {
if (mysql_errno (&mysql) == CR_UNKNOWN_HOST)
die (STATE_WARNING, "QUERY %s: %s\n", _("WARNING"), mysql_error (&mysql));
else if (mysql_errno (&mysql) == CR_VERSION_ERROR)
die (STATE_WARNING, "QUERY %s: %s\n", _("WARNING"), mysql_error (&mysql));
else if (mysql_errno (&mysql) == CR_OUT_OF_MEMORY)
die (STATE_WARNING, "QUERY %s: %s\n", _("WARNING"), mysql_error (&mysql));
else if (mysql_errno (&mysql) == CR_IPSOCK_ERROR)
die (STATE_WARNING, "QUERY %s: %s\n", _("WARNING"), mysql_error (&mysql));
else if (mysql_errno (&mysql) == CR_SOCKET_CREATE_ERROR)
die (STATE_WARNING, "QUERY %s: %s\n", _("WARNING"), mysql_error (&mysql));
else
die (STATE_CRITICAL, "QUERY %s: %s\n", _("CRITICAL"), mysql_error (&mysql));
}
if (mysql_query (&mysql, sql_query) != 0) {
error = strdup(mysql_error(&mysql));
mysql_close (&mysql);
die (STATE_CRITICAL, "QUERY %s: %s - %s\n", _("CRITICAL"), _("Error with query"), error);
}
/* store the result */
if ( (res = mysql_store_result (&mysql)) == NULL) {
error = strdup(mysql_error(&mysql));
mysql_close (&mysql);
die (STATE_CRITICAL, "QUERY %s: Error with store_result - %s\n", _("CRITICAL"), error);
}
/* Check there is some data */
if (mysql_num_rows(res) == 0) {
mysql_close(&mysql);
die (STATE_WARNING, "QUERY %s: %s\n", _("WARNING"), _("No rows returned"));
}
/* fetch the first row */
if ( (row = mysql_fetch_row (res)) == NULL) {
error = strdup(mysql_error(&mysql));
mysql_free_result (res);
mysql_close (&mysql);
die (STATE_CRITICAL, "QUERY %s: Fetch row error - %s\n", _("CRITICAL"), error);
}
/* free the result */
mysql_free_result (res);
/* close the connection */
mysql_close (&mysql);
if (! is_numeric(row[0])) {
die (STATE_CRITICAL, "QUERY %s: %s - '%s'\n", _("CRITICAL"), _("Is not a numeric"), row[0]);
}
value = strtod(row[0], NULL);
if (verbose >= 3)
printf("mysql result: %f\n", value);
status = get_status(value, my_thresholds);
if (status == STATE_OK) {
printf("QUERY %s: ", _("OK"));
} else if (status == STATE_WARNING) {
printf("QUERY %s: ", _("WARNING"));
} else if (status == STATE_CRITICAL) {
printf("QUERY %s: ", _("CRITICAL"));
}
printf(_("'%s' returned %f | %s"), sql_query, value,
fperfdata("result", value, "",
my_thresholds->warning?TRUE:FALSE, my_thresholds->warning?my_thresholds->warning->end:0,
my_thresholds->critical?TRUE:FALSE, my_thresholds->critical?my_thresholds->critical->end:0,
FALSE, 0,
FALSE, 0)
);
printf("\n");
return status;
}
bool MySQLConnection::Open(const std::string& infoString)
{
MYSQL *mysqlInit;
mysqlInit = mysql_init(NULL);
if (!mysqlInit)
{
sLog.outError("Could not initialize Mysql connection");
return false;
}
Tokens tokens = StrSplit(infoString, ";");
Tokens::iterator iter;
std::string host, port_or_socket, user, password, database;
int port;
char const* unix_socket;
iter = tokens.begin();
if (iter != tokens.end())
host = *iter++;
if (iter != tokens.end())
port_or_socket = *iter++;
if (iter != tokens.end())
user = *iter++;
if (iter != tokens.end())
password = *iter++;
if (iter != tokens.end())
database = *iter++;
mysql_options(mysqlInit, MYSQL_SET_CHARSET_NAME, "utf8");
#ifdef _WIN32
if (host==".") // named pipe use option (Windows)
{
unsigned int opt = MYSQL_PROTOCOL_PIPE;
mysql_options(mysqlInit, MYSQL_OPT_PROTOCOL, (char const*)&opt);
port = 0;
unix_socket = 0;
}
else // generic case
{
port = atoi(port_or_socket.c_str());
unix_socket = 0;
}
#else
if (host==".") // socket use option (Unix/Linux)
{
unsigned int opt = MYSQL_PROTOCOL_SOCKET;
mysql_options(mysqlInit, MYSQL_OPT_PROTOCOL, (char const*)&opt);
host = "localhost";
port = 0;
unix_socket = port_or_socket.c_str();
}
else // generic case
{
port = atoi(port_or_socket.c_str());
unix_socket = 0;
}
#endif
m_Mysql = mysql_real_connect(mysqlInit, host.c_str(), user.c_str(),
password.c_str(), database.c_str(), port, unix_socket, 0);
if (m_Mysql)
{
sLog.outDetail("Connected to MySQL database at %s", host.c_str());
sLog.outString("MySQL client library: %s", mysql_get_client_info());
sLog.outString("MySQL server ver: %s ", mysql_get_server_info( m_Mysql));
if (!mysql_autocommit(m_Mysql, 1))
sLog.outDetail("AUTOCOMMIT SUCCESSFULLY SET TO 1");
else
sLog.outDetail("AUTOCOMMIT NOT SET TO 1");
// set connection properties to UTF8 to properly handle locales for different
// server configs - core sends data in UTF8, so MySQL must expect UTF8 too
Execute("SET NAMES `utf8`");
Execute("SET CHARACTER SET `utf8`");
#if MYSQL_VERSION_ID >= 50003
my_bool my_true = (my_bool)1;
if (mysql_options(m_Mysql, MYSQL_OPT_RECONNECT, &my_true))
sLog.outDetail("Failed to turn on MYSQL_OPT_RECONNECT.");
else
sLog.outDetail("Successfully turned on MYSQL_OPT_RECONNECT.");
#else
#warning "Your mySQL client lib version does not support reconnecting after a timeout.\nIf this causes you any trouble we advice you to upgrade your mySQL client libs to at least mySQL 5.0.13 to resolve this problem."
#endif
return true;
}
else
{
sLog.outError("Could not connect to MySQL database at %s: %s\n", host.c_str(), mysql_error(mysqlInit));
mysql_close(mysqlInit);
return false;
}
}
int wsql_connection__init__(wsql_connection *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = {
"host", "user", "password", "database",
"port", "socket_name", "connect_timeout", "compress",
"init_command", "read_default_file", "read_default_group", "client_flag",
"ssl", "local_infile", "nonblocking", NULL
};
TRACE1("%p", self);
MYSQL *conn = NULL;
PyObject *ssl = NULL;
#if HAVE_OPENSSL
char *key = NULL, *cert = NULL, *ca = NULL, *capath = NULL, *cipher = NULL;
#endif
char *host = NULL, *user = NULL, *password = NULL,
*database = NULL, *socket_name = NULL,
*init_command=NULL, *read_default_file=NULL, *read_default_group=NULL;
unsigned int port = 0, client_flag = 0, connect_timeout = 0;
int nonblocking = 0, compress = -1, local_infile = -1;
self->open = 0;
self->autocommit = 0;
self->connected = 0;
CHECK_SERVER(-1);
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ssssIsIisssIOii:connect",
kwlist,
&host, &user, &password, &database,
&port, &socket_name, &connect_timeout, &compress,
&init_command, &read_default_file, &read_default_group,
&client_flag, &ssl, &local_infile, &nonblocking))
{
return -1;
}
if (nonblocking)
{
#ifndef HAVE_ASYNCIO
PyErr_SetString(wsql_not_supported_error, "The asynchronous operations does not supported.");
return -1;
#endif
}
#define GET_ITEM_STRING(k, t, d) \
{ t = PyMapping_GetItemString(d, #k);\
if (t) { k = PyString_AsString(t); Py_DECREF(t);} \
PyErr_Clear(); \
}
if (ssl)
{
#if HAVE_OPENSSL
PyObject *value = NULL;
GET_ITEM_STRING(ca, value, ssl);
GET_ITEM_STRING(capath, value, ssl);
GET_ITEM_STRING(cert, value, ssl);
GET_ITEM_STRING(key, value, ssl);
GET_ITEM_STRING(cipher, value, ssl);
#else
PyErr_SetString(wsql_not_supported_error, "client library does not have SSL support");
return -1;
#endif
}
#undef GET_ITEM_STRING
Py_BEGIN_ALLOW_THREADS ;
conn = mysql_init(&(self->connection));
if (conn != NULL)
{
if (compress != -1)
{
mysql_options(conn, MYSQL_OPT_COMPRESS, 0);
client_flag |= CLIENT_COMPRESS;
}
if (connect_timeout)
mysql_options(conn, MYSQL_OPT_CONNECT_TIMEOUT, (char *)&connect_timeout);
if (init_command != NULL)
mysql_options(conn, MYSQL_INIT_COMMAND, init_command);
if (read_default_file != NULL)
mysql_options(conn, MYSQL_READ_DEFAULT_FILE, read_default_file);
if (read_default_group != NULL)
mysql_options(conn, MYSQL_READ_DEFAULT_GROUP, read_default_group);
if (local_infile != -1)
mysql_options(conn, MYSQL_OPT_LOCAL_INFILE, (char *) &local_infile);
#ifdef _WIN32
if (socket_name != NULL)
mysql_options(conn, MYSQL_OPT_NAMED_PIPE, 0);
#endif
#if HAVE_OPENSSL
if (ssl)
mysql_ssl_set(conn, key, cert, ca, capath, cipher);
#endif
if (nonblocking)
{
#ifdef HAVE_ASYNCIO
if (!mysql_real_connect_nonblocking_init(
conn, host, user, password, database, port, socket_name, client_flag))
{
conn = NULL;
}
#endif
}
else
{
conn = mysql_real_connect(conn, host, user, password, database, port, socket_name, client_flag);
}
}
self->autocommit = self->connection.server_capabilities & CLIENT_TRANSACTIONS ? 1 : 0;
Py_END_ALLOW_THREADS ;
if (conn == NULL)
{
wsql_raise_error(self);
return -1;
}
self->open = 1;
if (!nonblocking)
{
self->connected = 1;
}
return 0;
}
int myDBConn::connectToDB(QString path)
{
QDir dir;
dir.setPath(path);
if (!dir.exists())
{
gbtLog(tr("The target path does not exists"));
return 0;
}
QString npath;
npath = path;
#ifdef Q_OS_WIN
npath = npath.replace("\\","/");
#endif
if (!m_connected)
{
QString dbParam;
dbParam = "--datadir="+npath;
QString kbSize;
kbSize = "--key_buffer_size="+QString::number(getBufferSize());
QByteArray ba = dbParam.toLocal8Bit();
char *c_str2 = ba.data();
QByteArray ba2 = kbSize.toLocal8Bit();
char *c_str3 = ba2.data();
QString baseParam;
baseParam = "--basedir="+npath;
QByteArray ba3 = baseParam.toLocal8Bit();
char *c_str4 = ba3.data();
static char *server_options[] = \
{ (char *)"mysql_test",
c_str2,
c_str4,
(char *)"--default-storage-engine=MyISAM",
(char *)"--loose-innodb=0",
(char *)"--skip-grant-tables=1",
(char *)"--myisam-recover=FORCE",
c_str3,
(char *)"--character-set-server=utf8",
(char *)"--collation-server=utf8_bin",
NULL };
int num_elements = (sizeof(server_options) / sizeof(char *)) - 1;
mysql_library_init(num_elements, server_options, NULL);
m_mysql = mysql_init(NULL);
int valopt;
valopt = 1;
if (mysql_options(m_mysql,MYSQL_OPT_LOCAL_INFILE,(void *)&valopt))
gbtLog("Error setting option");
mysql_real_connect(m_mysql, NULL,NULL,NULL, "database1", 0,NULL,0);
m_drv = new GOBLETDriver(m_mysql);
if (m_drv)
{
m_connected = true;
return 1;
}
}
return 0;
}
int main() {
MYSQL_ROW row;
MYSQL_RES *result;
int i;
char query[1024];
int hdr;
#define HDR ((struct header *)(buf+hdr))
if (!(conn = mysql_init(NULL))) return -1;
mysql_options(conn, MYSQL_SET_CHARSET_NAME, "utf8");
if (!mysql_real_connect(conn, "localhost", DBUSER, DBPASS, "pismo", 0, MYSQL_SOCKET, 0)) {
fprintf(stderr, "Failed to connect to database: Error: %s\n", mysql_error(conn));
return -2;
}
buf_init();
hdr = buf_alloc(sizeof(struct header));
HDR->signature = SIGNATURE;
mysql_query(conn, "select o.id, o.spis, coalesce(o.alias,''), max(coalesce(t._1,0)), min(coalesce(t.id,1000000))-1, max(coalesce(t.id,-1))-1 "
"from doc__biblia_obsah o left outer join doc__biblia_text t on o.id=t._0 "
"group by o.id, o.spis, coalesce(o.alias,'') "
"order by o.id asc");
result = mysql_store_result(conn);
HDR->n_knihy = mysql_num_rows(result);
ASGN(HDR->knihy, buf_alloc(HDR->n_knihy * sizeof(struct kniha)));
#define KNH ((struct kniha *)(buf+HDR->knihy))
i=0;
while ((row = mysql_fetch_row(result))) {
int j;
sscanf(row[0], "%d", &j);
if (i!=j-1) { fprintf(stderr, "nesuvisle id\n"); exit(1); }
ASGN(KNH[i].meno, buf_add(row[1], strlen(row[1])+1));
ASGN(KNH[i].alias, buf_add(row[2], strlen(row[2])+1));
sscanf(row[3], "%d", &KNH[i].n_hlav);
sscanf(row[4], "%d", &KNH[i].min);
sscanf(row[5], "%d", &KNH[i].max);
ASGN(KNH[i].hlava, buf_alloc(sizeof(struct hlava)*KNH[i].n_hlav));
for (j=0; j<KNH[i].n_hlav; j++) {
MYSQL_ROW row2;
MYSQL_RES *result2;
int k;
#define HLV ((struct hlava *)(buf+KNH[i].hlava))
sprintf(query, "select min(coalesce(t.id,1000000))-1, max(coalesce(t.id,-1))-1 "
"from doc__biblia_text t "
"where t._0=%d and t._1=%d", i+1, j+1);
mysql_query(conn, query);
result2 = mysql_store_result(conn);
row2 = mysql_fetch_row(result2);
sscanf(row2[0], "%d", &HLV[j].min);
sscanf(row2[1], "%d", &HLV[j].max);
// printf("kniha %d, hlava %d, min %d, max %d\n", i, j, HLV[j].min, HLV[j].max);
mysql_free_result(result2);
sprintf(query, "select t._2, min(t.id)-1, max(t.id)-1 "
"from doc__biblia_text t "
"where t._0=%d and t._1=%d and t._2 is not null group by t._2", i+1, j+1);
mysql_query(conn, query);
result2 = mysql_store_result(conn);
HLV[j].n_versov = mysql_num_rows(result2);
// if (!HLV[j].n_versov) printf("kniha = %s; hlava = %d; versov=%d\n", row[1], j, HLV[j].n_versov);
ASGN(HLV[j].vers, buf_alloc(sizeof(struct vers)*HLV[j].n_versov));
for (k=0; k < HLV[j].n_versov; k++) {
int l;
#define VRS ((struct vers *)(buf+HLV[j].vers))
row2 = mysql_fetch_row(result2);
sscanf(row2[0], "%d", &l);
if (l-1 != k) {
fprintf(stderr, "nesuvisle id versa k=%d h=%d v=%d!=%d, ignorujem\n", i+1, j+1, l, k+1);
k--;
HLV[j].n_versov--;
continue;
}
sscanf(row2[1], "%d", &VRS[k].min);
sscanf(row2[2], "%d", &VRS[k].max);
// printf("k=%d min=%d=%s max=%d=%s\n", k, VRS[k].min, row2[1], VRS[k].max, row2[2]);
}
mysql_free_result(result2);
}
i++;
}
mysql_free_result(result);
mysql_query(conn, "select max(coalesce(id,0)) from doc__biblia_text where _0 is not null order by id asc");
result = mysql_store_result(conn);
row = mysql_fetch_row(result);
sscanf(row[0], "%d", &HDR->n_text);
mysql_free_result(result);
mysql_query(conn, "select id, _0-1, coalesce(_1, 0)-1, coalesce(_2, 0)-1, "
" coalesce(html,''), coalesce(nvg_html,'') "
"from doc__biblia_text where _0 is not null order by id asc");
result = mysql_store_result(conn);
i=0;
ASGN(HDR->text, buf_alloc(sizeof(struct text)*HDR->n_text));
#define TXT ((struct text *)(buf+HDR->text))
while ((row = mysql_fetch_row(result))) {
int j;
sscanf(row[0], "%d", &j);
while (i<j-1) {
TXT[i].k = TXT[i].h = TXT[i].v = -1;
ASGN(TXT[i].t, buf_add("", 1));
i++;
}
sscanf(row[1], "%d", &TXT[i].k);
sscanf(row[2], "%d", &TXT[i].h);
sscanf(row[3], "%d", &TXT[i].v);
ASGN(TXT[i].t, buf_add(row[4], strlen(row[4])+1));
ASGN(TXT[i].t_nvg, buf_add(row[5], strlen(row[5])+1));
// printf("txt %d = %s\n", i, row[4]);
i++;
}
mysql_free_result(result);
mysql_query(conn, "select max(coalesce(id,0)) from doc__biblia_ppc order by id asc");
result = mysql_store_result(conn);
row = mysql_fetch_row(result);
sscanf(row[0], "%d", &HDR->n_ppc);
mysql_free_result(result);
mysql_query(conn, "select id, coalesce(html,'') from doc__biblia_ppc order by id asc");
result = mysql_store_result(conn);
i=0;
ASGN(HDR->ppc, buf_alloc(sizeof(int32_t)*HDR->n_ppc));
#define PPC ((int32_t *)(buf+HDR->ppc))
while ((row = mysql_fetch_row(result))) {
int j;
sscanf(row[0], "%d", &j);
while (i<j-1) {
ASGN(PPC[i], buf_add("", 1));
i++;
}
ASGN(PPC[i], buf_add(row[1], strlen(row[1])+1));
i++;
}
mysql_free_result(result);
/*
mysql_query(conn, "select datum, zalm, citania from liturgicke_citania order by datum asc");
result = mysql_store_result(conn);
HDR->n_kalendar = mysql_num_rows(result);
ASGN(HDR->kalendar, buf_alloc(sizeof(struct kalendar)*HDR->n_kalendar));
#define KAL ((struct kalendar *)(buf+HDR->kalendar))
i = 0;
while ((row = mysql_fetch_row(result))) {
sscanf(row[0], "%d-%d-%d", &KAL[i].y, &KAL[i].m, &KAL[i].d);
ASGN(KAL[i].zalm, buf_add(row[1], strlen(row[1])+1));
ASGN(KAL[i].text, buf_add(row[2], strlen(row[2])+1));
i++;
}
mysql_free_result(result);
*/
for (i=0; i<TABLES; i++) {
int j;
int min = (1<<i);
int max = (i==TABLES-1) ? (1<<30) : (1<<(i+1))-1;
sprintf(query, "(select 0, id-1, start-1 as start, end-1 from doc__biblia_text "
"where end-start+1>=%d and end-start+1<=%d) union "
"(select 1, id-1, start-1, end-1 from doc__biblia_ppc "
"where end-start+1>=%d and end-start+1<=%d) order by start asc", min, max, min, max);
mysql_query(conn, query);
result = mysql_store_result(conn);
HDR->n_item[i] = mysql_num_rows(result);
ASGN(HDR->item[i], buf_alloc(sizeof(struct item)*HDR->n_item[i]));
#define ITM ((struct item *)(buf+HDR->item[i]))
j = 0;
while ((row = mysql_fetch_row(result))) {
sscanf(row[0], "%d", &ITM[j].comment);
sscanf(row[1], "%d", &ITM[j].id);
sscanf(row[2], "%d", &ITM[j].b);
sscanf(row[3], "%d", &ITM[j].e);
j++;
}
mysql_free_result(result);
}
mysql_query(conn, "select o.id, o.popis, o.text "
"from doc__biblia_uvod o "
"order by o.id asc");
result = mysql_store_result(conn);
HDR->n_uvod = mysql_num_rows(result);
ASGN(HDR->uvod, buf_alloc(HDR->n_uvod * sizeof(struct uvod)));
#define UVD ((struct uvod *)(buf+HDR->uvod))
i=0;
while ((row = mysql_fetch_row(result))) {
ASGN(UVD[i].kniha, buf_add(row[1], strlen(row[1])+1));
ASGN(UVD[i].text, buf_add(row[2], strlen(row[2])+1));
i++;
}
mysql_free_result(result);
dump("pismo.bin");
mysql_close(conn);
return 0;
}
bool DatabaseMysql::Initialize(const char *infoString)
{
if(!Database::Initialize(infoString))
return false;
tranThread = NULL;
MYSQL *mysqlInit;
mysqlInit = mysql_init(NULL);
if (!mysqlInit)
{
sLog.outError( "Could not initialize Mysql connection" );
return false;
}
InitDelayThread();
Tokens tokens = StrSplit(infoString, ";");
Tokens::iterator iter;
std::string host, port_or_socket, user, password, database;
int port;
char const* unix_socket;
iter = tokens.begin();
if(iter != tokens.end())
host = *iter++;
if(iter != tokens.end())
port_or_socket = *iter++;
if(iter != tokens.end())
user = *iter++;
if(iter != tokens.end())
password = *iter++;
if(iter != tokens.end())
database = *iter++;
mysql_options(mysqlInit,MYSQL_SET_CHARSET_NAME,"utf8");
#ifdef WIN32
if(host==".") // named pipe use option (Windows)
{
unsigned int opt = MYSQL_PROTOCOL_PIPE;
mysql_options(mysqlInit,MYSQL_OPT_PROTOCOL,(char const*)&opt);
port = 0;
unix_socket = 0;
}
else // generic case
{
port = atoi(port_or_socket.c_str());
unix_socket = 0;
}
#else
if(host==".") // socket use option (Unix/Linux)
{
unsigned int opt = MYSQL_PROTOCOL_SOCKET;
mysql_options(mysqlInit,MYSQL_OPT_PROTOCOL,(char const*)&opt);
host = "localhost";
port = 0;
unix_socket = port_or_socket.c_str();
}
else // generic case
{
port = atoi(port_or_socket.c_str());
unix_socket = 0;
}
#endif
mMysql = mysql_real_connect(mysqlInit, host.c_str(), user.c_str(),
password.c_str(), database.c_str(), port, unix_socket, 0);
if (mMysql)
{
sLog.outDetail( "Connected to MySQL database at %s\r\n",
host.c_str());
sLog.outString( "MySQL client library: %s", mysql_get_client_info());
sLog.outString( "MySQL server ver: %s ", mysql_get_server_info( mMysql));
/*----------SET AUTOCOMMIT ON---------*/
// It seems mysql 5.0.x have enabled this feature
// by default. In crash case you can lose data!!!
// So better to turn this off
// ---
// This is wrong since mangos use transactions,
// autocommit is turned of during it.
// Setting it to on makes atomic updates work
if (!mysql_autocommit(mMysql, 1))
sLog.outDetail("AUTOCOMMIT SUCCESSFULLY SET TO 1");
else
sLog.outDetail("AUTOCOMMIT NOT SET TO 1");
/*-------------------------------------*/
return true;
}
else
{
sLog.outError( "Could not connect to MySQL database at %s: %s\n",
host.c_str(),mysql_error(mysqlInit));
mysql_close(mysqlInit);
return false;
}
}
int
main (int argc, char **argv)
{
MYSQL mysql;
MYSQL_RES *res;
MYSQL_ROW row;
/* should be status */
char *result = NULL;
char *error = NULL;
char slaveresult[SLAVERESULTSIZE];
char* perf;
perf = strdup ("");
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
/* Parse extra opts if any */
argv=np_extra_opts (&argc, argv, progname);
if (process_arguments (argc, argv) == ERROR)
usage4 (_("Could not parse arguments"));
/* initialize mysql */
mysql_init (&mysql);
if (opt_file != NULL)
mysql_options(&mysql,MYSQL_READ_DEFAULT_FILE,opt_file);
if (opt_group != NULL)
mysql_options(&mysql,MYSQL_READ_DEFAULT_GROUP,opt_group);
else
mysql_options(&mysql,MYSQL_READ_DEFAULT_GROUP,"client");
if (ssl)
mysql_ssl_set(&mysql,key,cert,ca_cert,ca_dir,ciphers);
/* establish a connection to the server and error checking */
if (!mysql_real_connect(&mysql,db_host,db_user,db_pass,db,db_port,db_socket,0)) {
if (mysql_errno (&mysql) == CR_UNKNOWN_HOST)
die (STATE_WARNING, "%s\n", mysql_error (&mysql));
else if (mysql_errno (&mysql) == CR_VERSION_ERROR)
die (STATE_WARNING, "%s\n", mysql_error (&mysql));
else if (mysql_errno (&mysql) == CR_OUT_OF_MEMORY)
die (STATE_WARNING, "%s\n", mysql_error (&mysql));
else if (mysql_errno (&mysql) == CR_IPSOCK_ERROR)
die (STATE_WARNING, "%s\n", mysql_error (&mysql));
else if (mysql_errno (&mysql) == CR_SOCKET_CREATE_ERROR)
die (STATE_WARNING, "%s\n", mysql_error (&mysql));
else
die (STATE_CRITICAL, "%s\n", mysql_error (&mysql));
}
/* get the server stats */
result = strdup (mysql_stat (&mysql));
/* error checking once more */
if (mysql_error (&mysql)) {
if (mysql_errno (&mysql) == CR_SERVER_GONE_ERROR)
die (STATE_CRITICAL, "%s\n", mysql_error (&mysql));
else if (mysql_errno (&mysql) == CR_SERVER_LOST)
die (STATE_CRITICAL, "%s\n", mysql_error (&mysql));
else if (mysql_errno (&mysql) == CR_UNKNOWN_ERROR)
die (STATE_CRITICAL, "%s\n", mysql_error (&mysql));
}
/* try to fetch some perf data */
if (mysql_query (&mysql, "show global status") == 0) {
if ( (res = mysql_store_result (&mysql)) == NULL) {
error = strdup(mysql_error(&mysql));
mysql_close (&mysql);
die (STATE_CRITICAL, _("status store_result error: %s\n"), error);
}
while ( (row = mysql_fetch_row (res)) != NULL) {
int i;
for(i = 0; i < LENGTH_METRIC_UNIT; i++) {
if (strcmp(row[0], metric_unit[i]) == 0) {
xasprintf(&perf, "%s%s ", perf, perfdata(metric_unit[i],
atol(row[1]), "", FALSE, 0, FALSE, 0, FALSE, 0, FALSE, 0));
continue;
}
}
for(i = 0; i < LENGTH_METRIC_COUNTER; i++) {
if (strcmp(row[0], metric_counter[i]) == 0) {
xasprintf(&perf, "%s%s ", perf, perfdata(metric_counter[i],
atol(row[1]), "c", FALSE, 0, FALSE, 0, FALSE, 0, FALSE, 0));
continue;
}
}
}
/* remove trailing space */
if (strlen(perf) > 0)
perf[strlen(perf) - 1] = '\0';
}
if(check_slave) {
/* check the slave status */
if (mysql_query (&mysql, "show slave status") != 0) {
error = strdup(mysql_error(&mysql));
mysql_close (&mysql);
die (STATE_CRITICAL, _("slave query error: %s\n"), error);
}
/* store the result */
if ( (res = mysql_store_result (&mysql)) == NULL) {
error = strdup(mysql_error(&mysql));
mysql_close (&mysql);
die (STATE_CRITICAL, _("slave store_result error: %s\n"), error);
}
/* Check there is some data */
if (mysql_num_rows(res) == 0) {
mysql_close(&mysql);
die (STATE_WARNING, "%s\n", _("No slaves defined"));
}
/* fetch the first row */
if ( (row = mysql_fetch_row (res)) == NULL) {
error = strdup(mysql_error(&mysql));
mysql_free_result (res);
mysql_close (&mysql);
die (STATE_CRITICAL, _("slave fetch row error: %s\n"), error);
}
if (mysql_field_count (&mysql) == 12) {
/* mysql 3.23.x */
snprintf (slaveresult, SLAVERESULTSIZE, _("Slave running: %s"), row[6]);
if (strcmp (row[6], "Yes") != 0) {
mysql_free_result (res);
mysql_close (&mysql);
die (STATE_CRITICAL, "%s\n", slaveresult);
}
} else {
/* mysql 4.x.x and mysql 5.x.x */
int slave_io_field = -1 , slave_sql_field = -1, seconds_behind_field = -1, i, num_fields;
MYSQL_FIELD* fields;
num_fields = mysql_num_fields(res);
fields = mysql_fetch_fields(res);
for(i = 0; i < num_fields; i++) {
if (strcmp(fields[i].name, "Slave_IO_Running") == 0) {
slave_io_field = i;
continue;
}
if (strcmp(fields[i].name, "Slave_SQL_Running") == 0) {
slave_sql_field = i;
continue;
}
if (strcmp(fields[i].name, "Seconds_Behind_Master") == 0) {
seconds_behind_field = i;
continue;
}
}
/* Check if slave status is available */
if ((slave_io_field < 0) || (slave_sql_field < 0) || (num_fields == 0)) {
mysql_free_result (res);
mysql_close (&mysql);
die (STATE_CRITICAL, "Slave status unavailable\n");
}
/* Save slave status in slaveresult */
snprintf (slaveresult, SLAVERESULTSIZE, "Slave IO: %s Slave SQL: %s Seconds Behind Master: %s", row[slave_io_field], row[slave_sql_field], seconds_behind_field!=-1?row[seconds_behind_field]:"Unknown");
/* Raise critical error if SQL THREAD or IO THREAD are stopped */
if (strcmp (row[slave_io_field], "Yes") != 0 || strcmp (row[slave_sql_field], "Yes") != 0) {
mysql_free_result (res);
mysql_close (&mysql);
die (STATE_CRITICAL, "%s\n", slaveresult);
}
if (verbose >=3) {
if (seconds_behind_field == -1) {
printf("seconds_behind_field not found\n");
} else {
printf ("seconds_behind_field(index %d)=%s\n", seconds_behind_field, row[seconds_behind_field]);
}
}
/* Check Seconds Behind against threshold */
if ((seconds_behind_field != -1) && (strcmp (row[seconds_behind_field], "NULL") != 0)) {
double value = atof(row[seconds_behind_field]);
int status;
status = get_status(value, my_threshold);
xasprintf (&perf, "%s %s", perf, fperfdata ("seconds behind master", value, "s",
TRUE, (double) warning_time,
TRUE, (double) critical_time,
FALSE, 0,
FALSE, 0));
if (status == STATE_WARNING) {
printf("SLOW_SLAVE %s: %s|%s\n", _("WARNING"), slaveresult, perf);
exit(STATE_WARNING);
} else if (status == STATE_CRITICAL) {
printf("SLOW_SLAVE %s: %s|%s\n", _("CRITICAL"), slaveresult, perf);
exit(STATE_CRITICAL);
}
}
}
/* free the result */
mysql_free_result (res);
}
/* close the connection */
mysql_close (&mysql);
/* print out the result of stats */
if (check_slave) {
printf ("%s %s|%s\n", result, slaveresult, perf);
} else {
printf ("%s|%s\n", result, perf);
}
return STATE_OK;
}
static int
config_connect(struct config *conf)
{
static const struct {
const char *name;
int cols;
} qspec[SQL_MAX] = {
{ "query_alias", 1 },
{ "query_domain", 1 },
{ "query_credentials", 2 },
{ "query_netaddr", 1 },
{ "query_userinfo", 3 },
{ "query_source", 1 },
{ "query_mailaddr", 1 },
{ "query_addrname", 1 },
};
my_bool reconn;
size_t i;
char *host, *username, *password, *database, *q;
log_debug("debug: table-mysql: (re)connecting");
/* Disconnect first, if needed */
config_reset(conf);
host = dict_get(&conf->conf, "host");
username = dict_get(&conf->conf, "username");
database = dict_get(&conf->conf, "database");
password = dict_get(&conf->conf, "password");
conf->db = mysql_init(NULL);
if (conf->db == NULL) {
log_warnx("warn: table-mysql: mysql_init failed");
goto end;
}
reconn = 1;
if (mysql_options(conf->db, MYSQL_OPT_RECONNECT, &reconn) != 0) {
log_warnx("warn: table-mysql: mysql_options: %s",
mysql_error(conf->db));
goto end;
}
if (!mysql_real_connect(conf->db, host, username, password, database,
0, NULL, 0)) {
log_warnx("warn: table-mysql: mysql_real_connect: %s",
mysql_error(conf->db));
goto end;
}
for (i = 0; i < SQL_MAX; i++) {
q = dict_get(&conf->conf, qspec[i].name);
if (q && (conf->statements[i] = table_mysql_prepare_stmt(
conf->db, q, 1, qspec[i].cols)) == NULL)
goto end;
}
q = dict_get(&conf->conf, "fetch_source");
if (q && (conf->stmt_fetch_source = table_mysql_prepare_stmt(conf->db,
q, 0, 1)) == NULL)
goto end;
log_debug("debug: table-mysql: connected");
return (1);
end:
config_reset(conf);
return (0);
}
int main (int argc, char *argv[]) {
MYSQL *mysql;
MYSQL_RES *result;
MYSQL_ROW row;
my_bool reconnect = 0;
mysql = mysql_init(NULL);
mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
CONN(0);
//mysql_real_connect(mysql, "127.0.0.1", "test", "test", "test", 3306, NULL, 0);
//mysql_real_connect(mysql, "10.1.170.196", "root", "root", "test", 3306, NULL, 0);
MYSQL_STMT *stmt;
MYSQL_BIND bind[9];
my_ulonglong affected_rows;
int param_count;
short small_data;
int int_data;
char str_data[STRING_SIZE];
unsigned long str_length;
my_bool is_null;
if (mysql_query(mysql, DROP_SAMPLE_TABLE))
{
fprintf(stderr, " DROP TABLE failed\n");
fprintf(stderr, " %s\n", mysql_error(mysql));
exit(0);
}
if (mysql_query(mysql, CREATE_SAMPLE_TABLE))
{
fprintf(stderr, " CREATE TABLE failed\n");
fprintf(stderr, " %s\n", mysql_error(mysql));
exit(0);
}
/* Prepare an INSERT query with 3 parameters */
/* (the TIMESTAMP column is not named; the server */
/* sets it to the current date and time) */
stmt = mysql_stmt_init(mysql);
if (!stmt)
{
fprintf(stderr, " mysql_stmt_init(), out of memory\n");
exit(0);
}
if (mysql_stmt_prepare(stmt, INSERT_SAMPLE, strlen(INSERT_SAMPLE)))
{
fprintf(stderr, " mysql_stmt_prepare(), INSERT failed\n");
fprintf(stderr, " %s\n", mysql_stmt_error(stmt));
exit(0);
}
fprintf(stdout, " prepare, INSERT successful\n");
/* Get the parameter count from the statement */
param_count= mysql_stmt_param_count(stmt);
fprintf(stdout, " total parameters in INSERT: %d\n", param_count);
/* Bind the data for all 3 parameters */
memset(bind, 0, sizeof(bind));
/* INTEGER PARAM */
/* This is a number type, so there is no need to specify buffer_length */
bind[0].buffer_type= MYSQL_TYPE_LONGLONG;
bind[0].buffer= (char *)&int_data;
bind[0].is_null= 0;
/* STRING PARAM */
bind[1].buffer_type= MYSQL_TYPE_STRING;
bind[1].buffer= (char *)str_data;
//bind[1].buffer_length= STRING_SIZE; //最大长度, string not use this, 其它类型buffer_length 也没用
bind[1].is_null= 0;
bind[1].length= &str_length; //实际大小, bind_
/* SMALLINT PARAM */
bind[2].buffer_type= MYSQL_TYPE_SHORT;
bind[2].buffer= (char *)&small_data;
bind[2].is_null= &is_null;
/* timestamp */
MYSQL_TIME t;
bind[3].buffer_type= MYSQL_TYPE_TIMESTAMP;
bind[3].buffer= (char*)&t;
bind[3].is_null= 0;
bind[4].buffer_type= MYSQL_TYPE_DATETIME;
bind[4].buffer= (char*)&t;
bind[4].is_null= 0;
bind[5].buffer_type= MYSQL_TYPE_DATE;
bind[5].buffer= (char*)&t;
bind[5].is_null= 0;
bind[6].buffer_type= MYSQL_TYPE_TIME;
bind[6].buffer= (char*)&t;
bind[6].is_null= 0;
bind[7].buffer_type= MYSQL_TYPE_STRING;
bind[7].buffer= (char *)str_data;
//bind[1].buffer_length= STRING_SIZE; //最大长度, string not use this, 其它类型buffer_length 也没用
bind[7].is_null= 0;
bind[7].length= &str_length; //实际大小, bind_
bind[8].buffer_type= MYSQL_TYPE_NULL;
bind[8].buffer= (char *)str_data;
//bind[1].buffer_length= STRING_SIZE; //最大长度, string not use this, 其它类型buffer_length 也没用
bind[8].is_null= 0;
bind[8].length= &str_length; //实际大小, bind_
/* Bind the buffers */
if (mysql_stmt_bind_param(stmt, bind))
{
fprintf(stderr, " mysql_stmt_bind_param() failed\n");
fprintf(stderr, " %s\n", mysql_stmt_error(stmt));
exit(0);
}
/* Specify the data values for the first row -------------------------------------------------- */
int_data= 10; /* integer */
strncpy(str_data, "MySQL", STRING_SIZE); /* string */
str_length= strlen(str_data);
t.year= 2032;
t.month= 02;
t.day= 03;
t.hour= 10;
t.minute= 45;
t.second= 20;
/* INSERT SMALLINT data as NULL */
is_null= 1;
/* Execute the INSERT statement - 1*/
if (mysql_stmt_execute(stmt))
{
fprintf(stderr, " mysql_stmt_execute(), 1 failed\n");
fprintf(stderr, " %s\n", mysql_stmt_error(stmt));
exit(0);
}
int_data= 333; /* integer */
mysql_stmt_execute(stmt);
/* Get the total number of affected rows */
affected_rows= mysql_stmt_affected_rows(stmt);
fprintf(stdout, " total affected rows(insert 1): %lu\n",
(unsigned long) affected_rows);
if (affected_rows != 1) /* validate affected rows */
{
fprintf(stderr, " invalid affected rows by MySQL\n");
exit(0);
}
/* Specify data values for second row, then re-execute the statement ----------------------------------------*/
int_data= 1000;
strncpy(str_data, "The most popular Open Source database", STRING_SIZE);
str_length= strlen(str_data);
small_data= 1000; /* smallint */
is_null= 0; /* reset */
/* Execute the INSERT statement - 2*/
if (mysql_stmt_execute(stmt))
{
fprintf(stderr, " mysql_stmt_execute, 2 failed\n");
fprintf(stderr, " %s\n", mysql_stmt_error(stmt));
exit(0);
}
/* Get the total rows affected */
affected_rows= mysql_stmt_affected_rows(stmt);
fprintf(stdout, " total affected rows(insert 2): %lu\n",
(unsigned long) affected_rows);
if (affected_rows != 1) /* validate affected rows */
{
fprintf(stderr, " invalid affected rows by MySQL\n");
exit(0);
}
/* Specify data values for third row, then re-execute the statement */
int_data= 1000;
strncpy(str_data, "The most popular Open Source database11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", STRING_SIZE);
str_length= strlen(str_data);
small_data= 10000; /* smallint */
is_null= 0; /* reset */
/* Execute the INSERT statement - 2*/
if (mysql_stmt_execute(stmt))
{
fprintf(stderr, " mysql_stmt_execute, 2 failed\n");
fprintf(stderr, " %s\n", mysql_stmt_error(stmt));
exit(0);
}
/* Get the total rows affected */
affected_rows= mysql_stmt_affected_rows(stmt);
fprintf(stdout, " total affected rows(insert 2): %lu\n",
(unsigned long) affected_rows);
if (affected_rows != 1) /* validate affected rows */
{
fprintf(stderr, " invalid affected rows by MySQL\n");
exit(0);
}
//-----------------------------
MYSQL_STMT *stmt2;
MYSQL_BIND bind2[3];
stmt2 = mysql_stmt_init(mysql);
//here get stmt_id
mysql_stmt_prepare(stmt2, INSERT_SAMPLE2, strlen(INSERT_SAMPLE2));
memset(bind2, 0, sizeof(bind2));
/* INTEGER PARAM */
/* This is a number type, so there is no need to specify buffer_length */
bind2[0].buffer_type= MYSQL_TYPE_LONG;
bind2[0].buffer= (char *)&int_data;
bind2[0].is_null= 0;
/* STRING PARAM */
bind2[1].buffer_type= MYSQL_TYPE_STRING;
bind2[1].buffer= (char *)str_data;
//bind[1].buffer_length= STRING_SIZE; //最大长度, string not use this, 其它类型buffer_length 也没用
bind2[1].is_null= 0;
bind2[1].length= &str_length; //实际大小, bind_
/* SMALLINT PARAM */
bind2[2].buffer_type= MYSQL_TYPE_SHORT;
bind2[2].buffer= (char *)&small_data;
bind2[2].is_null= &is_null;
/* Bind the buffers */
mysql_stmt_bind_param(stmt2, bind2);
/* Specify the data values for the first row -------------------------------------------------- */
int_data= 999; /* integer */
strncpy(str_data, "LALA", STRING_SIZE); /* string */
str_length= strlen(str_data);
t.year= 2017;
t.month= 02;
t.day= 03;
t.hour= 10;
t.minute= 45;
t.second= 20;
/* INSERT SMALLINT data as NULL */
is_null= 1;
/* Execute the INSERT statement - 1*/
mysql_stmt_execute(stmt2);
mysql_stmt_execute(stmt);
/* Close the statement */
mysql_stmt_close(stmt2);
mysql_stmt_close(stmt);
}
bool DatabaseMysql::Initialize(const char *infoString)
{
if(!Database::Initialize(infoString))
return false;
tranThread = NULL;
MYSQL *mysqlInit;
mysqlInit = mysql_init(NULL);
if (!mysqlInit)
{
sLog.outError( "Could not initialize Mysql connection" );
return false;
}
InitDelayThread();
Tokens tokens = StrSplit(infoString, ";");
Tokens::iterator iter;
std::string host, port_or_socket, user, password, database;
int port;
char const* unix_socket;
iter = tokens.begin();
if(iter != tokens.end())
host = *iter++;
if(iter != tokens.end())
port_or_socket = *iter++;
if(iter != tokens.end())
user = *iter++;
if(iter != tokens.end())
password = *iter++;
if(iter != tokens.end())
database = *iter++;
mysql_options(mysqlInit,MYSQL_SET_CHARSET_NAME,"utf8");
#ifdef WIN32
if(host==".") // named pipe use option (Windows)
{
unsigned int opt = MYSQL_PROTOCOL_PIPE;
mysql_options(mysqlInit,MYSQL_OPT_PROTOCOL,(char const*)&opt);
port = 0;
unix_socket = 0;
}
else // generic case
{
port = atoi(port_or_socket.c_str());
unix_socket = 0;
}
#else
if(host==".") // socket use option (Unix/Linux)
{
unsigned int opt = MYSQL_PROTOCOL_SOCKET;
mysql_options(mysqlInit,MYSQL_OPT_PROTOCOL,(char const*)&opt);
host = "localhost";
port = 0;
unix_socket = port_or_socket.c_str();
}
else // generic case
{
port = atoi(port_or_socket.c_str());
unix_socket = 0;
}
#endif
mMysql = mysql_real_connect(mysqlInit, host.c_str(), user.c_str(),
password.c_str(), database.c_str(), port, unix_socket, 0);
if (mMysql)
{
DETAIL_LOG( "Connected to MySQL database at %s",
host.c_str());
sLog.outString( "MySQL client library: %s", mysql_get_client_info());
sLog.outString( "MySQL server ver: %s ", mysql_get_server_info( mMysql));
/*----------SET AUTOCOMMIT ON---------*/
// It seems mysql 5.0.x have enabled this feature
// by default. In crash case you can lose data!!!
// So better to turn this off
// ---
// This is wrong since mangos use transactions,
// autocommit is turned of during it.
// Setting it to on makes atomic updates work
if (!mysql_autocommit(mMysql, 1))
DETAIL_LOG("AUTOCOMMIT SUCCESSFULLY SET TO 1");
else
DETAIL_LOG("AUTOCOMMIT NOT SET TO 1");
/*-------------------------------------*/
// set connection properties to UTF8 to properly handle locales for different
// server configs - core sends data in UTF8, so MySQL must expect UTF8 too
PExecute("SET NAMES `utf8`");
PExecute("SET CHARACTER SET `utf8`");
#if MYSQL_VERSION_ID >= 50003
my_bool my_true = (my_bool)1;
if (mysql_options(mMysql, MYSQL_OPT_RECONNECT, &my_true))
{
sLog.outDetail("Failed to turn on MYSQL_OPT_RECONNECT.");
}
else
{
sLog.outDetail("Successfully turned on MYSQL_OPT_RECONNECT.");
}
#else
sLog.outDetail("Your mySQL client lib version does not support reconnecting after a timeout.");
sLog.outDetail("If this causes you any trouble we advice you to upgrade");
sLog.outDetail("Your mySQL client libs to at least mySQL 5.0.13 to resolve this problem.");
#endif
return true;
}
else
{
sLog.outError( "Could not connect to MySQL database at %s: %s\n",
host.c_str(),mysql_error(mysqlInit));
mysql_close(mysqlInit);
return false;
}
}
int main(int argc, char** argv)
{
slist_cursor_t* c;
const char* q;
query_test_t* qtest;
skygw_query_type_t qtype;
bool succp;
bool failp = true;
unsigned int f = 0;
int nsucc = 0;
int nfail = 0;
MYSQL* mysql;
char* workingdir;
char ddoption[1024];
ss_dfprintf(stderr, ">> testmain\n");
c = slist_init();
/** Test some functions */
q = "SELECT MY_UDF('Hello')";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, true));
/** This could be QUERY_TYPE_LOCAL_READ */
q = "SELECT repeat('a', 1024)";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_READ, false, true));
/** This could be QUERY_TYPE_LOCAL_READ */
q = "SELECT soundex('Hello')";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_READ, false, true));
q = "SELECT ssoundexx('Hello')";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, true));
/** This could be QUERY_TYPE_LOCAL_READ */
q = "SELECT now()";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_READ, false, true));
/** This could be QUERY_TYPE_LOCAL_READ */
q = "SELECT rand()";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_READ, false, true));
q = "SELECT rand(234), MY_UDF('Hello'), soundex('Hello')";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, true));
/** Read-only SELECTs */
q = "SELECT user from mysql.user";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_READ, false, true));
q = "select tt1.id, tt2.id from t1 tt1, t2 tt2 where tt1.name is "
"not null and tt2.name is not null";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_READ, false, false));
/** SELECT ..INTO clauses > session updates */
q = "SELECT user from mysql.user INTO DUMPFILE '/tmp/dump1'";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, false, false));
q = "SELECT user INTO DUMPFILE '/tmp/dump2 ' from mysql.user";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, false, false));
q = "SELECT user from mysql.user INTO OUTFILE '/tmp/out1'";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, false, false));
/** Database and table name must be separated by a dot */
q = "SELECT user INTO OUTFILE '/tmp/out2 ' from mysql-user";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, true, false));
/** Database and table name must be separated by a dot */
q = "SELECT user INTO OUTFILE '/tmp/out2 ' from mysql_foo_user";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, false, false));
q = "SELECT user FROM mysql.user limit 1 INTO @local_variable";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, false, false));
q = "SELECT user INTO @local_variable FROM mysql.user limit 1";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, false, false));
q = "SELECT non_existent_attr INTO @d FROM non_existent_table";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, false, false));
q = "select * from table1 "
"where table1.field IN "
"(select * from table1a union select * from table1b) union "
"select * from table2 where table2.field = "
"(select (select f1 from table2a where table2a.f2 = table2b.f3) "
"from table2b where table2b.f1 = table2.f2) union "
"select * from table3";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_READ, false, true));
/** RENAME TABLEs */
q = "RENAME TABLE T1 to T2";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, false));
/** INSERTs */
q = "INSERT INTO T1 (SELECT * FROM T2)";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, true));
q = "INSERT INTO T1 VALUES(2, 'foo', 'toomanyattributes')";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, true));
q = "INSERT INTO T2 VALUES(1, 'sthrgey')";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, false));
q = "INSERT INTO T2 VALUES(8, 'ergstrhe')";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, false));
q = "INSERT INTO T2 VALUES(9, NULL)";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, false));
/** Ok, delimeter is client-side parameter which shouldn't be handled
* on server side.
*/
q = "delimiter //";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, true, true));
/** SETs, USEs > Session updates */
q = "SET @a=1";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, false, true));
q = "USE TEST";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, false, false));
/** Object creation statements */
q = "create procedure si (out param1 int) \nbegin select count(*) "
"into param1 from t1; \nend";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, true));
q = "CREATE TABLE T1 (id integer primary key, name varchar(10))";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, true));
q = "DROP TABLE T1";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, false));
q = "ALTER TABLE T1 ADD COLUMN WHYME INTEGER NOT NULL";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, false));
q = "TRUNCATE TABLE T1";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, false));
q = "DROP SERVER IF EXISTS VICTIMSRV";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, false, true));
q = "CREATE USER FOO IDENTIFIED BY 'BAR'";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, true));
q = "OPTIMIZE NO_WRITE_TO_BINLOG TABLE T1";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, true));
q = "SELECT NOW();CREATE TABLE T1 (ID INTEGER);"
"SET sql_log_bin=0;CREATE TABLE T2 (ID INTEGER)";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_WRITE, false, true));
/** Setting database makes this SESSION_WRITE */
q = "USE TEST;CREATE TABLE T1 (ID INTEGER);"
"SET sql_log_bin=0;CREATE TABLE T2 (ID INTEGER)";
slcursor_add_case(
c,
query_test_init(q, QUERY_TYPE_SESSION_WRITE, false, true));
/**
* Init libmysqld.
*/
workingdir = getenv("PWD");
if (workingdir == NULL) {
fprintf(stderr,
"Failed to resolve the working directory, $PWD is not "
"set.\n");
goto return_without_server;
} else if (access(workingdir, R_OK) != 0) {
fprintf(stderr,
"Failed to access the working directory due %d, %s\n",
errno,
strerror(errno));
goto return_without_server;
} else {
char** so = server_options;
snprintf(datadir, 1023, "%s/data", workingdir);
mkdir(datadir, 0777);
snprintf(ddoption, 1023, "--datadir=%s", datadir);
while (strncmp(*so++, "--datadir=", 10) != 0) ;
if (*so == NULL) {
fprintf(stderr, "Failed to find datadir option.\n");
goto return_without_server;
}
*so = ddoption;
snprintf(mysqldir, 1023, "%s/mysql", workingdir);
setenv("MYSQL_HOME", mysqldir, 1);
}
failp = mysql_library_init(num_elements, server_options, server_groups);
if (failp) {
MYSQL* mysql = mysql_init(NULL);
ss_dassert(mysql != NULL);
fprintf(stderr,
"mysql_init failed, %d : %s\n",
mysql_errno(mysql),
mysql_error(mysql));
goto return_without_server;
}
fprintf(stderr,
"\nExecuting selected cases in "
"skygw_query_classifier_get_type :\n\n");
/**
* Set cursor to the beginning, scan through the list and execute
* test cases.
*/
succp = slcursor_move_to_begin(c);
while(succp) {
qtest = slcursor_get_case(c);
qtest->qt_result_type =
skygw_query_classifier_get_type(qtest->qt_query_str, f);
succp = slcursor_step_ahead(c);
}
/**
* Scan through test results and compare them against expected
* results.
*/
succp = slcursor_move_to_begin(c);
fprintf(stderr, "\nScanning through the results :\n\n");
while(succp) {
qtest = slcursor_get_case(c);
if (!query_test_types_match(qtest)) {
nfail += 1;
ss_dfprintf(stderr,
"* Failed: \"%s\" -> %s (Expected %s)\n",
query_test_get_querystr(qtest),
STRQTYPE(query_test_get_result_type(qtest)),
STRQTYPE(query_test_get_query_type(qtest)));
} else {
nsucc += 1;
ss_dfprintf(stderr,
"Succeed\t: \"%s\" -> %s\n",
query_test_get_querystr(qtest),
STRQTYPE(query_test_get_query_type(qtest)));
}
succp = slcursor_step_ahead(c);
}
fprintf(stderr,
"------------------------------------------\n"
"Tests in total %d, SUCCEED %d, FAILED %d\n",
nsucc+nfail,
nsucc,
nfail);
/**
* Scan test results and re-execute those which are marked to be
* executed also in the server. This serves mostly debugging purposes.
*/
succp = slcursor_move_to_begin(c);
mysql = mysql_init(NULL);
if (mysql == NULL) {
fprintf(stderr, "mysql_init failed\n");
goto return_without_server;
}
mysql_options(mysql,
MYSQL_READ_DEFAULT_GROUP,
"libmysqld_client");
mysql_options(mysql, MYSQL_OPT_USE_EMBEDDED_CONNECTION, NULL);
mysql_options(mysql, MYSQL_OPT_USE_EMBEDDED_CONNECTION, NULL);
mysql = mysql_real_connect(mysql,
NULL,
"skygw",
"skygw",
NULL,
0,
NULL,
CLIENT_MULTI_STATEMENTS);
if (mysql == NULL) {
fprintf(stderr, "mysql_real_connect failed\n");
goto return_with_handle;
}
fprintf(stderr,
"\nRe-execution of selected cases in Embedded server :\n\n");
while(succp) {
qtest = slcursor_get_case(c);
if (query_test_exec_also_in_server(qtest)) {
MYSQL_RES* results;
MYSQL_ROW record;
const char* query_str;
query_str = query_test_get_querystr(qtest);
failp = mysql_query(mysql, query_str);
if (failp) {
ss_dfprintf(stderr,
"* Failed: \"%s\" -> %d : %s\n",
query_str,
mysql_errno(mysql),
mysql_error(mysql));
} else {
ss_dfprintf(stderr,
"Succeed\t: \"%s\"\n",
query_str);
results = mysql_store_result(mysql);
if (results != NULL) {
while((record = mysql_fetch_row(results))) {
while(record != NULL && *record != NULL) {
ss_dfprintf(stderr, "%s ", *record);
record++;
}
ss_dfprintf(stderr, "\n");
}
mysql_free_result(results);
}
}
}
succp = slcursor_step_ahead(c);
}
slist_done(c);
fprintf(stderr, "------------------------------------------\n");
return_with_handle:
mysql_close(mysql);
mysql_thread_end();
mysql_library_end();
return_without_server:
ss_dfprintf(stderr, "\n<< testmain\n");
fflush(stderr);
return 0;
}
bool MySQLConnection::Open()
{
MYSQL *mysqlInit;
mysqlInit = mysql_init(NULL);
if (!mysqlInit)
{
TC_LOG_ERROR("sql.sql", "Could not initialize Mysql connection to database `%s`", m_connectionInfo.database.c_str());
return false;
}
int port;
char const* unix_socket;
//unsigned int timeout = 10;
mysql_options(mysqlInit, MYSQL_SET_CHARSET_NAME, "utf8");
//mysql_options(mysqlInit, MYSQL_OPT_READ_TIMEOUT, (char const*)&timeout);
#ifdef _WIN32
if (m_connectionInfo.host == ".") // named pipe use option (Windows)
{
unsigned int opt = MYSQL_PROTOCOL_PIPE;
mysql_options(mysqlInit, MYSQL_OPT_PROTOCOL, (char const*)&opt);
port = 0;
unix_socket = 0;
}
else // generic case
{
port = atoi(m_connectionInfo.port_or_socket.c_str());
unix_socket = 0;
}
#else
if (m_connectionInfo.host == ".") // socket use option (Unix/Linux)
{
unsigned int opt = MYSQL_PROTOCOL_SOCKET;
mysql_options(mysqlInit, MYSQL_OPT_PROTOCOL, (char const*)&opt);
m_connectionInfo.host = "localhost";
port = 0;
unix_socket = m_connectionInfo.port_or_socket.c_str();
}
else // generic case
{
port = atoi(m_connectionInfo.port_or_socket.c_str());
unix_socket = 0;
}
#endif
m_Mysql = mysql_real_connect(mysqlInit, m_connectionInfo.host.c_str(), m_connectionInfo.user.c_str(),
m_connectionInfo.password.c_str(), m_connectionInfo.database.c_str(), port, unix_socket, 0);
if (m_Mysql)
{
if (!m_reconnecting)
{
TC_LOG_INFO("sql.sql", "MySQL client library: %s", mysql_get_client_info());
TC_LOG_INFO("sql.sql", "MySQL server ver: %s ", mysql_get_server_info(m_Mysql));
// MySQL version above 5.1 IS required in both client and server and there is no known issue with different versions above 5.1
// if (mysql_get_server_version(m_Mysql) != mysql_get_client_version())
// TC_LOG_INFO("sql.sql", "[WARNING] MySQL client/server version mismatch; may conflict with behaviour of prepared statements.");
}
TC_LOG_INFO("sql.sql", "Connected to MySQL database at %s", m_connectionInfo.host.c_str());
mysql_autocommit(m_Mysql, 1);
// set connection properties to UTF8 to properly handle locales for different
// server configs - core sends data in UTF8, so MySQL must expect UTF8 too
mysql_set_character_set(m_Mysql, "utf8");
return PrepareStatements();
}
else
{
TC_LOG_ERROR("sql.sql", "Could not connect to MySQL database at %s: %s\n", m_connectionInfo.host.c_str(), mysql_error(mysqlInit));
mysql_close(mysqlInit);
return false;
}
}
static VALUE _mysql_client_options(VALUE self, int opt, VALUE value) {
int result;
const void *retval = NULL;
unsigned int intval = 0;
const char * charval = NULL;
bool boolval;
GET_CLIENT(self);
REQUIRE_NOT_CONNECTED(wrapper);
if (NIL_P(value))
return Qfalse;
switch(opt) {
case MYSQL_OPT_CONNECT_TIMEOUT:
intval = NUM2UINT(value);
retval = &intval;
break;
case MYSQL_OPT_READ_TIMEOUT:
intval = NUM2UINT(value);
retval = &intval;
break;
case MYSQL_OPT_WRITE_TIMEOUT:
intval = NUM2UINT(value);
retval = &intval;
break;
case MYSQL_OPT_LOCAL_INFILE:
intval = (value == Qfalse ? 0 : 1);
retval = &intval;
break;
case MYSQL_OPT_RECONNECT:
boolval = (value == Qfalse ? 0 : 1);
retval = &boolval;
break;
#ifdef MYSQL_SECURE_AUTH
case MYSQL_SECURE_AUTH:
boolval = (value == Qfalse ? 0 : 1);
retval = &boolval;
break;
#endif
case MYSQL_READ_DEFAULT_FILE:
charval = (const char *)StringValueCStr(value);
retval = charval;
break;
case MYSQL_READ_DEFAULT_GROUP:
charval = (const char *)StringValueCStr(value);
retval = charval;
break;
case MYSQL_INIT_COMMAND:
charval = (const char *)StringValueCStr(value);
retval = charval;
break;
#ifdef HAVE_CONST_MYSQL_ENABLE_CLEARTEXT_PLUGIN
case MYSQL_ENABLE_CLEARTEXT_PLUGIN:
boolval = (value == Qfalse ? 0 : 1);
retval = &boolval;
break;
#endif
default:
return Qfalse;
}
result = mysql_options(wrapper->client, opt, retval);
/* Zero means success */
if (result != 0) {
rb_warn("%s\n", mysql_error(wrapper->client));
} else {
/* Special case for options that are stored in the wrapper struct */
switch (opt) {
case MYSQL_OPT_RECONNECT:
wrapper->reconnect_enabled = boolval;
break;
case MYSQL_OPT_CONNECT_TIMEOUT:
wrapper->connect_timeout = intval;
break;
}
}
return (result == 0) ? Qtrue : Qfalse;
}
int MYSQLC::Open(PGLOBAL g, const char *host, const char *db,
const char *user, const char *pwd,
int pt, const char *csname)
{
const char *pipe = NULL;
uint cto = 6000, nrt = 12000;
my_bool my_true= 1;
m_DB = mysql_init(NULL);
if (!m_DB) {
strcpy(g->Message, "mysql_init failed: no memory");
return RC_FX;
} // endif m_DB
// Removed to do like FEDERATED do
//mysql_options(m_DB, MYSQL_READ_DEFAULT_GROUP, "client-mariadb");
mysql_options(m_DB, MYSQL_OPT_USE_REMOTE_CONNECTION, NULL);
mysql_options(m_DB, MYSQL_OPT_CONNECT_TIMEOUT, &cto);
mysql_options(m_DB, MYSQL_OPT_READ_TIMEOUT, &nrt);
//mysql_options(m_DB, MYSQL_OPT_WRITE_TIMEOUT, ...);
#if defined(__WIN__)
if (!strcmp(host, ".")) {
mysql_options(m_DB, MYSQL_OPT_NAMED_PIPE, NULL);
pipe = mysqld_unix_port;
} // endif host
#else // !__WIN__
if (!strcmp(host, "localhost"))
pipe = mysqld_unix_port;
#endif // !__WIN__
#if 0
if (pwd && !strcmp(pwd, "*")) {
if (GetPromptAnswer(g, "*Enter password:"******"mysql_real_connect failed: (%d) %s",
mysql_errno(m_DB), mysql_error(m_DB));
#else // !_DEBUG
sprintf(g->Message, "(%d) %s", mysql_errno(m_DB), mysql_error(m_DB));
#endif // !_DEBUG
mysql_close(m_DB);
m_DB = NULL;
return RC_FX;
} // endif mysql_real_connect
return RC_OK;
} // end of Open
/*++
ConnectionOpen
Opens a server connection.
Arguments:
context - Opaque context passed to <PoolCreate>.
data - Pointer to a pointer that receives the DB_CONTEXT structure.
Return Values:
If the function succeeds, the return value is nonzero (true).
If the function fails, the return value is zero (false).
--*/
static BOOL FCALL ConnectionOpen(VOID *context, VOID **data)
{
DB_CONTEXT *db;
DB_CONFIG_SERVER *server;
DWORD error;
DWORD i;
INT attempt;
INT attemptMax;
LONG serverIndex;
LONG serverNextIndex;
MYSQL *connection;
my_bool optReconnect;
UINT optTimeout;
UNREFERENCED_PARAMETER(context);
ASSERT(data != NULL);
TRACE("context=%p data=%p", context, data);
db = MemAllocate(sizeof(DB_CONTEXT));
if (db == NULL) {
LOG_ERROR("Unable to allocate memory for database context.");
error = ERROR_NOT_ENOUGH_MEMORY;
goto failed;
}
ZeroMemory(db, sizeof(DB_CONTEXT));
//
// Have the MySQL client library allocate the handle structure for us. This is
// in case the MYSQL structure changes in a future version of the client library.
//
db->handle = mysql_init(NULL);
if (db->handle == NULL) {
LOG_ERROR("Unable to allocate memory for MySQL handle.");
error = ERROR_NOT_ENOUGH_MEMORY;
goto failed;
}
// If the maximum number of attempts were not specified, try all servers
if (dbConfigGlobal.connAttempts > 0) {
attemptMax = dbConfigGlobal.connAttempts;
} else {
attemptMax = dbConfigServerCount;
}
for (attempt = 0; attempt < attemptMax; attempt++) {
// Use the most recent server for the connection attempt
serverIndex = dbIndex;
server = &dbConfigServers[serverIndex];
TRACE("Connecting to server #%d [%s] on attempt %lu/%lu.",
serverIndex, server->name, attempt+1, attemptMax);
// Set connection options
optTimeout = (UINT)dbConfigGlobal.connTimeout;
if (mysql_options(db->handle, MYSQL_OPT_CONNECT_TIMEOUT, &optTimeout) != 0) {
TRACE("Failed to set connection timeout option.");
}
optReconnect = FALSE;
if (mysql_options(db->handle, MYSQL_OPT_RECONNECT, &optReconnect) != 0) {
TRACE("Failed to set reconnection option.");
}
if (server->compression) {
if (mysql_options(db->handle, MYSQL_OPT_COMPRESS, 0) != 0) {
TRACE("Failed to set compression option.");
}
}
if (server->sslEnable) {
//
// This function always returns 0. If the SSL setup is incorrect,
// the call to mysql_real_connect() will return an error.
//
mysql_ssl_set(db->handle, server->sslKeyFile, server->sslCertFile,
server->sslCAFile, server->sslCAPath, server->sslCiphers);
}
// Attempt connection with server
connection = mysql_real_connect(db->handle,
server->host, server->user, server->password,
server->database, server->port, NULL, CLIENT_INTERACTIVE);
if (connection == NULL) {
LOG_ERROR("Unable to connect to server [%s]: %s",
server->name, mysql_error(db->handle));
} else if (mysql_get_server_version(db->handle) < 50019) {
LOG_ERROR("Unsupported version of MySQL Server [%s]: running v%s, must be v5.0.19 or newer.",
server->name, mysql_get_server_info(db->handle));
} else {
// Pointer values should be the same as from mysql_init()
ASSERT(connection == db->handle);
// Allocate pre-compiled statement structures
for (i = 0; i < ELEMENT_COUNT(db->stmt); i++) {
db->stmt[i] = mysql_stmt_init(db->handle);
if (db->stmt[i] == NULL) {
LOG_ERROR("Unable to allocate memory for statement structure.");
error = ERROR_NOT_ENOUGH_MEMORY;
goto failed;
}
}
// Successfully connected, set the global server index
InterlockedExchange(&dbIndex, serverIndex);
// Update context's server index and time stamps
db->index = serverIndex;
GetSystemTimeAsFileTime(&db->created.fileTime);
db->used.value = db->created.value;
LOG_INFO("Connected to %s [%s], running MySQL Server v%s.",
mysql_get_host_info(db->handle), server->name,
mysql_get_server_info(db->handle));
*data = db;
return TRUE;
}
// Unsuccessful connection, continue to the next server
serverNextIndex = serverIndex + 1;
if (serverNextIndex >= (LONG)dbConfigServerCount) {
serverNextIndex = 0;
}
//
// Compare the current server index before swapping values in the
// event that another thread has already changed the index.
//
InterlockedCompareExchange(&dbIndex, serverNextIndex, serverIndex);
}
// Unable to connect to any servers
error = ERROR_CONNECTION_REFUSED;
failed:
if (db != NULL) {
ConnectionClose(NULL, db);
}
SetLastError(error);
return FALSE;
}
