Tutorial de SQLite Linux para principiantes - Tutorial de introducción a SQLite

Este tutorial de SQLite Linux está destinado a principiantes que desean aprender cómo comenzar con la base de datos SQLite. SQLite es uno de los programas de bases de datos más utilizados del mundo. Entonces, ¿qué es una base de datos y qué es SQLite?

En este tutorial aprenderás:

• Qué es una base de datos y qué es SQLite

• Instalación rápida

• Cómo crear una base de datos usando SQLite

• Los conceptos básicos de SQLite

A partir de esto, podrá crear sus propias bases de datos simples y rápidamente podrá utilizarlas, cuando y donde sea necesario. SQLite se utiliza en muchísimos dispositivos en todo el mundo. Se debería considerar esto como una parte básica del aprendizaje informático.

¿Qué es SQLite y qué es una base de datos?

SQLite es un programa de base de datos de código abierto que utiliza un subconjunto del lenguaje descriptor de bases de datos SQL. Las bases de datos son útiles para recopilar paquetes de información similares en un solo lugar, una base de datos. SQL es un estándar abierto muy conocido. El lenguaje de consulta de la base de datos puede entonces enviar consultas para extraer datos particulares de la base de datos o seleccionar todos los datos.

Instalación rápida

Entonces empecemos. Este tutorial no trata sobre la instalación de programas. Hay muchos otros tutoriales para eso. Pero aquí hay algunos consejos que pueden ayudar a alguien nuevo en Linux. Por ejemplo, en Debian, se ejecutaría el comando:

$ apt install sqlite

que probablemente instalará SQLite versión 3. En Gentoo, sería:

$ emerge sqlite

entonces portage cargará y compilará automáticamente la versión más actual. Consulta la documentación de tu distribución. (synaptic, es otro instalador popular).

Para aquellos que prefieren compilar desde el código fuente, pueden escribir el siguiente script o descargarlo:

$ FILE=sqlite-autoconf-3360000
$ wget --show-progress https://sqlite.org/2021/${FILE}.tar.gz
$ tar zxvf ${FILE}.tar.gz
$ cd ${FILE}
$ ./configure --prefix=/usr/local
$ make
$ sudo make install
$ cd -

Ahora, si tuvo éxito con la instalación, escriba el siguiente comando:

$ sqlite

Probablemente recibirás un mensaje como:

bash: sqlite: command not found

Si presiona y luego , probablemente verá:

$ sqlite3
SQLite version 3.35.5 2021-04-19 18:32:05
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database.
sqlite> 

Si eso es lo que obtienes, ¡entonces estamos listos para rockear! (Sustituya la expresión apropiada….) Si no, su motor de búsqueda de Internet es su amigo.

Lo que significa el mensaje sqlite> es que SQLite está funcionando y listo para hacer lo que usted le diga. Ahora, salga escribiendo ^D o .exit.

Para los ejemplos asumiremos una persona arbitraria, en este caso un numismático (coleccionista de monedas). La base de datos se llamará numismatist.db y la tabla de esquema será coins. Por supuesto, eres bienvenido y te animamos a cambiar las cosas mientras trabajas con los ejemplos.

Hay muchas formas de empezar a utilizar SQLite. Comenzaremos con una representación de archivo de texto y construiremos a partir de ahí. Entonces, utilice su editor de texto favorito y edite numismatist.sql para que contenga lo siguiente (si aún no tiene un editor, siga leyendo y pronto podrá terminar de todos modos). ):

/*
 * numismatist.sql	Beginner's database
 */

PRAGMA foreign_keys=OFF;
BEGIN TRANSACTION;

Create Table coins(
	denomination	TEXT,
	value		FLOAT,
	comments	TEXT
);

Insert into coins values(
	'Quarter',
	30.35,
	'Gift from Grandpa'
);

COMMIT;

Ahora, guarde este archivo, luego haga una copia usted mismo, para cuando desee crear otra base de datos nueva, por ejemplo:

$ cp numismatist.sql skeleton.sql
$ chmod -w skeleton.sql

Ahora, cada vez que quieras empezar de nuevo o crear tu propia base de datos, tendrás un ejemplo trivial para modificar y ampliar. (O colóquelo en un archivo make en nuevo: y deje que make haga el trabajo, para aquellos que estén familiarizados con make).

A continuación, tenemos que decirle a SQLite que cree nuestra base de datos usando los comandos en el archivo que acabamos de crear. Entonces, tendremos una base de datos real.

$ cat numismatist.sql | sqlite3 numismatist.db

Ahora prueba que funcionó usando:

$ sqlite3 numismatist.db 'select * from coins'

Deberías ver algo muy similar a lo siguiente:

Quarter|30.35|Gift from Grandpa

Todo esto se puede hacer desde SQLite, si, por ejemplo, no tienes un editor o simplemente quieres trabajar directamente en SQLite para aprender su comportamiento en la línea de comandos. Simplemente escriba lo siguiente:

$ sqlite3 numismatist.db

Para obtener ayuda, utilice man sqlite3 o en el indicador sqlite>, escriba .help. Luego escriba los comandos del archivo numismatist.sql anterior. Ahora, escribe:

