Replace Statement::Ptr with std::shared_ptr

Author: Kacperos155

include/SQLiteCpp/Column.h

@@ -14,8 +14,11 @@
 #include <SQLiteCpp/Exception.h>
 
 #include <string>
+#include <memory>
 #include <climits> // For INT_MAX
 
+// Forward declarations to avoid inclusion of <sqlite3.h> in a header
+struct sqlite3_stmt;
 
 namespace SQLite
 {
@@ -26,7 +29,6 @@ extern const int TEXT;      ///< SQLITE_TEXT
 extern const int BLOB;      ///< SQLITE_BLOB
 extern const int Null;      ///< SQLITE_NULL
 
-
 /**
  * @brief Encapsulation of a Column in a row of the result pointed by the prepared Statement.
  *
@@ -52,7 +54,7 @@ class Column
      * @param[in] aStmtPtr  Shared pointer to the prepared SQLite Statement Object.
      * @param[in] aIndex    Index of the column in the row of result, starting at 0
      */
-    Column(Statement::Ptr& aStmtPtr, int aIndex) noexcept;
+    Column(Statement::TStatementPtr& aStmtPtr, int aIndex) noexcept;
 
     // default destructor: the finalization will be done by the destructor of the last shared pointer
     // default copy constructor and assignment operator are perfectly suited :
@@ -250,8 +252,8 @@ class Column
     }
 
 private:
-    Statement::Ptr  mStmtPtr;   ///< Shared Pointer to the prepared SQLite Statement Object
-    int             mIndex;     ///< Index of the column in the row of result, starting at 0
+    Statement::TStatementPtr    mStmtPtr;  ///< Shared Pointer to the prepared SQLite Statement Object
+    int                         mIndex;    ///< Index of the column in the row of result, starting at 0
 };
 
 /**
@@ -281,7 +283,7 @@ T Statement::getColumns()
 template<typename T, const int... Is>
 T Statement::getColumns(const std::integer_sequence<int, Is...>)
 {
-    return T{Column(mStmtPtr, Is)...};
+    return T{Column(mpPreparedStatement, Is)...};
 }
 
 #endif

include/SQLiteCpp/Statement.h

@@ -15,6 +15,7 @@
 
 #include <string>
 #include <map>
+#include <memory>
 
 // Forward declarations to avoid inclusion of <sqlite3.h> in a header
 struct sqlite3;
@@ -50,8 +51,6 @@ extern const int OK; ///< SQLITE_OK
  */
 class Statement
 {
-    friend class Column; // For access to Statement::Ptr inner class
-
 public:
     /**
      * @brief Compile and register the SQL query for the provided SQLite Database Connection
@@ -645,52 +644,8 @@ class Statement
     /// Return UTF-8 encoded English language explanation of the most recent failed API call (if any).
     const char* getErrorMsg() const noexcept;
 
-private:
-    /**
-     * @brief Shared pointer to the sqlite3_stmt SQLite Statement Object.
-     *
-     * Manage the finalization of the sqlite3_stmt with a reference counter.
-     *
-     * This is a internal class, not part of the API (hence full documentation is in the cpp).
-     */
-    // TODO Convert this whole custom pointer to a C++11 std::shared_ptr with a custom deleter
-    class Ptr
-    {
-    public:
-        // Prepare the statement and initialize its reference counter
-        Ptr(sqlite3* apSQLite, std::string& aQuery);
-        // Copy constructor increments the ref counter
-        Ptr(const Ptr& aPtr);
-
-        // Move constructor
-        Ptr(Ptr&& aPtr);
-
-        // Decrement the ref counter and finalize the sqlite3_stmt when it reaches 0
-        ~Ptr();
-
-        /// Inline cast operator returning the pointer to SQLite Database Connection Handle
-        operator sqlite3*() const
-        {
-            return mpSQLite;
-        }
-
-        /// Inline cast operator returning the pointer to SQLite Statement Object
-        operator sqlite3_stmt*() const
-        {
-            return mpStmt;
-        }
-
-    private:
-        /// @{ Unused/forbidden copy/assignment operator
-        Ptr& operator=(const Ptr& aPtr);
-        /// @}
-
-    private:
-        sqlite3*        mpSQLite;    //!< Pointer to SQLite Database Connection Handle
-        sqlite3_stmt*   mpStmt;      //!< Pointer to SQLite Statement Object
-        unsigned int*   mpRefCount;  //!< Pointer to the heap allocated reference counter of the sqlite3_stmt
-                                     //!< (to share it with Column objects)
-    };
+    /// Shared pointer to SQLite Prepared Statement Object
+    typedef std::shared_ptr<sqlite3_stmt> TStatementPtr;
 
 private:
     /**
@@ -702,7 +657,7 @@ class Statement
     {
         if (SQLite::OK != aRet)
         {
-            throw SQLite::Exception(mStmtPtr, aRet);
+            throw SQLite::Exception(mpSQLite, aRet);
         }
     }
 
@@ -728,17 +683,33 @@ class Statement
         }
     }
 
+    /**
+     * @brief Prepare statement object.
+     * 
+     * @return Shared pointer to prepared statement object
+     */
+    TStatementPtr prepareStatement();
+
+    /**
+     * @brief Return a prepared statement object.
+     * 
+     * Throw an exception if the statement object was not prepared.
+     * @return raw pointer to Prepared Statement Object
+     */
+    sqlite3_stmt* getPreparedStatement() const;
+
 private:
     /// Map of columns index by name (mutable so getColumnIndex can be const)
     typedef std::map<std::string, int> TColumnNames;
 
 private:
-    std::string             mQuery;         //!< UTF-8 SQL Query
-    Ptr                     mStmtPtr;       //!< Shared Pointer to the prepared SQLite Statement Object
-    int                     mColumnCount;   //!< Number of columns in the result of the prepared statement
-    mutable TColumnNames    mColumnNames;   //!< Map of columns index by name (mutable so getColumnIndex can be const)
-    bool                    mbHasRow;       //!< true when a row has been fetched with executeStep()
-    bool                    mbDone;         //!< true when the last executeStep() had no more row to fetch
+    std::string             mQuery;                 //!< UTF-8 SQL Query
+    sqlite3*                mpSQLite;               //!< Pointer to SQLite Database Connection Handle
+    TStatementPtr           mpPreparedStatement;    //!< Shared Pointer to the prepared SQLite Statement Object
+    int                     mColumnCount{0};        //!< Number of columns in the result of the prepared statement
+    mutable TColumnNames    mColumnNames;           //!< Map of columns index by name (mutable so getColumnIndex can be const)
+    bool                    mbHasRow{false};        //!< true when a row has been fetched with executeStep()
+    bool                    mbDone{false};          //!< true when the last executeStep() had no more row to fetch
 };
 
 

