PoolDatabaseConnection.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
 
#include <sptk5/Logger.h>
#include <sptk5/Strings.h>
#include <sptk5/Variant.h>
#include <sptk5/db/DatabaseConnectionString.h>
 
#include <list>
#include <set>
#include <vector>
 
namespace sptk {
 
class Query;
 
using DBHandle = uint8_t*;
using StmtHandle = uint8_t*;
using SStmtHandle = std::shared_ptr<uint8_t>;
 
enum class DatabaseConnectionType : uint16_t
{
    UNKNOWN = 0,       
    MYSQL = 1,         
    ORACLE = 2,        
    POSTGRES = 4,      
    SQLITE3 = 8,       
    FIREBIRD = 16,     
    GENERIC_ODBC = 32, 
    MSSQL_ODBC = 64    
};
 
enum class DatabaseObjectType : uint8_t
{
    UNDEFINED,  
    TABLES,     
    VIEWS,      
    PROCEDURES, 
    FUNCTIONS,  
    DATABASES   
};
 
struct QueryColumnTypeSize {
    VariantDataType type; 
    size_t length;        
};
 
using QueryColumnTypeSizeVector = std::vector<QueryColumnTypeSize>;
 
using QueryColumnTypeSizeMap = std::map<std::string, QueryColumnTypeSize, std::less<>>;
 
class SP_EXPORT PoolDatabaseConnectionQueryMethods
{
    friend class Query;
 
    friend class QueryStatementManagement;
 
public:
    virtual ~PoolDatabaseConnectionQueryMethods() = default;
 
protected:
    void querySetStmt(Query* q, SStmtHandle stmt);
 
    static void querySetPrepared(Query* q, bool pf);
 
    static void querySetActive(Query* q, bool af);
 
    static void querySetEof(Query* q, bool eof);
 
    // These methods implement the actions requested by CQuery
    virtual String queryError(const Query* query) const = 0;
 
    virtual void queryAllocStmt(Query* query) = 0;
 
    virtual void queryFreeStmt(Query* query) = 0;
 
    virtual void queryCloseStmt(Query* query) = 0;
 
    virtual void queryPrepare(Query* query) = 0;
 
    virtual void queryExecute(Query* query) = 0;
 
    virtual int queryColCount(Query* query) = 0;
 
    virtual void queryColAttributes(Query* query, int16_t column, int16_t descType, int32_t& value) = 0;
 
    virtual void queryColAttributes(Query* query, int16_t column, int16_t descType, char* buff, int len) = 0;
 
    virtual void queryBindParameters(Query* query) = 0;
 
    virtual void queryOpen(Query* query) = 0;
 
    virtual void queryFetch(Query* query) = 0;
 
    virtual String paramMark(unsigned paramIndex);
 
    [[noreturn]] void notImplemented(const String& methodName) const;
 
    bool linkQuery(Query* q);
 
    bool unlinkQuery(Query* q);
 
    void disconnectAllQueries();
 
private:
    std::map<Query*, SStmtHandle> m_queryList; 
};
 
class SP_EXPORT PoolDatabaseConnection
    : public PoolDatabaseConnectionQueryMethods
{
    friend class Query;
 
    friend class QueryStatementManagement;
 
public:
    void open(const String& connectionString = "");
 
    void close();
 
    virtual bool active() const;
 
    virtual DBHandle handle() const;
 
    const DatabaseConnectionString& connectionString() const
    {
        return m_connString;
    }
 
    void connectionString(const DatabaseConnectionString& connectionString);
 
    virtual String nativeConnectionString() const
    {
        return "";
    }
 
    virtual DatabaseConnectionType connectionType() const
    {
        return m_connType;
    }
 
    virtual String driverDescription() const
    {
        return m_driverDescription;
    }
 
    void beginTransaction();
 
    void commitTransaction();
 
    void rollbackTransaction();
 
    bool inTransaction() const
    {
        return m_inTransaction;
    }
 
    virtual void objectList(DatabaseObjectType objectType, Strings& objects) = 0;
 
    void bulkInsert(const String& tableName, const Strings& columnNames, const std::vector<VariantVector>& data)
    {
        _bulkInsert(tableName, columnNames, data);
    }
 
    void executeBatchFile(const String& batchFileName, Strings* errors = nullptr)
    {
        _executeBatchFile(batchFileName, errors);
    }
 
    void executeBatchSQL(const sptk::Strings& batchSQL, Strings* errors = nullptr)
    {
        _executeBatchSQL(batchSQL, errors);
    }
 
protected:
    bool getInTransaction() const;
 
    void setInTransaction(bool inTransaction);
 
    explicit PoolDatabaseConnection(const String& connectionString, DatabaseConnectionType connectionType, std::chrono::seconds connectTimeout);
 
    PoolDatabaseConnection(const PoolDatabaseConnection&) = delete;
 
    PoolDatabaseConnection(PoolDatabaseConnection&&) noexcept = default;
 
    PoolDatabaseConnection& operator=(const PoolDatabaseConnection&) = delete;
 
    PoolDatabaseConnection& operator=(PoolDatabaseConnection&&) noexcept = default;
 
    ~PoolDatabaseConnection() override;
 
    virtual void _openDatabase(const String& connectionString);
 
    virtual void closeDatabase();
 
    virtual void driverBeginTransaction();
 
    virtual void driverEndTransaction(bool commit);
 
    [[noreturn]] static void logAndThrow(const String& method, const String& error);
 
    virtual void _bulkInsert(const String& tableName, const Strings& columnNames,
                             const std::vector<VariantVector>& data);
 
    virtual void _executeBatchFile(const String& batchFileName, Strings* errors);
 
    virtual void _executeBatchSQL(const sptk::Strings& batchSQL, Strings* errors);
 
    virtual void connectionType(DatabaseConnectionType connType)
    {
        m_connType = connType;
    }
 
    void bulkInsertRecords(const String& tableName, const Strings& columnNames,
                           const std::vector<VariantVector>::const_iterator& begin,
                           const std::vector<VariantVector>::const_iterator& end);
 
    std::chrono::seconds connectTimout() const
    {
        return m_connectionTimeout;
    }
 
private:
    DatabaseConnectionString m_connString;    
    DatabaseConnectionType m_connType;        
    String m_driverDescription;               
    bool m_inTransaction {false};             
    std::chrono::seconds m_connectionTimeout; 
};
 
using SPoolDatabaseConnection = std::shared_ptr<PoolDatabaseConnection>;
 
SP_EXPORT String escapeSQLString(const String& str, bool tsv = false);
 
} // namespace sptk