Merge pull request #1411 from fnc12/feature/logger

Logger

Author: fnc12

.vscode/settings.json

@@ -76,11 +76,12 @@
         "__config": "cpp",
         "any": "cpp",
         "__threading_support": "cpp",
-        "complex": "cpp",
         "condition_variable": "cpp",
-        "execution": "cpp",
-        "fstream": "cpp",
+        "complex": "cpp",
+        "thread": "cpp",
         "future": "cpp",
+        "fstream": "cpp",
+        "execution": "cpp",
         "iostream": "cpp",
         "numbers": "cpp",
         "queue": "cpp",

dev/connection_holder.h

@@ -34,11 +34,12 @@ namespace sqlite_orm {
                 // therefore we can just use an atomic increment but don't need sequencing due to `prevCount > 0`.
                 if (_retainCount.fetch_add(1, std::memory_order_relaxed) == 0) {
                     int open_flags = internal::db_open_mode_to_int_flags(this->open_mode);
-#if SQLITE_VERSION_NUMBER >= 3008008
+#if SQLITE_VERSION_NUMBER >= 3037002
                     open_flags |= SQLITE_OPEN_EXRESCODE;
 #endif
 
-                    int rc = sqlite3_open_v2(this->filename.c_str(), &this->db, open_flags, this->vfs_name.c_str());
+                    const int rc =
+                        sqlite3_open_v2(this->filename.c_str(), &this->db, open_flags, this->vfs_name.c_str());
 
                     if (rc != SQLITE_OK) SQLITE_ORM_CPP_UNLIKELY /*possible, but unexpected*/ {
                         throw_translated_sqlite_error(rc);

dev/implementations/storage_definitions.h

@@ -149,12 +149,16 @@ namespace sqlite_orm {
                 }
             });
 
-            std::stringstream ss;
-            ss << "INSERT INTO " << streaming_identifier(destinationTableName) << " ("
-               << streaming_identifiers(columnNames) << ") "
-               << "SELECT " << streaming_identifiers(columnNames) << " FROM " << streaming_identifier(sourceTableName)
-               << std::flush;
-            perform_void_exec(db, ss.str());
+            std::string sql;
+            {
+                std::stringstream ss;
+                ss << "INSERT INTO " << streaming_identifier(destinationTableName) << " ("
+                   << streaming_identifiers(columnNames) << ") "
+                   << "SELECT " << streaming_identifiers(columnNames) << " FROM "
+                   << streaming_identifier(sourceTableName) << std::flush;
+                sql = ss.str();
+            }
+            this->executor.perform_void_exec(db, sql.data());
         }
     }
 }

dev/mapped_view.h

