none
Getting started witn SQL Server RRS feed

  • Discussion générale

  • J'ouvre cette discussion pour mettre à disposition des utilisateur les différents élément nécessaire à l'interfaçage entre une application et une base de données:

    Nous appellerons dans ce cadre le fichier InterbaseManager:

    Je met à la disposition des utilisateur le fichier dans son état courant et je le renseignerai au fur est à mesure des vérifications.

    J'utilise SQL Server Management studio pour vérifier les requêtes et pour crée la base au départ.

    Dans l'état actuel du logiciel il reste deux méthodes a vérifier GetInteger et GetString

    il y a deux fichiers: le premier est le header:

    /*******************************************************************************
     * NOM: 
     * ROLE: 
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #ifndef INTERBASEMANAGERM_H
    #define INTERBASEMANAGERM_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    /*_____GLOBAL-TYPES___________________________________________________________*/
    /*******************************************************************************
     * NOM:
     * ROLE:
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #ifndef INTERBASEMANAGERM_H
    #define INTERBASEMANAGERM_H
    /*_____INCLUDE-FILES__________________________________________________________*/
    /*_____GLOBAL-DEFINE__________________________________________________________*/
    /*_____GLOBAL-TYPES___________________________________________________________*/
    namespace SpecificationLoader
    {
        using namespace System;
        using namespace System::ComponentModel;
        using namespace System::Collections;
        using namespace System::Windows::Forms;
        using namespace System::Data;
        using namespace System::Drawing;
        using namespace System::IO;
        using namespace System::Data::Sql;
        using namespace System::Data::SqlClient;
        using namespace System::Runtime::InteropServices;
        using namespace msclr::interop;

        ref class CInterbaseManagerM
        {
        public:
            static SqlCommand^ myCommand;
            static SqlDataReader^ myReader;
            static SqlConnection^ myConnexion;
            static SqlTransaction^ myTransaction;
            CInterbaseManagerM::CInterbaseManagerM();
            CInterbaseManagerM::~CInterbaseManagerM();
            static erc CInterbaseManagerM::ConnectServer(std::wstring wsUserName, std::wstring wsPassword, std::wstring wsHost);
            static erc CInterbaseManagerM::DisconnectServer();
            static erc CInterbaseManagerM::DisconnectDatabase();
            static void CInterbaseManagerM::ConnectDatabase();
            static int CInterbaseManagerM::GetIdentifier( std::wstring wsTable_Name, std::wstring wsRowName);
            static void CInterbaseManagerM::CommitTransaction();
            static void CInterbaseManagerM::edit( char* final_err_buff );
            static void CInterbaseManagerM::ExecuteRequest( std::wstring wsRequest, unsigned long * dwNbResultFound);
            static void CInterbaseManagerM::ExecuteSelectRequest( std::wstring wsRequest, unsigned long * dwNbResultFound);
            static void CInterbaseManagerM::First( std::wstring sRequest);
            static void CInterbaseManagerM::CloseCursor();
            static void CInterbaseManagerM::Next( int* iEndReached);
            static int CInterbaseManagerM::GetInteger(int Row);
            static System::String^ CInterbaseManagerM::GetString( int Row);
            static void CInterbaseManagerM::CloseReader();
        };
    };
    #endif


    Le second est le fichier qui comprend le code des méthodes

    /*------------------------------------------------------------------------------------------------*/
    /* Global conception    : 06-13-2003 ; 10:44:49                                                                                                                                                       */
    /* Specification        : 23-05-2003 ; 16:33:41                                                   */
    /* ALITEC                                                                                         */
    /* Rue Leonard de vinci                                                                           */
    /* 53061 LAVAL CEDEX 09                                                                           */
    /* (c) Copyright ALITEC                                                                           */
    /*------------------------------------------------------------------------------------------------*/
    /*******************************************************************************
     * NOM:
     * ROLE:
     * HISTORIQUE:
        * 05/05/2001, xxx, initial version
    *******************************************************************************/
    #pragma managed
    /*_____INCLUDE-FILES__________________________________________________________*/

    #include "StdAfx.h"
    #include "AlignStructure.h"
    #include "Macro.h"
    #include "Message.h"
    #include "Enumerations.hpp"
    #include "Structure.h"
    #include "TypeDefs.hpp"
    #include "Layout.h"
    #include "POS.h"
    #include "ClassesAligner.hpp"
    #include "Database.h"
    #include "StrConv.h"
    #include "InterbaseManagerM.hpp"

    /*_____LOCAL-DEFINE___________________________________________________________*/
    #define longueur 1024
    /*_____LOCAL-TYPES____________________________________________________________*/
    /*_____GLOBAL-DATA____________________________________________________________*/

    char* sDest;

    bool                              m_bServerConnected;
    static char                       final_err_buff[2048];

    static char * p1;
    static char * p2;
    static char * p3;
    static char * p4;
    static char * p5;

    static char * p6;
    static char * p7;
    static char * p8;
    static char * p9;

    static char* p10;



    //#import "C:\Program Files\Fichiers Communs\System\ADO\msado15.dll"
    //no_namespace rename("EOF", "EndOfFile")

    namespace SpecificationLoader
    {
        using namespace System;
        using namespace System::ComponentModel;
        using namespace System::Collections;
        using namespace System::Configuration;
        using namespace System::Windows::Forms;
        using namespace System::Data;
        using namespace System::Drawing;
        using namespace System::IO;
        using namespace System::Data::Sql;
        using namespace System::Data::SqlClient;
        using namespace System::Runtime::InteropServices;
    //
    /*------------------------------------------------------------------------------------------------*/
    /*Name          Constructeur                                                                      */
    /*Role                                                                                            */
    /*Interface                                                                                       */
    /*In            None                                                                              */
    /*In/Out        None                                                                              */
    /*Result        None                                                                              */
    /*Constraints   None                                                                              */
    /*Resources                                                                                       */
    /*PreCondition                                                                                    */
    /*------------------------------------------------------------------------------------------------*/
    //
        CInterbaseManagerM::CInterbaseManagerM()
        {
            ;
        };
    //
    /*------------------------------------------------------------------------------------------------*/
    /*Name          Destructeur                                                                       */
    /*Role                                                                                            */
    /*Interface                                                                                       */
    /*In            None                                                                              */
    /*In/Out        None                                                                              */
    /*Result        None                                                                              */
    /*Constraints   None                                                                              */
    /*Resources                                                                                       */
    /*PreCondition                                                                                    */
    /*------------------------------------------------------------------------------------------------*/
    //
        CInterbaseManagerM::~CInterbaseManagerM()
        {
            ;
        };
    //

    /*------------------------------------------------------------------------------------------------*/
    /*Name          ConnectServer                                                                     */
    /*Role          Initialize member variables with the parameters                                   */
    /*Interface                                                                                       */
    /*In            UserName, Password, Host                                                          */
    /*In/Out        None                                                                              */
    /*Result        Error code                                                                        */
    /*Constraints   None                                                                              */
    /*Resources                                                                                       */
    /*PreCondition                                                                                    */
    /*------------------------------------------------------------------------------------------------*/
    //PROC ConnectServer(In : UserName, Password, Host
    //                   Result : Error code)
        erc CInterbaseManagerM::ConnectServer(std::wstring wsUserName, std::wstring wsPassword, std::wstring wsHost)
        {
        //DATA
        //
            enum enDisconnectServerError
            {
              ERROR_TSQLQUERY_POINTER_NOT_NULL = 1,
              ERROR_TSQLCONNECTION_POINTER_NOT_NULL,
              ERROR_SERVER_CONNECTED,
              ERROR_CONNECTION_COMPONENTS_CREATION,
            };
            bool bIsConnected;
            char sServerName[256];
            size_t len;
            HRESULT hr = S_OK;
            erc ErrorCode = INIT_NO_ERROR;
        //ATAD
        //DO
            len = strlen( "LocalHost");
            strcpy_s( sServerName, len + 1, "LocalHost");
            sServerName[len] = 0;
        //  [Set the value of UserName ("m_pTSQLConnection") with "UserName"]
            len = wcslen( wsUserName.c_str());
            if( ErrorCode == INIT_NO_ERROR || ErrorCode == 1)
            {
                myConnexion = gcnew SqlConnection();
                myConnexion->ConnectionString = "Integrated Security=true;User Instance=true;database=COHERENCE;server=ALLIANCE-EA8F7A\\SQLEXPRESS";
                myConnexion->Open();
                myCommand = myConnexion->CreateCommand();
            }
            else
               bIsConnected = false;
            ErrorCode = INIT_NO_ERROR;
            m_bServerConnected = true;
            return(ErrorCode);
        //OD
        }
    /*------------------------------------------------------------------------------------------------*/
    /*Name          DisconnectServer                                                                     */
    /*Role          Initialize member variables with the parameters                                   */
    /*Interface                                                                                       */
    /*In            UserName, Password, Host                                                          */
    /*In/Out        None                                                                              */
    /*Result        Error code                                                                        */
    /*Constraints   None                                                                              */
    /*Resources                                                                                       */
    /*PreCondition                                                                                    */
    /*------------------------------------------------------------------------------------------------*/
    //PROC ConnectServer(In : UserName, Password, Host
    //                   Result : Error code)
        erc CInterbaseManagerM::DisconnectServer()
        {
            myConnexion->Close();
            m_bServerConnected = false;
            myConnexion = nullptr;
            return( 0);
        }
        
        erc CInterbaseManagerM::DisconnectDatabase()
        {
            if ( myConnexion != nullptr)
            {
                myConnexion->Close();
                m_bServerConnected = false;
            }
            return( 0);
        }
    //
    /*------------------------------------------------------------------------------------------------*/
    /*Name          ExecuteRequest                                                                    */
    /*Role          Execute a select request                                                          */
    /*Interface                                                                                       */
    /*In            Request                                                                           */
    /*              Result        indicate if the function has returned a result                      */
    /*In/Out        None                                                                              */
    /*Result        list of semantic Elements                                                         */
    /*Constraints   None                                                                              */
    /*Resources                                                                                       */
    /*PreCondition                                                                                    */
    /*------------------------------------------------------------------------------------------------*/
    //PROC ExecuteRequestAndReadElement(In : wsRequest   Result : List)
        void CInterbaseManagerM::ExecuteRequest( std::wstring wsRequest, unsigned long * dwNbResultFound)
        {
        //DATA
        //
            enum enExecuteRequestError
            {
              ERROR_SELECT_REQUEST_NULL = 1,
              ERROR_SELECT_REQUEST_EXECUTION,
              ERROR_TSQLQUERY_POINTER_NULL,
              ERROR_DATABASE_NOT_CONNECTED,
              ERROR_TSQLCONNECTION_POINTER_NULL,
            };
            erc ErrorCode = INIT_NO_ERROR;
            System::String^ sRequest;
            sRequest = gcnew String( wsRequest.c_str());
        //ATAD
        //DO
            // IF myConnection" is not NULL) THEN
            if( myCommand != nullptr)
            {    
                myCommand->CommandText = sRequest;
                myTransaction = myConnexion->BeginTransaction();
                myCommand->Transaction = myTransaction;
                //la doc dit que ExecuteNonQuery retourne le nombre d'enregistrement dans la table, il retourne -1 si la table est vide;
                *dwNbResultFound = (unsigned long)myCommand->ExecuteNonQuery();
                //OD
            }
        };

    //
    /*------------------------------------------------------------------------------------------------*/
    /*Name          ExecuteRequestAndReadElement                                                */
    /*Role          Execute a select request                                                          */
    /*Interface                                                                                       */
    /*In            Request                                                                           */
    /*              Result        indicate if the function has returned a result                      */
    /*In/Out        None                                                                              */
    /*Result        list of semantic Elements                                                         */
    /*Constraints   None                                                                              */
    /*Resources                                                                                       */
    /*PreCondition                                                                                    */
    /*------------------------------------------------------------------------------------------------*/
    //PROC ExecuteRequestAndReadElement(In : wsRequest   Result : List)
        void CInterbaseManagerM::ExecuteSelectRequest( std::wstring wsRequest, unsigned long * dwNbResultFound)
        {
        //DATA
        //
            enum enExecuteRequestError
            {
              ERROR_SELECT_REQUEST_NULL = 1,
              ERROR_SELECT_REQUEST_EXECUTION,
              ERROR_TSQLQUERY_POINTER_NULL,
              ERROR_DATABASE_NOT_CONNECTED,
              ERROR_TSQLCONNECTION_POINTER_NULL,
            };
            erc ErrorCode = INIT_NO_ERROR;
            System::String^ sRequest;
            sRequest = gcnew String( wsRequest.c_str());
        //ATAD
        //DO
            // IF myConnection" is not NULL) THEN
            if( myCommand != nullptr)
            {    
                myCommand->CommandText = sRequest;
                myTransaction = myConnexion->BeginTransaction();
                myCommand->Transaction = myTransaction;
                // quelle est la différence avec Execute?
                *dwNbResultFound = 0;
                myReader = myCommand->ExecuteReader();
                // bool bFound = (m_pTSQLStatement->Fetch() == true);
                //OD
            }
            
        };


        
        void CInterbaseManagerM::CommitTransaction()
        {
            myTransaction->Commit();
        }
        
        int CInterbaseManagerM::GetIdentifier( std::wstring wsTable_Name, std::wstring wsRowName)
        {
            std::wstring wsRequest;
            int i;
            unsigned long dwNbResultFound = 0;
            wsRequest = L"SELECT " + wsRowName + L" FROM " + wsTable_Name;
            CInterbaseManagerM::ExecuteSelectRequest(wsRequest, &dwNbResultFound);
            while( myReader->Read())
            {
                i = GetInteger( 0);
                dwNbResultFound++;
            }
            if( dwNbResultFound == 0)
                i = 1;
            myReader->Close();
            myTransaction->Commit();
            wsRequest = L"SET IDENTITY_INSERT  [" + wsTable_Name + L"] ON";
            CInterbaseManagerM::ExecuteRequest(wsRequest, &dwNbResultFound);
            myTransaction->Commit();
            return (i);
        };
        
        void CInterbaseManagerM::ConnectDatabase()
        {
        }
        
        void CInterbaseManagerM::CloseCursor()
        {
                myCommand->CommandText = L"CLOSE cur";
                myCommand->ExecuteNonQuery();
                myCommand->CommandText = L"DEALLOCATE cur";
                myCommand->ExecuteNonQuery();
        }
        
        void CInterbaseManagerM::First( std::wstring wsRequest)
        {
            std::wstring wsText = L"DECLARE cur SCROLL CURSOR FOR " + wsRequest;
            System::String^ sRequest = gcnew System::String( wsText.c_str());
            myCommand->CommandText = sRequest;
            myCommand->ExecuteNonQuery();
            myCommand->CommandText = L"OPEN cur";
            myCommand->ExecuteNonQuery();
            myCommand->CommandText = L"FETCH FIRST FROM cur";
        };

        void CInterbaseManagerM::Next( int* iEndReached)
        {
            myCommand->CommandText = L"FETCH NEXT FROM cur";
            *iEndReached = myCommand->ExecuteNonQuery();
        };

        int CInterbaseManagerM::GetInteger(int Row)
        {
            //Row->Id = Id;
            System::Int32 id = Row;
            System::Decimal^ ident;
            int i;
            ident = myReader->GetDecimal( id);
            i = Decimal::ToSingle( *ident);
            return( i);//Row->Id);
        };

        System::String^ CInterbaseManagerM::GetString( int Row)
        {
            return( myReader->GetString( Row));
        }
        
        void CInterbaseManagerM::CloseReader()
        {
            myReader->Close();
        }

        void CInterbaseManagerM::edit( char* final_err_buff )
        {
            int j = 0;
            for(int i = 0; i > 2048; i = i + 200)
            {
                j++;
                switch( j)
                {
                    case 1:
                        p1 = final_err_buff;
                        break;
                    case 2:
                        p2 = &final_err_buff[100];
                        break;
                    case 3:
                        p3 = &final_err_buff[200];
                        break;
                    case 4:
                        p4 = &final_err_buff[300];
                        break;
                    case 5:
                        p5 = &final_err_buff[400];
                        break;
                    case 6:
                        p6 = &final_err_buff[600];
                        break;
                    case 7:
                        p7 = &final_err_buff[700];
                        break;
                    case 8:
                        p8 = &final_err_buff[800];
                        break;
                    case 9:
                        p9 = &final_err_buff[900];
                        break;
                    case 10:
                        p10 = &final_err_buff[1000];
                        break;
                    default:
                        break;
                }
            }
        };
    };



    Jean Noël Martin







    • Déplacé Aurel Bera mardi 22 avril 2014 09:27 Informations inexactes
    • Modifié JeanNoel53 mercredi 23 avril 2014 09:57
    samedi 19 avril 2014 12:37

