c++ sql

[serban_b]

Salut am si eu o problema incerc sa fac un program, problema e ca trebuie neaparat sa lucrez cu o baza de date insa eu am cunostinte doar de c++, sql si php medii, problema e doar lucrarea cu baza de date in rest ma descurc cu tot, am tot citit, forumuri tutoriale pentru moment nu imi dau seama nici ce sa folosesc mi-am instalat vc++ 2008, mi-am luat si o carte "programarea bazelor de date cv++ 6" de la teora dar tot nu imi dau seama care e cel mai potrivit pentru aplicatia mea, sper sa ma puteti ajuta

[neagu_laurentiu]

E poveste lunga... dar nu ai specificat baza de date.
Pe scurt, recomandarea mea in materie de C++ & Windows: C++Builder, VC++/CLI & ADO.NET sau VC++ & MFC ODBC.
ADO/OLEDB & C++ ar fi mai complicat pentru inceput...

[Silviu Ardelean]

Cartea respectiva, nu e nici de departe recomandata pentru incepatori in database programming.
Iti recomand sa incerci sa gasesti niste tutoriale potrivite despre VC++ database programming using ODBC. Un exemplu ar fi si http://msdn.microsoft.com/en-gb/visualc/cc896546.aspx.

De asemenea, daca vrei sa treci direct la ADO, un punct de plecare ar putea fi folosirea wrapperului urmator: http://www.codeproject.com/KB/database/ ... lass1.aspx.
Din aceeasi categorie, vei avea nevoie si de informatii prezentate pe http://www.codeproject.com/KB/database/ ... rings.aspx.

[cristianamarie]

trebuie neaparat sa lucrez cu o baza de date insa eu am cunostinte doar de c++, sql si php medii

c++ si sql ajung. Oricum, nici C++ nu e de mare folos decit la ADO si in special OLEDB. Restul sint API-uri C (ODBC).

nu imi dau seama nici ce sa folosesc mi-am instalat vc++ 2008

Si Platform SDK, rabdare si samples. Ce e drept, sample-uri erau cele din MSDN din 1999.

mi-am luat si o carte "programarea bazelor de date cv++ 6" de la teora dar tot nu imi dau seama care e cel mai potrivit pentru aplicatia mea, sper sa ma puteti ajuta

Care e cel (cea) mai potrivit ce? Fel de a lucra cu databases? Ca sa il parafrazez pe un nene de la SQL Server (cred): "lucrul cu database e foarte simplu, e in 3 pasi: connect, fa treaba, disconnect".

Incepe cu ODBC. SQLAllocHandle (env, dbc, statement), SQLExecDirect etc. Nu trebuie sa inveti toate functiile ODBC deodata.
Uite, iti atasez doua fisiere de start. (Le-as fi atasat, dar nu merge extensia .h si nu incerc o alta.) Main-ul si utilizarea iti ramin exercitiu.

SQLSupport.h

Cod: Selectaţi tot

// SQLSupport.h : SQL connectivity and query classes

#pragma once

#include <vector>

namespace SQL {

   /*
   //   SQL 2000, 7            Driver={SQL Server};Server=myServerAddress;Database=myDataBase;Uid=myUsername;Pwd=myPassword;
                        Driver={SQL Server};Server=myServerAddress;Database=myDataBase;Trusted_Connection=Yes;
                        
   //   SQL 2005   TRUSTED      Driver={SQL Native Client};Server=myServerAddress;Database=myDataBase; Uid=myUsername;Pwd=myPassword;
               USER      Driver={SQL Native Client};Server=myServerAddress;Database=myDataBase; Trusted_Connection=yes;
               INSTANCE   Driver={SQL Native Client};Server=myServerName\theInstanceName;Database=myDataBase; Trusted_Connection=yes;   
   //   SQL 2008            Driver={SQL Server Native Client 10.0};Server=myServerAddress;Database=myDataBase;Uid=myUsername;Pwd=myPassword;
                        Driver={SQL Server Native Client 10.0};Server=myServerAddress;Database=myDataBase;Trusted_Connection=yes;
                        Driver={SQL Server Native Client 10.0};Server=myServerName\theInstanceName; Database=myDataBase;Trusted_Connection=yes;
   */

class SqlError
{
   private:
      SQLSMALLINT   m_iRec;
      CStringW m_strSqlState;
      SQLINTEGER m_lNativeError;
      CStringW m_strErrorMsg;
   public:
      SqlError()
         : m_iRec(-1)
         , m_lNativeError(0)
      {}
      SqlError(SQLSMALLINT iRec,
         const CStringW& strSqlState,
         SQLINTEGER lNativeError,
         const CStringW& strErrorMsg)
         : m_iRec(iRec)
         , m_strSqlState(strSqlState)
         , m_lNativeError(lNativeError)
         , m_strErrorMsg(strErrorMsg)
      {}
      SqlError(const SqlError& src)
      {
         m_iRec = src.Record();
         m_strSqlState = src.SqlState();
         m_lNativeError = src.NativeError();
         m_strErrorMsg = src.ErrorMessage();
      }
      ~SqlError()
      {}
   public:
      SQLSMALLINT   Record() const
      {
         return m_iRec;
      }
      const CStringW& SqlState() const
      {
         return m_strSqlState;
      }
      SQLINTEGER NativeError() const
      {
         return m_lNativeError;
      }
      const CStringW& ErrorMessage() const
      {
         return m_strErrorMsg;
      }
   public:
      SqlError& operator=(const SqlError& src)
      {
         m_iRec = src.Record();
         m_strSqlState = src.SqlState();
         m_lNativeError = src.NativeError();
         m_strErrorMsg = src.ErrorMessage();
         return *this;
      }
   public:
      bool IsWarning() const
      {
         return m_strSqlState.Compare(L"01000") == 0;
      }
};


template<class T, SQLSMALLINT _HTYPE, SQLHANDLE _HNULL>
class Handle
{
   public:
      Handle()
         : _hSql(_HNULL)
         , _hType(_HTYPE)
         , _res(SQL_SUCCESS)
      {}
      virtual ~Handle()
      {}
   private:
      Handle(const Handle&);
      Handle& operator=(const Handle&);
   public:
      operator bool() const
      {
         return _hSql != Null();
      }
      bool operator!() const
      {
         return _hSql == Null();
      }
      operator SQLHANDLE()
      {
         if(this == NULL)
         {
            return Null();
         }
         return _hSql;
      }
      static SQLHANDLE Null()
      {
         return _HNULL;
      }
   public:
      virtual bool Open(SQLHANDLE hParent = SQL_NULL_HANDLE)
      {
         if(!_PrepareOpen(hParent))
         {
            return false;
         }
         if(!_Open(hParent))
         {
            return false;
         }
         return _PostOpen();
      }
      virtual bool Close()
      {
         if(!_PrepareClose())
         {
            return false;
         }
         return _Close();
      }
   protected:
      virtual bool _PrepareOpen(SQLHANDLE hParent)
      {
         return true;
         UNREFERENCED_PARAMETER(hParent);
      }
      virtual bool _PostOpen()
      {
         return true;
      }
      virtual bool _Open(SQLHANDLE hParent)
      {
         _res = ::SQLAllocHandle(_HTYPE, hParent, &_hSql);
         return SQL_SUCCEEDED(_res);
      }
      virtual bool _PrepareClose()
      {
         return true;
      }
      virtual bool _Close()
      {
         if(_hSql == Null())
         {
            return false;
         }
         _res = ::SQLFreeHandle(_HTYPE, _hSql);
         _hSql = Null();
         return true;
      }
   public:
      SQLRETURN GetLastError() const
      {
         return _res;
      }
      const std::vector<SqlError>& GetErrors() const
      {
         return _Errors;
      }
      bool HaveErrors() const
      {
         if(_Errors.empty())
         {
            return false;
         }
         //   scan for errors or warnings
         std::vector<SqlError>::const_iterator ite;
         for(ite = _Errors.begin();
            ite != _Errors.end();
            ite++)
         {
            if(!ite->IsWarning())
            {
               return true;
            }
         }
         return false;
      }
      bool ReadErrors()
      {
         if(!_Errors.empty())
         {
            _Errors.clear();
         }

         //   read errors
         SQLINTEGER lNativeError = 0;
         WCHAR szErrorMsg[SQL_MAX_MESSAGE_LENGTH + 1] = L"";
         WCHAR szSqlState[6] = L"";
         SQLSMALLINT cchMsg = 0;

         memset(szErrorMsg, 0, _countof(szErrorMsg) * sizeof(WCHAR));
         memset(szSqlState, 0, _countof(szSqlState) * sizeof(WCHAR));

         SQLSMALLINT iRec = 1;
         while(true)
         {
            _res = ::SQLGetDiagRecW(_hType
               , _hSql
               , iRec
               , szSqlState
               , &lNativeError
               , szErrorMsg
               , _countof(szErrorMsg) - 1
               , &cchMsg);
            if(SQL_SUCCEEDED(_res))
            {
               _Errors.push_back(
                  SqlError(iRec, szSqlState, lNativeError, szErrorMsg));
            }
            if(_res == SQL_NO_DATA)
            {
               break;
            }
            iRec++;
         }
         return true;
      }
   protected:
      SQLRETURN _res;
      SQLSMALLINT _hType;
      SQLHANDLE _hSql;
      std::vector<SqlError> _Errors;
};

class Environment
   : public Handle<Environment, SQL_HANDLE_ENV, SQL_NULL_HENV>
{
   public:
      Environment();
      ~Environment();
   private:
      Environment(const Environment&);
      Environment& operator=(const Environment&);
   public:
      bool SetAttr(SQLINTEGER Attribute, SQLINTEGER Value);
      bool SetODBCVersion(SQLINTEGER version = SQL_OV_ODBC3);
   protected:
      virtual bool _PostOpen();
};

class Connection
   : public Handle<Connection, SQL_HANDLE_DBC, SQL_NULL_HDBC>
{
   public:
      explicit Connection(bool fAutoDisconnect = true);
      ~Connection();
   private:
      Connection(const Connection&);
      Connection& operator=(const Connection&);
   public:
      bool Open(Environment* pEnv);
      bool Connect(const CStringW& strServer,
                const CStringW& strDatabase,
                const CStringW& strUser,
                const CStringW& strPassword,
                HWND hwnd = NULL);
      bool Disconnect();
      bool IsConnected() const;
   private:
      bool _fAutoDisconnect;
      bool _fConnected;
};

class Statement
   : public Handle<Statement, SQL_HANDLE_STMT, SQL_NULL_HSTMT>
{
   public:
      Statement();
      ~Statement();
   private:
      Statement(const Statement&);
      Statement& operator=(const Statement&);
   public:
      bool Open(Connection* pConn);
   public:
      bool ExecDirect(LPCWSTR pcwszStatement, SQLINTEGER iLength = SQL_NTS);
      bool Fetch();
      bool Cancel();
      bool BindColumn(SQLUSMALLINT usColNumber, long* plVar, SQLLEN* pcbLen);
};

};   //   namespace SQL

