// methods for formatting
// ---------------------------------------------
std::string SqliteDatabase::vprepare(const char *format, va_list args)
{
std::string strFormat = format;
std::string strResult = "";
char *p;
size_t pos;
// %q is the sqlite format string for %s.
// Any bad character, like "'", will be replaced with a proper one
pos = 0;
while ( (pos = strFormat.find("%s", pos)) != std::string::npos )
strFormat.replace(pos++, 2, "%q");
// the %I64 enhancement is not supported by sqlite3_vmprintf
// must be %ll instead
pos = 0;
while ( (pos = strFormat.find("%I64", pos)) != std::string::npos )
strFormat.replace(pos++, 4, "%ll");
p = sqlite3_vmprintf(strFormat.c_str(), args);
if ( p )
{
strResult = p;
sqlite3_free(p);
}
return strResult;
}
/**
* A query that can't retrieve results
*/
static gboolean
xmms_sqlite_exec (sqlite3 *sql, const char *query, ...)
{
gchar *q, *err;
va_list ap;
gint ret;
g_return_val_if_fail (query, FALSE);
g_return_val_if_fail (sql, FALSE);
va_start (ap, query);
q = sqlite3_vmprintf (query, ap);
ret = sqlite3_exec (sql, q, NULL, NULL, &err);
if (ret == SQLITE_BUSY) {
printf ("BUSY EVENT!");
g_assert_not_reached ();
}
if (ret != SQLITE_OK) {
printf ("Error in query! \"%s\" (%d) - %s", q, ret, err);
sqlite3_free (q);
va_end (ap);
return FALSE;
}
sqlite3_free (q);
va_end (ap);
return TRUE;
}
int Database::execute(const char *sql_fmt, ...)
{
if (!m_db) return false;
if (m_result_table) finalize();
va_list ap;
va_start(ap, sql_fmt);
char *sql = sqlite3_vmprintf(sql_fmt, ap);
va_end(ap);
if (!sql) {
fprintf(stderr, "can't allocate memory for sql statement!\n");
return 0;
}
m_result_table = NULL;
m_curr_row = 0;
if (sqlite3_get_table(m_db, sql, &m_result_table, &m_rows, &m_cols, &m_error) != SQLITE_OK) {
debug("error executing SQL query (%s): %s\n", sql, m_error);
finalize();
sqlite3_free(sql);
return 0;
}
sqlite3_free(sql);
m_curr_row = 1;
return m_rows;
}
const char* cSQLiteDatabase::sprintf(const char* Format, ...){
va_list vlist;
va_start(vlist, Format);
char* SQLStatement = sqlite3_vmprintf(Format, vlist);
va_end(vlist);
return SQLStatement;
}
/*
** Print an error message and then quit.
*/
static void fatalError(const char *zFormat, ...){
va_list ap;
char *zMsg;
char zPrefix[30];
va_start(ap, zFormat);
zMsg = sqlite3_vmprintf(zFormat, ap);
va_end(ap);
sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s:FATAL: ", g.zName);
if( g.pLog ){
printWithPrefix(g.pLog, zPrefix, zMsg);
fflush(g.pLog);
maybeClose(g.pLog);
}
if( g.pErrLog && safe_strcmp(g.zErrLog,g.zLog) ){
printWithPrefix(g.pErrLog, zPrefix, zMsg);
fflush(g.pErrLog);
maybeClose(g.pErrLog);
}
sqlite3_free(zMsg);
if( g.db ){
int nTry = 0;
g.iTimeout = 0;
while( trySql("UPDATE client SET wantHalt=1;")==SQLITE_BUSY
&& (nTry++)<100 ){
sqlite3_sleep(10);
}
}
sqlite3_close(g.db);
exit(1);
}
int
sql_get_int_field(sqlite3 *db, const char *fmt, ...)
{
va_list ap;
int counter, result;
char *sql;
int ret;
sqlite3_stmt *stmt;
va_start(ap, fmt);
sql = sqlite3_vmprintf(fmt, ap);
//DPRINTF(E_DEBUG, L_DB_SQL, "sql: %s\n", sql);
switch (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL))
{
case SQLITE_OK:
break;
default:
DPRINTF(E_ERROR, L_DB_SQL, "prepare failed: %s\n", sqlite3_errmsg(db));
sqlite3_free(sql);
return -1;
}
sqlite3_free(sql);
for (counter = 0;
((result = sqlite3_step(stmt)) == SQLITE_BUSY || result == SQLITE_LOCKED) && counter < 2;
counter++) {
/* While SQLITE_BUSY has a built in timeout,
SQLITE_LOCKED does not, so sleep */
if (result == SQLITE_LOCKED)
sleep(1);
}
switch (result)
{
case SQLITE_DONE:
/* no rows returned */
ret = 0;
break;
case SQLITE_ROW:
if (sqlite3_column_type(stmt, 0) == SQLITE_NULL)
{
ret = 0;
break;
}
ret = sqlite3_column_int(stmt, 0);
break;
default:
DPRINTF(E_WARN, L_DB_SQL, "%s: step failed: %s\n", __func__, sqlite3_errmsg(db));
ret = -1;
break;
}
sqlite3_finalize(stmt);
return ret;
}
/**
* DB_exec will run a SQL query, using the sqlite3_mprintf syntax, and
* convert the results to a tns_value_t* that you can use. It returns
* one of four types of results:
*
* - tns_tag_null -- The query wasn't expected to return anything, like UPDATE.
* - tns_tag_list(empty) -- The query expected to return rows, but nothing returned.
* - tns_tag_list -- There's rows that resulted from the query.
* - NULL -- There was an error processing your query.
*
* You own the row and everything in it, and you should know what the columns
* are, but they are tagged properly for each type that comes from the query.
*/
tns_value_t *DB_exec(const char *query, ...)
{
va_list argp;
va_start(argp, query);
char *zErrMsg = NULL;
tns_value_t *res = NULL;
int rc = 0;
sqlite3_stmt *stmt = NULL;
const char *sql_tail = NULL;
char *sql = NULL;
check(CONFIG_DB != NULL, "The config database is not open.");
sql = sqlite3_vmprintf(query, argp);
check_mem(sql);
rc = sqlite3_prepare_v2(CONFIG_DB, sql, -1, &stmt, &sql_tail);
check(rc == SQLITE_OK, "SQL error \"%s\" at: '%s'", sqlite3_errmsg(CONFIG_DB), sql_tail);
// we want to return a tns_tag_null if this is a query with no
// results, which means we have to do a little bit of weird logic
rc = sqlite3_step(stmt);
if(rc == SQLITE_DONE) {
if(sqlite3_column_count(stmt) == 0) {
// query like UPDATE with no results possible
res = tns_get_null();
} else {
// query that had results possible but had none
res = tns_new_list();
}
} else if(rc == SQLITE_ROW) {
// query with results, process them
res = tns_new_list();
do {
tns_value_t *row = DB_convert_column(stmt);
check(row != NULL, "Failed to convert DB column for sql: '%s'", sql);
tns_add_to_list(res, row);
} while((rc = sqlite3_step(stmt)) == SQLITE_ROW);
}
check(rc != SQLITE_ERROR, "Failure executing sql: %s", sqlite3_errmsg(CONFIG_DB));
sqlite3_free(sql);
sqlite3_finalize(stmt);
va_end(argp);
return res;
error:
va_end(argp);
if(stmt) sqlite3_finalize(stmt);
if(zErrMsg) sqlite3_free(zErrMsg);
if(sql) sqlite3_free(sql);
if(res) tns_value_destroy(res);
return NULL;
}
int cSQLiteDatabase::execStatement(const char* Statement, ...){
va_list vlist;
va_start(vlist, Statement);
char* SQLStatement = sqlite3_vmprintf(Statement, vlist);
va_end(vlist);
int ret = this->exec(SQLStatement);
sqlite3_free(SQLStatement);
return ret;
}
static void geom_tls_msg_handler(const char *fmt, ...) {
geom_geos_clear_error();
va_list args;
va_start(args, fmt);
char *err = sqlite3_vmprintf(fmt, args);
GPKG_TLS_SET(last_geos_error, err);
va_end(args);
}
const char* CppSQLite3Buffer::format(const char* szFormat, ...)
{
clear();
va_list va;
va_start(va, szFormat);
mpBuf = sqlite3_vmprintf(szFormat, va);
va_end(va);
return mpBuf;
}
void reg_throw(reg_error* errPtr, char* code, char* fmt, ...) {
va_list list;
va_start(list, fmt);
errPtr->description = sqlite3_vmprintf(fmt, list);
va_end(list);
errPtr->code = code;
errPtr->free = (reg_error_destructor*)sqlite3_free;
}
int database::executef(char const* sql, ...)
{
va_list ap;
va_start(ap, sql);
char* msql = sqlite3_vmprintf(sql, ap);
va_end(ap);
return execute(msql);
}
static void asyncTrace(const char *zFormat, ...){
char *z;
va_list ap;
va_start(ap, zFormat);
z = sqlite3_vmprintf(zFormat, ap);
va_end(ap);
fprintf(stderr, "[%d] %s", (int)pthread_self(), z);
sqlite3_free(z);
}
int database::executef(char const* sql, ...)
{
va_list ap;
va_start(ap, sql);
std::unique_ptr<char, void (*)(void *)> msql(sqlite3_vmprintf(sql, ap), sqlite3_free);
va_end(ap);
return eexecute(msql.get());
}
int database::executef(char const* sql, ...)
{
va_list ap;
va_start(ap, sql);
boost::shared_ptr<char> msql(sqlite3_vmprintf(sql, ap), sqlite3_free);
va_end(ap);
return execute(msql.get());
}
// Same but accepts a va_list
void SqlDatabase::sqlExecVar(const char* szSQL, va_list args) {
require(mpDB);
char* szSqlFormatted = sqlite3_vmprintf(szSQL, args);
if (!szSqlFormatted)
throw new SqlDatabaseException("Unable to apply format to SQL string");
const int result = sqlite3_exec(mpDB, szSqlFormatted, 0, 0, 0);
sqlite3_free(szSqlFormatted);
if (result != SQLITE_OK)
throw new SqlDatabaseException(sqlite3_errmsg(mpDB));
}
/*
** Try to run arbitrary SQL. Return success code.
*/
static int trySql(const char *zFormat, ...){
va_list ap;
char *zSql;
int rc;
va_start(ap, zFormat);
zSql = sqlite3_vmprintf(zFormat, ap);
va_end(ap);
rc = sqlite3_exec(g.db, zSql, 0, 0, 0);
sqlite3_free(zSql);
return rc;
}
/*
** Run an SQL statement
*/
static int runSql(sqlite3 *db, const char *zFormat, ...) {
va_list ap;
char *zSql;
int rc;
va_start(ap, zFormat);
zSql = sqlite3_vmprintf(zFormat, ap);
rc = sqlite3_exec(db, zSql, 0, 0, 0);
va_end(ap);
return rc;
}
static void *
memory(const char* format, ...)
{
void* ptr = NULL;
va_list list;
va_start(list, format);
ptr = sqlite3_vmprintf(format, list);
va_end(list);
return ptr;
}
/*
** Send trace output defined by zFormat and subsequent arguments.
*/
static void vfstrace_printf(
vfstrace_info *pInfo,
const char *zFormat,
...
){
va_list ap;
char *zMsg;
va_start(ap, zFormat);
zMsg = sqlite3_vmprintf(zFormat, ap);
va_end(ap);
pInfo->xOut(zMsg, pInfo->pOutArg);
sqlite3_free(zMsg);
}
/*
** Run arbitrary SQL. Issue a fatal error on failure.
*/
static void runSql(const char *zFormat, ...){
va_list ap;
char *zSql;
int rc;
va_start(ap, zFormat);
zSql = sqlite3_vmprintf(zFormat, ap);
va_end(ap);
rc = sqlite3_exec(g.db, zSql, 0, 0, 0);
if( rc!=SQLITE_OK ){
fatalError("%s\n%s\n", sqlite3_errmsg(g.db), zSql);
}
sqlite3_free(zSql);
}
/**
wrapper di comodo attorno sqlite3_exec()
esegue, in modo verboso (stampa a video i risultati della query), una query
data su un database
\param db database su cui effetturare la query
\param query comandi SQL da effetturare (sintassi printf-like + "%q" e "%Q")
\return il valore di sqlite3_exec()
\sa sqlite3_exec(), callback_print()
*/
int esegui_query(sqlite3* db, const char* query, ...) {
va_list ap;
va_start(ap, query);
char* quoted_query = sqlite3_vmprintf(query, ap);
va_end(ap);
char* errmsg = NULL;
int r = sqlite3_exec(db, quoted_query, callback_print, NULL, &errmsg);
sqlite3_free(quoted_query);
if (errmsg) {
warn("esegui_query: `%s'\n", errmsg);
sqlite3_free(errmsg);
}
return r;
}
/*
** Print a log message
*/
static void logMessage(const char *zFormat, ...){
va_list ap;
char *zMsg;
char zPrefix[30];
va_start(ap, zFormat);
zMsg = sqlite3_vmprintf(zFormat, ap);
va_end(ap);
sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s: ", g.zName);
if( g.pLog ){
printWithPrefix(g.pLog, zPrefix, zMsg);
fflush(g.pLog);
}
sqlite3_free(zMsg);
}
// returns STMT, or NULL
sqlite3_stmt *dfs_db_blob_stmt(void *data, int len, char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
char *q = sqlite3_vmprintf(fmt, ap);
va_end(ap);
sqlite3_stmt *stmt = dfs_db_prepare(q);
sqlite3_free(q);
sqlite3_bind_blob(stmt, 1, data, len, SQLITE_STATIC);
dfs_db_step(stmt);
return stmt;
}
// --
// Queue querys
// --
void
eina_adb_queue_query(EinaAdb *self, gchar *query, ...)
{
g_return_if_fail(EINA_IS_ADB(self));
g_return_if_fail(query != NULL);
EinaAdbPrivate *priv = GET_PRIVATE(self);
va_list args;
va_start(args, query);
gchar *q = sqlite3_vmprintf(query, args);
va_end(args);
g_queue_push_tail(priv->queue, q);
adb_schedule_flush(self);
}
static void
geos_warning_r (int pool_index, const char *fmt, va_list ap)
{
/* reporting some GEOS warning - thread safe */
char *msg;
msg = sqlite3_vmprintf (fmt, ap);
if (msg)
{
spatialite_e ("GEOS warning: %s\n", msg);
setGeosWarningMsg (pool_index, msg);
sqlite3_free (msg);
}
else
setGeosWarningMsg (pool_index, NULL);
}
// mprintf interface, no return value
int dfs_db_do(char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
char *q = sqlite3_vmprintf(fmt, ap);
va_end(ap);
sqlite3_stmt *stmt = dfs_db_prepare(q);
int res = dfs_db_step(stmt);
sqlite3_free(q);
sqlite3_finalize(stmt);
return res;
}
gboolean
eina_adb_query_exec(EinaAdb *self, const gchar *query, ...)
{
g_return_val_if_fail(EINA_IS_ADB(self), FALSE);
va_list args;
va_start(args, query);
gchar *_query = sqlite3_vmprintf(query, args);
va_end(args);
g_return_val_if_fail((query != NULL), FALSE);
gboolean ret = eina_adb_query_exec_raw(self, _query);
sqlite3_free(_query);
return ret;
}
/*
** Prepare an SQL statement. Issue a fatal error if unable.
*/
static sqlite3_stmt *prepareSql(const char *zFormat, ...){
va_list ap;
char *zSql;
int rc;
sqlite3_stmt *pStmt = 0;
va_start(ap, zFormat);
zSql = sqlite3_vmprintf(zFormat, ap);
va_end(ap);
rc = sqlite3_prepare_v2(g.db, zSql, -1, &pStmt, 0);
if( rc!=SQLITE_OK ){
sqlite3_finalize(pStmt);
fatalError("%s\n%s\n", sqlite3_errmsg(g.db), zSql);
}
sqlite3_free(zSql);
return pStmt;
}
int esegui_query_callback(sqlite3* db, int(*callback)(void*, int, char**,
char**), void* callback_par, const char* query, ...) {
va_list ap;
va_start(ap, query); /* inizializzo ap col primo valore successivo a
query, se ce ne sono */
char* quoted_query = sqlite3_vmprintf(query, ap);
va_end(ap); // chiudo ap (...)
char* errmsg = NULL;
int r = sqlite3_exec(db, quoted_query, callback, callback_par, &errmsg);
sqlite3_free(quoted_query);
if (errmsg) {
warn("esegui_query_callback: `%s'\n", errmsg);
sqlite3_free(errmsg);
}
return r;
}
