cSQLCmd.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cSQLCmd_H
#define _INC_cSQLCmd_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cSQLConfig.h"
#include "../Variant/cVariant.h"
#include "../Variant/cVarMap.h"
#include "GrayCore/include/cArray.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cVarMap;
 
        enum SQLCMD_TYPE
        {
 
                SQLCMD_SProc = 0,       
                SQLCMD_Create,          
                SQLCMD_Drop,            
                SQLCMD_Select,          
                SQLCMD_Delete,          
                SQLCMD_Insert,          
                SQLCMD_Update,          
        };
 
        class GRAYLIB_LINK cSQLCmd
        {
 
        public:
                static const char* k_pszNULL; // = "NULL";
 
        protected:
                cStringA m_sTable;              
                cStringA m_sCommand;    
 
        public:
                cSQLCmd(cStringA sTableName = "", cStringA sCommand = "");
                virtual ~cSQLCmd();
 
                virtual SQLCMD_TYPE get_CmdType() const = 0;
                virtual bool isResultsExpected() const
                {
                        return false;
                }
 
                cStringA get_Table() const
                {
                        return m_sTable;
                }
                void put_Table(cStringA sTable)
                {
                        ResetCommand0();        // m_sCommand must be rebuilt after this.
                        m_sTable = sTable;
                }
 
                bool isCommandMade() const
                {
                        return ! m_sCommand.IsEmpty();
                }
                cStringA get_Command() const
                {
                        return m_sCommand;
                }
                void put_Command(cStringA sCommand)
                {
                        m_sCommand = sCommand;
                }
                void ResetCommand0()
                {
                        m_sCommand = "";        // just this must be rebuilt.
                }
                virtual void ResetCommand();
                virtual void MakeCommand(const cSQLConfigCmd& cfg) = 0; 
 
                static bool GRAYCALL IsValueTime(const char* pszVal);
                static cStringA GRAYCALL MakeValueTime(const cSQLConfigCmd& cfg, const cTimeDouble& date);
                static cStringA GRAYCALL MakeValueStr(const cSQLConfigCmd& cfg, const cVariant& vVal);
        };
 
        enum SQL_COMPARE_TYPE
        {
                SQL_COMPARE_Equals,
                SQL_COMPARE_GreaterThan,        // > -- greater than
                SQL_COMPARE_LessThan,           // < -- less than
                SQL_COMPARE_GreaterThanE,       // >= -- greater than or equal to
                SQL_COMPARE_LessThanE,          // <= -- less than or equal to
                SQL_COMPARE_NotEqual,           // <> -- not equal to
                SQL_COMPARE_Like,                       // wildcard string matching.
                SQL_COMPARE_IS_NULL,
                SQL_COMPARE_IS_NOT_NULL,
                SQL_COMPARE_QTY,
        };
 
        class GRAYLIB_LINK cSQLCmdWhere
        {
 
        public:
                static const char* const k_SQLCompares[SQL_COMPARE_QTY];
                static const char* const k_Param; // = "?";             // Place holder for param. For late rendering based on driver used.
 
        private:
                cStringA m_sWhere;                              
                cArrayStruct<cVariant> m_aParams;       
 
        public:
                cSQLCmdWhere();
 
                void SetWhereParenthesis();
 
                void AddWhereCmd(const char* pszWhereCmd, bool bUseOr = false);
                void AddWhereV(const char* pszColumnName, const char* pszValue = nullptr, SQL_COMPARE_TYPE eCmp = SQL_COMPARE_IS_NULL, bool bUseOr = false);
 
                void AddWhereInt(const char* pszColumnName, int value, SQL_COMPARE_TYPE eCmp = SQL_COMPARE_Equals, bool bUseOr = false);
                void AddWhereUInt(const char* pszColumnName, UINT value, SQL_COMPARE_TYPE eCmp = SQL_COMPARE_Equals, bool bUseOr = false);
                void AddWhereDouble(const char* pszColumnName, double value, SQL_COMPARE_TYPE eCmp = SQL_COMPARE_Equals, bool bUseOr = false);
                void AddWhereTime(const char* pszColumnName, const cTimeDouble& date, SQL_COMPARE_TYPE eCmp = SQL_COMPARE_Equals, bool bUseOr = false);
                void AddWhereStr(const char* pszColumnName, const char* pszValue, SQL_COMPARE_TYPE eCmp = SQL_COMPARE_Equals, bool bUseOr = false);
 
                cStringA MakeCommandWhere(const cSQLConfigCmd& cmd, bool bIncludeWhereLiteral = true);
                void ResetCommandWhere();
        };
 
        class GRAYLIB_LINK cSQLCmdCreate : public cSQLCmd
        {
 
                typedef cSQLCmd SUPER_t;
 
        private:
                cArrayStruct<cSQLColumnInfo> m_aColumnInfo;
 
        public:
                cSQLCmdCreate(cStringA sTableName);
                virtual ~cSQLCmdCreate();
 
                virtual SQLCMD_TYPE get_CmdType() const override { return SQLCMD_Create; }
 
                void AddColumnInfo(cStringA sName, VARTYPE_TYPE eVarType, INT16 iScale, bool bNullable);
 
                virtual void ResetCommand() override;
                virtual void MakeCommand(const cSQLConfigCmd& cfg) override;
        };
 
        class GRAYLIB_LINK cSQLCmdDrop : public cSQLCmd
        {
                typedef cSQLCmd SUPER_t;
        public:
                cSQLCmdDrop(cStringA sTableName);
                virtual SQLCMD_TYPE get_CmdType() const override { return SQLCMD_Drop; }
                virtual void MakeCommand(const cSQLConfigCmd& cfg) override;
        };
 
        class GRAYLIB_LINK cSQLCmdSelect : public cSQLCmd
        {
 
                typedef cSQLCmd SUPER_t;
 
        public:
                cSQLCmdWhere m_Where;   
 
        protected:
                cStringA m_sSelect;     
                cStringA m_sGroupBy;
                cStringA m_sOrderBy;
                ITERATE_t m_iLimit;             
 
        public:
                cSQLCmdSelect(cStringA sFromTable);
                virtual ~cSQLCmdSelect();
 
                virtual SQLCMD_TYPE get_CmdType() const override { return SQLCMD_Select; }
                virtual bool isResultsExpected() const
                {
                        return true;
                }
 
                void SetCount(const char* pszColumnName = nullptr);
                void SetCountWhereInt(const char* pszColumnName, int iValue);
 
                void AddSelectCol(const char* pszColumnName);
                void _cdecl SetSelectColsF(const char* pszColumnName, ...);
                void put_Select(cStringA sSelect);
 
                void put_GroupBy(cStringA sColumnName);
                void put_OrderBy(cStringA sColumnName);
                void put_Limit(int iLimit=1);
 
                virtual void ResetCommand() override;
                virtual void MakeCommand(const cSQLConfigCmd& cfg) override;
        };
 
        class GRAYLIB_LINK cSQLCmdDelete : public cSQLCmd
        {
 
                typedef cSQLCmd SUPER_t;
        public:
                cSQLCmdWhere m_Where;
        public:
                cSQLCmdDelete(cStringA sTable);
 
                virtual SQLCMD_TYPE get_CmdType() const override { return SQLCMD_Delete; }
 
                virtual void ResetCommand() override
                {
                        m_Where.ResetCommandWhere();
                        SUPER_t::ResetCommand();
                }
 
                virtual void MakeCommand(const cSQLConfigCmd& cfg) override;
        };
 
        class GRAYLIB_LINK cSQLCmdInsertBase : public cSQLCmd
        {
                typedef cSQLCmd SUPER_t;
 
        public:
                cVarMap m_Values;       
 
        public:
                cSQLCmdInsertBase(cStringA sTableName);
                virtual void ResetCommand() override;
                void MakeCommandInsert(const cSQLConfigCmd& cfg, bool bFieldNames = true);
 
                bool HasColumns() const
                {
                        return(m_Values.m_aTuples.GetSize() > 0);
                }
                void AddColumn(const char* pszColumnName, const cVariant& vVal)
                {
                        ResetCommand0();        // m_sCommand must be rebuilt after this.
                        m_Values.SetValVar(pszColumnName, vVal);
                }
        };
 
        class GRAYLIB_LINK cSQLCmdInsert
                : public cSQLCmdInsertBase
        {
 
                typedef cSQLCmdInsertBase SUPER_t;
        public:
                cSQLCmdInsert(cStringA sTable = "");
                virtual SQLCMD_TYPE get_CmdType() const override { return SQLCMD_Insert; }
                virtual void MakeCommand(const cSQLConfigCmd& cfg) override;
        };
 
        class GRAYLIB_LINK cSQLCmdUpdate
                : public cSQLCmdInsertBase
        {
 
                typedef cSQLCmdInsertBase SUPER_t;
        public:
                cSQLCmdWhere m_Where;   
 
        public:
                explicit cSQLCmdUpdate(cStringA sTableName = "");
 
                virtual SQLCMD_TYPE get_CmdType() const override { return SQLCMD_Update; }
 
                virtual void ResetCommand() override;
                virtual void MakeCommand(const cSQLConfigCmd& cfg) override;
        };
};
 
#endif // _INC_cSQLCmd_H