si SQLSupport.cpp:

Cod: Selectaţi tot

// SQLSupport.cpp : SQL connectivity and query classes implementation
#include "stdafx.h"
#include "SQLSupport.h"

namespace SQL {

Environment::Environment()
{}

Environment::~Environment()
{
   Close();
}

bool Environment::SetAttr(SQLINTEGER Attribute, SQLINTEGER Value)
{
   _res = ::SQLSetEnvAttr(_hSql, Attribute, (SQLPOINTER*)Value, 0);
   return SQL_SUCCEEDED(_res);
}

bool Environment::SetODBCVersion(SQLINTEGER version)
{
   return SetAttr(SQL_ATTR_ODBC_VERSION, version);
}

bool Environment::_PostOpen()
{
   _res = SetODBCVersion();
   return SQL_SUCCEEDED(_res);
}

//   Connection
Connection::Connection(bool fAutoDisconnect)
   : _fAutoDisconnect(fAutoDisconnect)
   , _fConnected(false)
{}

Connection::~Connection()
{
   if(_fAutoDisconnect)
   {
      Disconnect();
   }
   Close();
}

bool Connection::Open(Environment* pEnv)
{
   return __super::Open(pEnv->operator SQLHANDLE());
}

bool Connection::Connect(const CStringW& strServer,
                   const CStringW& strDatabase,
                   const CStringW& strUser,
                   const CStringW& strPassword,
                   HWND hwnd)
{
   if(_hSql == NULL)
   {
      return false;
   }

   //   set options here...

   WCHAR szConnIn[256] = L"";
   wsprintfW(szConnIn
      , L"Driver={SQL Server};"
        L"Server={%s};"
        L"Database={%s};"
        L"Uid={%s};"
        L"Pwd={%s};"
      , strServer
      , strDatabase
      , strUser
      , strPassword);

   WCHAR szConnOut[256] = L"";
   SQLSMALLINT cchConnStrOut = _countof(szConnOut) - 1;

   _res = ::SQLDriverConnectW(
        _hSql
      , hwnd
      , (SQLWCHAR *)szConnIn
      , SQL_NTS
      , (SQLWCHAR *)szConnOut
      , cchConnStrOut
      , &cchConnStrOut
      , SQL_DRIVER_NOPROMPT);
   if(SQL_SUCCEEDED(_res))
   {
      _fConnected = true;
   }
   else
   {
      if(ReadErrors())
      {
         if(HaveErrors())
         {
            return false;
         }
      }
   }
   return SQL_SUCCEEDED(_res);
}

bool Connection::Disconnect()
{
   if(_hSql == SQL_NULL_HDBC || !_fConnected)
   {
      return false;
   }
   _res = ::SQLDisconnect(_hSql);
   _fConnected = false;
   return SQL_SUCCEEDED(_res);
}

bool Connection::IsConnected() const
{
   return _fConnected;
}

//   Statement
Statement::Statement()
{}

Statement::~Statement()
{
   Close();
}

bool Statement::Open(Connection* pConn)
{
   return __super::Open(pConn->operator SQLHANDLE());
}

bool Statement::ExecDirect(LPCWSTR pcwszStatement,
                     SQLINTEGER iLength)
{
   if(_hSql == SQL_NULL_HSTMT)
   {
      ATLASSERT(FALSE);
      return false;
   }
   if(pcwszStatement == NULL)
   {
      ATLASSERT(FALSE);
      return false;
   }

   _res = ::SQLExecDirectW(_hSql, (SQLWCHAR *)pcwszStatement, iLength);
   if(_res != SQL_SUCCESS)
   {
      if(ReadErrors())
      {
         if(HaveErrors())
         {
            return false;
         }
      }
   }
   return SQL_SUCCEEDED(_res);
}

bool Statement::Fetch()
{
   if(_hSql == SQL_NULL_HSTMT)
   {
      ATLASSERT(FALSE);
      return false;
   }

   _res = ::SQLFetch(_hSql);
   if(_res == SQL_NO_DATA)
   {
      return false;
   }
   return SQL_SUCCEEDED(_res);
}

bool Statement::Cancel()
{
   if(_hSql == SQL_NULL_HSTMT)
   {
      ATLASSERT(FALSE);
      return false;
   }

   _res = ::SQLCancel(_hSql);
   return SQL_SUCCEEDED(_res);
}

bool Statement::BindColumn(SQLUSMALLINT usColNumber,
                     long* plVar,
                     SQLLEN* pcbLen)
{
   if(_hSql == SQL_NULL_HSTMT)
   {
      ATLASSERT(FALSE);
      return false;
   }
   if(plVar == NULL)
   {
      ATLASSERT(FALSE);
      return false;
   }
   if(pcbLen == NULL)
   {
      ATLASSERT(FALSE);
      return false;
   }

   _res = ::SQLBindCol(_hSql, usColNumber,
      SQL_C_LONG, (SQLPOINTER)plVar,
      0, (SQLINTEGER *)pcbLen);

   return SQL_SUCCEEDED(_res);
}


};   //   namespace SQL

