SQLite - C / C ++

In diesem Kapitel erfahren Sie, wie Sie SQLite in C / C ++ - Programmen verwenden.

Installation

Bevor Sie SQLite in unseren C / C ++ - Programmen verwenden, müssen Sie sicherstellen, dass auf dem Computer eine SQLite-Bibliothek eingerichtet ist. Sie können das Kapitel SQLite-Installation überprüfen, um den Installationsprozess zu verstehen.

C / C ++ - Schnittstellen-APIs

Im Folgenden finden Sie wichtige C / C ++ - SQLite-Schnittstellenroutinen, die ausreichen können, um mit der SQLite-Datenbank Ihres C / C ++ - Programms zu arbeiten. Wenn Sie nach einer komplexeren Anwendung suchen, können Sie die offizielle SQLite-Dokumentation lesen.

Sr.Nr. API & Beschreibung
1

sqlite3_open(const char *filename, sqlite3 **ppDb)

Diese Routine öffnet eine Verbindung zu einer SQLite-Datenbankdatei und gibt ein Datenbankverbindungsobjekt zurück, das von anderen SQLite-Routinen verwendet werden soll.

Wenn das Dateinamenargument NULL oder ': memory:' ist, erstellt sqlite3_open () eine speicherinterne Datenbank im RAM, die nur für die Dauer der Sitzung gültig ist.

Wenn der Dateiname nicht NULL ist, versucht sqlite3_open (), die Datenbankdatei mithilfe ihres Werts zu öffnen. Wenn keine Datei mit diesem Namen vorhanden ist, öffnet sqlite3_open () eine neue Datenbankdatei mit diesem Namen.
2

sqlite3_exec(sqlite3*, const char *sql, sqlite_callback, void *data, char **errmsg)

Diese Routine bietet eine schnelle und einfache Möglichkeit, SQL-Befehle auszuführen, die von einem SQL-Argument bereitgestellt werden, das aus mehr als einem SQL-Befehl bestehen kann.

Hier ist das erste Argument sqlite3 ein offenes Datenbankobjekt, sqlite_callback ist ein Rückruf, für den Daten das erste Argument sind, und errmsg wird zurückgegeben, um alle von der Routine ausgelösten Fehler zu erfassen.

Die Routine SQLite3_exec () analysiert und führt jeden in der sql Argument, bis es das Ende der Zeichenfolge erreicht oder auf einen Fehler stößt.
3

sqlite3_close(sqlite3*)

Diese Routine schließt eine Datenbankverbindung, die zuvor durch einen Aufruf von sqlite3_open () geöffnet wurde. Alle mit der Verbindung verbundenen vorbereiteten Anweisungen sollten vor dem Schließen der Verbindung abgeschlossen werden.

Wenn noch Fragen bestehen, die noch nicht abgeschlossen wurden, gibt sqlite3_close () SQLITE_BUSY mit der Fehlermeldung zurück, dass aufgrund nicht finalisierter Anweisungen nicht geschlossen werden kann.

Verbindung zur Datenbank herstellen

Das folgende C-Codesegment zeigt, wie eine Verbindung zu einer vorhandenen Datenbank hergestellt wird. Wenn die Datenbank nicht vorhanden ist, wird sie erstellt und schließlich wird ein Datenbankobjekt zurückgegeben.

#include <stdio.h>
#include <sqlite3.h> 

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;

   rc = sqlite3_open("test.db", &db);

   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }
   sqlite3_close(db);
}

Lassen Sie uns nun das obige Programm kompilieren und ausführen, um unsere Datenbank zu erstellen test.dbim aktuellen Verzeichnis. Sie können Ihren Pfad gemäß Ihren Anforderungen ändern.

$gcc test.c -l sqlite3
$./a.out
Opened database successfully

Wenn Sie C ++ - Quellcode verwenden möchten, können Sie Ihren Code wie folgt kompilieren:

$g++ test.c -l sqlite3

Hier verknüpfen wir unser Programm mit der sqlite3-Bibliothek, um dem C-Programm die erforderlichen Funktionen bereitzustellen. Dadurch wird eine Datenbankdatei test.db in Ihrem Verzeichnis erstellt und Sie erhalten das folgende Ergebnis.

-rwxr-xr-x. 1 root root 7383 May 8 02:06 a.out
-rw-r--r--. 1 root root  323 May 8 02:05 test.c
-rw-r--r--. 1 root root    0 May 8 02:06 test.db

Erstellen Sie eine Tabelle

Das folgende C-Codesegment wird verwendet, um eine Tabelle in der zuvor erstellten Datenbank zu erstellen -

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
   int i;
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stdout, "Opened database successfully\n");
   }

   /* 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 );";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
   
   if( rc != SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Table created successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Wenn das obige Programm kompiliert und ausgeführt wird, erstellt es eine COMPANY-Tabelle in Ihrer test.db und die endgültige Auflistung der Datei lautet wie folgt:

-rwxr-xr-x. 1 root root 9567 May 8 02:31 a.out
-rw-r--r--. 1 root root 1207 May 8 02:31 test.c
-rw-r--r--. 1 root root 3072 May 8 02:31 test.db

INSERT-Betrieb

Das folgende C-Codesegment zeigt, wie Sie Datensätze in der im obigen Beispiel erstellten COMPANY-Tabelle erstellen können:

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
   int i;
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* 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 );";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
   
   if( rc != SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Records created successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Wenn das obige Programm kompiliert und ausgeführt wird, werden die angegebenen Datensätze in der COMPANY-Tabelle erstellt und die folgenden zwei Zeilen angezeigt:

Opened database successfully
Records created successfully

SELECT-Betrieb

Bevor wir mit dem eigentlichen Beispiel zum Abrufen von Datensätzen fortfahren, wollen wir uns einige Details zur Rückruffunktion ansehen, die wir in unseren Beispielen verwenden. Dieser Rückruf bietet eine Möglichkeit, Ergebnisse aus SELECT-Anweisungen zu erhalten. Es hat die folgende Erklärung -

typedef int (*sqlite3_callback)(
   void*,    /* Data provided in the 4th argument of sqlite3_exec() */
   int,      /* The number of columns in row */
   char**,   /* An array of strings representing fields in the row */
   char**    /* An array of strings representing column names */
);

Wenn der obige Rückruf in der Routine sqlite_exec () als drittes Argument bereitgestellt wird, ruft SQLite diese Rückruffunktion für jeden Datensatz auf, der in jeder innerhalb des SQL-Arguments ausgeführten SELECT-Anweisung verarbeitet wird.

Das folgende C-Codesegment zeigt, wie Sie Datensätze aus der im obigen Beispiel erstellten COMPANY-Tabelle abrufen und anzeigen können.

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName){
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++){
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

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

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Wenn das obige Programm kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

Callback function called: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

UPDATE-Betrieb

Das folgende C-Codesegment zeigt, wie wir die UPDATE-Anweisung verwenden können, um einen Datensatz zu aktualisieren und dann aktualisierte Datensätze aus der COMPANY-Tabelle abzurufen und anzuzeigen.

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName){
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create merged SQL statement */
   sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1; " \
         "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Wenn das obige Programm kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

Callback function called: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

DELETE-Betrieb

Das folgende C-Codesegment zeigt, wie Sie mit der DELETE-Anweisung einen beliebigen Datensatz löschen und dann die verbleibenden Datensätze aus der COMPANY-Tabelle abrufen und anzeigen können.

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName) {
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create merged SQL statement */
   sql = "DELETE from COMPANY where ID=2; " \
         "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

Wenn das obige Programm kompiliert und ausgeführt wird, wird das folgende Ergebnis erzeugt.

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved