SQLite - C/C++

Installer

Avant d'utiliser SQLite dans un programme C/C++, nous devons nous assurer que la bibliothèque SQLite est déjà présente sur la machine. Vous pouvez vous référer au chapitre sur l'installation de SQLite pour comprendre le processus d'installation.

API d'interface C/C++

Voici les routines d'interface C/C++ / SQLite importantes qui peuvent répondre à vos besoins d'utilisation de la base de données SQLite dans des programmes C/C++. Si vous avez besoin de plus de détails, veuillez consulter la documentation officielle de SQLite.

Non.API et description
1sqlite3_open(const char *filename, sqlite3 **ppDb)

Cette routine ouvre une connexion à un fichier de base de données SQLite et renvoie un objet de connexion à la base de données à utiliser par d'autres routines SQLite.

Si le paramètrefilenameest NULL ou ':memory:', alors sqlite3_open() créera une base de données en mémoire dans la RAM, qui ne durera que le temps de la session.

Si le paramètre filename n'est pas NULL, alors sqlite3_open() tentera d'ouvrir le fichier de base de données en utilisant la valeur de ce paramètre. Si le fichier portant ce nom n'existe pas, sqlite3_open() créera un nouveau fichier de base de données portant ce nom et l'ouvrira.

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

Cette routine fournit un raccourci pour exécuter des commandes SQL. Les commandes SQL sont fournies par le paramètre sql et peuvent consister en plusieurs commandes SQL.

Ici, le premier paramètresqlite3est l'objet de base de données ouvert,sqlite_callbackest une fonction de rappel,dataComme premier paramètre, errmsg sera renvoyé pour récupérer toute erreur générée par le programme.

La routine sqlite3_exec() analyse et exécutesqlchaque commande donnée par le paramètre, jusqu'à la fin de la chaîne ou qu'une erreur soit rencontrée.

3sqlite3_close(sqlite3*)

Cette routine ferme la connexion à la base de données précédemment ouverte en appelant sqlite3_open(). Toutes les instructions associées à la connexion doivent être terminées avant que la connexion ne soit fermée.

S'il reste des requêtes inachevées, sqlite3_close() renverra un message d'erreur SQLITE_BUSY interdisant la fermeture.

Connexion à la base de données

L'extrait de code C suivant montre comment se connecter à une base de données existante. Si la base de données n'existe pas, elle sera créée, et finalement un objet de base de données sera renvoyé.

#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));
      exit(0);
   }else{
      fprintf(stderr, "Opened database successfully\n");
   }
   sqlite3_close(db);
}

Maintenant, compilons et exécutons le programme ci-dessus pour créer notre base de données dans le répertoire couranttest.db. Vous pouvez modifier le chemin selon vos besoins.

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

Si vous souhaitez utiliser du code source C++, vous pouvez compiler le code comme indiqué ci-dessous :

$g++ test.c -l sqlite3

Ici, liez notre programme à la bibliothèque sqlite3 pour fournir les fonctions nécessaires au programme C. Cela créera un fichier de base de données test.db dans votre répertoire, et vous obtiendrez le résultat suivant :

-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

Créer une table

L'extrait de code C suivant sera utilisé pour créer une table dans la base de données créée précédemment :

#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));
      exit(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;
}

Lorsque le programme ci-dessus est compilé et exécuté, il créera la table COMPANY dans le fichier test.db. La liste finale des fichiers est la suivante :

-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

Opération INSERT

L'extrait de code C suivant montre comment créer des enregistrements dans la table COMPANY créée ci-dessus :

#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));
      exit(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;
}

Lorsque le programme ci-dessus est compilé et exécuté, il créera les enregistrements donnés dans la table COMPANY et affichera les deux lignes suivantes :

Opened database successfully
Records created successfully

Opération SELECT

Avant de commencer à expliquer l'exemple de récupération d'enregistrements, comprenons d'abord quelques détails de la fonction de rappel, qui sera utilisée dans notre exemple. Cette fonction de rappel fournit un moyen d'obtenir des résultats à partir d'une instruction SELECT. Elle est déclarée comme suit :

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

Si la fonction de rappel ci-dessus est passée comme troisième paramètre dans la routine sqlite_exec(), alors SQLite appellera cette fonction de rappel pour chaque enregistrement traité dans chaque instruction SELECT exécutée dans le paramètre SQL.

L'extrait de code C suivant montre comment récupérer et afficher des enregistrements de la table COMPANY créée précédemment :

#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));
      exit(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;
}

Lorsque le programme ci-dessus est compilé et exécuté, il produira le résultat suivant :

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

Opération UPDATE

L'extrait de code C suivant montre comment utiliser une instruction UPDATE pour mettre à jour n'importe quel enregistrement, puis récupérer et afficher les enregistrements mis à jour de la table COMPANY :

#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));
      exit(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;
}

Lorsque le programme ci-dessus est compilé et exécuté, il produira le résultat suivant :

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

Opération DELETE

L'extrait de code C suivant montre comment utiliser une instruction DELETE pour supprimer n'importe quel enregistrement, puis récupérer et afficher les enregistrements restants de la table COMPANY :

#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));
      exit(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;
}

Lorsque le programme ci-dessus est compilé et exécuté, il produira le résultat suivant :

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
Autres extensions