Latest web development tutorials

SQLite - C / C ++

installieren

In der C / C ++ Programm vor SQLite verwenden, müssen wir sicherstellen, dass es die SQLite-Bibliothek an der Maschine ist. Sie können die SQLite Installationsabschnitt für den Installationsvorgang anzuzeigen.

C / C ++ Schnittstelle API

Im Folgenden sind die wichtigsten C & C ++ / SQLite-Interface-Programm auf Ihre Bedürfnisse mit SQLite-Datenbank in C / C ++ Programme erfüllen. Wenn Sie weitere Informationen benötigen, wenden Sie sich bitte die offizielle SQLite-Dokumentation.

序号API & 描述
1sqlite3_open(const char *filename, sqlite3 **ppDb)

该例程打开一个指向 SQLite 数据库文件的连接，返回一个用于其他 SQLite 程序的数据库连接对象。

如果filename参数是 NULL 或 ':memory:'，那么 sqlite3_open() 将会在 RAM 中创建一个内存数据库，这只会在 session 的有效时间内持续。

如果文件名 filename 不为 NULL，那么 sqlite3_open() 将使用这个参数值尝试打开数据库文件。如果该名称的文件不存在，sqlite3_open() 将创建一个新的命名为该名称的数据库文件并打开。

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

该例程提供了一个执行 SQL 命令的快捷方式，SQL 命令由 sql 参数提供，可以由多个 SQL 命令组成。

在这里，第一个参数sqlite3是打开的数据库对象，sqlite_callback是一个回调，data作为其第一个参数，errmsg 将被返回用来获取程序生成的任何错误。

sqlite3_exec() 程序解析并执行由sql参数所给的每个命令，直到字符串结束或者遇到错误为止。

3sqlite3_close(sqlite3*)

该例程关闭之前调用 sqlite3_open() 打开的数据库连接。所有与连接相关的语句都应在连接关闭之前完成。

如果还有查询没有完成，sqlite3_close() 将返回 SQLITE_BUSY 禁止关闭的错误消息。

Mit der Datenbank verbinden

Der folgende C-Code-Snippet zeigt, wie mit einer vorhandenen Datenbank zu verbinden. Wenn die Datenbank nicht vorhanden ist, wird sie erstellt, und kehrt schließlich ein Datenbankobjekt. 

#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, "Datenbank kann nicht geöffnet werden:% s \ n", sqlite3_errmsg (db));
      exit (0);
   } Else {
      fprintf (stderr, "Geöffnet Datenbank erfolgreich \ n");
   }
   sqlite3_close (db);
}

Nun lassen Sie uns zusammenzustellen und um das obige Programm ausführen, unsere Datenbanktest.db im aktuellen Verzeichnis erstellen.Sie können den Pfad nach Bedarf ändern. 

$ Gcc test.c -l sqlite3
$. / A.out
Geöffnete Datenbank erfolgreich

Wenn Sie die C ++ Quellcode verwenden möchten, können mit dem folgenden Code entsprechend zusammengestellt werden zeigt: 

$ G ++ test.c -l sqlite3

Hier unser Programm Links sqlite3-Bibliothek für C-Programm die notwendigen Funktionen zur Verfügung zu stellen. Dies wird eine Datenbankdatei test.db in Ihrem Verzeichnis zu erstellen, erhalten Sie die folgenden Ergebnisse erhalten: 

-rwxr-xr-x. 1 root root 7383 8. Mai 02.06 a.out
-rw-r - r-- 1 root root 323 8. Mai 02.05 test.c.
-rw-r - r-- 1 root root 0 8. Mai 02.06 test.db.

Erstellen Sie eine Tabelle

Der folgende C-Code-Snippet wird verwendet, um eine Tabelle in der Datenbank zu erstellen, die zuvor erstellt: 

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

