/*
 * ADOCommand.h 
 * Copyright (c) 2009 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2009/05/11
// 2009/05/15
// 2009/05/22 Added a helpler method appendToParameters to create an ADOParameter object
//        and append it to ADOParameters of ADOCommand object.
// 2009/05/22 Added a method enablePrepared(bool)

#pragma once

#include <sol/sql/ADOObject.h>
#include <sol/sql/ADORecordset.h>
#include <sol/sql/ADOParameter.h>
#include <sol/sql/ADOParameters.h>


namespace SOL {

class ADOCommand :public ADOObject {

public:
    /**
     * Constructor
     */
    ADOCommand()
    {
    }

public:
    ~ADOCommand()
    {
    }
    
public:
    HRESULT createInstance()
    {
        return ADOObject::createInstance(__uuidof(ADODB::Command));
    }

public:
    void set(ADODB::_CommandPtr pC) 
    {
        setObject((IDispatchPtr)pC);
    }

public:
    ADODB::_CommandPtr getCommandPtr() 
    {
        return (ADODB::_CommandPtr)getObject();
    }

public:
    ADODB::_ConnectionPtr getActiveConnection()
    {
        return getCommandPtr()->GetActiveConnection();
    }

public:
    void putRefActiveConnection(__in ADODB::_Connection* ppvObject)
    {
        getCommandPtr()->PutRefActiveConnection(ppvObject);
    }


public:

    void putActiveConnection(__in const _variant_t& ppvObject)
    {
        getCommandPtr()->PutActiveConnection(ppvObject);
    }

public:

    void putActiveConnection(__in ADODB::_ConnectionPtr activeConnection)
    {
        _variant_t varConnection((IDispatch*)activeConnection);
        getCommandPtr()->PutActiveConnection(varConnection);
    }

public:

    _bstr_t getCommandText()
    {
        return getCommandPtr()->GetCommandText();
    }

public:

    void putCommandText(__in _bstr_t pbstr)
    {
        getCommandPtr()->PutCommandText(pbstr);
    }

public:

    long getCommandTimeout()
    {
        return getCommandPtr()->GetCommandTimeout();
    }

public:
    void putCommandTimeout(__in long pl)
    {
        getCommandPtr()->PutCommandTimeout(pl);
    }

public:

    VARIANT_BOOL getPrepared()
    {
        return getCommandPtr()->GetPrepared();
    }

public:
    //2008/05/23
    bool enablePrepared()
    {
        bool rc = false;
        VARIANT_BOOL prepared = getCommandPtr()->GetPrepared();
        if (prepared == VARIANT_TRUE) {
            rc = true;
        }
        return rc;
    }

public:
    //2009/05/22
    void enablePrepared(__in bool flag)
    {
        VARIANT_BOOL prepared = VARIANT_FALSE;
        if (flag) {
            prepared = VARIANT_TRUE;
        }
        getCommandPtr()->PutPrepared(prepared);
    }

public:

    void putPrepared(__in VARIANT_BOOL pfPrepared)
    {
        getCommandPtr()->PutPrepared(pfPrepared);
    }

public:
    /**
     1 Execute commandText property put by putCommandText method.
     2 Return an instance of ADORecordset to the first parameter recordset.
     3 Return the number of records affected by this operation.

    option takes one of the following enum.

    CommandTypeEnum
    {
    adCmdUnspecified 
    adCmdText
    adCmdTable
    adCmdStoredProc
    adCmdUnknown (default)
    adCmdFile
    adCmdTableDirect
    };
     */
    //2009/05/17 
    long execute(
        __out ADORecordset& recordset,
        __in_opt variant_t* parameters=NULL,
        __in_opt long options =ADODB::adCmdUnspecified)

    {
        long rc = -1L;
        _variant_t varAffected(0L);

        ADODB::_RecordsetPtr recset = execute(
            varAffected,
            parameters,
            options);
        if (recset) {
            recordset.set(recset);
            rc = (long)varAffected;
        } else {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL", __FUNCTION__);
        }
        return rc;
    }


