En este artículo , nos gustaría presentar el artículo sobre SQLITE combinado con C++ o C.
Antes de continuar con este tutorial, debemos seguir el procedimiento de instalación de SQLITE3 que se puede encontrar fácilmente aquí . Al mismo tiempo se requiere un conocimiento básico de SQL .
Mostraremos las siguientes operaciones:
- Conexión/Creación de Base de Datos
- Crear mesa
- Insertar
- Borrar
- Seleccione
En aras de la simplicidad, usemos una base de datos simple hecha de una sola tabla.
Conexión a Base de Datos/Creación de Tabla
En este fragmento, utilizaremos dos rutinas contenidas en la biblioteca sqlite3.h .
- sqlite3_open(const char *filename, sqlite3 **ppDb) - sqlite3_close(sqlite3 *ppDb)
La compilación se ejecuta mediante la adición del comando -l sqlite3 .
#include <iostream>
#include <sqlite3.h>
int main(int argc, char** argv)
{
sqlite3* DB;
int exit = 0;
exit = sqlite3_open("example.db", &DB);
if (exit) {
std::cerr << "Error open DB " << sqlite3_errmsg(DB) << std::endl;
return (-1);
}
else
std::cout << "Opened Database Successfully!" << std::endl;
sqlite3_close(DB);
return (0);
}
Producción:
$ g++ createDB.cpp -l sqlite3 $ ./a.out Opened Database Successfully! $ ls create.cpp a.out example.db
La primera rutina devuelve un número entero: si el número entero es igual a 0, tuvo éxito. Si la base de datos aún no existe, se creará en el mismo directorio donde se ejecutó el proceso.
El segundo simplemente cierra la conexión previamente abierta por SQLITE3_OPEN() .
Toda declaración preparada asociada con la conexión debe finalizarse antes de cerrar la conexión.
Crear mesa
En este fragmento usaremos la rutina:
- sqlite3_exec(sqlite3*, const char *sql, sqlite_callback, void *data, char **errmsg)
#include <iostream>
#include <sqlite3.h>
int main(int argc, char** argv)
{
sqlite3* DB;
std::string sql = "CREATE TABLE PERSON("
"ID INT PRIMARY KEY NOT NULL, "
"NAME TEXT NOT NULL, "
"SURNAME TEXT NOT NULL, "
"AGE INT NOT NULL, "
"ADDRESS CHAR(50), "
"SALARY REAL );";
int exit = 0;
exit = sqlite3_open("example.db", &DB);
char* messaggeError;
exit = sqlite3_exec(DB, sql.c_str(), NULL, 0, &messaggeError);
if (exit != SQLITE_OK) {
std::cerr << "Error Create Table" << std::endl;
sqlite3_free(messaggeError);
}
else
std::cout << "Table created Successfully" << std::endl;
sqlite3_close(DB);
return (0);
}
Producción:
$ g++ createTable.cpp -l sqlite3 $ ./a.out Table created Successfully
Esta rutina devuelve un número entero: si el número entero es igual a la macro SQLITE_OK , todo funcionó bien.
Para este ejemplo, se omiten los controles de apertura de Base de datos, que están escritos en el código pasado.
Insertar y Eliminar
Usaremos la rutina SQLITE3_EXEC() para Insertar también. El procedimiento y las comprobaciones son similares al anterior. Solo hay una diferencia en la string que usamos con SQLITE3_EXEC() .
#include <iostream>
#include <sqlite3.h>
#include <string>
using namespace std;
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* messaggeError;
int exit = sqlite3_open("example.db", &DB);
string query = "SELECT * FROM PERSON;";
cout << "STATE OF TABLE BEFORE INSERT" << endl;
sqlite3_exec(DB, query.c_str(), callback, NULL, NULL);
string sql("INSERT INTO PERSON VALUES(1, 'STEVE', 'GATES', 30, 'PALO ALTO', 1000.0);"
"INSERT INTO PERSON VALUES(2, 'BILL', 'ALLEN', 20, 'SEATTLE', 300.22);"
"INSERT INTO PERSON VALUES(3, 'PAUL', 'JOBS', 24, 'SEATTLE', 9900.0);");
exit = sqlite3_exec(DB, sql.c_str(), NULL, 0, &messaggeError);
if (exit != SQLITE_OK) {
std::cerr << "Error Insert" << std::endl;
sqlite3_free(messaggeError);
}
else
std::cout << "Records created Successfully!" << std::endl;
cout << "STATE OF TABLE AFTER INSERT" << endl;
sqlite3_exec(DB, query.c_str(), callback, NULL, NULL);
sql = "DELETE FROM PERSON WHERE ID = 2;";
exit = sqlite3_exec(DB, sql.c_str(), NULL, 0, &messaggeError);
if (exit != SQLITE_OK) {
std::cerr << "Error DELETE" << std::endl;
sqlite3_free(messaggeError);
}
else
std::cout << "Record deleted Successfully!" << std::endl;
cout << "STATE OF TABLE AFTER DELETE OF ELEMENT" << endl;
sqlite3_exec(DB, query.c_str(), callback, NULL, NULL);
sqlite3_close(DB);
return (0);
}
Producción:
$ g++ insertDelete.cpp -l sqlite3 $ ./a.out STATE OF TABLE BEFORE INSERT Records created Successfully! STATE OF TABLE AFTER INSERT ID = 1 NAME = STEVE SURNAME = GATES AGE = 30 ADDRESS = PALO ALTO SALARY = 1000.0 ID = 2 NAME = BILL SURNAME = ALLEN AGE = 20 ADDRESS = SEATTLE SALARY = 300.22 ID = 3 NAME = PAUL SURNAME = JOBS AGE = 24 ADDRESS = SEATTLE SALARY = 9900.0 Record deleted Successfully! STATE OF TABLE AFTER DELETE OF ELEMENT ID = 1 NAME = STEVE SURNAME = GATES AGE = 30 ADDRESS = PALO ALTO SALARY = 1000.0 ID = 3 NAME = PAUL SURNAME = JOBS AGE = 24 ADDRESS = SEATTLE SALARY = 9900.0
Seleccione
Antes de continuar mostrando la operación Seleccionar, que podríamos considerar fácilmente la más importante de todo el tutorial, echemos un vistazo al prototipo de devolución de llamada , que vamos a usar en nuestro ejemplo.
Esta operación nos permite obtener una salida de la operación Seleccionar:
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 */ );
Ahora, usaremos la función de devolución de llamada en Seleccionar como se muestra en el siguiente fragmento:
#include <iostream>
#include <sqlite3.h>
using namespace std;
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;
int exit = 0;
exit = sqlite3_open("example.db", &DB);
string data("CALLBACK FUNCTION");
string sql("SELECT * FROM PERSON;");
if (exit) {
std::cerr << "Error open DB " << sqlite3_errmsg(DB) << std::endl;
return (-1);
}
else
std::cout << "Opened Database Successfully!" << std::endl;
int rc = sqlite3_exec(DB, sql.c_str(), callback, (void*)data.c_str(), NULL);
if (rc != SQLITE_OK)
cerr << "Error SELECT" << endl;
else {
cout << "Operation OK!" << endl;
}
sqlite3_close(DB);
return (0);
}
Salida:
$g++ select.cpp -l sqlite3
$./a.out
Opened Database Successfully! RESULT OF SELECT ID = 1 NAME = STEVE SURNAME = GATES AGE = 30 ADDRESS = PALO ALTO SALARY = 1000.0 ID = 3 NAME = PAUL SURNAME = JOBS AGE = 24 ADDRESS = SEATTLE SALARY = 9900.0 Operation OK!
Este artículo proporciona una guía rápida para bases de datos con SQLITE3 usando C++/C.
En nuestros ejemplos, usamos C++, pero cuando pasamos nuestras strings, llamamos al método c_str() , para convertir la string en una array de caracteres: esto demuestra que todas las rutinas utilizadas también se pueden utilizar en C.
Este artículo fue escrito en colaboración con Vittorio Triassi , estudiante del Departamento de Ciencia y Tecnología de la Universidad de Nápoles Parthenope .
Publicación traducida automáticamente
Artículo escrito por GiovanniDezio y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA