statement.hpp

/*
 * File:   statement.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 STATEMENT_HPP
#define STATEMENT_HPP

#include "result_set.hpp"

namespace vgi { namespace dbconn { namespace dbi {

class connection;

struct istatement
{
    virtual ~istatement() { }
    virtual void prepare(const std::string& sql) = 0;
    virtual void call(const std::string& sql) = 0;
    virtual iresult_set* execute(const std::string& sql, bool cursor = false, bool scrollable = false) = 0;
    virtual iresult_set* execute() = 0;
    virtual bool cancel() = 0;
    virtual int proc_retval() = 0;
    virtual void set_null(size_t col_idx) = 0;
    virtual void set_short(size_t col_idx, int16_t val) = 0;
    virtual void set_ushort(size_t col_idx, uint16_t val) = 0;
    virtual void set_int(size_t col_idx, int32_t val) = 0;
    virtual void set_uint(size_t col_idx, uint32_t val) = 0;
    virtual void set_long(size_t col_idx, int64_t val) = 0;
    virtual void set_ulong(size_t col_idx, uint64_t val) = 0;
    virtual void set_float(size_t col_idx, float val) = 0;
    virtual void set_double(size_t col_idx, double val) = 0;
    virtual void set_bool(size_t col_idx, bool val) = 0;
    virtual void set_char(size_t col_idx, char val) = 0;
    virtual void set_string(size_t col_idx, const std::string& val) = 0;
    virtual void set_date(size_t col_idx, int val) = 0;
    virtual void set_time(size_t col_idx, double val) = 0;
    virtual void set_datetime(size_t col_idx, time_t val) = 0;
    virtual void set_u16char(size_t col_idx, char16_t val) = 0;
    virtual void set_u16string(size_t col_idx, const std::u16string& val) = 0;
    virtual void set_binary(size_t col_idx, const std::vector<uint8_t>& val) = 0;
};


class statement
{
public:
    statement(statement&& stmt) : stmt_impl(std::move(stmt.stmt_impl))
    {
    }

    statement& operator=(statement&& stmt)
    {
        if (this != &stmt)
            stmt_impl = std::move(stmt.stmt_impl);
        return *this;
    }

    void prepare(const std::string& sql)
    {
        stmt_impl->prepare(sql);
    }

    void call(const std::string& proc)
    {
        stmt_impl->call(proc);
    }

    result_set execute()
    {
        return result_set(stmt_impl->execute());
    }

    result_set execute(const std::string& sql, bool cursor = false, bool scrollable = false)
    {
        return result_set(stmt_impl->execute(sql, cursor, scrollable));
    }

    bool cancel()
    {
        return stmt_impl->cancel();
    }
    
    int proc_retval()
    {
        return stmt_impl->proc_retval();
    }
    
    virtual void set_null(size_t col_idx)
    {
        stmt_impl->set_null(col_idx);
    }
    
    virtual void set_short(size_t col_idx, int16_t val)
    {
        stmt_impl->set_short(col_idx, val);
    }
    
    virtual void set_ushort(size_t col_idx, uint16_t val)
    {
        stmt_impl->set_ushort(col_idx, val);
    }
    
    virtual void set_int(size_t col_idx, int32_t val)
    {
        stmt_impl->set_int(col_idx, val);
    }
    
    virtual void set_uint(size_t col_idx, uint32_t val)
    {
        stmt_impl->set_uint(col_idx, val);
    }
    
    virtual void set_long(size_t col_idx, int64_t val)
    {
        stmt_impl->set_long(col_idx, val);
    }
    
    virtual void set_ulong(size_t col_idx, uint64_t val)
    {
        stmt_impl->set_ulong(col_idx, val);
    }
    
    virtual void set_float(size_t col_idx, float val)
    {
        stmt_impl->set_float(col_idx, val);
    }
    
    virtual void set_double(size_t col_idx, double val)
    {
        stmt_impl->set_double(col_idx, val);
    }
    
    virtual void set_bool(size_t col_idx, bool val)
    {
        stmt_impl->set_bool(col_idx, val);
    }
    
    virtual void set_char(size_t col_idx, char val)
    {
        stmt_impl->set_char(col_idx, val);
    }
    
    virtual void set_string(size_t col_idx, const std::string& val)
    {
        stmt_impl->set_string(col_idx, val);
    }
    
    virtual void set_date(size_t col_idx, int val)
    {
        stmt_impl->set_date(col_idx, val);
    }
    
    virtual void set_time(size_t col_idx, double val)
    {
        stmt_impl->set_time(col_idx, val);
    }
    
    virtual void set_datetime(size_t col_idx, time_t val)
    {
        stmt_impl->set_datetime(col_idx, val);
    }
    
    virtual void set_u16char(size_t col_idx, char16_t val)
    {
        stmt_impl->set_u16char(col_idx, val);
    }
    
    virtual void set_u16string(size_t col_idx, const std::u16string& val)
    {
        stmt_impl->set_u16string(col_idx, val);
    }
    
    virtual void set_binary(size_t col_idx, const std::vector<uint8_t>& val)
    {
        stmt_impl->set_binary(col_idx, val);
    }
    
private:
    friend class connection;
    statement(istatement* stmt) : stmt_impl(stmt) { }
    statement(const statement&) = delete;
    statement& operator=(const statement&) = delete;

private:
    std::unique_ptr<istatement> stmt_impl;

}; // statement

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

#endif // STATEMENT_HPP