[jos8cal]

Din moment ce nu ai specificat DB-ul, m-as hazarda sa presupun ca nu te intereseaza atit de mult tipul ei, cit faptul de a avea o aplicatie care lucreaza cu un DB in C/C++. Cum spui ca esti familiar cu C-ul, Iti recomand ceva simplu si rapid de implementat: SQLite. Totul se rezuma la un fisier pe disk pe care-l interoghezi din C intr-un mod banal.
Sample: http://www.sqlite.org/quickstart.html

[Silviu Ardelean]

Oricum, nici C++ nu e de mare folos decit la ADO si in special OLEDB. Restul sint API-uri C (ODBC).

Pentru ODBC mai exista si clasele wrapper din MFC, CDatabase, CRecordset, etc, iar acestea sunt C++ toata ziua.

[cristianamarie]

Pentru ODBC mai exista si clasele wrapper din MFC, CDatabase, CRecordset, etc, iar acestea sunt C++ toata ziua.

(Clarificare) Keyword: wrapper. In afara ca sint niste convenience wrappers, API-ul e C si se lucreaza cu handles. Spre deosebire de OLEDB sau ADO unde chiar e C++/COM si se lucreaza cu obiecte C++ (ma rog, interfete). Asta voiam sa zic. Oricum, nu era important.

