RowOperations.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_ROW_OPERATIONS_H
#define __SSRC_WSPR_DATABASE_ROW_OPERATIONS_H

#include <ssrc/wispers/database/Database.h>
#include <ssrc/wisp/utility/wisp_import.h>

#include <boost/integer_traits.hpp>

__BEGIN_NS_SSRC_WSPR_DATABASE

namespace detail {
  template<typename T, bool is_basic> struct FindRow;

  template<typename T>
  struct FindRow<T, true> {
    template<typename... P>
    static std::pair<bool, T> exec(PreparedStatement & query, P && ...p) {
      QueryResult && result = query.execute(std::forward<P>(p)...);

      if(result.result_set) {
        std::pair<bool, T> value(true, result.result_set->value<T>());
        query.reset();
        return value;
      }

      return std::pair<bool, T>(false, T());
    }
  };

  template<typename T>
  struct FindRow<T, false> {
    template<typename... P>
    static std::pair<bool, T> exec(PreparedStatement & query, P && ...p) {
      QueryResult && result = query.execute(std::forward<P>(p)...);

      if(result.result_set) {
        std::pair<bool, T> value(true, *result.result_set);
        query.reset();
        return value;
      }

      return std::pair<bool, T>(false, T());
    }
  };
}

// Convenience function for implementing single object lookups.
template<typename T, typename... P>
inline std::pair<bool, T> find_row(PreparedStatement & query, P && ...p)
  SSRC_DECL_THROW(DatabaseException)
{
  return detail::FindRow<T, detail::is_basic_type<T>::value>::exec(query, std::forward<P>(p)...);
}

struct DefaultValueBinder {
  typedef PreparedStatement binder_type;

  static binder_type & binder(PreparedStatement & statement) {
    return statement;
  }
};

struct DefaultValueLoader {
  template<typename T>
  const DefaultValueLoader &
  load(const ResultSet & result, const unsigned int index, T & value) const {
    value = std::move(result.value<typename detail::ResultSetValueTraits<T, detail::is_basic_type<T>::value>::db_value_type>(index));
    return *this;
  }

private:
  template<const unsigned int index, typename T, typename... P>
  const DefaultValueLoader & _loadp(const ResultSet & result,  T & value) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return load(result, index, value);
  }

  template<const unsigned int index, typename T, typename... P>
  const DefaultValueLoader & _loadp(const ResultSet & result,  T & value, P & ...p) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return load(result, index, value)._loadp<index + 1>(result, p...);
  }

public:
  template<typename... P>
  const DefaultValueLoader & loadp(const ResultSet & result,  P & ...p) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _loadp<0>(result, p...);
  }

  template<const unsigned int index, typename... P>
  const DefaultValueLoader & loadp(const ResultSet & result,  P & ...p) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _loadp<index>(result, p...);
  }
};

namespace detail {
  template<typename row_type, unsigned int i>
  struct PrimaryKeyCond {
    static inline std::ostream & apply(std::ostream & query) {
      return (PrimaryKeyCond<row_type, i-1>::apply(query) << " AND `" << row_type::template column_name<row_type::template Key<i>::column>() << "` = ?");
    }
  };

  template<typename row_type>
  struct PrimaryKeyCond<row_type, 0> {
    static inline std::ostream & apply(std::ostream & query) {
      return
        (query << "`" << row_type::template column_name<row_type::template Key<0>::column>() << "` = ?");
    }
  };
}

template<typename Row, typename ValueBinder = DefaultValueBinder,
         typename ValueLoader = DefaultValueLoader>
struct RowOperationsReadOnly {
  typedef Row row_type;
  typedef std::pair<bool, row_type> find_result_type;
  typedef ValueBinder binder_type;
  typedef ValueLoader loader_type;

  static const bool ImplicitColumns = false;
  static const bool ExplicitColumns = true;

  prepared_statement_ptr find_statement, exists_statement;
  binder_type binder;
  loader_type loader;

protected:

