put together a minimalistic sqlite wrapper

Signed-off-by: Michael Krelin <hacker@klever.net>

1 files changed, 124 insertions, 0 deletions

diff --git a/src/seclude.h b/src/seclude.h
new file mode 100644
index 0000000..cab3699
--- a/dev/null
+++ b/src/seclude.h
@@ -0,0 +1,124 @@
+#ifndef __SECLUDE_H
+#define __SECLUDE_H
+
+#include <sqlite3.h>
+#include <stdexcept>
+#include <tr1/memory>
+#include <cstdarg>
+
+namespace seclude {
+    using std::tr1::shared_ptr;
+
+    static struct sql_null_type { } sql_null;
+
+
+    struct sqlite3_error : public std::runtime_error {
+        int code, ecode;
+        sqlite3_error(sqlite3 *s,const std::string& m)
+            : std::runtime_error(m+": "+(s?sqlite3_errmsg(s):"unknown error")),
+              code(s?sqlite3_errcode(s):-1), ecode(s?sqlite3_extended_errcode(s):-1) { }
+        sqlite3_error(sqlite3_stmt *s,const std::string& m)
+            : std::runtime_error(m+": "+(s?sqlite3_errmsg(sqlite3_db_handle(s)):"unknown error")),
+              code(s?sqlite3_errcode(sqlite3_db_handle(s)):-1),
+              ecode(s?sqlite3_extended_errcode(sqlite3_db_handle(s)):-1) { }
+    };
+
+
+    static void sqlite3_stmt_deleter(sqlite3_stmt* s) { s && sqlite3_finalize(s); }
+    struct stmt_t : public shared_ptr<sqlite3_stmt> {
+        stmt_t(sqlite3_stmt *s) : shared_ptr<sqlite3_stmt>(s,sqlite3_stmt_deleter) { }
+
+        bool step() {
+            switch(sqlite3_step(get())) {
+                case SQLITE_DONE: return false;
+                case SQLITE_ROW: return true;
+            }
+            panic("failed to sqlite3_step()");
+        }
+        stmt_t& reset() {
+            return worry(sqlite3_reset(get()),"failed to sqlite3_reset()");
+        }
+        stmt_t& clear_bindings() {
+            return worry(sqlite3_clear_bindings(get()),"failed to sqlite3_clear_bindings()");
+        }
+        int data_count() { return sqlite3_data_count(get()); }
+        int column_count() { return sqlite3_column_count(get()); }
+        template<typename T> T column(int i);
+        std::string column_name(int i) { return sqlite3_column_name(get(),i); }
+        int column_type(int i) { return sqlite3_column_type(get(),i); }
+        bool is_column_null(int i) { return column_type(i)==SQLITE_NULL; }
+
+        template<typename T> int bind_(int i,T v);
+        template<typename T>
+        stmt_t& bind(int i,T v) {
+            return worry(bind_(i,v),"failed to perform binding");
+        }
+        template<typename T>
+        stmt_t& bind(const char *n,T v) { return bind(bind_parameter_index(n),v); }
+        int bind_parameter_index(const char *n) {
+            int rv = sqlite3_bind_parameter_index(get(),n);
+            if(!rv) throw std::invalid_argument("failed to sqlite3_bind_parameter_index()");
+            return rv;
+        }
+
+
+        stmt_t& worry(int c,const char *m) { if(c!=SQLITE_OK) panic(m); return *this;}
+        stmt_t& panic(const std::string& m) { throw sqlite3_error(get(),m); return *this;}
+    };
+
+    template<> inline int stmt_t::bind_<int>(int i,int v) {
+        return sqlite3_bind_int(get(),i,v); }
+    template<> inline int stmt_t::bind_<long>(int i,long v) {
+        return sqlite3_bind_int64(get(),i,v); }
+    template<> inline int stmt_t::bind_<sqlite3_int64>(int i,sqlite3_int64 v) {
+        return sqlite3_bind_int64(get(),i,v); }
+    template<> inline int stmt_t::bind_<double>(int i,double v) {
+        return sqlite3_bind_double(get(),i,v); }
+    template<> inline int stmt_t::bind_<const std::string&>(int i,const std::string& v) {
+        return sqlite3_bind_text(get(),i,v.c_str(),-1,SQLITE_TRANSIENT); }
+    template<> inline int stmt_t::bind_<std::string>(int i,std::string v) {
+        return sqlite3_bind_text(get(),i,v.c_str(),-1,SQLITE_TRANSIENT); }
+    template<> inline int stmt_t::bind_<const char *>(int i,const char *v) {
+        return sqlite3_bind_text(get(),i,v,-1,SQLITE_TRANSIENT); }
+    template<> inline int stmt_t::bind_<sql_null_type>(int i,sql_null_type) {
+        return sqlite3_bind_null(get(),i); }
+
+    template<> int stmt_t::column<int>(int i) { return sqlite3_column_int(get(),i); }
+    template<> long stmt_t::column<long>(int i) { return sqlite3_column_int64(get(),i); }
+    template<> sqlite3_int64 stmt_t::column<sqlite3_int64>(int i) { return sqlite3_column_int64(get(),i); }
+    template<> double stmt_t::column<double>(int i) { return sqlite3_column_double(get(),i); }
+    template<> std::string stmt_t::column<std::string>(int i) { return (const char*)sqlite3_column_text(get(),i); }
+
+
+    static void sqlite3_deleter(sqlite3* s) { s && sqlite3_close(s); }
+    struct db_t : public shared_ptr<sqlite3> {
+        db_t(const char *f) {
+            sqlite3 *s=0;
+            int c = sqlite3_open(f,&s);
+            reset(s,sqlite3_deleter);
+            worry(c,"failed to sqlite3_open()");
+        }
+
+        void exec(const char *s) {
+            char *e = 0;
+            int c = sqlite3_exec(get(),s,NULL,NULL,&e);
+            if(e) sqlite3_free(e);
+            worry(c,"failed to sqlite3_exec()");
+        }
+
+        stmt_t prepare(const char *s) {
+            sqlite3_stmt *r=0;
+            int c = sqlite3_prepare(get(),s,-1,&r,0);
+            stmt_t rv(r);
+            worry(c,"failed to sqlite3_prepare()");
+            return rv;
+        }
+
+        int changes() { return sqlite3_changes(get()); }
+
+        void worry(int c,const char *m) { if(c!=SQLITE_OK) throw sqlite3_error(get(),m); }
+    };
+
+}
+
+#endif /* __SECLUDE_H */