result_set.hpp

/*
 * File:   result_set.hpp
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef RESULT_SET_HPP
#define RESULT_SET_HPP

#include "utilities.hpp"

namespace vgi { namespace dbconn { namespace dbi {

class statement;

struct iresult_set
{
    // c++11 uses 'move' for return of std::string and std::vector and thus efficient
    virtual ~iresult_set() { }
    virtual bool has_data() = 0;
    virtual bool more_results() = 0;
    virtual size_t row_count() const = 0;
    virtual size_t rows_affected() const = 0;
    virtual size_t column_count() const = 0;
    virtual bool next() = 0;
    virtual bool prev() = 0;
    virtual bool first() = 0;
    virtual bool last() = 0;
    virtual std::string column_name(size_t col_idx) = 0;
    virtual int column_index(const std::string& col_name) = 0;
    virtual bool is_null(size_t col_idx) = 0;
    virtual int16_t get_short(size_t col_idx) = 0;
    virtual uint16_t get_ushort(size_t col_idx) = 0;
    virtual int32_t get_int(size_t col_idx) = 0;
    virtual uint32_t get_uint(size_t col_idx) = 0;
    virtual int64_t get_long(size_t col_idx) = 0;
    virtual uint64_t get_ulong(size_t col_idx) = 0;
    virtual float get_float(size_t col_idx) = 0;
    virtual double get_double(size_t col_idx) = 0;
    virtual bool get_bool(size_t col_idx) = 0;
    virtual char get_char(size_t col_idx) = 0;
    virtual std::string get_string(size_t col_idx) = 0;
    virtual int get_date(size_t col_idx) = 0;
    virtual double get_time(size_t col_idx) = 0;
    virtual time_t get_datetime(size_t col_idx) = 0;
    virtual char16_t get_u16char(size_t col_idx) = 0;
    virtual std::u16string get_u16string(size_t col_idx) = 0;
    virtual std::vector<uint8_t> get_binary(size_t col_idx) = 0;
};


class result_set
{
public:
    result_set(const result_set& rs) : rs_impl(rs.rs_impl)
    {
    }

    result_set(result_set&& rs) : rs_impl(std::move(rs.rs_impl))
    {
    }

    result_set& operator=(const result_set& rs)
    {
        if (this != &rs)
            rs_impl = rs.rs_impl;
        return *this;
    }

    result_set& operator=(result_set&& rs)
    {
        if (this != &rs)
            rs_impl = std::move(rs.rs_impl);
        return *this;
    }

    bool has_data()
    {
        return rs_impl->has_data();
    }

    bool more_results()
    {
        return rs_impl->more_results();
    }

    size_t row_count() const
    {
        return rs_impl->row_count();
    }

    size_t rows_affected() const
    {
        return rs_impl->rows_affected();
    }

    size_t column_count() const
    {
        return rs_impl->column_count();
    }

    const std::string column_name(size_t col_idx)
    {
        return std::move(rs_impl->column_name(col_idx));
    }

    int column_index(const std::string& col_name)
    {
        return rs_impl->column_index(col_name);
    }

    bool next()
    {
        return rs_impl->next();
    }

    bool prev()
    {
        return rs_impl->prev();
    }

    bool first()
    {
        return rs_impl->first();
    }

    bool last()
    {
        return rs_impl->last();
    }

    bool is_null(size_t col_idx)
    {
        return rs_impl->is_null(col_idx);
    }

    bool is_null(const std::string& colname)
    {
        return rs_impl->is_null(rs_impl->column_index(colname));
    }

#define get_type_by_index(t) get_##t(size_t col_idx) { return rs_impl->get_##t(col_idx); }
#define get_type_by_name(t)  get_##t(const std::string& colname) { return rs_impl->get_##t(rs_impl->column_index(colname)); }

    int16_t get_type_by_index(short);
    int16_t get_type_by_name(short);
    uint16_t get_type_by_index(ushort);
    uint16_t get_type_by_name(ushort);
    int32_t get_type_by_index(int);
    int32_t get_type_by_name(int);
    uint32_t get_type_by_index(uint);
    uint32_t get_type_by_name(uint);
    int64_t get_type_by_index(long);
    int64_t get_type_by_name(long);
    uint64_t get_type_by_index(ulong);
    uint64_t get_type_by_name(ulong);
    float get_type_by_index(float);
    float get_type_by_name(float);
    double get_type_by_index(double);
    double get_type_by_name(double);
    bool get_type_by_index(bool);
    bool get_type_by_name(bool);
    char get_type_by_index(char);
    char get_type_by_name(char);
    std::string get_type_by_index(string);
    std::string get_type_by_name(string);
    int get_type_by_index(date);
    int get_type_by_name(date);
    double get_type_by_index(time);
    double get_type_by_name(time);
    time_t get_type_by_index(datetime);
    time_t get_type_by_name(datetime);
    char16_t get_type_by_index(u16char);
    char16_t get_type_by_name(u16char);
    std::u16string get_type_by_index(u16string);
    std::u16string get_type_by_name(u16string);
    std::vector<uint8_t> get_type_by_index(binary);
    std::vector<uint8_t> get_type_by_name(binary);


private:
    friend class statement;
    result_set(iresult_set* rs) : rs_impl(rs) { }

private:
    iresult_set* rs_impl;

}; // result_set

} } } // namespace vgi::dbconn::dbi

#endif // RESULT_SET_HPP