Clean SQLite calling style.

libgearman-server/plugins/queue/sqlite/instance.cc

@@ -114,33 +114,40 @@ int Instance::_sqlite_lock()
     return SQLITE_OK;
   }
 
-  sqlite3_stmt* sth;
-  int ret= _sqlite_query(gearman_literal_param("BEGIN TRANSACTION"), &sth);
-  if (ret != SQLITE_OK)
-  {
-    gearmand_log_error(AT, "failed to begin transaction: %s", sqlite3_errmsg(_db));
-    if (sth)
-    {
-      sqlite3_finalize(sth);
-    }
-
-    return ret;
-  }
-
-  ret= sqlite3_step(sth);
-  if (ret != SQLITE_DONE)
+  char* error= NULL;
+  sqlite3_exec(_db, "BEGIN TRANSACTION", NULL, NULL, &error);
+  if (error != NULL)
   {
-    gearmand_log_error(AT, "lock error: %s", sqlite3_errmsg(_db));
-    sqlite3_finalize(sth);
-    return ret;
+    gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM,
+                       "failed to begin transaction: %s",
+                       error);
+    return sqlite3_errcode(_db);
   }
 
-  sqlite3_finalize(sth);
   _in_trans++;
 
   return SQLITE_OK;
 }
 
+gearmand_error_t Instance::_sqlite_dispatch(const std::string& arg, bool send_error)
+{
+  char* error= NULL;
+  sqlite3_exec(_db, arg.c_str(), NULL, NULL, &error);
+
+  if (error != NULL)
+  {
+    if (send_error)
+    {
+      return gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM,
+                                "%s", error);
+    }
+
+    return GEARMAN_UNKNOWN_OPTION;
+  }
+
+  return GEARMAN_SUCCESS;
+}
+
 int Instance::_sqlite_commit()
 {
   if (_in_trans == 0)
@@ -149,29 +156,16 @@ int Instance::_sqlite_commit()
     return SQLITE_OK;
   }
 
-  sqlite3_stmt* sth;
-  int ret= _sqlite_query(gearman_literal_param("COMMIT"), &sth);
-  if (ret != SQLITE_OK)
-  {
-    gearmand_log_error("_sqlite_commit",
-                       "failed to commit transaction: %s",
-                       sqlite3_errmsg(_db));
-    if (sth)
-    {
-      sqlite3_finalize(sth);
-    }
-
-    return ret;
-  }
+  char* error= NULL;
+  sqlite3_exec(_db, "COMMIT", NULL, NULL, &error);
 
-  ret= sqlite3_step(sth);
-  if (ret != SQLITE_DONE)
+  if (error != NULL)
   {
-    gearmand_log_error("_sqlite_commit", "commit error: %s", sqlite3_errmsg(_db));
-    sqlite3_finalize(sth);
-    return ret;
+    gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM,
+                       "failed to commit transaction: %s", error);
+    return sqlite3_errcode(_db);
   }
-  sqlite3_finalize(sth);
+
   _in_trans= 0;
 
   return SQLITE_OK;
@@ -248,21 +242,10 @@ gearmand_error_t Instance::init()
 
     gearmand_log_info(GEARMAN_DEFAULT_LOG_PARAM, "sqlite module creating table '%s'", _table.c_str());
 
-    if (_sqlite_query(query.c_str(), query.size(), &sth) != SQLITE_OK)
+    gearmand_error_t ret= _sqlite_dispatch(query);
+    if (ret != GEARMAN_SUCCESS)
     {
-      return gearmand_gerror(sqlite3_errmsg(_db), GEARMAN_QUEUE_ERROR);
-    }
-
-    if (sqlite3_step(sth) != SQLITE_DONE)
-    {
-      gearmand_gerror(sqlite3_errmsg(_db), GEARMAN_QUEUE_ERROR);
-      sqlite3_finalize(sth);
-      return GEARMAN_QUEUE_ERROR;
-    }
-
-    if (sqlite3_finalize(sth) != SQLITE_OK)
-    {
-      return gearmand_gerror(sqlite3_errmsg(_db), GEARMAN_QUEUE_ERROR);
+      return ret;
     }
   }
   else
@@ -270,7 +253,8 @@ gearmand_error_t Instance::init()
     std::string query("SELECT when_to_run FROM ");
     query+= _table;
 
-    if (_sqlite_query(query.c_str(), query.size(), &sth) != SQLITE_OK)
+    gearmand_error_t ret= _sqlite_dispatch(query);
+    if (ret != GEARMAN_SUCCESS)
     {
       gearmand_info("No epoch support in sqlite queue");
       _epoch_support= false;
@@ -288,29 +272,15 @@ int Instance::_sqlite_rollback()
     return SQLITE_OK;
   }
 
-  sqlite3_stmt* sth;
-  int ret= _sqlite_query(gearman_literal_param("ROLLBACK"), &sth);
-  if (ret != SQLITE_OK)
-  {
-    gearmand_log_error("_sqlite_rollback",
-                       "failed to rollback transaction: %s",
-                       sqlite3_errmsg(_db));
-    if (sth)
-    {
-      sqlite3_finalize(sth);
-    }
+  char* error= NULL;
+  sqlite3_exec(_db, "ROLLBACK", NULL, NULL, &error);
 
-    return ret;
-  }
-  ret= sqlite3_step(sth);
-  if (ret != SQLITE_DONE)
+  if (error != NULL)
   {
-    gearmand_log_error("_sqlite_rollback", "rollback error: %s",
-                       sqlite3_errmsg(_db));
-    sqlite3_finalize(sth);
-    return ret;
+    gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM,
+                       "failed to commit transaction: %s", error);
+    return sqlite3_errcode(_db);
   }
