Query.h

/*
╔══════════════════════════════════════════════════════════════════════════════╗
║                        SIMPLY POWERFUL TOOLKIT (SPTK)                        ║
╟──────────────────────────────────────────────────────────────────────────────╢
║  copyright            © 1999-2022 Alexey Parshin. All rights reserved.       ║
║  email                alexeyp@gmail.com                                      ║
╚══════════════════════════════════════════════════════════════════════════════╝
┌──────────────────────────────────────────────────────────────────────────────┐
│   This library is free software; you can redistribute it and/or modify it    │
│   under the terms of the GNU Library General Public License as published by  │
│   the Free Software Foundation; either version 2 of the License, or (at your │
│   option) any later version.                                                 │
│                                                                              │
│   This library 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 Library   │
│   General Public License for more details.                                   │
│                                                                              │
│   You should have received a copy of the GNU Library General Public License  │
│   along with this library; if not, write to the Free Software Foundation,    │
│   Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.               │
│                                                                              │
│   Please report all bugs and problems to alexeyp@gmail.com.                  │
└──────────────────────────────────────────────────────────────────────────────┘
*/
 
#pragma once
 
#ifdef WIN32
#include <winsock2.h>
 
#include <windows.h>
#endif
 
#include <sptk5/DataSource.h>
 
#include <sptk5/FieldList.h>
#include <sptk5/db/AutoDatabaseConnection.h>
#include <sptk5/db/QueryParameterList.h>
#include <sptk5/threads/Locks.h>
 
namespace sptk {
 
class SP_EXPORT QueryStatementManagement
    : public DataSource
{
public:
    explicit QueryStatementManagement(bool autoPrepare)
        : m_autoPrepare(autoPrepare)
    {
    }
 
    QueryStatementManagement(const QueryStatementManagement& other) = delete;
 
    StmtHandle statement() const
    {
        return m_statement;
    }
 
    bool autoPrepare() const
    {
        return m_autoPrepare;
    }
 
    bool active() const
    {
        return m_active;
    }
 
    bool prepared() const
    {
        return m_prepared;
    }
 
    bool eof() const override
    {
        return m_eof;
    }
 
    bool bulkMode() const;
 
    void connect(PoolDatabaseConnection* db);
 
    void disconnect();
 
    PoolDatabaseConnection* database() const
    {
        return m_db;
    }
 
    void database(PoolDatabaseConnection* db)
    {
        connect(db);
    }
 
protected:
    void setDatabase(PoolDatabaseConnection* db);
 
    void setStatement(StmtHandle statement)
    {
        m_statement = statement;
    }
 
    void setPrepared(bool prepared)
    {
        m_prepared = prepared;
    }
 
    void setActive(bool active)
    {
        m_active = active;
    }
 
    void setEof(bool eof)
    {
        m_eof = eof;
    }
 
    void setBulkMode(bool _bulkMode);
 
    void closeStmt(bool freeStatement = false);
 
    void closeQuery(bool releaseStatement = false);
 
    Strings& messages()
    {
        return m_messages;
    }
 
    String& getSQL()
    {
        return m_sql;
    }
 
    const String& getSQL() const
    {
        return m_sql;
    }
 
    void setSQL(const String& sql)
    {
        m_sql = sql;
    }
 
    [[noreturn]] void notImplemented(const String& functionName) const;
 
private:
    bool m_autoPrepare {true};              
    StmtHandle m_statement {nullptr};       
    bool m_prepared {false};                
    bool m_active {false};                  
    bool m_eof {true};                      
    bool m_bulkMode {false};                
    String m_sql;                           
    Strings m_messages;                     
    PoolDatabaseConnection* m_db {nullptr}; 
};
 
class SP_EXPORT Query
    : public QueryStatementManagement
{
    friend class PoolDatabaseConnection;
 
    friend class PoolDatabaseConnectionQueryMethods;
 
public:
    Query() noexcept;
 
    explicit Query(const DatabaseConnection& db, const String& sql = "", bool autoPrepare = true);
 
    explicit Query(PoolDatabaseConnection* db, const String& sql = "", bool autoPrepare = true);
 
    Query(const Query&) = delete;
 
    Query& operator=(const Query&) = delete;
 
    ~Query() override;
 
    Field& operator[](size_t fieldIndex) override
    {
        return m_fields[(int) fieldIndex];
    }
 
    Field& operator[](const String& fieldName) override
    {
        return m_fields[fieldName];
    }
 
    size_t fieldCount() const override
    {
        return m_fields.size();
    }
 
    [[noreturn]] size_t recordCount() const override
    {
        notImplemented("recordCount");
    }
 
    [[nodiscard]] virtual String sql() const
    {
        return getSQL();
    }
 
    virtual void sql(const String& _sql);
 
    FieldList& fields()
    {
        return m_fields;
    }
 
    QueryParameterList& params()
    {
        return m_params;
    }
 
    bool readField(const char* fname, Variant& value) override;
 
    bool writeField(const char* fname, const Variant& fvalue) override;
 
    bool open() override;
 
    bool close() override
    {
        closeQuery();
        return true;
    }
 
    bool next() override
    {
        fetch();
        return true;
    }
 
    virtual void exec()
    {
        open();
    }
 
    virtual void exec(const String& newSQL)
    {
        sql(newSQL);
        open();
    }
 
    void fetch();
 
    size_t paramCount() const
    {
        return m_params.size();
    }
 
    QueryParameter& param(const char* paramName) const
    {
        return m_params[paramName];
    }
 
    QueryParameter& param(const String& paramName) const
    {
        return m_params[paramName.c_str()];
    }
 
    QueryParameter& param(size_t paramIndex) const
    {
        return m_params[paramIndex];
    }
 
    [[noreturn]] static void throwError(const String& method, const String& error);
 
protected:
    void execute();
 
    bool loadData() override
    {
        return false;
    }
 
    bool saveData() override
    {
        return false;
    }
 
private:
    QueryParameterList m_params;
 
    FieldList m_fields {true};
 
    void sqlParseParameter(const char* paramStart, const char* paramEnd, int& paramNumber, String& sql);
 
    String parseParameters(const String& _sql);
 
    const char* readParamater(String& sql, int& paramNumber, const char* paramStart, const char* paramEnd);
};
 
using SQuery = std::shared_ptr<Query>;
 
#define THROW_QUERY_ERROR(query, error)                                             \
    {                                                                               \
        std::stringstream err;                                                      \
        err << error;                                                               \
        throw sptk::DatabaseException(err.str(), __FILE__, __LINE__, query->sql()); \
    }
 
constexpr int FETCH_BUFFER_SIZE = 1024;
 
} // namespace sptk