sqlite> select * from coins;

Nuevamente deberías ver:

Quarter|30.35|Gift from Grandpa

Ahora tenemos una base de datos. Veámoslo más de cerca. El comando create table coins(... creó el formato de registro para la base de datos.

El insertar en valores de monedas(... en realidad completó un registro. Ahora, puedes simplemente presionar y seguir editando y agregando registros hasta que tu corazón esté contenido. Enumere los registros con, seleccione * de monedas; Si olvida agregar el ;, obtendrá un ...> mensaje de continuación. Simplemente escriba ; allí y finalizará el comando.

Cómo se utilizan las bases de datos

Ahora que tenemos el bloque de construcción más básico, una base de datos, podemos explorar lo que sucede a medida que esta base de datos crece en tamaño. Las bases de datos suelen ser enormes, ¿no? Entonces, ¿cómo escribimos millones de líneas en una base de datos para realizar pruebas? ¡Nadie va a hacer eso! Simple, así es como (si usas bash), simplemente usa este script:

#!/bin/bash
function my_insert() {
      echo "insert into coins values('$1', $2, 'From Grandpa');"
}
i=1.25        # establish minimum coin value
for a in `seq 1 10000` ; do
      new_val=`calc "$i+$RANDOM/1000"`
      my_insert "Quarter-$a" $new_val >> big_add-list
      printf "Processing %i\n" $a # modulo 100 == 0 would be better
done

Ahora, combine los nuevos comandos en la base de datos existente:

$ cat big_add-list | sqlite3 numismatist.db
$ sqlite3 numismatist.db 'select * from coins'
Quarter|30.35|Gift from Grandpa
Quarter-1|126.11|From Grandpa
Quarter-2|193.31|From Grandpa
		.
		.
		.
Quarter-9998|290.69|From Grandpa
Quarter-9999|211.44|From Grandpa
Quarter-10000|286.31|From Grandpa

Y ahí lo tienes. Una gran base de datos llena de registros. Le animo a que entre y explore manualmente esta base de datos. Puede agregar, eliminar y modificar cualquiera de sus registros, hasta que esté satisfecho de comprender cómo funcionan las cosas. Y, si lo rompe, intente comprender qué hizo para romperlo y luego intente repararlo, en lugar de simplemente desecharlo y restaurar la copia de seguridad.

Ésta es una lección valiosa. Ahora, cada vez que desee agregar registros a una base de datos, simplemente coloque todos los comandos de inserción en un archivo y luego transmítalo a SQLite.

Los fundamentos de SQLite

Pero esto no es todo lo que puedes hacer con SQLite. Puede escribir programas que incluyan la biblioteca SQLite para permitirle crear lo que desee con ella. Como se mencionó, puede usar bash u otros scripts para ayudar a crear bases de datos extensas y bastante complejas. Puede explorar el comando select para consultar su base de datos de formas únicas. Este es solo el comienzo.

Estas son algunas de las muchas cosas que quizás desee estudiar a continuación en su viaje SQLite. Hay muchos, así que no consideres que esto sea ni siquiera una lista completa:

• interfaz del programa c/c++

• Interfaz de Python

• Navegador SQLite

Sería negligente si no explicara algunos de los comandos SQLite más comunes. Primero, los comandos dot se usan dentro del propio comando SQLite, pero consulte la página de manual y el comando .help, ya que serán mucho más completos:

sqlite> .help
.open		clears out memory
.open FILE	clears memory, then opens FILE
.dump		converts resident database to TEXT
.exit, .quit	terminates current session
.read FILE	reads database named FILE
.read '|cmd'	execute command 'cmd', then read its stream
.output	?FILE?	send output to FILE; reset to STDOUT
.shell, .system	execute an Operating System (shell) command
.save		writes database to storage
.show		display settings
.cd		change directory
.lint		identify possible schema errors

Y por último, aquí están los Tipos que pueden incluirse en cualquier registro (la lista no es exhaustiva):

• NULL valor vacío o nulo

• INTEGER Entero de 1 a 8 bytes

• FLOAT Número de punto flotante IEEE de 8 bytes

• TEXT UTF-8 Cadena de texto (actualmente el valor predeterminado para Linux)

• BLOB Datos almacenados palabra por palabra. Ejemplo: foto/jpeg, texto grande, binario

Conclusión

En este Tutorial de SQLite Linux hemos visto que crear una base de datos puede ser una tarea muy sencilla. Cuando se combina con SQLite, cualquier individuo tiene el poder de simplificar enormemente las tareas que comúnmente maneja una base de datos. Aquí hay algunas sugerencias para que el usuario experimente:

• Dirección y directorio telefónico

• Inventario (colecciones de monedas, etc.)

• Lista de quehaceres

• Archivos de archivo: fotografías; letras; currículums; artículos como este

• Divida un libro o códice completo en una base de datos con capacidad de búsqueda. (Esta es la tarea que asumió el autor en su primera experiencia con una base de datos. De hecho, varios códices a la vez).

Esperamos que hayas disfrutado de este artículo. No dude en enviar cualquier comentario que pueda tener.