PostgreSQL - Interfaccia C / C ++

Questo tutorial utilizzerà libpqxxlibreria, che è l'API client ufficiale C ++ per PostgreSQL. Il codice sorgente per libpqxx è disponibile sotto la licenza BSD, quindi sei libero di scaricarlo, passarlo ad altri, modificarlo, venderlo, includerlo nel tuo codice e condividere le tue modifiche con chiunque tu scelga.

Installazione

L'ultima versione di libpqxx è disponibile per essere scaricata dal link Download Libpqxx . Quindi scarica l'ultima versione e segui i seguenti passaggi:

wget http://pqxx.org/download/software/libpqxx/libpqxx-4.0.tar.gz
tar xvfz libpqxx-4.0.tar.gz
cd libpqxx-4.0
./configure
make
make install

Prima di iniziare a utilizzare l'interfaccia PostgreSQL C / C ++, trova il file pg_hba.conf file nella directory di installazione di PostgreSQL e aggiungi la seguente riga:

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

È possibile avviare / riavviare il server postgres nel caso in cui non sia in esecuzione utilizzando il seguente comando:

[[email protected]]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

API dell'interfaccia C / C ++

Le seguenti sono importanti routine di interfaccia che possono soddisfare le tue esigenze per lavorare con il database PostgreSQL dal tuo programma C / C ++. Se stai cercando un'applicazione più sofisticata, puoi esaminare la documentazione ufficiale di libpqxx oppure puoi utilizzare le API disponibili in commercio.

S. No. API e descrizione
1

pqxx::connection C( const std::string & dbstring )

Questo è un typedef che verrà utilizzato per connettersi al database. Qui, dbstring fornisce i parametri richiesti per connettersi al database, ad esempiodbname = testdb user = postgres password=pass123 hostaddr=127.0.0.1 port=5432.

Se la connessione è impostata correttamente, crea C con l'oggetto connessione che fornisce varie utili funzioni pubbliche.
2

C.is_open()

Il metodo is_open () è un metodo pubblico di oggetto di connessione e restituisce un valore booleano. Se la connessione è attiva, questo metodo restituisce true, altrimenti restituisce false.
3

C.disconnect()

Questo metodo viene utilizzato per disconnettere una connessione al database aperta.
4

pqxx::work W( C )

Si tratta di un typedef che verrà utilizzato per creare un oggetto transazionale utilizzando la connessione C, che alla fine verrà utilizzato per eseguire istruzioni SQL in modalità transazionale.

Se l'oggetto transazione viene creato correttamente, viene assegnato alla variabile W che verrà utilizzata per accedere ai metodi pubblici relativi all'oggetto transazionale.
5

W.exec(const std::string & sql)

Questo metodo pubblico dall'oggetto transazionale verrà utilizzato per eseguire l'istruzione SQL.
6

W.commit()

Questo metodo pubblico dall'oggetto transazionale verrà utilizzato per eseguire il commit della transazione.
7

W.abort()

Questo metodo pubblico dall'oggetto transazionale verrà utilizzato per eseguire il rollback della transazione.
8

pqxx::nontransaction N( C )

Si tratta di un typedef che verrà utilizzato per creare un oggetto non transazionale utilizzando la connessione C, che alla fine verrà utilizzato per eseguire istruzioni SQL in modalità non transazionale.

Se l'oggetto transazione viene creato correttamente, viene assegnato alla variabile N che verrà utilizzata per accedere ai metodi pubblici relativi all'oggetto non transazionale.
9

N.exec(const std::string & sql)

Questo metodo pubblico da un oggetto non transazionale verrà utilizzato per eseguire l'istruzione SQL e restituisce un oggetto risultato che in realtà è un interatore che contiene tutti i record restituiti.

Connessione al database

Il seguente segmento di codice C mostra come connettersi a un database esistente in esecuzione sulla macchina locale alla porta 5432. Qui, ho usato la barra rovesciata \ per la continuazione della riga.

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }
}

Ora, compiliamo ed eseguiamo il programma sopra per connetterci al nostro database testdb, che è già disponibile nello schema ed è possibile accedervi utilizzando postgres utente e password pass123 .

È possibile utilizzare l'ID utente e la password in base alle impostazioni del database. Ricordati di mantenere -lpqxx e -lpq nell'ordine dato! In caso contrario, il linker si lamenterà amaramente delle funzioni mancanti con nomi che iniziano con "PQ".

$g++ test.cpp -lpqxx -lpq
$./a.out
Opened database successfully: testdb

Crea una tabella

Il seguente segmento di codice C verrà utilizzato per creare una tabella nel database creato in precedenza:

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }

      /* Create SQL statement */
      sql = "CREATE TABLE COMPANY("  \
      "ID INT PRIMARY KEY     NOT NULL," \
      "NAME           TEXT    NOT NULL," \
      "AGE            INT     NOT NULL," \
      "ADDRESS        CHAR(50)," \
      "SALARY         REAL );";

      /* Create a transactional object. */
      work W(C);
      
      /* Execute SQL query */
      W.exec( sql );
      W.commit();
      cout << "Table created successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Quando il programma sopra indicato viene compilato ed eseguito, creerà la tabella COMPANY nel database testdb e visualizzerà le seguenti istruzioni:

Opened database successfully: testdb
Table created successfully

Operazione INSERT

Il seguente segmento di codice C mostra come possiamo creare record nella nostra tabella AZIENDA creata nell'esempio precedente:

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }

      /* Create SQL statement */
      sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "  \
         "VALUES (1, 'Paul', 32, 'California', 20000.00 ); " \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "  \
         "VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); "     \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
         "VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );" \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
         "VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );";

      /* Create a transactional object. */
      work W(C);
      
      /* Execute SQL query */
      W.exec( sql );
      W.commit();
      cout << "Records created successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Quando il programma sopra indicato viene compilato ed eseguito, creerà dati record nella tabella AZIENDA e mostrerà le seguenti due righe:

Opened database successfully: testdb
Records created successfully

Operazione SELECT

Il seguente segmento di codice C mostra come possiamo recuperare e visualizzare i record dalla nostra tabella AZIENDA creata nell'esempio precedente -

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }

      /* Create SQL statement */
      sql = "SELECT * from COMPANY";

      /* Create a non-transactional object. */
      nontransaction N(C);
      
      /* Execute SQL query */
      result R( N.exec( sql ));
      
      /* List down all the records */
      for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
         cout << "ID = " << c[0].as<int>() << endl;
         cout << "Name = " << c[1].as<string>() << endl;
         cout << "Age = " << c[2].as<int>() << endl;
         cout << "Address = " << c[3].as<string>() << endl;
         cout << "Salary = " << c[4].as<float>() << endl;
      }
      cout << "Operation done successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Quando il programma sopra indicato viene compilato ed eseguito, produrrà il seguente risultato:

Opened database successfully: testdb
ID = 1
Name = Paul
Age = 32
Address = California
Salary = 20000
ID = 2
Name = Allen
Age = 25
Address = Texas
Salary = 15000
ID = 3
Name = Teddy
Age = 23
Address = Norway
Salary = 20000
ID = 4
Name = Mark
Age = 25
Address = Rich-Mond
Salary = 65000
Operation done successfully

Operazione UPDATE

Il seguente segmento di codice C mostra come possiamo utilizzare l'istruzione UPDATE per aggiornare qualsiasi record e quindi recuperare e visualizzare i record aggiornati dalla nostra tabella COMPANY -

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }
      
      /* Create a transactional object. */
      work W(C);
      /* Create  SQL UPDATE statement */
      sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1";
      /* Execute SQL query */
      W.exec( sql );
      W.commit();
      cout << "Records updated successfully" << endl;
      
      /* Create SQL SELECT statement */
      sql = "SELECT * from COMPANY";

      /* Create a non-transactional object. */
      nontransaction N(C);
      
      /* Execute SQL query */
      result R( N.exec( sql ));
      
      /* List down all the records */
      for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
         cout << "ID = " << c[0].as<int>() << endl;
         cout << "Name = " << c[1].as<string>() << endl;
         cout << "Age = " << c[2].as<int>() << endl;
         cout << "Address = " << c[3].as<string>() << endl;
         cout << "Salary = " << c[4].as<float>() << endl;
      }
      cout << "Operation done successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Quando il programma sopra indicato viene compilato ed eseguito, produrrà il seguente risultato:

Opened database successfully: testdb
Records updated successfully
ID = 2
Name = Allen
Age = 25
Address = Texas
Salary = 15000
ID = 3
Name = Teddy
Age = 23
Address = Norway
Salary = 20000
ID = 4
Name = Mark
Age = 25
Address = Rich-Mond
Salary = 65000
ID = 1
Name = Paul
Age = 32
Address = California
Salary = 25000
Operation done successfully

Operazione DELETE

Il seguente segmento di codice C mostra come possiamo utilizzare l'istruzione DELETE per eliminare qualsiasi record e quindi recuperare e visualizzare i record rimanenti dalla nostra tabella COMPANY -

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }
      
      /* Create a transactional object. */
      work W(C);
      /* Create  SQL DELETE statement */
      sql = "DELETE from COMPANY where ID = 2";
      /* Execute SQL query */
      W.exec( sql );
      W.commit();
      cout << "Records deleted successfully" << endl;
      
      /* Create SQL SELECT statement */
      sql = "SELECT * from COMPANY";

      /* Create a non-transactional object. */
      nontransaction N(C);
      
      /* Execute SQL query */
      result R( N.exec( sql ));
      
      /* List down all the records */
      for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
         cout << "ID = " << c[0].as<int>() << endl;
         cout << "Name = " << c[1].as<string>() << endl;
         cout << "Age = " << c[2].as<int>() << endl;
         cout << "Address = " << c[3].as<string>() << endl;
         cout << "Salary = " << c[4].as<float>() << endl;
      }
      cout << "Operation done successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Quando il programma sopra indicato viene compilato ed eseguito, produrrà il seguente risultato:

Opened database successfully: testdb
Records deleted successfully
ID = 3
Name = Teddy
Age = 23
Address = Norway
Salary = 20000
ID = 4
Name = Mark
Age = 25
Address = Rich-Mond
Salary = 65000
ID = 1
Name = Paul
Age = 32
Address = California
Salary = 25000
Operation done successfully