  static string select_columns_expression(bool explicit_columns) {
    std::ostringstream query;

    if(explicit_columns) {
      query << '`' << row_type::column_name(0) << '`';
      for(unsigned int i = 1; i < row_type::ElementCount; ++i)
        query << ",`" << row_type::column_name(i) << '`';
      return query.str();
    } else {
      return string("*");
    }
  }

public:
  RowOperationsReadOnly(Database & db,
                        const binder_type & binder = DefaultValueBinder(),
                        const loader_type & loader = DefaultValueLoader(),
                        const bool explicit_columns = ImplicitColumns,
                        const string & table_name = row_type::table_name()) :
    binder(binder), loader(loader)
  {
    using detail::PrimaryKeyCond;

    std::ostringstream query;
    string && select_columns = select_columns_expression(explicit_columns);

    query << "SELECT " << select_columns << " FROM `"
          << table_name << "` WHERE ";
    PrimaryKeyCond<row_type, row_type::PrimaryKeyCount - 1>::apply(query);

    find_statement = db.prepare(query.str());

    query.str("");
    query << "SELECT count(1) FROM `" << table_name << "` WHERE ";
    PrimaryKeyCond<row_type, row_type::PrimaryKeyCount - 1>::apply(query);
    exists_statement = db.prepare(query.str());
  }

  bool exists(const typename row_type::primary_key_type & key)
    SSRC_DECL_THROW(DatabaseException)
  {
    row_type::bind_primary_key(binder.binder(*exists_statement), key);
    unsigned int result = exists_statement->execute().result_set->value<unsigned int>();
    exists_statement->reset();
    return (result != 0);
  }

  bool exists(const row_type & row) SSRC_DECL_THROW(DatabaseException) {
    row.bind_primary_key(binder.binder(*exists_statement));
    unsigned int result = exists_statement->execute().result_set->value<unsigned int>();
    exists_statement->reset();
    return (result != 0);
  }

  template<typename... P> 
  bool exists(const P & ...p) SSRC_DECL_THROW(DatabaseException) {
    unsigned int result =
      exists_statement->execute(p...).result_set->value<unsigned int>();
    exists_statement->reset();
    return (result != 0);
  }

  find_result_type find(const typename row_type::primary_key_type & key)
    SSRC_DECL_THROW(DatabaseException)
  {
    row_type::bind_primary_key(binder.binder(*find_statement), key);
    QueryResult && result = find_statement->execute();

    if(result.result_set) {
      find_result_type value(true, *result.result_set);
      find_statement->reset();
      return value;
    }

    return find_result_type(false, row_type());
  }

  find_result_type find(const row_type & row) SSRC_DECL_THROW(DatabaseException) {
    row.bind_primary_key(binder.binder(*find_statement));
    QueryResult && result = find_statement->execute();

    if(result.result_set) {
      find_result_type value(true, *result.result_set);
      find_statement->reset();
      return value;
    }

    return find_result_type(false, row_type());
  }

  bool find(const typename row_type::primary_key_type & key,
            row_type & result_row)
    SSRC_DECL_THROW(DatabaseException)
  {
    row_type::bind_primary_key(binder.binder(*find_statement), key);
    QueryResult && result = find_statement->execute();

    if(result.result_set) {
      result_row.load_row(*result.result_set, loader);
      find_statement->reset();
      return true;
    }

    return false;
  }

  bool find(const row_type & row, row_type & result_row)
    SSRC_DECL_THROW(DatabaseException)
  {
    row.bind_primary_key(binder.binder(*find_statement));
    QueryResult && result = find_statement->execute();

    if(result.result_set) {
      result_row.load_row(*result.result_set, loader);
      find_statement->reset();
      return true;
    }

    return false;
  }

  template<typename... P> 
  find_result_type find(const P & ...p) SSRC_DECL_THROW(DatabaseException) {
    QueryResult && result = find_statement->execute(p...);

    if(result.result_set) {
      find_result_type value(true, *result.result_set);
      find_statement->reset();
      return value;
    }

    return find_result_type(false, row_type());
  }

};

template<typename Row, typename ValueBinder = DefaultValueBinder,
         typename ValueLoader = DefaultValueLoader>
