SQLite - C/C++

Instalación

Antes de usar SQLite en programas C/C++, debemos asegurarnos de que la biblioteca SQLite ya esté instalada en la máquina. Puede consultar el capítulo de instalación de SQLite para conocer el proceso de instalación.

API de interfaz C/C++

A continuación se muestran los importantes programas de interfaz C&C++/SQLite que pueden satisfacer sus necesidades de usar la base de datos SQLite en programas C/C++. Si necesita más detalles, consulte la documentación oficial de SQLite.

N.ºAPI y descripción
1sqlite3_open(const char *filename, sqlite3 **ppDb)

Esta rutina abre una conexión a un archivo de base de datos SQLite y devuelve un objeto de conexión de base de datos utilizado para otros programas SQLite.

Sifilenameel parámetro es NULL o ':memory:', entonces sqlite3_open() creará una base de datos en memoria en la RAM, que solo persistirá mientras dure la sesión.

Si el nombre de archivo filename no es NULL, sqlite3_open() intentará abrir el archivo de base de datos usando este valor de parámetro. Si el archivo con ese nombre no existe, sqlite3_open() creará y abrirá un nuevo archivo de base de datos con ese nombre.

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

Esta rutina proporciona un método abreviado para ejecutar comandos SQL, los cuales son proporcionados por el parámetro sql y pueden consistir en múltiples comandos SQL.

Aquí, el primer parámetrosqlite3es el objeto de base de datos abierto,sqlite_callbackes una devolución de llamada (callback),datacomo su primer parámetro, se devolverá errmsg para obtener cualquier error generado por el programa.

El programa sqlite3_exec() analiza y ejecuta cada comando dado porsqlel parámetro, hasta el final de la cadena o hasta que se encuentre un error.

3sqlite3_close(sqlite3*)

Esta rutina cierra la conexión de base de datos abierta anteriormente por sqlite3_open(). Todas las declaraciones relacionadas con la conexión deben completarse antes de cerrar la conexión.

Si aún hay consultas sin completar, sqlite3_close() devolverá el mensaje de error SQLITE_BUSY que prohíbe el cierre.

Conectar a la base de datos

El siguiente fragmento de código C muestra cómo conectarse a una base de datos existente. Si la base de datos no existe, se creará y finalmente se devolverá un objeto de base de datos.

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

Ahora, compilemos y ejecutemos el programa anterior para crear nuestra base de datos en el directorio actual.test.db. Puede cambiar la ruta según sea necesario.

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

Si desea usar código fuente de C++, puede compilar el código como se muestra a continuación:

$g++ test.c -l sqlite3

Aquí, enlazamos nuestro programa con la biblioteca sqlite3 para proporcionar las funciones necesarias al programa C. Esto creará un archivo de base de datos test.db en su directorio, y obtendrá el siguiente resultado:

-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

Crear tabla

El siguiente fragmento de código C se utilizará para crear una tabla en la base de datos creada anteriormente:

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

Cuando el programa anterior se compila y ejecuta, creará la tabla COMPANY en el archivo test.db. La lista final de archivos es la siguiente:

-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

Operación INSERT

El siguiente fragmento de código C muestra cómo crear registros en la tabla COMPANY creada anteriormente:

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

Cuando el programa anterior se compila y ejecuta, creará los registros dados en la tabla COMPANY y mostrará las siguientes dos líneas:

Opened database successfully
Records created successfully

Operación SELECT

Antes de empezar a explicar el ejemplo de obtención de registros, comprendamos algunos detalles de la función de devolución de llamada, que se utilizará en nuestro ejemplo. Esta devolución de llamada proporciona una forma de obtener resultados de sentencias SELECT. Se declara de la siguiente manera:

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 devolución de llamada anterior se usa como tercer parámetro en el programa sqlite_exec(), SQLite invocará esta función de devolución de llamada para cada registro procesado en cada sentencia SELECT ejecutada dentro del parámetro SQL.

El siguiente fragmento de código C muestra cómo obtener y mostrar registros de la tabla COMPANY creada anteriormente:

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

Cuando el programa anterior se compila y ejecuta, producirá el siguiente resultado:

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

Operación UPDATE

El siguiente fragmento de código C muestra cómo usar la sentencia UPDATE para actualizar cualquier registro, y luego obtener y mostrar los registros actualizados de la tabla 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;
}

Cuando el programa anterior se compila y ejecuta, producirá el siguiente resultado:

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

Operación DELETE

El siguiente fragmento de código C muestra cómo usar la sentencia DELETE para eliminar cualquier registro, y luego obtener y mostrar los registros restantes de la tabla 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;
}

Cuando el programa anterior se compila y ejecuta, producirá el siguiente resultado:

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
Otras extensiones