@@ -51,12 +51,14 @@ namespace sqlite_orm {
 
             mapped_iterator<T, db_objects_type> begin() {
                 using context_t = serializer_context<db_objects_type>;
+
                 auto& dbObjects = obtain_db_objects(this->storage);
                 context_t context{dbObjects};
                 context.skip_table_name = false;
                 context.replace_bindable_with_question = true;
 
-                statement_finalizer stmt{prepare_stmt(this->connection.get(), serialize(this->expression, context))};
+                const std::string sql = serialize(this->expression, context);
+                statement_finalizer stmt{prepare_stmt(this->connection.get(), sql)};
                 iterate_ast(this->expression.conditions, conditional_binder{stmt.get()});
                 return {dbObjects, std::move(stmt)};
             }

dev/pragma.h

@@ -22,6 +22,7 @@ namespace sqlite_orm {
 
     namespace internal {
         struct storage_base;
+        struct sqlite_executor;
 
         template<class T>
         int getPragmaCallback(void* data, int argc, char** argv, char** x) {
@@ -42,7 +43,8 @@ namespace sqlite_orm {
         struct pragma_t {
             using get_connection_t = std::function<internal::connection_ref()>;
 
-            pragma_t(get_connection_t get_connection_) : get_connection(std::move(get_connection_)) {}
+            pragma_t(get_connection_t get_connection_, const sqlite_executor& executor) :
+                get_connection(std::move(get_connection_)), executor(executor) {}
 
             std::vector<std::string> module_list() {
                 return this->get_pragma<std::vector<std::string>>("module_list");
@@ -156,13 +158,17 @@ namespace sqlite_orm {
                 auto connection = this->get_connection();
 
                 std::vector<sqlite_orm::table_xinfo> result;
-                std::ostringstream ss;
-                ss << "PRAGMA "
-                      "table_xinfo("
-                   << streaming_identifier(tableName) << ")" << std::flush;
-                perform_exec(
+                std::string sql;
+                {
+                    std::ostringstream ss;
+                    ss << "PRAGMA "
+                          "table_xinfo("
+                       << streaming_identifier(tableName) << ")" << std::flush;
+                    sql = ss.str();
+                }
+                this->executor.perform_exec(
                     connection.get(),
-                    ss.str(),
+                    sql,
                     [](void* data, int argc, char** argv, char**) -> int {
                         auto& res = *(std::vector<sqlite_orm::table_xinfo>*)data;
                         if (argc) {
@@ -192,14 +198,18 @@ namespace sqlite_orm {
             std::vector<sqlite_orm::table_info> table_info(const std::string& tableName) const {
                 auto connection = this->get_connection();
 
-                std::ostringstream ss;
-                ss << "PRAGMA "
-                      "table_info("
-                   << streaming_identifier(tableName) << ")" << std::flush;
+                std::string sql;
+                {
+                    std::ostringstream ss;
+                    ss << "PRAGMA "
+                          "table_info("
+                       << streaming_identifier(tableName) << ")" << std::flush;
+                    sql = ss.str();
+                }
                 std::vector<sqlite_orm::table_info> result;
-                perform_exec(
+                this->executor.perform_exec(
                     connection.get(),
-                    ss.str(),
+                    sql,
                     [](void* data, int argc, char** argv, char**) -> int {
                         auto& res = *(std::vector<sqlite_orm::table_info>*)data;
                         if (argc) {
@@ -225,12 +235,14 @@ namespace sqlite_orm {
             int synchronous_ = -1;
             signed char journal_mode_ = -1;  //  if != -1 stores static_cast<sqlite_orm::journal_mode>(journal_mode)
             get_connection_t get_connection;
+            const sqlite_executor& executor;
 
             template<class T>
             T get_pragma(const std::string& name) {
                 auto connection = this->get_connection();
                 T result;
-                perform_exec(connection.get(), "PRAGMA " + name, getPragmaCallback<T>, &result);
+                const std::string sql = "PRAGMA " + name;
+                this->executor.perform_exec(connection.get(), sql, getPragmaCallback<T>, &result);
                 return result;
             }
 
@@ -257,12 +269,12 @@ namespace sqlite_orm {
                 this->set_pragma_impl(ss.str(), db);
             }
 
-            void set_pragma_impl(const std::string& query, sqlite3* db = nullptr) {
+            void set_pragma_impl(const std::string& sql, sqlite3* db = nullptr) {
                 if (db) {
-                    perform_void_exec(db, query);
+                    this->executor.perform_void_exec(db, sql.data());
                 } else {
-                    auto con = this->get_connection();
-                    perform_void_exec(con.get(), query);
+                    auto connection = this->get_connection();
+                    this->executor.perform_void_exec(connection.get(), sql.data());
                 }
             }
         };

dev/result_set_view.h

@@ -51,11 +51,13 @@ namespace sqlite_orm::internal {
             using select_type = polyfill::detected_or_t<expression_type, expression_type_t, expression_type>;
             using column_result_type = column_result_of_t<ExprDBOs, select_type>;
             using context_t = serializer_context<ExprDBOs>;
+
             context_t context{exprDBOs};
             context.skip_table_name = false;
             context.replace_bindable_with_question = true;
 
-            statement_finalizer stmt{prepare_stmt(this->connection.get(), serialize(this->expression, context))};
+            const std::string sql = serialize(this->expression, context);
+            statement_finalizer stmt{prepare_stmt(this->connection.get(), sql)};
             iterate_ast(this->expression, conditional_binder{stmt.get()});
 
             // note: it is enough to only use the 'expression DBOs' at compile-time to determine the column results;