resultset.hpp

// Copyright (c) 2022 Klemens D. Morgenstern
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_SQLITE_RESULTSET_HPP
#define BOOST_SQLITE_RESULTSET_HPP
 
#include <memory>
#include <boost/sqlite/row.hpp>
#include <boost/describe/members.hpp>
 
#include <boost/system/result.hpp>
 
BOOST_SQLITE_BEGIN_NAMESPACE
struct connection ;
struct resultset
{
    row current() const &
    {
        row r;
        r.stm_ = impl_.get();
        return r;
    }
    bool done() const {return done_;}
 
    BOOST_SQLITE_DECL bool read_next(system::error_code & ec, error_info & ei);
    BOOST_SQLITE_DECL bool read_next();
 
    std::size_t column_count() const
    {
      return sqlite3_column_count(impl_.get());
    }
    core::string_view column_name(std::size_t idx) const
    {
      return sqlite3_column_name(impl_.get(), idx);
    }
    core::string_view table_name(std::size_t idx) const
    {
      return sqlite3_column_table_name(impl_.get(), idx);
    }
    core::string_view column_origin_name(std::size_t idx) const
    {
      return sqlite3_column_origin_name(impl_.get(), idx);
    }
 
    struct iterator
    {
      using value_type = value;
      using difference_type   = int;
      using reference         = value&;
      using iterator_category = std::forward_iterator_tag;
 
      iterator() {}
      explicit iterator(sqlite3_stmt * stmt, bool sentinel) : sentinel_(sentinel )
      {
        row_.stm_ = stmt;
      }
 
      bool operator!=(iterator rhs) const
      {
        return sentinel_ != rhs.sentinel_;
      }
 
      row &operator*()  { return row_; }
      row *operator->() { return &row_; }
 
      BOOST_SQLITE_DECL
      iterator operator++();
 
      iterator operator++(int)
      {
        auto l = *this;
        ++(*this);
        return l;
      }
 
     private:
      row row_;
      bool sentinel_ = true;
    };
 
    iterator begin() { return iterator(impl_.get(), done_);}
    iterator   end() { return iterator(impl_.get(), true); }
 
  private:
    friend struct connection;
    friend struct statement;
 
    struct deleter_
    {
        constexpr deleter_() noexcept {}
        bool delete_ = true;
        void operator()(sqlite3_stmt * sm)
        {
            if (sqlite3_data_count(sm) > 0)
              while ( sqlite3_step(sm) == SQLITE_ROW);
            if (delete_)
                sqlite3_finalize(sm);
            else
            {
                sqlite3_clear_bindings(sm);
                sqlite3_reset(sm);
            }
 
        }
    };
    std::unique_ptr<sqlite3_stmt, deleter_> impl_;
    bool done_ = false;
};
 
BOOST_SQLITE_END_NAMESPACE
 
 
#endif //BOOST_SQLITE_RESULTSET_HPP