public:
    /**
    option takes one of the following enum.

    CommandTypeEnum
    {
    adCmdUnspecified 
    adCmdText
    adCmdTable
    adCmdStoredProc
    adCmdUnknown (default)
    adCmdFile
    adCmdTableDirect
    };
     */
    bool execute(
        __out _variant_t& recordsAffected,
        __out ADORecordset& recordset,
        __in_opt variant_t* parameters=NULL,
        __in_opt long options =ADODB::adCmdUnspecified)

    {
        bool rc = false;

        ADODB::_RecordsetPtr recset = execute(
            recordsAffected,
            parameters,
            options);
        if (recset) {
            recordset.set(recset);
            rc = true;
        } else {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL", __FUNCTION__);
        }
        return rc;
    }


public:
    ADODB::_RecordsetPtr execute(
        __out _variant_t& recordsAffected,
        __in variant_t* parameters =NULL,
        __in long options = ADODB::adCmdUnspecified)
    {
        return getCommandPtr()->Execute(
            &recordsAffected,
            (VARIANT*)parameters,
            options);
    }

public:
    /**
    type takes one of the following values.

    DataTypeEnum
    {
    adEmpty = 0,
    adTinyInt = 16,
    adSmallInt = 2,
    adInteger = 3,
    adBigInt = 20,
    adUnsignedTinyInt = 17,
    adUnsignedSmallInt = 18,
    adUnsignedInt = 19,
    adUnsignedBigInt = 21,
    adSingle = 4,
    adDouble = 5,
    adCurrency = 6,
    adDecimal = 14,
    adNumeric = 131,
    adBoolean = 11,
    adError = 10,
    adUserDefined = 132,
    adVariant = 12,
    adIDispatch = 9,
    adIUnknown = 13,
    adGUID = 72,
    adDate = 7,
    adDBDate = 133,
    adDBTime = 134,
    adDBTimeStamp = 135,
    adBSTR = 8,
    adChar = 129,
    adVarChar = 200,
    adLongVarChar = 201,
    adWChar = 130,
    adVarWChar = 202,
    adLongVarWChar = 203,
    adBinary = 128,
    adVarBinary = 204,
    adLongVarBinary = 205,
    adChapter = 136,
    adFileTime = 64,
    adPropVariant = 138,
    adVarNumeric = 139,
    adArray = 8192
    };

    parameter takes one of the following values.

    ParameterDirectionEnum
    {
    adParamUnknown = 0,
    adParamInput = 1,
    adParamOutput = 2,
    adParamInputOutput = 3,
    adParamReturnValue = 4
    };
     */
    bool createParameter(
        __in _bstr_t name,
        __in ADODB::DataTypeEnum type,
        __in ADODB::ParameterDirectionEnum direction,
        __in ADODB::ADO_LONGPTR size,
        __in const _variant_t& value,//vtMissing,
        __out ADOParameter& parameter
        )
    {
        bool rc = false;
        ADODB::_ParameterPtr pParam = createParameter(
                name,
                type,
                direction,
                size,
                value);
        if (pParam) {
            parameter.set(pParam);
            rc = true;
        } else {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL", __FUNCTION__);
        }
        return rc;
    }

public:

    ADODB::_ParameterPtr createParameter(
        __in _bstr_t name,
        __in ADODB::DataTypeEnum type,
        __in ADODB::ParameterDirectionEnum direction,
        __in ADODB::ADO_LONGPTR size,
        __in_opt const _variant_t& value = vtMissing)
    {
        return getCommandPtr()->CreateParameter(
                name,
                type,
                direction,
                size,
                value);
    }

public:
    /**
     * Create an ADOParameter Object from arguments of appendToParameters
     * and apppend it to ADOParameters of ADOCommand.
     */
    //2009/05/22
    //2009/05/27
    bool appendParameter(
        __in _bstr_t name,
        __in ADODB::DataTypeEnum type,
        __in ADODB::ParameterDirectionEnum direction,
        __in ADODB::ADO_LONGPTR size,
        __in const _variant_t& value
        //__out ADOParameter& parameter
        )
    {
        bool rc = false;
        ADODB::_ParameterPtr pParam = createParameter(
                name,
                type,
                direction,
                size,
                value);
        if (pParam) {
            //If succeeded to create a Parameter, 
            // then append it to an ADOParameters obect of this ADOCommand.
            ADOParameters parameters;
            if (getParameters(parameters)) {
                IDispatch* iobject = (IDispatch*)pParam;
                if (parameters.append(iobject)) {
                    rc = true;
                }
            }
        } else {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL", __FUNCTION__);
        }
        return rc;
    }

