Added a C++ wrapper for SQLite.

dlib/sqlite.h

+// Copyright (C) 2011  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_SQLiTE_HEADER
+#define DLIB_SQLiTE_HEADER
+
+#include "sqlite/sqlite_tools.h"
+
+#endif // DLIB_SVm_HEADER
+
+
+

dlib/sqlite/sqlite_tools.h

+// Copyright (C) 2011  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#ifndef DLIB_SQLiTE_TOOLS_H_
+#define DLIB_SQLiTE_TOOLS_H_
+
+
+#include "sqlite_tools_abstract.h"
+#include "sqlite.h"
+
+// ----------------------------------------------------------------------------------------
+
+namespace dlib
+{
+    namespace sqlite
+    {
+
+        class transaction : noncopyable
+        {
+        public:
+            transaction (
+                database& db_
+            ) :
+                db(db_),
+                committed(false)
+            {
+                db.exec("begin transaction");
+            }
+
+            void commit ()
+            {
+                if (!committed)
+                {
+                    committed = true;
+                    db.exec("commit");
+                }
+            }
+
+            ~transaction()
+            {
+                if (!committed)
+                    db.exec("rollback");
+            }
+
+        private:
+            database& db;
+            bool committed;
+
+        };
+
+    // ------------------------------------------------------------------------------------
+
+
+        template <
+            typename T
+            >
+        void query_object (
+            database& db,
+            const std::string& query,
+            T& item
+        )
+        {
+            statement st(db, query);
+            st.exec();
+            if (st.move_next() && st.get_num_columns() == 1)
+            {
+                st.get_column_as_object(0,item);
+                if (st.move_next())
+                    throw sqlite_error("query doesn't result in exactly 1 element");
+            }
+            else
+            {
+                throw sqlite_error("query doesn't result in exactly 1 element");
+            }
+        }
+
+    // ------------------------------------------------------------------------------------
+
+        inline std::string query_text (
+            database& db,
+            const std::string& query
+        )
+        {
+            statement st(db, query);
+            st.exec();
+            if (st.move_next() && st.get_num_columns() == 1)
+            {
+                const std::string& temp = st.get_column_as_text(0);
+                if (st.move_next())
+                    throw sqlite_error("query doesn't result in exactly 1 element");
+                return temp;
+            }
+            else
+            {
+                throw sqlite_error("query doesn't result in exactly 1 element");
+            }
+        }
+
+    // ------------------------------------------------------------------------------------
+
+        inline double query_double (
+            database& db,
+            const std::string& query
+        )
+        {
+            statement st(db, query);
+            st.exec();
+            if (st.move_next() && st.get_num_columns() == 1)
+            {
+                double temp = st.get_column_as_double(0);
+                if (st.move_next())
+                    throw sqlite_error("query doesn't result in exactly 1 element");
+                return temp;
+            }
+            else
+            {
+                throw sqlite_error("query doesn't result in exactly 1 element");
+            }
+        }
+
+    // ------------------------------------------------------------------------------------
+
+        inline int query_int (
+            database& db,
+            const std::string& query
+        )
+        {
+            statement st(db, query);
+            st.exec();
+            if (st.move_next() && st.get_num_columns() == 1)
+            {
+                int temp = st.get_column_as_int(0);
+                if (st.move_next())
+                    throw sqlite_error("query doesn't result in exactly 1 element");
+                return temp;
+            }
+            else
+            {
+                throw sqlite_error("query doesn't result in exactly 1 element");
+            }
+        }
+
+    // ------------------------------------------------------------------------------------
+
+        inline int64 query_int64 (
+            database& db,
+            const std::string& query
+        )
+        {
+            statement st(db, query);
+            st.exec();
+            if (st.move_next() && st.get_num_columns() == 1)
+            {
+                int64 temp = st.get_column_as_int64(0);
+                if (st.move_next())
+                    throw sqlite_error("query doesn't result in exactly 1 element");
+                return temp;
+            }
+            else
+            {
+                throw sqlite_error("query doesn't result in exactly 1 element");
+            }
+        }
+
+    // ------------------------------------------------------------------------------------
+
+        inline const std::vector<char> query_blob (
+            database& db,
+            const std::string& query
+        )
+        {
+            statement st(db, query);
+            st.exec();
+            if (st.move_next() && st.get_num_columns() == 1)
+            {
+                const std::vector<char>& temp = st.get_column_as_blob(0);
+                if (st.move_next())
+                    throw sqlite_error("query doesn't result in exactly 1 element");
+                return temp;
+            }
+            else
+            {
+                throw sqlite_error("query doesn't result in exactly 1 element");
+            }
+        }
+
+    // ------------------------------------------------------------------------------------
+
+    }
+}
+
+#endif // DLIB_SQLiTE_TOOLS_H_
+