-  sqlite3_finalize(sth);
   _in_trans= 0;
 
   return SQLITE_OK;
@@ -462,7 +432,8 @@ gearmand_error_t Instance::done(gearman_server_st *server,
 
   if (sqlite3_step(sth) != SQLITE_DONE)
   {
-    gearmand_log_error("_sqlite_done", "delete error: %s",
+    gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM,
+                       "delete error: %s",
                        sqlite3_errmsg(_db));
     sqlite3_finalize(sth);
     return GEARMAN_QUEUE_ERROR;

libgearman-server/plugins/queue/sqlite/instance.hpp

@@ -82,6 +82,7 @@ public:
   gearmand_error_t replay(gearman_server_st *server);
 
 private:
+  gearmand_error_t _sqlite_dispatch(const std::string& arg, bool send_error= true);
   int _sqlite_query(const char *query, size_t query_size, sqlite3_stmt ** sth);
   int _sqlite_commit();
   int _sqlite_rollback();

libtest/result.cc

@@ -60,13 +60,7 @@ __skipped::__skipped(const char *file_arg, int line_arg, const char *func_arg):
 __failure::__failure(const char *file_arg, int line_arg, const char *func_arg, const std::string& mesg):
   __test_result(file_arg, line_arg, func_arg)
 {
-  snprintf(_error_message, sizeof(_error_message), "FAIL: %.*s", int(mesg.size()), mesg.c_str());
-}
-
-__failure::__failure(const char *file_arg, int line_arg, const char *func_arg):
-  __test_result(file_arg, line_arg, func_arg)
-{
-  snprintf(_error_message, sizeof(_error_message), "FAIL");
+  snprintf(_error_message, sizeof(_error_message), "%.*s", int(mesg.size()), mesg.c_str());
 }
 
 } // namespace libtest

libtest/result.hpp

@@ -96,7 +96,6 @@ class __failure : public __test_result
 {
 public:
   __failure(const char *file, int line, const char *func, const std::string&);
-  __failure(const char *file, int line, const char *func);
 
   const char* what() const throw()
   {
@@ -112,5 +111,4 @@ private:
 
 #define _SUCCESS throw libtest::__success(LIBYATL_DEFAULT_PARAM)
 #define SKIP throw libtest::__skipped(LIBYATL_DEFAULT_PARAM)
-#define FAIL throw libtest::__failure(LIBYATL_DEFAULT_PARAM)
-#define FAILED(__mesg) throw libtest::__failure(LIBYATL_DEFAULT_PARAM, __mesg)
+#define FAIL(__mesg) throw libtest::__failure(LIBYATL_DEFAULT_PARAM, __mesg)

libtest/runner.cc

@@ -60,8 +60,9 @@ test_return_t Runner::run(test_callback_fn* func, void *object)
     {
       return TEST_SKIPPED;
     }
-    catch (libtest::__failure)
+    catch (libtest::__failure e)
     {
+      libtest::stream::make_cerr(e.file(), e.line(), e.func()) << e.what();
       return TEST_FAILURE;
     }
     catch (libtest::__success)
@@ -84,8 +85,9 @@ test_return_t Runner::pre(test_callback_fn* func, void *object)
     {
       return TEST_SKIPPED;
     }
-    catch (libtest::__failure)
+    catch (libtest::__failure e)
     {
+      libtest::stream::make_cerr(e.file(), e.line(), e.func()) << e.what();
       return TEST_FAILURE;
     }
     catch (libtest::__success)
@@ -108,8 +110,9 @@ test_return_t Runner::post(test_callback_fn* func, void *object)
     {
       return TEST_SKIPPED;
     }
-    catch (libtest::__failure)
+    catch (libtest::__failure e)
     {
+      libtest::stream::make_cerr(e.file(), e.line(), e.func()) << e.what();
       return TEST_FAILURE;
     }
     catch (libtest::__success)

libtest/unittest.cc

@@ -141,27 +141,10 @@ static test_return_t test_throw_skip_TEST(void *)
 }
 
 static test_return_t test_throw_fail_TEST(void *)
-{
-  try {
-    FAIL;
-  }
-  catch (libtest::__failure)
-  {
-    return TEST_SUCCESS;
-  }
-  catch (...)
-  {
-    return TEST_FAILURE;
-  }
-
-  return TEST_FAILURE;
-}
-
-static test_return_t test_throw_failure_TEST(void *)
 {
   std::string error_messsage("test message!");
   try {
-    FAILED(error_messsage);
+    FAIL(error_messsage);
   }
   catch (libtest::__failure e)
   {
@@ -950,7 +933,6 @@ test_st tests_log[] ={
   {"SUCCESS", false, test_throw_success_TEST },
   {"SKIP", false, test_throw_skip_TEST },
   {"FAIL", false, test_throw_fail_TEST },
-  {"FAILED", false, test_throw_failure_TEST },
   {0, 0, 0}
 };