src/Column.cpp

@@ -26,7 +26,7 @@ const int Null      = SQLITE_NULL;
 
 
 // Encapsulation of a Column in a row of the result pointed by the prepared Statement.
-Column::Column(Statement::Ptr& aStmtPtr, int aIndex) noexcept :
+Column::Column(Statement::TStatementPtr& aStmtPtr, int aIndex) noexcept :
     mStmtPtr(aStmtPtr),
     mIndex(aIndex)
 {
@@ -35,21 +35,21 @@ Column::Column(Statement::Ptr& aStmtPtr, int aIndex) noexcept :
 // Return the named assigned to this result column (potentially aliased)
 const char* Column::getName() const noexcept
 {
-    return sqlite3_column_name(mStmtPtr, mIndex);
+    return sqlite3_column_name(mStmtPtr.get(), mIndex);
 }
 
 #ifdef SQLITE_ENABLE_COLUMN_METADATA
 // Return the name of the table column that is the origin of this result column
 const char* Column::getOriginName() const noexcept
 {
-    return sqlite3_column_origin_name(mStmtPtr, mIndex);
+    return sqlite3_column_origin_name(mStmtPtr.get(), mIndex);
 }
 #endif
 
 // Return the integer value of the column specified by its index starting at 0
 int Column::getInt() const noexcept
 {
-    return sqlite3_column_int(mStmtPtr, mIndex);
+    return sqlite3_column_int(mStmtPtr.get(), mIndex);
 }
 
 // Return the unsigned integer value of the column specified by its index starting at 0
@@ -61,50 +61,50 @@ unsigned Column::getUInt() const noexcept
 // Return the 64bits integer value of the column specified by its index starting at 0
 long long Column::getInt64() const noexcept
 {
-    return sqlite3_column_int64(mStmtPtr, mIndex);
+    return sqlite3_column_int64(mStmtPtr.get(), mIndex);
 }
 
 // Return the double value of the column specified by its index starting at 0
 double Column::getDouble() const noexcept
 {
-    return sqlite3_column_double(mStmtPtr, mIndex);
+    return sqlite3_column_double(mStmtPtr.get(), mIndex);
 }
 
 // Return a pointer to the text value (NULL terminated string) of the column specified by its index starting at 0
 const char* Column::getText(const char* apDefaultValue /* = "" */) const noexcept
 {
-    const char* pText = reinterpret_cast<const char*>(sqlite3_column_text(mStmtPtr, mIndex));
+    const char* pText = reinterpret_cast<const char*>(sqlite3_column_text(mStmtPtr.get(), mIndex));
     return (pText?pText:apDefaultValue);
 }
 
 // Return a pointer to the blob value (*not* NULL terminated) of the column specified by its index starting at 0
 const void* Column::getBlob() const noexcept
 {
-    return sqlite3_column_blob(mStmtPtr, mIndex);
+    return sqlite3_column_blob(mStmtPtr.get(), mIndex);
 }
 
 // Return a std::string to a TEXT or BLOB column
 std::string Column::getString() const
 {
     // Note: using sqlite3_column_blob and not sqlite3_column_text
     // - no need for sqlite3_column_text to add a \0 on the end, as we're getting the bytes length directly
-    const char *data = static_cast<const char *>(sqlite3_column_blob(mStmtPtr, mIndex));
+    const char *data = static_cast<const char *>(sqlite3_column_blob(mStmtPtr.get(), mIndex));
 
     // SQLite docs: "The safest policy is to invoke… sqlite3_column_blob() followed by sqlite3_column_bytes()"
     // Note: std::string is ok to pass nullptr as first arg, if length is 0
-    return std::string(data, sqlite3_column_bytes(mStmtPtr, mIndex));
+    return std::string(data, sqlite3_column_bytes(mStmtPtr.get(), mIndex));
 }
 
 // Return the type of the value of the column
 int Column::getType() const noexcept
 {
-    return sqlite3_column_type(mStmtPtr, mIndex);
+    return sqlite3_column_type(mStmtPtr.get(), mIndex);
 }
 
 // Return the number of bytes used by the text value of the column
 int Column::getBytes() const noexcept
 {
-    return sqlite3_column_bytes(mStmtPtr, mIndex);
+    return sqlite3_column_bytes(mStmtPtr.get(), mIndex);
 }
 
 // Standard std::ostream inserter