Database.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WSPR_DATABASE_DATABASE_H
#define __SSRC_WSPR_DATABASE_DATABASE_H

#include <ssrc/wispers/database/types.h>
#include <sstream>
#include <cstring>

// TODO: Add support for handling SQLITE_BUSY.  Currently we throw!
__BEGIN_NS_SSRC_WSPR_DATABASE

struct QueryResult {
  unsigned int changes;
  result_set_ptr result_set;

  explicit QueryResult(const unsigned int changes = 0) :
    changes(changes), result_set()
  { }

  explicit QueryResult(const result_set_ptr & result_set) :
    changes(0), result_set(result_set)
  { }
};

// Forward declaration;

class PreparedStatement {
  friend class Database;

  sqlite3_stmt_ptr _statement;

  PreparedStatement(sqlite3_ptr & db, const string & statement) :
    _statement(detail::sqlite3_stmt_initializer(db, statement),
               detail::sqlite3_stmt_init())
  {
    if(_statement.init_error())
      throw DatabaseException(_statement);
  }

public:

  enum BindPolicy { BindTransient, BindStatic };

  bool expired() {
    return SQLite3::sqlite3_expired(_statement.get());
  }

  unsigned int count_parameters() {
    return SQLite3::sqlite3_bind_parameter_count(_statement.get());
  }

  PreparedStatement & bind(const unsigned int index, const double value)
    SSRC_DECL_THROW(DatabaseException)
  {
    if(SQLite3::sqlite3_bind_double(_statement.get(), index, value)
       != SQLITE_OK)
      throw DatabaseException(_statement);
    return *this;
  }

  PreparedStatement & bind(const unsigned int index, const int value)
    SSRC_DECL_THROW(DatabaseException)
  {
    if(SQLite3::sqlite3_bind_int(_statement.get(), index, value) != SQLITE_OK)
      throw DatabaseException(_statement);
    return *this;
  }

  PreparedStatement & bind(const unsigned int index, const unsigned int value)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind(index, static_cast<int>(value));
  }

  PreparedStatement & bind(const unsigned int index, const std::int16_t value)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind(index, static_cast<int>(value));
  }

  PreparedStatement & bind(const unsigned int index, const std::uint16_t value)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind(index, static_cast<int>(value));
  }

  PreparedStatement & bind(const unsigned int index, const bool value)
    SSRC_DECL_THROW(DatabaseException)
  {
    if(SQLite3::sqlite3_bind_int(_statement.get(), index, value) != SQLITE_OK)
      throw DatabaseException(_statement);
    return *this;
  }

  PreparedStatement & bind(const unsigned int index, const std::int64_t value)
    SSRC_DECL_THROW(DatabaseException)
  {
    if(SQLite3::sqlite3_bind_int64(_statement.get(), index, value)
       != SQLITE_OK)
      throw DatabaseException(_statement);
    return *this;
  }

  PreparedStatement & bind(const unsigned int index, const std::uint64_t value)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind(index, static_cast<std::int64_t>(value));
  }

#if (LONG_MAX == INT_MAX)
  PreparedStatement & bind(const unsigned int index, const long value)
    SSRC_DECL_THROW(DatabaseException)
  {
    if(SQLite3::sqlite3_bind_int64(_statement.get(), index, value)
       != SQLITE_OK)
      throw DatabaseException(_statement);
    return *this;
  }

  PreparedStatement & bind(const unsigned int index, const unsigned long value)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind(index, static_cast<long>(value));
  }
