PostgreSQL - C/C++ Schnittstelle: Ein Anfängerguide

Hallo, zukünftige Datenbank-Zauberer! Ich freue mich sehr, Ihr Guide auf dieser aufregenden Reise in die Welt von PostgreSQL und C/C++ zu sein. Als jemand, der seit vielen Jahren Informatik unterrichtet, kann ich Ihnen versichern, dass diese Kombination wie Erdnussbutter und Marmelade ist - sie funktionieren einfach wunderbar zusammen! Also, rollen wir die Ärmel hoch und tauchen ein.

Installation

Bevor wir anfangen zu codieren, müssen wir unsere Umgebung einrichten. Denken Sie daran als die Vorbereitung Ihrer Küche vor dem Kochen eines Gourmet-Meals. Wir brauchen zwei Hauptzutaten:

1. PostgreSQL
2. libpq (PostgreSQLs C-Client-Bibliothek)

Für Windows-Benutzer: Laden Sie den PostgreSQL-Installer von der offiziellen Website herunter. Es ist so einfach wie die Installation jedes anderen Programms - einfach dem Assistenten folgen!

Für unsere Linux-Freunde ist es sogar einfacher. Öffnen Sie Ihr Terminal und tippen Sie:

sudo apt-get install postgresql postgresql-contrib libpq-dev

Mac-Benutzer, ihr seid nicht vergessen! Verwenden Sie Homebrew:

brew install postgresql

Nach der Installation vergessen Sie nicht, den PostgreSQL-Dienst zu starten. Auf den meisten Systemen können Sie dies mit:

sudo service postgresql start

Großartig! Jetzt ist unsere Küche (ich meine, Entwicklungsumgebung) bereit. Lassen Sie uns anfangen zu kochen... ich meine, zu codieren!

C/C++ Schnittstellen-APIs

PostgreSQL bietet eine Reihe von C-Funktionen, die es uns ermöglichen, mit der Datenbank zu interagieren. Diese Funktionen sind unsere Werkzeuge, wie Schöpflöffel und Schneebesen in einer Küche. Hier sind die Hauptfunktionen, die wir verwenden werden:

Funktion	Beschreibung
PQconnectdb()	Verbindet zur Datenbank
PQfinish()	Schließt die Datenbankverbindung
PQexec()	Führt einen SQL-Befehl aus
PQstatus()	Überprüft den Verbindungszustand
PQresultStatus()	Überprüft das Ergebnis einer Abfrage
PQntuples()	Gibt die Anzahl der Zeilen in einem Ergebnis zurück
PQnfields()	Gibt die Anzahl der Spalten in einem Ergebnis zurück
PQgetvalue()	Ruft einen Felzwert aus einem Ergebnis ab

Machen Sie sich keine Sorgen, wenn diese jetzt einschüchternd aussehen. Wir werden sie alle bald verwenden, und Sie werden sehen, wie freundlich sie eigentlich sind!

Verbindung zur Datenbank herstellen

Lassen Sie uns mit den Grundlagen beginnen - die Verbindung zu unserer Datenbank herstellen. Es ist so, als бы an die Tür zu klopfen und zu sagen: "Hallo, PostgreSQL! Darf ich rein?"

#include <stdio.h>
#include <stdlib.h>
#include <libpq-fe.h>

int main() {
PGconn *conn = PQconnectdb("dbname=testdb user=john password=secret");

if (PQstatus(conn) == CONNECTION_BAD) {
fprintf(stderr, "Verbindung zur Datenbank fehlgeschlagen: %s\n", PQerrorMessage(conn));
PQfinish(conn);
exit(1);
}

printf("Erfolgreich mit der Datenbank verbunden!\n");
PQfinish(conn);
return 0;
}

Lassen Sie uns dies herunterbrechen:

1. Wir includieren die notwendigen Header, einschließlich libpq-fe.h, das uns Zugang zu den PostgreSQL-Funktionen gibt.
2. Wir verwenden PQconnectdb(), um zu unserer Datenbank zu verbinden. Ersetzen Sie "testdb", "john" und "secret" durch Ihren tatsächlichen Datenbanknamen, Benutzername und Passwort.
3. Wir überprüfen, ob die Verbindung erfolgreich war, mit PQstatus().
4. Wenn erfolgreich, drucken wir eine glückliche Nachricht. Wenn nicht, drucken wir den Fehler und beenden das Programm.
5. Schließlich schließen wir die Verbindung mit PQfinish().

Kompilieren Sie dieses Programm mit:

gcc -o connect connect.c -I/usr/include/postgresql -lpq

Führen Sie es aus, und wenn alles gut geht, werden Sie "Erfolgreich mit der Datenbank verbunden!" sehen. Herzlichen Glückwunsch, Sie haben gerade PostgreSQL die Hand gegeben!

Tabelle erstellen

Jetzt, wo wir drin sind, lassen's uns eine Tabelle erstellen. Denken Sie daran als das Einrichten eines neuen Arbeitsblatts in Excel.

PGresult *res = PQexec(conn, "CREATE TABLE students (id SERIAL PRIMARY KEY, name VARCHAR(100), age INT)");