Toutes les réponses

  • Bonjour

    A priori on a trouvé le code pour l'autre thread.

    Arrêtez de donner des informations erronées.

    Le code posté ici  ne fonctionne pas correctement.

    Comme déjà expliqué FETCH First /Fetch Next ne peut pas fonctionner avec un DataReader.

    J’ai tombe aussi sur ce code :

    while( bEndReached = false )

                        {

    Qui n’exécute jamais car vous faites une allocation. Attention au signe « = » utilisé ici contre « == » que vous devez utiliser normalement.

    Normalement on utilise les CURSEUR SQL pour un traitement séquentiel. On l’utilise plutôt avec des procédures stockes. Si vous utiliser le Reader, simplement passez le While sans envoyer les autres commandes « FETCH FIRST/FETCH NEXT » .

    Je veux deplacer votre thread dans le forum "Hors context". Si vous voulez vraiment etre utile, ne plus donnez des informations incorrectes.

    Bonne journée,


    Aurel BERA, MSFT
    MSDN Community Support. LE CONTENU EST FOURNI "TEL QUEL" SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE.
    S'il vous plaît n'oubliez pas de "Marquer comme réponse" les réponses qui ont résolu votre problème. C'est une voie commune pour reconnaître ceux qui vous ont aidé, et rend plus facile pour les autres visiteurs de trouver plus tard la résolution.

    mardi 22 avril 2014 09:26