static int Rückruf (void * NOTUSED, int argc, char ** argv, char ** azColName) {
   int i;
   for (i = 0; i & lt; 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;

   / * Offene Datenbank * /
   rc = sqlite3_open ( "test.db", & db);
   if (rc) {
      fprintf (stderr, "Datenbank kann nicht geöffnet werden:% s \ n", sqlite3_errmsg (db));
      exit (0);
   } Else {
      fprintf (stdout "Geöffnete Datenbank erfolgreich \ n");
   }

   Erstellen / * SQL-Anweisung * /
   sql = "CREATE TABLE COMPANY (" \
         "ID INT PRIMARY KEY NOT NULL," \
         "NAME TEXT NOT NULL," \
         "AGE INT NOT NULL," \
         "ADDRESS CHAR (50)," \
         "GEHALT REAL);"

   Ausführen / * SQL-Anweisung * /
   rc = sqlite3_exec (db, sql, Rückruf, 0, & zErrMsg);
   if (rc! = SQLITE_OK) {
   fprintf (stderr, "SQL-Fehler:% s \ n", zErrMsg);
      sqlite3_free (zErrMsg);
   } Else {
      fprintf (stdout "Tabelle erstellt erfolgreich \ n");
   }
   sqlite3_close (db);
   return 0;
}

Wenn das obige Programm kompiliert und ausgeführt wird, erstellt es COMPANY Tabelle in test.db Datei, die endgültige Liste der Dateien wie folgt: 

-rwxr-xr-x. 1 root root 9567 8. Mai 02.31 a.out
-rw-r - r-- 1 root root 1207 8. Mai 02.31 test.c.
-rw-r - r-- 1 root root 3072 8. Mai 02.31 test.db.

INSERT-Operation

Der folgende C-Code-Snippet zeigt, wie Datensätze in der Tabelle FIRMA oben erstellt zu erstellen: 

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

static int Rückruf (void * NOTUSED, int argc, char ** argv, char ** azColName) {
   int i;
   for (i = 0; i & lt; 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;

   / * Offene Datenbank * /
   rc = sqlite3_open ( "test.db", & db);
   if (rc) {
      fprintf (stderr, "Datenbank kann nicht geöffnet werden:% s \ n", sqlite3_errmsg (db));
      exit (0);
   } Else {
      fprintf (stderr, "Geöffnet Datenbank erfolgreich \ n");
   }

   Erstellen / * SQL-Anweisung * /
   sql = "INSERT INTO COMPANY (ID, Name, Alter, Adresse, GEHALT)" \
         "VALUES (1, 'Paul', 32, 'California', 20000.00)," \
         "INSERT INTO COMPANY (ID, Name, Alter, Adresse, GEHALT)" \
         "VALUES (2, 'Allen', 25 'Texas', 15000.00)," \
         "INSERT INTO COMPANY (ID, Name, Alter, Adresse, GEHALT)" \
         "VALUES (3, 'Teddy', 23," Norwegen ", 20000.00)," \
         "INSERT INTO COMPANY (ID, Name, Alter, Adresse, GEHALT)" \
         "VALUES (4, 'Mark', 25 ', Reiche-Mond', 65000.00);"

   Ausführen / * SQL-Anweisung * /
   rc = sqlite3_exec (db, sql, Rückruf, 0, & zErrMsg);
   if (rc! = SQLITE_OK) {
      fprintf (stderr, "SQL-Fehler:% s \ n", zErrMsg);
      sqlite3_free (zErrMsg);
   } Else {
      fprintf (stdout, "Aufzeichnungen erstellt erfolgreich \ n");
   }
   sqlite3_close (db);
   return 0;
}

Wenn das obige Programm kompiliert und ausgeführt wird, wird es für einen bestimmten Datensatz in der Tabelle FIRMA erstellen und zeigt die beiden folgenden Zeilen: 

Geöffnete Datenbank erfolgreich
Aufzeichnungen erstellt erfolgreich

SELECT-Operationen

Bevor wir dokumentierte Beispiele beginnen zu erklären, lassen Sie uns zunächst einige der Details der Callback-Funktion zu verstehen, die unserem Beispiel wird zu verwenden. Dieser Callback stellt die Ergebnisse einer SELECT-Anweisung Verfahren erhalten. Es erklärt sich wie folgt: 

typedef int (* sqlite3_callback) (
void *, / * Daten im 4. Argument von sqlite3_exec vorgesehen () * /
int, / * Die Anzahl der Spalten in der Zeile * /
char **, / * Ein Array von Strings Felder in der Zeile darstellen * /
char ** / * Ein Array von Strings Spaltennamen repräsentieren * /
);

Wenn die oben genannten Callback als dritter Parameter in sqlite_exec () Prozedur, dann SQLite SQL für jeden Datensatz innerhalb der Parameter der einzelnen SELECT-Anweisung Ausführungsprozess ruft die Callback-Funktion.

Der folgende C-Code-Snippet zeigt, wie aus der Tabelle FIRMA zuvor erstellt bekommen und zeigt den Datensatz: 

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

static int Rückruf (void * data, int argc, char ** argv, char ** azColName) {
   int i;
   fprintf (stderr, "% s:" (const char *) Daten);
   for (i = 0; i & lt; 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-Funktion namens";

   / * Offene Datenbank * /
   rc = sqlite3_open ( "test.db", & db);
   if (rc) {
      fprintf (stderr, "Datenbank kann nicht geöffnet werden:% s \ n", sqlite3_errmsg (db));
      exit (0);
   } Else {
      fprintf (stderr, "Geöffnet Datenbank erfolgreich \ n");
   }

   Erstellen / * SQL-Anweisung * /
   sql = "select * from COMPANY";

   Ausführen / * SQL-Anweisung * /
   rc = sqlite3_exec (db, sql, Rückruf, (void *) Daten & zErrMsg);
   if (rc! = SQLITE_OK) {
      fprintf (stderr, "SQL-Fehler:% s \ n", zErrMsg);
      sqlite3_free (zErrMsg);
   } Else {
      fprintf (stdout, "Operation erfolgreich \ n done");
   }
   sqlite3_close (db);
   return 0;
}

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

Geöffnete Datenbank erfolgreich
Callback-Funktion aufgerufen: ID = 1
NAME = Paul
AGE = 32
ADDRESS = Kalifornien
GEHALT = 20.000,0

Callback-Funktion aufgerufen: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
GEHALT = 15.000,0

Callback-Funktion aufgerufen: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norwegen
GEHALT = 20.000,0

Callback-Funktion aufgerufen: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Reiche-Mond
GEHALT = 65.000,0

Der Betrieb getan erfolgreich

UPDATE-Operation

Der folgende C-Code-Snippet zeigt, wie die UPDATE-Anweisung zu verwenden, um alle Datensätze zu aktualisieren, dann aus COMPANY Tisch zu bekommen und den aktualisierten Datensatz anzuzeigen: 

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

static int Rückruf (void * data, int argc, char ** argv, char ** azColName) {
   int i;
   fprintf (stderr, "% s:" (const char *) Daten);
   for (i = 0; i & lt; 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-Funktion namens";

   / * Offene Datenbank * /
   rc = sqlite3_open ( "test.db", & db);
   if (rc) {
      fprintf (stderr, "Datenbank kann nicht geöffnet werden:% s \ n", sqlite3_errmsg (db));
      exit (0);
   } Else {
      fprintf (stderr, "Geöffnet Datenbank erfolgreich \ n");
   }

   / * Fusionierten SQL-Anweisung erstellen * /
   sql = "UPDATE GESELLSCHAFT GEHALT = 25000.00 wo ID = 1;" \
         "Select * from COMPANY";

   Ausführen / * SQL-Anweisung * /
   rc = sqlite3_exec (db, sql, Rückruf, (void *) Daten & zErrMsg);
   if (rc! = SQLITE_OK) {
      fprintf (stderr, "SQL-Fehler:% s \ n", zErrMsg);
      sqlite3_free (zErrMsg);
   } Else {
      fprintf (stdout, "Operation erfolgreich \ n done");
   }
   sqlite3_close (db);
   return 0;
}

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

Geöffnete Datenbank erfolgreich
Callback-Funktion aufgerufen: ID = 1
NAME = Paul
AGE = 32
ADDRESS = Kalifornien
GEHALT = 25.000,0

Callback-Funktion aufgerufen: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
GEHALT = 15.000,0

Callback-Funktion aufgerufen: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norwegen
GEHALT = 20.000,0

Callback-Funktion aufgerufen: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Reiche-Mond
GEHALT = 65.000,0

Der Betrieb getan erfolgreich

DELETE-Operation

Der folgende C-Code-Snippet zeigt, wie die DELETE-Anweisung zu verwenden, um alle Datensätze löscht, und dann von der Firma Tabelle entnommen und zeigt die verbleibende Aufnahme: 

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

static int Rückruf (void * data, int argc, char ** argv, char ** azColName) {
   int i;
   fprintf (stderr, "% s:" (const char *) Daten);
   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-Funktion namens";

   / * Offene Datenbank * /
   rc = sqlite3_open ( "test.db", & db);
   if (rc) {
      fprintf (stderr, "Datenbank kann nicht geöffnet werden:% s \ n", sqlite3_errmsg (db));
      exit (0);
   } Else {
      fprintf (stderr, "Geöffnet Datenbank erfolgreich \ n");
   }

   / * Fusionierten SQL-Anweisung erstellen * /
   sql = "DELETE von Unternehmen, in dem ID = 2;" \
         "Select * from COMPANY";

   Ausführen / * SQL-Anweisung * /
   rc = sqlite3_exec (db, sql, Rückruf, (void *) Daten & zErrMsg);
   if (rc! = SQLITE_OK) {
      fprintf (stderr, "SQL-Fehler:% s \ n", zErrMsg);
      sqlite3_free (zErrMsg);
   } Else {
      fprintf (stdout, "Operation erfolgreich \ n done");
   }
   sqlite3_close (db);
   return 0;
}

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

Geöffnete Datenbank erfolgreich
Callback-Funktion aufgerufen: ID = 1
NAME = Paul
AGE = 32
ADDRESS = Kalifornien
GEHALT = 20.000,0

Callback-Funktion aufgerufen: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norwegen
GEHALT = 20.000,0

Callback-Funktion aufgerufen: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Reiche-Mond
GEHALT = 65.000,0

Der Betrieb getan erfolgreich