struct RowOperations :
  public RowOperationsReadOnly<Row, ValueBinder, ValueLoader>
{
  typedef RowOperationsReadOnly<Row, ValueBinder, ValueLoader> super;

  WISP_IMPORT_T(super, row_type);
  WISP_IMPORT_T(super, find_result_type);
  WISP_IMPORT_T(super, binder_type);
  WISP_IMPORT_T(super, loader_type);

  prepared_statement_ptr insert_statement, save_statement, erase_statement;

public:
  RowOperations(Database & db,
                const binder_type & binder = DefaultValueBinder(),
                const loader_type & loader = DefaultValueLoader(),
                const bool explicit_columns = super::ImplicitColumns,
                const string & table_name = row_type::table_name()) :
    super(db, binder, loader, explicit_columns, table_name)
  {
    using detail::PrimaryKeyCond;

    std::ostringstream query;
    string insert_columns(" ");
    string && select_columns =
      super::select_columns_expression(explicit_columns);

    if(explicit_columns) {
      insert_columns.append("(").append(select_columns).append(")");
    }

    query << "INSERT OR IGNORE INTO `" << table_name << "`"
          << insert_columns << "VALUES(?";

    for(unsigned int i = 1; i < row_type::ElementCount; ++i)
      query << ",?";
    query << ")";

    insert_statement = db.prepare(query.str());

    query.str("");
    query << "INSERT OR REPLACE INTO `" << table_name
          << "`" << insert_columns << "VALUES(?";

    for(unsigned int i = 1; i < row_type::ElementCount; ++i)
      query << ",?";
    query << ")";

    save_statement = db.prepare(query.str());

    query.str("");
    query << "DELETE FROM `" << table_name << "` WHERE ";
    PrimaryKeyCond<row_type, row_type::PrimaryKeyCount - 1>::apply(query);

    erase_statement = db.prepare(query.str());
  }

  bool insert(const row_type & row) SSRC_DECL_THROW(DatabaseException) {
    row.bind_row(super::binder.binder(*insert_statement));
    return (insert_statement->execute().changes > 0);
  }

  template<typename iterator_type>
  unsigned int insert(const iterator_type & begin, const iterator_type & end)
    SSRC_DECL_THROW(DatabaseException)
  {
    unsigned int total = 0;
    for(iterator_type it = begin; it !=end; ++it) {
      if(insert(*it))
        ++total;
    }
    return total;
  }

  bool save(const row_type & row) SSRC_DECL_THROW(DatabaseException) {
    row.bind_row(super::binder.binder(*save_statement));
    return (save_statement->execute().changes > 0);
  }

  template<typename iterator_type>
  unsigned int save(const iterator_type & begin, const iterator_type & end)
    SSRC_DECL_THROW(DatabaseException)
  {
    unsigned int total = 0;
    for(iterator_type it = begin; it !=end; ++it) {
      if(save(*it))
        ++total;
    }
    return total;
  }

  unsigned int erase(const typename row_type::primary_key_type & key)
    SSRC_DECL_THROW(DatabaseException)
  {
    row_type::bind_primary_key(super::binder.binder(*erase_statement), key);
    return erase_statement->execute().changes;
  }

  unsigned int erase(const row_type & row) SSRC_DECL_THROW(DatabaseException) {
    row.bind_primary_key(super::binder.binder(*erase_statement));
    return erase_statement->execute().changes;
  }

  template<typename iterator_type>
  unsigned int
  erase_range(const iterator_type & begin, const iterator_type & end)
    SSRC_DECL_THROW(DatabaseException)
  {
    unsigned int total = 0;
    for(iterator_type it = begin; it !=end; ++it) {
      total+=erase(*it);
    }
    return total;
  }

  template<typename... P> 
  unsigned int erase(const P & ...p) SSRC_DECL_THROW(DatabaseException) {
    return erase_statement->execute(p...).changes;
  }
};

// Utility functions for commonly recurring cases.
template<typename value_type, typename... P>
inline value_type find_value(const prepared_statement_ptr & query,
                             const value_type & default_value,
                             P && ...p)
{
  std::pair<bool, value_type> && result =
    find_row<value_type>(*query, std::forward<P>(p)...);
  return (result.first ? result.second : default_value);
}

template<typename value_type, typename... P>
inline value_type max_id(const prepared_statement_ptr & max_query, P && ...p) {
  return find_value<value_type>(max_query,
                                boost::integer_traits<value_type>::const_min,
                                std::forward<P>(p)...);
}

__END_NS_SSRC_WSPR_DATABASE

#endif