Revenind la intrebarea initiala - eu zic ca invatarea temeinica incepe cu API-ul, nu cu clasele. Clasele nu fac nimic mai mult decit API-ul in sine - doar ajuta cu RAII, smart pointers etc. La fel cum imi e greu sa apreciez un om care stie pWnd->Create sau nu stie ce e CreateWindowEx.
Dar asta depinde de fiecare, la urma urmei - poate omul vrea sa termine vreun proiect rapid sa isi ia diploma sau sa cistige niste banutzi si nu il mai intereseaza.

[Silviu Ardelean]

Pentru ODBC mai exista si clasele wrapper din MFC, CDatabase, CRecordset, etc, iar acestea sunt C++ toata ziua.

(Clarificare) Keyword: wrapper. In afara ca sint niste convenience wrappers, API-ul e C si se lucreaza cu handles. Spre deosebire de OLEDB sau ADO unde chiar e C++/COM si se lucreaza cu obiecte C++ (ma rog, interfete). Asta voiam sa zic. Oricum, nu era important.

Nu vreau sa creez o polemica pe aceasta tema, dar cand vorbim la nivel de utilizarator MFC (CDatabase, CRecordset) vorbim in termeni C++, chiar daca in spate se afla niste functii C de Win32API.

[serban_b]

Multumesc pentru raspunsuri, nu ma asteptam la un suport atat de bun si rapid, din pacate nu am inteles mai nimic din cele 2 fisiere postate de cristianamarie, m-am uitat pe articolul de pe codeproject, am vazut ca are totul foarte bine explicat, toate functile, pentru moment incerc sa fac ceva pe baza celor scrise acolo, sper sa imi iasa daca nu trec la php acolo mi se pare totul mult mai simplu in privinta asta

[Silviu Ardelean]

m-am uitat pe articolul de pe codeproject, am vazut ca are totul foarte bine explicat, toate functile, pentru moment incerc sa fac ceva pe baza celor scrise acolo

