Statement.h

/* Copyright (C) 2006-2026 by Tommi Maekitalo
   Copyright (C) 2006-2026 by Marc Boris Duerner
   SPDX-License-Identifier: LGPL-2.1-or-later WITH mif-exception
*/
 
#ifndef PT_DB_STATEMENT_H
#define PT_DB_STATEMENT_H
 
#include <Pt/SmartPtr.h>
#include <Pt/Signal.h>
#include <Pt/Date.h>
#include <Pt/Time.h>
#include <Pt/DateTime.h>
#include <Pt/Db/Api.h>
#include <Pt/Db/Cursor.h>
#include <Pt/Db/IStatement.h>
#include <Pt/Db/IConnection.h>
#include <Pt/Db/Row.h>
#include <string>
 
 
namespace Pt {
 
namespace Db {
 
  class Connection;
  class Result;
  class Row;

    class PT_DB_API Statement
    {
        public:
            typedef IStatement::size_type size_type;
 
        private:
            SmartPtr<IStatement, InternalRefCounted<IStatement> > _stmt;
 
        public:
            Statement(IStatement* stmt = 0)
            : _stmt(stmt)
            { }
 
            ~Statement();

            Statement& clear()
            { _stmt->clear(); return *this; }
 

            Statement& setNull(const std::string& col)
            { _stmt->setNull(col); return *this; }

            Statement& set(const std::string& col, bool data)
            { _stmt->setBool(col, data); return *this; }

            Statement& set(const std::string& col, int data)
            { _stmt->setInt(col, data); return *this; }

            Statement& set(const std::string& col, unsigned data)
            { _stmt->setUnsigned(col, data); return *this; }

            Statement& set(const std::string& col, float data)
            { _stmt->setFloat(col, data); return *this; }

            Statement& set(const std::string& col, double data)
            { _stmt->setDouble(col, data); return *this; }

            Statement& set(const std::string& col, char data)
            { _stmt->setChar(col, data); return *this; }

            Statement& set(const std::string& col, const std::string& data)
            { _stmt->setString(col, data); return *this; }

            Statement& set(const std::string& col, const Blob& data)
            { _stmt->setBlob(col, data); return *this; }

            Statement& set(const std::string& col, const char* data)
            { data == 0 ? _stmt->setNull(col)
                            : _stmt->setString(col, data); return *this; }

            Statement& set(const std::string& col, const Date& data)
            { _stmt->setDate(col, data); return *this; }

            Statement& set(const std::string& col, const Time& data)
            { _stmt->setTime(col, data); return *this; }

            Statement& set(const std::string& col, const DateTime& data)
            {
                _stmt->setDatetime(col, data);
                return *this;
            }

            Cursor getCursor(size_type batchSize);

            void cancel();
 
        public:
            size_type execute();

            void beginExecute();

            size_type endExecute();

            Signal<>& executeFinished();

            long long lastInsertId() const;
 
        public:
            Result select();

            Row selectRow();

            Value selectValue();

            void beginSelect();

            Result endSelect();

            Signal<>& selectFinished();
 
        public:
            bool operator!() const
            { return !_stmt; }

            const IStatement* getImpl() const
            { return &*_stmt; }

            IStatement* impl()
            { return _stmt.get(); }
    };
 
} // namespace Db
 
} // namespace Pt
 
#endif // PT_DB_STATEMENT_H