Implement SQLite extension loading

Author: amanda-wee

README.md

@@ -35,6 +35,7 @@ Features
 * Support for creating SQL functions (scalar, aggregate, and window)
 * Support for creating SQL collations
 * Support for database operation interrupts
+* Support for loading SQLite extension libraries
 * Optional "strict typing" on a per-query basis, allowing for the prevention of SQLite automatic type conversions across the SQLite fundamental types when retrieving values
 * Convenience functions for attaching and detaching databases
 

include/sqlitemm.hpp

@@ -244,6 +244,14 @@ namespace sqlitemm
          */
         long long last_insert_rowid() const noexcept;
 
+        /**
+         * Loads an SQLite extension library from the named file.
+         *
+         * If the entry point name is an empty string, SQLite will try to come
+         * up with an entry point name on its own.
+         */
+        void load_extension(const std::string& filename, const std::string entry_point_name = std::string{});
+
         /**
          * Connects to the database given by filename.
          */

src/sqlitemm.cpp

@@ -307,6 +307,24 @@ namespace sqlitemm
         return static_cast<long long>(sqlite3_last_insert_rowid(db));
     }
 
+    void Connection::load_extension(const std::string& filename, const std::string entry_point_name)
+    {
+        char* error_message = nullptr;
+        int result_code = sqlite3_load_extension(
+            db, filename.c_str(), entry_point_name.empty() ? nullptr : entry_point_name.c_str(), &error_message
+        );
+        if (result_code != SQLITE_OK)
+        {
+            std::string message{"failed to load SQLite extension"};
+            if (error_message)
+            {
+                message = error_message;
+                sqlite3_free(error_message);
+            }
+            throw Error(message, result_code);
+        }
+    }
+
     void Connection::open(const std::string& filename)
     {
         assert(!db);

tests/connection.cpp

@@ -389,3 +389,32 @@ SCENARIO("interrupts can be started and checked")
     // so we shall just run it to make sure it does not throw:
     REQUIRE_NOTHROW(conn.interrupt());
 }
+
+SCENARIO("SQLite extensions can be loaded")
+{
+    sqlitemm::Connection conn(":memory:");
+    int load_extension_enabled = 0;
+    conn.set_config(SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, &load_extension_enabled);
+
+    // It is difficult to simulate loading an extension,
+    // so we will test failure:
+    WHEN("an invalid extension is attempted to be loaded")
+    {
+        try
+        {
+            conn.load_extension("test_for_failure");
+        }
+        catch(const sqlitemm::Error& e)
+        {
+            std::string error_message = e.what();
+            if (load_extension_enabled)
+            {
+                REQUIRE(error_message.find("(no such file)") != std::string::npos);
+            }
+            else
+            {
+                REQUIRE(error_message == "not authorized");
+            }
+        }
+    }
+}