#endif

  PreparedStatement & bind(const unsigned int index, const char * const value,
                           const unsigned int bytes,
                           const BindPolicy policy = BindTransient)
    SSRC_DECL_THROW(DatabaseException)
  {
    if(SQLite3::sqlite3_bind_text(_statement.get(), index, value,
                                  bytes,
                                  (policy == BindTransient ?
                                   SQLITE_TRANSIENT : SQLITE_STATIC)))
      throw DatabaseException(_statement);
    return *this;
  }

  PreparedStatement & bind(const unsigned int index, const char * const value,
                           const BindPolicy policy = BindTransient)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind(index, value, std::strlen(value), policy);
  }

  PreparedStatement & bind(const unsigned int index, const string & value,
                           const BindPolicy policy = BindTransient)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind(index, value.c_str(), value.size(), policy);
  }

  PreparedStatement & bind(const unsigned int index, const void *value,
                           const unsigned int bytes,
                           const BindPolicy policy = BindTransient)
    SSRC_DECL_THROW(DatabaseException)
  {
    if(SQLite3::sqlite3_bind_blob(_statement.get(), index, value, bytes,
                                  (policy == BindTransient ?
                                   SQLITE_TRANSIENT : SQLITE_STATIC)))
      throw DatabaseException(_statement);
    return *this;
  }

  PreparedStatement & bind(const unsigned int index, const blob_type & blob,
                           const BindPolicy policy = BindTransient)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind(index, blob.first, blob.second, policy);
  }

  /*
   * We allow client code to implement custom bind functions
   * by defining a function called bind_column with the following
   * signature:
   * PreparedStatement & bind_column(PreparedStatement & statement,
   *                                 const unsigned int index,
   *                                 const T & t);
   */
  template<typename T>
  PreparedStatement & bind(const unsigned int index, const T & t)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind_column(*this, index, t);
  }

  PreparedStatement & unbind(const unsigned int index)
    SSRC_DECL_THROW(DatabaseException)
  {
    if(SQLite3::sqlite3_bind_null(_statement.get(), index) != SQLITE_OK)
      throw DatabaseException(_statement);
    return *this;
  }

  PreparedStatement & unbind() SSRC_DECL_THROW(DatabaseException) {
    if(SQLite3::sqlite3_clear_bindings(_statement.get()) != SQLITE_OK)
      throw DatabaseException(_statement);
    return *this;
  }

  void reset() SSRC_DECL_THROW(DatabaseException) {
    if(SQLite3::sqlite3_reset(_statement.get()) != SQLITE_OK)
      throw DatabaseException(_statement);
  }

  QueryResult execute() SSRC_DECL_THROW(DatabaseException) {
    int result;

    result = detail::step(_statement);

    if(result == SQLITE_DONE) {
      return
        QueryResult(SQLite3::sqlite3_changes(SQLite3::sqlite3_db_handle(_statement.get())));
    }

    if(result != SQLITE_ROW)
      throw DatabaseException(_statement);

    return QueryResult(result_set_ptr(new ResultSet(_statement)));
  }

  template<typename functor>
  unsigned int for_each(const functor & apply) SSRC_DECL_THROW(DatabaseException) {
    QueryResult && result = execute();

    if(result.result_set)
      return result.result_set->for_each(apply);

    return 0;
  }

  // TODO: Move to ResultSetMetaData?  Add other metadata functions.
  unsigned int count_columns() {
    return SQLite3::sqlite3_column_count(_statement.get());
  }

  string column_name(const unsigned int index) {
    const char *name = SQLite3::sqlite3_column_name(_statement.get(), index);

    return (name ? name : string());
  }

private:

  /* _bindp is a support function for compile-time expansion of bind
     sequence required by bindp.  It has the effect of producing
     bind(1,p1).bind(2,p2).bind(3,p3) ...
   */

  template<const unsigned int index, typename T>
  PreparedStatement & _bindp(const T & t)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind(index, t);
  }

  template<const unsigned int index, typename T, typename... P>
  PreparedStatement &
  _bindp(const T & t, const P & ...p)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bind(index, t)._bindp<index + 1>(p...);
  }

public:

  template<typename... P>
  PreparedStatement &  bindp(const P & ...p) SSRC_DECL_THROW(DatabaseException) {
    return _bindp<1>(p...);
  }

  template<typename... P>
  QueryResult execute(const P & ...p) SSRC_DECL_THROW(DatabaseException) {
    return bindp(p...).execute();
  }

  template<typename... P, typename functor>
  unsigned int for_each(const functor & apply, const P & ...p)
    SSRC_DECL_THROW(DatabaseException)
  {
    return bindp(p...).for_each(apply);
  }
};

typedef SSRC_UNIQUE_PTR<PreparedStatement> prepared_statement_ptr;

class Database {

  sqlite3_ptr _database;
  prepared_statement_ptr _begin_transaction;
  prepared_statement_ptr _rollback_transaction;
  prepared_statement_ptr _end_transaction;

public:

  explicit
  Database(const string & db_name = ":memory:") SSRC_DECL_THROW(DatabaseException) :
    _database(db_name)
  {
    if(_database.init_error())
      throw DatabaseException("database init error");

    _begin_transaction    = prepare("BEGIN");
    _rollback_transaction = prepare("ROLLBACK");
    _end_transaction      = prepare("END");
  }

  prepared_statement_ptr prepare(const string & statement)
    SSRC_DECL_THROW(DatabaseException)
  {
    return prepared_statement_ptr(new PreparedStatement(_database, statement));
  }

  void execute(const string & statement)
    SSRC_DECL_THROW(DatabaseException)
  {
    char *err = 0;

    if(SQLite3::sqlite3_exec(_database.get(), statement.c_str(), 0, 0, &err)
       != SQLITE_OK && err != 0)
    {
      string error(err);
      SQLite3::sqlite3_free(err);
      throw DatabaseException(error);
    }
  }

  bool auto_commit() {
    return SQLite3::sqlite3_get_autocommit(_database.get());
  }

  void begin_transaction() SSRC_DECL_THROW(DatabaseException) {
    _begin_transaction->execute();
  }

  void rollback_transaction() SSRC_DECL_THROW(DatabaseException) {
    _rollback_transaction->execute();
  }

  void end_transaction() SSRC_DECL_THROW(DatabaseException) {
    _end_transaction->execute();
  }
};

__END_NS_SSRC_WSPR_DATABASE

#endif