if (PQresultStatus(res) != PGRES_COMMAND_OK) {
fprintf(stderr, "Tabelle erstellen fehlgeschlagen: %s\n", PQerrorMessage(conn));
PQclear(res);
PQfinish(conn);
exit(1);
}

printf("Tabelle erfolgreich erstellt!\n");
PQclear(res);

Hier verwenden wir PQexec() um einen SQL-Befehl auszuführen. Wir erstellen eine Tabelle namens "students" mit drei Spalten: id, name und age. Der SERIAL-Typ für id bedeutet, dass er automatisch für jeden neuen Eintrag erhöht wird - sehr praktisch!

INSERT-Operation

Lassen's uns einige Daten in unsere Tabelle einfügen. Es ist so, als würde man die Zeilen eines Arbeitsblatts ausfüllen.

const char *insert_query = "INSERT INTO students (name, age) VALUES ($1, $2)";
const char *param_values[2] = {"Alice", "20"};
int param_lengths[2] = {strlen(param_values[0]), strlen(param_values[1])};
int param_formats[2] = {0, 0};

PGresult *res = PQexecParams(conn, insert_query, 2, NULL, param_values, param_lengths, param_formats, 0);

if (PQresultStatus(res) != PGRES_COMMAND_OK) {
fprintf(stderr, "INSERT fehlgeschlagen: %s\n", PQerrorMessage(conn));
PQclear(res);
PQfinish(conn);
exit(1);
}

printf("Daten erfolgreich eingefügt!\n");
PQclear(res);

Hier verwenden wir PQexecParams() anstelle von PQexec(). Diese Funktion ermöglicht es uns, Parameter in unserer Abfrage zu verwenden, was sicherer und effizienter ist. Die $1 und $2 in der Abfrage sind Platzhalter für unsere Parameter.

SELECT-Operation

Jetzt holen wir uns unsere Daten. Es ist so, als würde man sich das ansehen, was man in seinem Arbeitsblatt geschrieben hat.

PGresult *res = PQexec(conn, "SELECT * FROM students");

if (PQresultStatus(res) != PGRES_TUPLES_OK) {
fprintf(stderr, "SELECT fehlgeschlagen: %s\n", PQerrorMessage(conn));
PQclear(res);
PQfinish(conn);
exit(1);
}

int rows = PQntuples(res);
int cols = PQnfields(res);

for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
printf("%s\t", PQgetvalue(res, i, j));
}
printf("\n");
}

PQclear(res);

Hier verwenden wir PQntuples() um die Anzahl der Zeilen zu erhalten, PQnfields() für die Anzahl der Spalten und PQgetvalue() um jeden Wert abzurufen. Es ist, als würde man durch das Arbeitsblatt von Zelle zu Zelle gehen!

UPDATE-Operation

Manchmal müssen wir unsere Daten ändern. Lassen's uns Alices Alter aktualisieren:

const char *update_query = "UPDATE students SET age = $1 WHERE name = $2";
const char *param_values[2] = {"21", "Alice"};
int param_lengths[2] = {strlen(param_values[0]), strlen(param_values[1])};
int param_formats[2] = {0, 0};

PGresult *res = PQexecParams(conn, update_query, 2, NULL, param_values, param_lengths, param_formats, 0);

if (PQresultStatus(res) != PGRES_COMMAND_OK) {
fprintf(stderr, "UPDATE fehlgeschlagen: %s\n", PQerrorMessage(conn));
PQclear(res);
PQfinish(conn);
exit(1);
}

printf("Daten erfolgreich aktualisiert!\n");
PQclear(res);

Dies ist ähnlich zu unserer INSERT-Operation, aber wir verwenden einen UPDATE SQL-Befehl stattdessen.

DELETE-Operation

Schließlich lernen wir, wie man Daten entfernt. Es ist so, als würde man eine Zeile aus seinem Arbeitsblatt löschen.

const char *delete_query = "DELETE FROM students WHERE name = $1";
const char *param_values[1] = {"Alice"};
int param_lengths[1] = {strlen(param_values[0])};
int param_formats[1] = {0};

PGresult *res = PQexecParams(conn, delete_query, 1, NULL, param_values, param_lengths, param_formats, 0);

if (PQresultStatus(res) != PGRES_COMMAND_OK) {
fprintf(stderr, "DELETE fehlgeschlagen: %s\n", PQerrorMessage(conn));
PQclear(res);
PQfinish(conn);
exit(1);
}

printf("Daten erfolgreich gelöscht!\n");
PQclear(res);

Und das war's! Wir haben die grundlegenden CRUD-Operationen (Erstellen, Lesen, Aktualisieren, Löschen) mit PostgreSQL und C abgedeckt. Erinnern Sie sich daran, Ihre Ergebnisse mit PQclear() freizugeben und Ihre Verbindung mit PQfinish() zu schließen, wenn Sie fertig sind. Es ist wie das Aufräumen nach dem Kochen - es hält Ihre Küche (und Ihr Programm) sauber.

Frohes Coden, zukünftige Datenbankmeister! Mögen Ihre Abfragen schnell sein und Ihre Verbindungen nie abrechen!

Credits: Image by storyset