Daca te impotmolesti undeva... nu ezita sa ne expui situatia in care te afli. Desi au trecut deja 5 ani de la terminarea facultatii, aplicatia mea practica pentru lucrarea de dizertatie a folosit aceaste clase.

[Ovidiu Cucu]

[...] trec la php acolo mi se pare totul mult mai simplu in privinta asta

E ca si cum ai spune "Plec in Somalia. Acolo scoala-i mai usoara deci si viata e mai roz..." .

[cristianamarie]

din pacate nu am inteles mai nimic din cele 2 fisiere postate de cristianamarie

Dupa toate probabilitatile, in afara cele doua fisiere, mai sint multe lucruri pe care trebuie sa le aprofundezi, cred. (Printre care cum sa descrii ceva ce nu iti iese/nu ai inteles prin mai mult decit "nu am inteles nimic"...)

Le-ai pus intr-un proiect si ai incercat sa faci ceva cu ele? nu ai inteles numele claselor? metodele? ai citit ODBC? Nu ai incercat, banuiesc, prea multe din toate astea, nu?

Despre fisiere si clasele din ele: sint niste clase de baza wrapper peste ODBC handle objects, plus Environment, Connection si Statement urmeaza by-the-book logica ODBC:

Cod: Selectaţi tot

alloc environment
  alloc connection
     connect
       alloc statement
       execute statement
       ...
    disconnect
  free connection
free environment

Metode gen Connection::Connect, Statement::ExecDirect sau BindColumn mie unuia mi se pare foarte clare.

Nu stiu ce e prin php, Pear:DB sau cu ce o sa te ciocnesti pe acolo, dar si acolo tot cu connect-fa treaba-disconnect o sa ai de-a face.

[neagu_laurentiu]

daca nu trec la php acolo mi se pare totul mult mai simplu in privinta asta

Pai hotaraste-te, ori faci aplicatii ori simulezi aplicatii ! De cand browser-ul e un container eficient de rulare ?
Niciodata nu am inteles de ce unii inlocuiesc aplicatiile desktop cu ceva unde se reinventeaza roata - si macar de-ar fi "roata" (inclusiv Oracle are obiceiul asta)...

[cristianamarie]

De cand browser-ul e un container eficient de rulare ?
Niciodata nu am inteles de ce unii inlocuiesc aplicatiile desktop cu ceva unde se reinventeaza roata - si macar de-ar fi "roata" (inclusiv Oracle are obiceiul asta)...

De cind avocatii decid ca scriptingul e mai eficient ca C-ul, sau ca limbajele cu j sau # in nume sint foarte bune, secsi si iecstraordinare. Cu runtime-uri C in spate, evident, pe care le scriu niste ruginitzi invechiti de peste 35 de ani carora le plac, din motive necunoscute, pointerii.

PS Iar Oracle nu e chiar exemplul cel mai bun de inovatie pe lumea asta. Sa zica mersi ca MS SQL Server nu ruleaza pe unix-uri. Inca. (Mai tii minte unde erau Sybase in 87 si MS avea drept doar readonly pe SQL Server? Si unde e Sybase acuma cu penibilul ala de Adaptive, si unde e SQL Server azi).

[serban_b]

Pai hotaraste-te, ori faci aplicatii ori simulezi aplicatii ! De cand browser-ul e un container eficient de rulare ?
Niciodata nu am inteles de ce unii inlocuiesc aplicatiile desktop cu ceva unde se reinventeaza roata - si macar de-ar fi "roata" (inclusiv Oracle are obiceiul asta)...

Este un proiect propriu care il fac cum vreau eu si unde vreau eu, nu sunt obligat sa folosesc nimic si am considerat ca e o ocazie buna sa invat si chestia asta dar daca nici cu ajutor nu sunt in stare inseamna ca ma depaseste si o sa invat asta cu alta ocazie si trec la ce stiu mai bine dar pentru moment inca imi bat capul cu c-ul.