dlib/sqlite/sqlite_tools_abstract.h

+// Copyright (C) 2011  Davis E. King (davis@dlib.net)
+// License: Boost Software License   See LICENSE.txt for the full license.
+#undef DLIB_SQLiTE_TOOLS_ABSTRACT_H_
+#ifdef DLIB_SQLiTE_TOOLS_ABSTRACT_H_
+
+
+#include "sqlite_abstract.h"
+
+// ----------------------------------------------------------------------------------------
+
+namespace dlib
+{
+    namespace sqlite
+    {
+
+        class transaction : noncopyable
+        {
+            /*!
+                WHAT THIS OBJECT REPRESENTS
+                    This object is a tool for creating exception safe
+                    database transactions.
+            !*/
+
+        public:
+            transaction (
+                database& db
+            );
+            /*!
+                ensures
+                    - Begins a database transaction which will be rolled back
+                      if commit() isn't called eventually.
+                    - In particular, performs: db.exec("begin transaction");
+            !*/
+
+            void commit (
+            );
+            /*!
+                ensures
+                    - if (commit() hasn't already been called) then
+                        - Commits all changes made during this database transaction.
+                        - In particular, performs: db.exec("commit");
+                    - else
+                        - does nothing
+            !*/
+
+            ~transaction(
+            );
+            /*!
+                ensures
+                    - if (commit() was never called) then
+                        - rolls back any changes made to the database during this transaction.
+                        - In particular, performs: db.exec("rollback");
+                    - else
+                        - does nothing
+            !*/
+
+        };
+
+    // ------------------------------------------------------------------------------------
+
+        template <
+            typename T
+            >
+        void query_object (
+            database& db,
+            const std::string& query,
+            T& item
+        );
+        /*!
+            ensures
+                - executes the given SQL query against db.  If the query results in a 
+                  single row and column being returned then the data in the column is 
+                  interpreted as a binary BLOB and deserialized into item.
+            throws
+                - sqlite_error or serialization_error if an error occurs which prevents
+                  this operation from succeeding.
+
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        std::string query_text (
+            database& db,
+            const std::string& query
+        );
+        /*!
+            ensures
+                - executes the given SQL query against db.  If the query results in a 
+                  single row and column being returned then the data in the column is 
+                  converted to text and returned.
+            throws
+                - sqlite_error if an error occurs which prevents this operation from 
+                  succeeding.
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        double query_double (
+            database& db,
+            const std::string& query
+        );
+        /*!
+            ensures
+                - executes the given SQL query against db.  If the query results in a 
+                  single row and column being returned then the data in the column is 
+                  converted to a double and returned.
+            throws
+                - sqlite_error if an error occurs which prevents this operation from 
+                  succeeding.
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        int query_int (
+            database& db,
+            const std::string& query
+        );
+        /*!
+            ensures
+                - executes the given SQL query against db.  If the query results in a 
+                  single row and column being returned then the data in the column is 
+                  converted to an int and returned.
+            throws
+                - sqlite_error if an error occurs which prevents this operation from 
+                  succeeding.
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        int64 query_int64 (
+            database& db,
+            const std::string& query
+        );
+        /*!
+            ensures
+                - executes the given SQL query against db.  If the query results in a 
+                  single row and column being returned then the data in the column is 
+                  converted to an int64 and returned.
+            throws
+                - sqlite_error if an error occurs which prevents this operation from 
+                  succeeding.
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+        const std::vector<char> query_blob (
+            database& db,
+            const std::string& query
+        );
+        /*!
+            ensures
+                - executes the given SQL query against db.  If the query results in a 
+                  single row and column being returned then the data in the column is 
+                  returned as a binary BLOB.
+            throws
+                - sqlite_error if an error occurs which prevents this operation from 
+                  succeeding.
+        !*/
+
+    // ------------------------------------------------------------------------------------
+
+    }
+}
+
+#endif // DLIB_SQLiTE_TOOLS_H_
+
+