int
main (int argc, char *argv[])
{
dbi_conn conn;
dbi_result result;
const char *err_msg;
int err_code;
if (argc < 2)
{
fprintf (stderr, "%s: Need a libdir as argument!\n", argv[0]);
return 1;
}
dbi_initialize (argv[1]);
conn = dbi_conn_new ("null");
dbi_conn_connect (conn);
/*
* Queries
*/
result = dbi_conn_query (conn, "COMMIT");
assert (result != NULL);
dbi_result_free (result);
dbi_conn_set_option_numeric (conn, "null.error.commit", 1);
result = dbi_conn_query (conn, "COMMIT");
assert (result == NULL);
dbi_conn_set_option_numeric (conn, "null.error.commit", 0);
result = dbi_conn_query (conn, "COMMIT");
assert (result != NULL);
dbi_result_free (result);
/*
* Normal queries
*/
result = dbi_conn_query (conn, "SELECT * FROM DUAL");
assert (result != NULL);
dbi_result_free (result);
dbi_conn_set_option_numeric (conn, "null.error.query", 1);
result = dbi_conn_query (conn, "SELECT * FROM DUAL");
assert (result == NULL);
dbi_conn_set_option_numeric (conn, "null.error.query", 0);
result = dbi_conn_query (conn, "SELECT * FROM DUAL");
assert (result != NULL);
dbi_result_free (result);
/*
* Cleanup
*/
dbi_conn_close (conn);
dbi_shutdown ();
return 0;
}
/**
* Sets standard db options in a dbi_conn.
*
* @param qbe QOF backend
* @param conn dbi_conn connection
* @param uri UriStrings containing the needed paramters.
* @return TRUE if successful, FALSE if error
*/
static bool
set_standard_connection_options (QofBackend* qbe, dbi_conn conn,
const UriStrings& uri)
{
gint result;
PairVec options;
options.push_back(std::make_pair("host", uri.m_host));
options.push_back(std::make_pair("dbname", uri.m_dbname));
options.push_back(std::make_pair("username", uri.m_username));
options.push_back(std::make_pair("password", uri.m_password));
options.push_back(std::make_pair("encoding", "UTF-8"));
try
{
set_options(conn, options);
auto result = dbi_conn_set_option_numeric(conn, "port", uri.m_portnum);
if (result < 0)
{
const char *msg = nullptr;
auto err = dbi_conn_error(conn, &msg);
PERR("Error setting port option to %d: %s", uri.m_portnum, msg);
throw std::runtime_error(msg);
}
}
catch (std::runtime_error& err)
{
qof_backend_set_error (qbe, ERR_BACKEND_SERVER_ERR);
return false;
}
return true;
}
static int _sql_setparam(struct sql_table_helper* th,char* key, char* value) {
char* dbi_errstr=NULL;
dbi_driver driver;
/* if not connected */
if (! th->conn) {
/* initialize some stuff */
th->table_next=th->table_start;
th->result=NULL;
th->connected=0;
/* initialize db */
if (getenv("RRDDEBUGSQL")) {
fprintf(stderr,"RRDDEBUGSQL: %li: initialize libDBI\n",time(NULL) );
}
dbi_initialize(NULL);
/* load the driver */
driver=dbi_driver_open(th->dbdriver);
if (! driver) {
rrd_set_error( "libdbi - no such driver: %s (possibly a dynamic link problem of the driver being linked without -ldbi)",th->dbdriver);
return -1;
}
/* and connect to driver */
th->conn=dbi_conn_open(driver);
/* and handle errors */
if (! th->conn) {
rrd_set_error( "libdbi - could not open connection to driver %s",th->dbdriver);
dbi_shutdown();
return -1;
}
}
if (th->connected) {
rrd_set_error( "we are already connected - can not set parameter %s=%s",key,value);
_sql_close(th);
return -1;
}
if (getenv("RRDDEBUGSQL")) {
fprintf(stderr,"RRDDEBUGSQL: %li: setting option %s to %s\n",time(NULL),key,value );
}
if (strcmp(key, "port") == 0) {
if (dbi_conn_set_option_numeric(th->conn,key,atoi(value))) {
dbi_conn_error(th->conn,(const char**)&dbi_errstr);
rrd_set_error( "libdbi: problems setting %s to %d - %s",key,value,dbi_errstr);
_sql_close(th);
return -1;
}
} else {
if (dbi_conn_set_option(th->conn,key,value)) {
dbi_conn_error(th->conn,(const char**)&dbi_errstr);
rrd_set_error( "libdbi: problems setting %s to %s - %s",key,value,dbi_errstr);
_sql_close(th);
return -1;
}
}
return 0;
}
/* Connect to the MYSQL database */
static logsql_opendb_ret log_sql_dbi_connect(server_rec *s, logsql_dbconnection *db)
{
const char *driver = apr_table_get(db->parms,"driver");
const char *host = apr_table_get(db->parms,"hostname");
const char *user = apr_table_get(db->parms,"username");
const char *passwd = apr_table_get(db->parms,"password");
const char *database = apr_table_get(db->parms,"database");
const char *s_tcpport = apr_table_get(db->parms,"port");
unsigned int tcpport = (s_tcpport)?atoi(s_tcpport):0;
const char *socketfile = apr_table_get(db->parms,"socketfile");
//dbi_result result;
dbi_conn_rec *dblink = db->handle;
if (!dblink) {
dblink = apr_pcalloc(db->p, sizeof(*dblink));
db->handle = (void *)dblink;
}
dblink->conn = dbi_conn_new(driver);
dbi_conn_set_option(dblink->conn, "host", host);
dbi_conn_set_option(dblink->conn, "username", user);
dbi_conn_set_option(dblink->conn, "password", passwd);
dbi_conn_set_option(dblink->conn, "dbname", database);
if (tcpport) {
dbi_conn_set_option_numeric(dblink->conn, "port", tcpport);
}
if (socketfile && !strcmp(driver,"mysql")) {
dbi_conn_set_option(dblink->conn, "mysql_unix_socket", socketfile);
}
if (!dbi_conn_connect(dblink->conn)) {
log_error(APLOG_MARK, APLOG_DEBUG, 0, s,
"HOST: '%s' PORT: '%d' DB: '%s' USER: '******' SOCKET: '%s'",
host, tcpport, database, user, socketfile);
return LOGSQL_OPENDB_SUCCESS;
} else {
const char *error;
dbi_conn_error(dblink->conn, &error);
log_error(APLOG_MARK, APLOG_ERR, 0, s,
"DBI Error: %s", error);
log_error(APLOG_MARK, APLOG_DEBUG, 0, s,
"HOST: '%s' PORT: '%d' DB: '%s' USER: '******' SOCKET: '%s'",
host, tcpport, database, user, socketfile);
return LOGSQL_OPENDB_FAIL;
}
}
static int cdbi_connect_database (cdbi_database_t *db) /* {{{ */
{
dbi_driver driver;
dbi_conn connection;
size_t i;
int status;
if (db->connection != NULL)
{
status = dbi_conn_ping (db->connection);
if (status != 0) /* connection is alive */
return (0);
dbi_conn_close (db->connection);
db->connection = NULL;
}
driver = dbi_driver_open_r (db->driver, dbi_instance);
if (driver == NULL)
{
ERROR ("dbi plugin: cdbi_connect_database: dbi_driver_open_r (%s) failed.",
db->driver);
INFO ("dbi plugin: Maybe the driver isn't installed? "
"Known drivers are:");
for (driver = dbi_driver_list_r (NULL, dbi_instance);
driver != NULL;
driver = dbi_driver_list_r (driver, dbi_instance))
{
INFO ("dbi plugin: * %s", dbi_driver_get_name (driver));
}
return (-1);
}
connection = dbi_conn_open (driver);
if (connection == NULL)
{
ERROR ("dbi plugin: cdbi_connect_database: dbi_conn_open (%s) failed.",
db->driver);
return (-1);
}
/* Set all the driver options. Because this is a very very very generic
* interface, the error handling is kind of long. If an invalid option is
* encountered, it will get a list of options understood by the driver and
* report that as `INFO'. This way, users hopefully don't have too much
* trouble finding out how to configure the plugin correctly.. */
for (i = 0; i < db->driver_options_num; i++)
{
if (db->driver_options[i].is_numeric)
{
status = dbi_conn_set_option_numeric (connection,
db->driver_options[i].key, db->driver_options[i].value.numeric);
if (status != 0)
{
char errbuf[1024];
ERROR ("dbi plugin: cdbi_connect_database (%s): "
"dbi_conn_set_option_numeric (\"%s\", %i) failed: %s.",
db->name,
db->driver_options[i].key, db->driver_options[i].value.numeric,
cdbi_strerror (connection, errbuf, sizeof (errbuf)));
}
}
else
{
status = dbi_conn_set_option (connection,
db->driver_options[i].key, db->driver_options[i].value.string);
if (status != 0)
{
char errbuf[1024];
ERROR ("dbi plugin: cdbi_connect_database (%s): "
"dbi_conn_set_option (\"%s\", \"%s\") failed: %s.",
db->name,
db->driver_options[i].key, db->driver_options[i].value.string,
cdbi_strerror (connection, errbuf, sizeof (errbuf)));
}
}
if (status != 0)
{
char const *opt;
INFO ("dbi plugin: This is a list of all options understood "
"by the `%s' driver:", db->driver);
for (opt = dbi_conn_get_option_list (connection, NULL);
opt != NULL;
opt = dbi_conn_get_option_list (connection, opt))
{
INFO ("dbi plugin: * %s", opt);
}
dbi_conn_close (connection);
return (-1);
}
} /* for (i = 0; i < db->driver_options_num; i++) */
status = dbi_conn_connect (connection);
if (status != 0)
{
char errbuf[1024];
ERROR ("dbi plugin: cdbi_connect_database (%s): "
"dbi_conn_connect failed: %s",
db->name, cdbi_strerror (connection, errbuf, sizeof (errbuf)));
dbi_conn_close (connection);
return (-1);
}
if (db->select_db != NULL)
{
status = dbi_conn_select_db (connection, db->select_db);
if (status != 0)
{
char errbuf[1024];
WARNING ("dbi plugin: cdbi_connect_database (%s): "
"dbi_conn_select_db (%s) failed: %s. Check the `SelectDB' option.",
db->name, db->select_db,
cdbi_strerror (connection, errbuf, sizeof (errbuf)));
dbi_conn_close (connection);
return (-1);
}
}
db->connection = connection;
return (0);
} /* }}} int cdbi_connect_database */
static gboolean
afsql_dd_ensure_initialized_connection(AFSqlDestDriver *self)
{
if (self->dbi_ctx)
return TRUE;
self->dbi_ctx = dbi_conn_new(self->type);
if (!self->dbi_ctx)
{
msg_error("No such DBI driver",
evt_tag_str("type", self->type),
NULL);
return FALSE;
}
dbi_conn_set_option(self->dbi_ctx, "host", self->host);
if (strcmp(self->type, "mysql"))
dbi_conn_set_option(self->dbi_ctx, "port", self->port);
else
dbi_conn_set_option_numeric(self->dbi_ctx, "port", atoi(self->port));
dbi_conn_set_option(self->dbi_ctx, "username", self->user);
dbi_conn_set_option(self->dbi_ctx, "password", self->password);
dbi_conn_set_option(self->dbi_ctx, "dbname", self->database);
dbi_conn_set_option(self->dbi_ctx, "encoding", self->encoding);
dbi_conn_set_option(self->dbi_ctx, "auto-commit", self->flags & AFSQL_DDF_EXPLICIT_COMMITS ? "false" : "true");
/* database specific hacks */
dbi_conn_set_option(self->dbi_ctx, "sqlite_dbdir", "");
dbi_conn_set_option(self->dbi_ctx, "sqlite3_dbdir", "");
/* Set user-specified options */
g_hash_table_foreach(self->dbd_options, afsql_dd_set_dbd_opt, self->dbi_ctx);
g_hash_table_foreach(self->dbd_options_numeric, afsql_dd_set_dbd_opt_numeric, self->dbi_ctx);
if (dbi_conn_connect(self->dbi_ctx) < 0)
{
const gchar *dbi_error;
dbi_conn_error(self->dbi_ctx, &dbi_error);
msg_error("Error establishing SQL connection",
evt_tag_str("type", self->type),
evt_tag_str("host", self->host),
evt_tag_str("port", self->port),
evt_tag_str("username", self->user),
evt_tag_str("database", self->database),
evt_tag_str("error", dbi_error),
NULL);
return FALSE;
}
if (self->session_statements != NULL)
{
GList *l;
for (l = self->session_statements; l; l = l->next)
{
if (!afsql_dd_run_query(self, (gchar *) l->data, FALSE, NULL))
{
msg_error("Error executing SQL connection statement",
evt_tag_str("statement", (gchar *) l->data),
NULL);
return FALSE;
}
}
}
return TRUE;
}
static void
afsql_dd_set_dbd_opt_numeric(gpointer key, gpointer value, gpointer user_data)
{
dbi_conn_set_option_numeric((dbi_conn)user_data, (gchar *)key,
GPOINTER_TO_INT(value));
}
