//Main.cpp
#include <stdio.h>
#include <conio.h>
#include  "ZC_ADO.hpp" 

int main(){
   {
   if(FAILED(::CoInitialize(NULL)))return - 1 ;
   }
   try {
     _bstr_t ConnStr =  "Provider=SQLOLEDB;\
                        Data Source=(local);\
                        Initial Catalog=Pubs;\
                        Integrated Security=SSPI" ;

     ZC_ADOConnection zcConn;
     zcConn.zm__Open(ConnStr, "","  ");

     ZC_ADORecordSet zcRS(zcConn);
     ZC_ADOCommand   zcSP(zcConn);

     try {
       zcRS.zm__Open(" select au_id, au_lname from authors ");

       while(FALSE==zcRS.zm__EOF()){
          fprintf(stderr," %-12s%-s\n ",
            (LPCSTR)(_bstr_t)zcRS.zm__FV(" au_id ")
           ,(LPCSTR)(_bstr_t)zcRS.zm__FV(1 )
          );
          zcRS.zm__Next();
       }
   
       zcSP.zm__AP("@P1 ", adParamInput,  adInteger, 0 ,  123 );
       zcSP.zm__AP("@P2 ", adParamOutput, adInteger, 0 ,    0 );
       zcSP.zm__Exec("MySP ");

       /*
       CREATE PROCEDURE [dbo].[MySP]
          @P1 int,
          @P2 int out
       AS
          set nocount on
          set @P2 = @P1+100
          return(@P2+1000000)
       GO
       */ 

       fprintf(stderr,"\nMySP\n ");
       fprintf(stderr," @RETURN = %d\n ",(int)zcSP.zm__PV(" @RETURN "));
       fprintf(stderr," @P1     = %d\n ",(int)zcSP.zm__PV(" @P1 "));
       fprintf(stderr," @P2     = %d\n ",(int)zcSP.zm__PV(2 ));
     }
     catch(_com_error& e){
        fprintf(stderr,"%s\n ",(LPCSTR)e.Description());
     }
     zcConn.zm__Close();
     zcSP.zm__ClearParameter();
   }
   catch(...){
      fprintf(stderr," Unhandled Exception\n");
   }

   ::CoUninitialize();
   getch();
   return  0 ;

//ZC_ADO.hpp
#import  "C:\Program Files\Common Files\System\ADO\msado15.dll"  \
        no_namespace rename( "EOF" ,  "adoEOF" )

const _bstr_t C_RollBackOpenTran =  "if(@@trancount>0 )rollback";

class ZC_ADOConnection {
  friend class ZC_ADORecordSet;
  friend class ZC_ADOCommand;
  public:
     ZC_ADOConnection();
    ~ZC_ADOConnection();
  private:
     _ConnectionPtr f_objConnection;
     _bstr_t        f_strConnString;
  public:
     void zm__Open  (const _bstr_t&,
                     const _bstr_t&,
                     const _bstr_t&
                    );
     void zm__Close ();
};

class ZC_ADORecordSet {
  public:
     ZC_ADORecordSet(const ZC_ADOConnection&);
    ~ZC_ADORecordSet();
  private:
    _RecordsetPtr  f_objRecordSet;
    _ConnectionPtr f_objConnection;
  public:
    void       zm__Open  (const _bstr_t&);
    void       zm__Close ();
    void       zm__Next  ();
    bool       zm__EOF   ();
    _variant_t zm__FV    (const _bstr_t&);
    _variant_t zm__FV    (const long&);
};

class ZC_ADOCommand {
  public:
    ZC_ADOCommand(const ZC_ADOConnection&);
   ~ZC_ADOCommand();
  private:
    _CommandPtr    f_objCommand;
    _ConnectionPtr f_objConnection;
    ParametersPtr  f_objParameters;
  public:
    void       zm__ClearParameter();
    void       zm__AP   (const _bstr_t&,
                         const ParameterDirectionEnum&,
                         const DataTypeEnum&,
                         const int&,
                         const _variant_t&
                        );
    _variant_t zm__PV   (const _bstr_t&);
    _variant_t zm__PV   (const long&);
    void       zm__Exec (const _bstr_t&);
};

//ZC_ADO.cpp
#include  "ZC_ADO.hpp" 

ZC_ADOConnection::ZC_ADOConnection(){
  f_strConnString =  "";

  f_objConnection.CreateInstance(__uuidof(Connection));
  f_objConnection->CommandTimeout = 300 ;
  f_objConnection->CursorLocation = adUseServer;
  f_objConnection->IsolationLevel = adXactReadCommitted;
  f_objConnection->Attributes     =  0 ;
}

ZC_ADOConnection::~ZC_ADOConnection(){
  zm__Close();
  f_objConnection =  0 ;
}

void ZC_ADOConnection::zm__Open(const _bstr_t& ConnStr,
                                const _bstr_t& UserID,
                                const _bstr_t& Passw
                               ){
  f_objConnection->Open(ConnStr,UserID,Passw,adConnectUnspecified);
}

void ZC_ADOConnection::zm__Close(){
  if(f_objConnection->State != adStateClosed)f_objConnection->Close();
}
 /******************************************************************************/ 
ZC_ADORecordSet::ZC_ADORecordSet(const ZC_ADOConnection& Conn){
  f_objConnection = Conn.f_objConnection;
  f_objRecordSet  =  0 ;
}

ZC_ADORecordSet::~ZC_ADORecordSet(){
  zm__Close();
}

void ZC_ADORecordSet::zm__Open(const _bstr_t& SQL){
  zm__Close();
  _CommandPtr cmd;
  cmd.CreateInstance(__uuidof(Command));
  try {
    cmd->ActiveConnection = f_objConnection;
    cmd->CommandType      = adCmdText;
    cmd->CommandTimeout   =  300 ;
    cmd->CommandText      = SQL;
    f_objRecordSet        = cmd->Execute( 0 , 0 ,adCmdText);
  }catch(_com_error &e){
    f_objConnection->Execute(C_RollBackOpenTran, 0 , 0 );
    throw e;
} }

void ZC_ADORecordSet::zm__Close(){
  if(f_objRecordSet){
    if(f_objRecordSet->State != adStateClosed)f_objRecordSet->Close();
    f_objRecordSet =  0 ;
} }

void ZC_ADORecordSet::zm__Next(){
  if(f_objRecordSet)if(f_objRecordSet->State != adStateClosed)f_objRecordSet->MoveNext();
}

bool ZC_ADORecordSet::zm__EOF(){
  if( 0  == f_objRecordSet)return TRUE;
  if(adStateClosed == f_objRecordSet->State)return TRUE;
  return(VARIANT_TRUE==f_objRecordSet->adoEOF);
}

_variant_t ZC_ADORecordSet::zm__FV(const _bstr_t& Name){
  return f_objRecordSet->Fields->Item[Name]->Value;
} 

_variant_t ZC_ADORecordSet::zm__FV(const long& Index){
  return f_objRecordSet->Fields->Item[Index]->Value;
} 
 /******************************************************************************/ 
ZC_ADOCommand::ZC_ADOCommand(const ZC_ADOConnection& Conn){
  f_objConnection = Conn.f_objConnection;
  
  f_objCommand.CreateInstance(__uuidof(Command));
  f_objCommand->CommandType    = adCmdStoredProc;
  f_objCommand->CommandTimeout =  300 ;

  f_objParameters = f_objCommand->Parameters;
  f_objParameters->Append(
    f_objCommand->CreateParameter(
       "@RETURN",
       adInteger,
       adParamReturnValue,
        0 ,
        0 
    )
  );
}

ZC_ADOCommand::~ZC_ADOCommand(){
  zm__ClearParameter();
  if(f_objParameters->Count> 0 )f_objParameters->Delete((long) 0 );
  f_objParameters =  0 ;
  f_objCommand    =  0 ;
}

void ZC_ADOCommand::zm__Exec(const _bstr_t& CmdText){
  f_objCommand->CommandText      = CmdText;
  f_objCommand->ActiveConnection = f_objConnection;
  try {
    f_objCommand->Execute( 0 , 0 ,adCmdStoredProc);
    f_objCommand->ActiveConnection =  0 ;
  }catch(_com_error &e){
    f_objConnection->Execute(C_RollBackOpenTran, 0 , 0 );
    throw e;
} }

void ZC_ADOCommand::zm__AP(const _bstr_t& Name,
                           const ParameterDirectionEnum& Direction,
                           const DataTypeEnum& Type,
                           const int& Size,
                           const _variant_t& Value){
  f_objParameters->Append(
     f_objCommand->CreateParameter(
       Name,
       Type,
       Direction,
       Size,
       Value
     )
  );
}

void ZC_ADOCommand::zm__ClearParameter(){
  while( f_objParameters->Count> 1  )f_objParameters->Delete((long) 1 );
}

_variant_t ZC_ADOCommand::zm__PV(const _bstr_t& Name){
  return f_objParameters->Item[Name]->Value;
}

_variant_t ZC_ADOCommand::zm__PV(const long& Index){
  return f_objParameters->Item[Index]->Value;
}

void CssApp::OnAppAbout(){
   ::CoInitialize(NULL);

   try {
//Специально делаю ошибку - вместо pubs пишу pubs$$$
     _bstr_t ConnStr =  "Provider=SQLOLEDB;\
                        Data Source=(local);\
                        Initial Catalog=pubs$$$;\ 
                        Integrated Security=SSPI" ;

     ZC_ADOConnection zcConn;
     ZC_ADORecordSet  zcRS(zcConn);
     ZC_ADOCommand    zcSP(zcConn);

     try {
       zcConn.zm__Open(ConnStr, " " , " " );//Я тут пробелы вставил, чтобы не зеленилось.

       zcRS.zm__Open( "select au_id, au_lname from authors" );

       _bstr_t Tmp = zcRS.zm__FV( "au_id" );
       AfxMessageBox(Tmp, 0 , 0 );
     }
     catch(_com_error& e){
        AfxMessageBox((LPCSTR)e.Description(), 0 , 0 );
     }
     zcConn.zm__Close();
     zcSP.zm__ClearParameter();
   }
   catch(...){
     AfxMessageBox( "Unhandled" , 0 , 0 );
   }
   ::CoUninitialize();
}