public:
    bool getParameters(__out ADOParameters& parameters)
    {
        bool rc = false;
        ADODB::ParametersPtr pParams = getParameters();
        if (pParams) {
            parameters.set(pParams);
            rc = true;
        } else {
            throw Exception(E_FAIL, "%s: %s", "E_FAIL", __FUNCTION__);
        }
        return rc;    
    }

public:
    // 2009/05/22
    bool appendParameter(ADOParameter& param)
    {
        bool rc = false;

        ADOParameters parameters;
        if (getParameters(parameters)) {
            IDispatch* iobject = (IDispatch*)param.getParameterPtr();
            if (parameters.append(iobject)) {
                rc = true;
            }
        }
        return rc;

    }

public:
    ADODB::ParametersPtr getParameters()
    {
        return getCommandPtr()->GetParameters();
    }

public:
    /**
    CommandTypeEnum
    {
    adCmdUnspecified = -1,
    adCmdUnknown = 8,
    adCmdText = 1,
    adCmdTable = 2,
    adCmdStoredProc = 4,
    adCmdFile = 256,
    adCmdTableDirect = 512
    };
    */
    void putCommandType(ADODB::CommandTypeEnum plCmdType)
    {
        getCommandPtr()->PutCommandType(plCmdType);
    }

public:

    ADODB::CommandTypeEnum getCommandType()
    {
        return getCommandPtr()->GetCommandType();
    }

public:

    _bstr_t getName()
    {
        return getCommandPtr()->GetName();
    }


public:
    void putName(_bstr_t pbstrName)
    {
        getCommandPtr()->PutName(pbstrName);
    }

public:
    long getState()
    {
        return getCommandPtr()->GetState();
    }

public:
    HRESULT cancel()
    {
        HRESULT hr = getCommandPtr()->Cancel();
        if (FAILED(hr)) {
            throw Exception(hr, "%s", __FUNCTION__);
        }
        return hr;

    }

public:
    void putRefCommandStream(IUnknown* pvStream)
    {
        getCommandPtr()->PutRefCommandStream(pvStream);
    }

public:
    _variant_t getCommandStream()
    {
        return getCommandPtr()->GetCommandStream();
    }

public:
    void putDialect(_bstr_t pbstrDialect)
    {
        getCommandPtr()->PutDialect(pbstrDialect);
    }

public:
    _bstr_t getDialect()
    {
        return getCommandPtr()->GetDialect();
    }


public:
    void putNamedParameters(VARIANT_BOOL pfNamedParameters)
    {
        getCommandPtr()->PutNamedParameters(pfNamedParameters);
    }

public:
    VARIANT_BOOL getNamedParameters()
    {
        return getCommandPtr()->GetNamedParameters();
    }

public:
    //2009/05/15
    //Return all fields list for a table of tableName to fields. 
    bool getFields(
        __in _bstr_t tableName,
        __in ADODB::_ConnectionPtr activeConnection,
        __out ADOFields& fields)
    {
        bool rc = false;
        
        putActiveConnection(activeConnection);
        putCommandText(tableName);
        putCommandType(ADODB::adCmdTable);
        putCommandTimeout(20);

        _variant_t recordsAffected(0L);
        ADORecordset recordset;
        if (execute(recordsAffected, recordset, NULL, 
            //ADODB::adOpenKeyset)) {
            ADODB::adCmdTable)) {            
            //ADOFields fields;
            if (recordset.getFields(fields)) {
                //long count = fields.getCount();
                //printf("OK, fields.getCount(): %d\n", count);
                rc = true;
            }
        }
        return rc;
    }
};

}