sqlite_wrap.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2020 by the OpenStructure authors
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 3.0 of the License, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//------------------------------------------------------------------------------
#ifndef OST_IO_SQLITE_WRAP_HH
#define OST_IO_SQLITE_WRAP_HH
/*
 Author: Marco Biasini
 
 lightweight sqlite wrapper
*/
#include <ost/message.hh>
#include <boost/shared_ptr.hpp>
 
#include <ost/base.hh>
#include <ost/message.hh>
 
#include <sqlite3.h>
#include "sqlite_conv.hh"
 
namespace ost { namespace db {
 
class Database;
typedef boost::shared_ptr<Database> DatabasePtr;
 
class PreparedStatement;
typedef boost::shared_ptr<PreparedStatement> PreparedStatementPtr;
 
class DLLEXPORT_OST_DB PreparedStatement {
  friend class Database;
public:
  PreparedStatement();
  ~PreparedStatement();
    
  sqlite3_stmt* Handle() 
  {
    return statement_;
  }
  bool Submit()
  {
    return sqlite3_step(statement_)==SQLITE_DONE;
  }
  void BindInt(int col, int value) 
  {
    sqlite3_bind_int(statement_, col, value);
  }
  void BindInt64(int col, sqlite3_int64 value) 
  {
    sqlite3_bind_int64(statement_, col, value);
  }  
  void BindText(int col, const String& text) 
  {
    sqlite3_bind_text(statement_, col, text.c_str(),
                      static_cast<int>(text.size()), NULL);
  }  
  void BindBlob(int col, const char* start, size_t size)
  {
    sqlite3_bind_blob(statement_, col, start, size, NULL);
  }
private:
  sqlite3_stmt* statement_;
};
 
class DLLEXPORT DatabaseError : public Error {
public:
  DatabaseError(const String& msg):
    Error(msg)
  {
    
  }
};
 
template <typename R>
class DLLEXPORT_OST_DB RowSet {
public:
  RowSet(PreparedStatementPtr stmt): 
    stmt_(stmt), value_()
  {
    this->Step();
  }
  RowSet():
    stmt_(), value_(), cur_val_(SQLITE_DONE) 
  { }
  R& operator*() {
    return value_;
  }
  RowSet<R>& operator++() 
  {
    this->Step();
    return *this;
  }
  
  bool AtEnd() 
  {
    return cur_val_!=SQLITE_ROW;
  }
private:
  void Step() 
  {
    cur_val_=sqlite3_step(stmt_->Handle());
    if (cur_val_==SQLITE_ROW) {
      SqlConvert(stmt_->Handle(), value_);
    } 
  }
  PreparedStatementPtr stmt_;
  R                    value_;
  int                  cur_val_;
};
 
class DLLEXPORT_OST_DB Database {
public:
  static DatabasePtr Open(const String& database);
  
  ~Database();
  PreparedStatementPtr Prepare(const String& query);
  
  sqlite3* Handle() 
  {
    return conn_;
  }
  
  sqlite3_int64 LastRowID();
  DatabasePtr Copy(const String& filename);
private:
  sqlite3*     conn_;
};
 
}}
 
#endif