PostgreSQL - Interface C / C ++

Este tutorial vai usar libpqxxbiblioteca, que é a API do cliente C ++ oficial para PostgreSQL. O código-fonte para libpqxx está disponível sob a licença BSD, então você é livre para baixá-lo, passá-lo para outros, alterá-lo, vendê-lo, incluí-lo em seu próprio código e compartilhar suas alterações com quem quiser.

Instalação

A versão mais recente do libpqxx está disponível para download no link Baixar Libpqxx . Portanto, baixe a versão mais recente e siga as seguintes etapas -

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

Antes de começar a usar a interface PostgreSQL C / C ++, encontre o pg_hba.conf arquivo no diretório de instalação do PostgreSQL e adicione a seguinte linha -

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

Você pode iniciar / reiniciar o servidor postgres caso ele não esteja sendo executado usando o seguinte comando -

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

APIs de interface C / C ++

A seguir estão rotinas de interface importantes que podem ser suficientes para trabalhar com o banco de dados PostgreSQL de seu programa C / C ++. Se você está procurando um aplicativo mais sofisticado, pode consultar a documentação oficial da libpqxx ou usar APIs disponíveis comercialmente.

S. No. API e descrição
1

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

Este é um typedef que será usado para conectar ao banco de dados. Aqui, dbstring fornece os parâmetros necessários para se conectar ao banco de dados, por exemplodbname = testdb user = postgres password=pass123 hostaddr=127.0.0.1 port=5432.

Se a conexão for configurada com sucesso, então ele cria C com o objeto de conexão que fornece várias funções públicas úteis.
2

C.is_open()

O método is_open () é um método público de objeto de conexão e retorna um valor booleano. Se a conexão estiver ativa, este método retorna verdadeiro, caso contrário, retorna falso.
3

C.disconnect()

Este método é usado para desconectar uma conexão de banco de dados aberta.
4

pqxx::work W( C )

Este é um typedef que será usado para criar um objeto transacional usando a conexão C, que, em última instância, será usado para executar instruções SQL no modo transacional.

Se o objeto de transação for criado com sucesso, ele será atribuído à variável W, que será usada para acessar métodos públicos relacionados ao objeto de transação.
5

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

Este método público do objeto transacional será usado para executar a instrução SQL.
6

W.commit()

Este método público do objeto transacional será usado para confirmar a transação.
7

W.abort()

Este método público do objeto transacional será usado para reverter a transação.
8

pqxx::nontransaction N( C )

Este é um typedef que será usado para criar um objeto não transacional usando a conexão C, que em última instância será usado para executar instruções SQL no modo não transacional.

Se o objeto de transação for criado com sucesso, ele será atribuído à variável N, que será usada para acessar métodos públicos relacionados ao objeto não transacional.
9

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

Este método público de objeto não transacional será usado para executar a instrução SQL e retorna um objeto de resultado que é na verdade um intérprete contendo todos os registros retornados.

Conectando-se ao banco de dados

O seguinte segmento de código C mostra como se conectar a um banco de dados existente em execução na máquina local na porta 5432. Aqui, usei barra invertida \ para continuação de linha.

#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;
   }
}

Agora, vamos compilar e executar o programa acima para conectar ao nosso banco de dados testdb, que já está disponível em seu esquema e pode ser acessado usando postgres de usuário e senha pass123 .

Você pode usar o ID do usuário e a senha com base na configuração do banco de dados. Lembre-se de manter o -lpqxx e -lpq na ordem fornecida! Caso contrário, o vinculador reclamará amargamente sobre as funções ausentes com nomes que começam com "PQ".

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

Crie uma mesa

O seguinte segmento de código C será usado para criar uma tabela no banco de dados criado anteriormente -

#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 o programa fornecido acima for compilado e executado, ele criará a tabela COMPANY em seu banco de dados testdb e exibirá as seguintes instruções -

Opened database successfully: testdb
Table created successfully

Operação INSERT

O seguinte segmento de código C mostra como podemos criar registros em nossa tabela COMPANY criada no exemplo acima -

#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 o programa fornecido acima for compilado e executado, ele criará determinados registros na tabela COMPANY e exibirá as duas linhas a seguir -

Opened database successfully: testdb
Records created successfully

SELECT Operação

O seguinte segmento de código C mostra como podemos buscar e exibir registros de nossa tabela COMPANY criada no exemplo acima -

#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 o programa fornecido acima for compilado e executado, ele produzirá o seguinte resultado -

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

Operação ATUALIZAR

O seguinte segmento de código C mostra como podemos usar a instrução UPDATE para atualizar qualquer registro e, em seguida, buscar e exibir registros atualizados de nossa tabela 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 o programa fornecido acima for compilado e executado, ele produzirá o seguinte resultado -

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

Operação DELETE

O seguinte segmento de código C mostra como podemos usar a instrução DELETE para excluir qualquer registro e, em seguida, buscar e exibir os registros restantes de nossa tabela 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 o programa fornecido acima for compilado e executado, ele produzirá o seguinte resultado -

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