Si ha trabajado con sistemas de bases de datos relacionales, es probable que haya oído hablar de sistemas de bases de datos populares como MySQL, SQL Server o PostgreSQL. SQLite es otro RDBMS extremadamente útil que es muy simple de configurar y operar. Además, tiene muchas características distintas sobre otras bases de datos relacionales. Este tutorial de SQLite enseña conceptos básicos que necesita saber con la ayuda de extensas prácticas prácticas.
Los temas discutidos en este artículo son:
- ¿Qué es SQLite?
- Características de SQLite
- Instalación de SQLite en Windows
- Comandos SQLite
- Comandos de base de datos
- Comandos de tabla
- Operaciones CRUD
- Cláusulas/Condiciones de SQLite
- Únete a SQLite
- Desventajas de SQLite
Tutorial de SQLite:¿Qué es SQLite?
Aquí está la definición estándar de la industria de SQLite:
SQLite es un motor de base de datos relacional de transacciones de código abierto, sin configuración, autónomo e independiente diseñado para integrarse en una aplicación.
Puedes considerar SQLite como un “encendedor ” versión de otro RDBMS complejo (Oracle, SQL, etc.), donde su motor de base de datos está configurado para procesamiento independiente (biblioteca en proceso) es decir, un sin servidor, autónomo, sin configuración y transaccional . Es conocido por su portabilidad, confiabilidad y gran rendimiento incluso en entornos con poca memoria. Además, SQLite es una opción popular como base de datos integrada para almacenamiento local/cliente en aplicaciones o programas finales, a diferencia de otros RDBMS, donde se configura el motor de base de datos cliente-servidor.
Características de SQLite
SQLite ofrece muchas funciones distintas, como:
- Sin servidor: La mayoría de las bases de datos SQL se implementan como un proceso de servidor independiente, pero SQLite no tiene un proceso de servidor independiente. Es un motor de base de datos sin servidor. Lee y escribe directamente en archivos de disco ordinarios.
- Configuración cero: No requiere configuración para que funcione. Esto significa que no hay ningún proceso de servidor que deba iniciarse, detenerse o configurarse como en un sistema cliente/servidor.
- Escribir manifiesto: SQLite utiliza la tipificación de manifiesto, que permite el almacenamiento de cualquier cantidad de cualquier tipo de datos en cualquier columna sin importar el tipo de datos declarado de la columna. Tenga en cuenta que hay ciertas excepciones a esta regla.
- Ligero: Como su nombre lo indica, la biblioteca SQLite es muy liviana. El caso es que, aunque el espacio que utiliza varía según el sistema donde se instale, puede ocupar menos de 600KiB de espacio.
- Portátil: A diferencia de otros DBMS, una base de datos SQLite completa se almacena en un solo archivo. Este archivo se puede compartir a través de medios extraíbles o protocolo de transferencia de archivos muy fácilmente.
- Opciones diversas: Muchos lenguajes de programación proporcionan enlaces para SQLite, incluidos C, C++, C#, Java, JavaScript, Ruby, Python y muchos más.
- Gratis: SQLite es gratuito y de código abierto. Para trabajar con SQLite no se requiere una licencia comercial.
Como se mencionó anteriormente, SQLite es conocido por su configuración cero, lo que significa que no se requiere una configuración o administración compleja. En la siguiente parte de este tutorial de SQLite, veamos cómo instalar SQLite en su sistema.
Tutorial de SQLite:Instalación de SQLite en Windows
Los pasos a seguir son:
Esta herramienta de línea de comandos de SQLite contendrá los siguientes productos de SQLite
- Núcleo de SQLite :El núcleo de SQLite contiene el motor de base de datos real y la API pública.
- Herramienta de línea de comandos SQLite3 :La aplicación sqlite3 es una herramienta de línea de comandos construida sobre el núcleo de SQLite.
- Extensión Tcl :Esta biblioteca es esencialmente una copia del núcleo de SQLite con los enlaces Tcl añadidos.
- Herramienta de análisis de SQLite :La herramienta de análisis de SQLite se utiliza para analizar archivos de bases de datos.
Paso 3: Después de eso, iniciar la línea de comandos de SQLite es tan simple como hacer clic en la aplicación sqlite3, lo que hará que aparezca la línea de comandos.
Si desea realizar más pruebas, simplemente escriba .help comando desde sqlite> solicitud para ver todos los comandos disponibles en sqlite3 como se muestra a continuación.
Nota: De forma predeterminada, una sesión de SQLite usa la base de datos en memoria, por lo tanto, todos los cambios desaparecerán cuando finalice la sesión.
Bastante simple, ¿verdad? Luego, comencemos con los comandos de SQLite.
Tutorial SQLite:Comandos SQLite
Esta sección del tutorial de SQLite presenta instrucciones SQL básicas que puede usar con SQLite.
Nota: Los comandos de SQLite terminan con un punto y coma (; ). Le dice a SQLite que su comando está completo y debe ejecutarse. Además, puede distribuir su comando en varias líneas y usar el punto y coma en la última línea.
Comandos de base de datos
Esta sección consta de esos comandos, mediante los cuales puede manejar su base de datos. Los comandos son:
- Crear base de datos SQLite
SQLite no usa la declaración CREATE DATABASE como en otros sistemas de administración de bases de datos relacionales, como MySQL, SQL Server, etc. Para crear una nueva base de datos en SQLite, simplemente ingrese sqlite3 seguido por el nombre del archivo que desea utilizar para la base de datos. El siguiente código crea un archivo de base de datos llamado StudentDetails.db:
Ejemplo
sqlite3 StudentDetails.db; sqlite> .databases main: D:sqliteStudentDetails.db;
- Base de datos adjunta de SQLite
Cuando tiene varias bases de datos, solo puede usar una a la vez. En SQLite, la declaración ATTACH DATABASE se usa para adjuntar una base de datos particular para la conexión actual. Después de este comando, todas las declaraciones de SQLite se ejecutarán en la base de datos adjunta.
Ejemplo
sqlite> ATTACH DATABASE 'DepartmentDetails.db' AS 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db
- Base de datos separada de SQLite
En SQLite, la declaración DETACH DATABASE se usa para separar la base de datos con nombre de alias de una conexión de base de datos que se adjuntó previamente mediante la declaración ATTACH. Si el mismo archivo de base de datos se adjuntó con varios alias, este comando desconectará solo el nombre dado y el resto del archivo adjunto seguirá existiendo. Las bases de datos dentro de la base de datos en memoria o temporal se destruirán por completo y el contenido se perderá.
Ejemplo
sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db Student: D:sqliteStudentDetails.db DeptInformation: D:sqliteDepartmentDetails.db sqlite> DETACH DATABASE 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Student: D:sqliteStudentDetails.db DeptInformation: D:sqliteDepartmentDetails.db
Comandos de tabla
Aquí aprenderemos cómo manejar tablas cuando usamos SQLite.
- Crear tabla de SQL
En SQLite, la declaración CREATE TABLE se usa para crear una nueva tabla. Al crear la tabla, debe nombrar la tabla y definir su columna y los tipos de datos de cada columna.
Sintaxis:
CREATE TABLE table_name( Column1 column_type [constraints] Column2 column_type [constraints] [.....] );
Ejemplo
CREATE TABLE StudentInfo( ID INT PRIMARY KEY NOT NULL, NAME TEXT NOT NULL, AGE INT NOT NULL, ADDRESS CHAR(50), DEPARTMENTID INTEGER NOT NULL, PHONE TEXT DEFAULT 'UNKNOWN', FOREIGN KEY(DEPARTMENTID) REFERENCES DepartmentInfo(DeptID) );
Puede verificar si la tabla se creó o no usando las .tables comando como se muestra a continuación. Tenga en cuenta que ya he creado una tabla llamada DepartmentInfo donde DeptID es la clave principal. La tabla de departamentos tiene una restricción de clave externa para la tabla de estudiantes.
sqlite> .tables StudentInfo Contacts Emp_Master
- Tabla desplegable de SQLite
En SQLite, la declaración DROP TABLE le permite eliminar o eliminar una tabla de la base de datos de SQLite. Una vez que se elimina la tabla, todos los datos que contiene se eliminan permanentemente de la base de datos. También se eliminan todos los índices y activadores asociados. Si hay alguna restricción de clave externa habilitada en esa tabla, se eliminará de manera equivalente para cada fila de la tabla y también se eliminarán todos los activadores asociados con la tabla.
Sintaxis
DROP TABLE [ IF EXISTS ] table_name;
Ejemplo
DROP TABLE Department; Error: no such table: Department DROP TABLE Company; sqlite> .tables StudentInfo
Además, hay una instrucción SQLite Alter Table , que entenderemos en las próximas secciones de este artículo. Ahora que hemos creado una tabla, veamos cómo insertar, eliminar y modificar los datos.
Tutorial SQLite:Operaciones CRUD
- Consulta de inserción de SQLite
Después de crear la tabla, el comando Insertar en de SQLite se puede usar para crear nuevas filas en la tabla especificada. Hay dos formas significativas de la declaración de inserción de SQLite. El primer formulario usa una cláusula VALUES para especificar una lista de valores para insertar.
Sintaxis
INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)] VALUES (value1, value2, value3,...valueN);
Ejemplo
INSERT INTO StudentInfo ( ID, NAME, AGE, ADDRESS, DEPARTMENTID, PHONE) VALUES (1,'Dean', 20, 'California', 2, '934*******');
Salida
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934*******
Aquí, se crea una sola fila nueva y cada valor se registra en su columna respectiva. Tenga en cuenta que ambas listas deben tener el mismo número de items. Aquí, la lista de las columnas es opcional. También podemos insertar datos a la tabla sin especificar la lista de columnas .
Ejemplo
INSERT INTO StudentInfo VALUES ( 2, 'SAM', 22, 'Texas', 2, '976*******');
Salida
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976*******
SQLite también ofrece una función para insertar varias filas en una sola instrucción INSERT. La sintaxis es como se muestra a continuación.
Ejemplo
INSERT INTO StudentInfo VALUES (3,'John',23,'Norway',1,'923*******'), (4,'Mitch',22,'Houston',3,'934*******');
Salida
Select *from StudentInfo; 1|Dean|20|California|2|934******* 2|SAM|22|Texas|2|976******* 3|John|23|Norway|1|923******* 4|Mitch|22|Houston|3|934*******
Como puede ver, el formato de la salida no es muy similar al anterior. Entonces, ¿cómo cambia el formato de salida en SQLite? Vamos a formatear la salida para que nuestros resultados sean un poco más fáciles de leer.
- Formando
Puedes usar .mode para cambiar el modo de salida. El ejemplo anterior usa .mode list, que muestra los resultados en forma de lista. Además, puede utilizar .headers instrucción para especificar si mostrar o no los encabezados de las columnas. Una vez que haya realizado los cambios, puede ver la configuración usando .show comando.
Ejemplo
sqlite>.mode 'column' sqlite> .headers on sqlite> .show echo: off eqp: off explain: auto headers: on mode: column nullvalue: "" output: stdout colseparator: "|" rowseparator: "n" stats: off width: filename: StudentDetails.db
Salida
SELECT *FROM StudentInfo; ID NAME AGE ADDRESS DEPARTMENT PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934*******
- Consulta de selección de SQLite
En SQLite, la instrucción Select se usa para obtener datos de una tabla, que devuelve datos en forma de una tabla de resultados. Estas tablas de resultados también se denominan conjuntos de resultados. Usando la declaración de selección de SQLite, podemos realizar cálculos simples o múltiples expresiones según nuestros requisitos. Ya usamos una declaración SELECT anteriormente cuando insertamos datos.
Sintaxis
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr]
- DISTINTO – Cuando usamos una palabra clave distinta en una declaración de selección, solo devuelve filas distintas de datos.
- TODOS – Si usamos la palabra clave TODOS en una declaración de selección, devuelve todas las filas de datos incluso si están duplicados.
- DESDE tabla-lista – Es una lista de tablas de las que desea obtener datos.
- expresión WHERE – La expresión WHERE se usa para definir nuestras condiciones personalizadas para obtener los datos requeridos de las tablas.
Ejemplo1
SELECT ID, NAME FROM StudentInfo WHERE AGE < 21;
Salida
ID NAME ---------- ---------- 1 Dean
Ejemplo2
Select NAME FROM StudentInfo WHERE DEPARTMENTID = (SELECT DeptID FROM DepartmentInfo WHERE DeptName = 'Psychology');
Salida
//fetches people from department whose id is 2 NAME ---------- Dean SAM
- Consulta de actualización de SQLite
En SQLite, la declaración UPDATE se puede usar para modificar los registros existentes en una tabla. La cláusula WHERE de SQLite se puede usar para especificar exactamente qué filas se deben actualizar. Puede actualizar fácilmente todas las filas, algunas filas o ninguna, según las condiciones de filtrado aplicadas por la cláusula WHERE.
Sintaxis
UPDATE table_name SET column1 = value1, column2 = value2...., columnN = valueN WHERE [condition];
Ejemplo
UPDATE StudentInfo SET DEPARTMENTID = 4 WHERE ID = '2';
Salida
SELECT *FROM StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 4 976******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934*******
- Consulta de eliminación de SQLite
En SQLite, la declaración DELETE se puede usar para eliminar el registro de la tabla. Puede eliminar fácilmente todas las filas, algunas filas o ninguna, según las condiciones de filtrado aplicadas por la cláusula WHERE.
Ejemplo
DELETE FROM DepartmentInfo WHERE DeptName = 'Science';
Salida
SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music
Si intenta eliminar un registro al que hace referencia una clave externa, obtendrá un error. Primero deberá eliminar los registros de clave externa, antes de eliminar el registro de clave principal. Intentemos eliminar el departamento de ciencias.
Ejemplo
DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; Error: FOREIGN KEY constraint failed
Por lo tanto, debemos eliminar los registros de clave externa antes de eliminar la clave principal.
DELETE FROM StudentInfo WHERE DEPARTMENTID = 4; sqlite> DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; sqlite> SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports SELECT *FROM StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2 934******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934*******
Ahora ya sabe cómo editar los registros en la tabla de la base de datos SQLite. Avanzando más en este blog de tutoriales de SQLite, analicemos las diferentes cláusulas y condiciones con las que se encuentra en SQLite con más frecuencia.
Cláusulas/Condiciones de SQLite
Antes de comenzar con las cláusulas, esta es la sintaxis completa de la instrucción SELECT en SQLite.
Sintaxis
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr] [GROUP BY expr-list] [HAVING expr] [compound-op select]* [ORDER BY sort-expr-list] [LIMIT integer [(OFFSET|,) integer]]
Nota:actualicé las tablas StudentInfo y DepartmentInfo como se muestra a continuación.
//Student Table ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2 934******* 3 John 23 Norway 1 923******* 4 Mitch 22 Houston 3 934******* 2 SAM 22 Texas 4 976******* 5 Johny 23 Norway 2 945******* 6 Robin 23 Norway 2 UNKNOWN //Department Details DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music 5 Science
- SQLite DONDE
En SQLite, la cláusula WHERE se usa para imponer restricciones en la declaración SELECT definiendo una o más condiciones para obtener los datos requeridos de las tablas en la base de datos. Si la condición especificada se cumple o es verdadera, devuelve un valor específico de la tabla. Como ha visto antes, la cláusula WHERE no solo se usa en la declaración SELECT, sino que también se usa en la declaración UPDATE, DELETE, etc.
Ejemplo
SELECT NAME FROM StudentInfo WHERE AGE = 23;NAME ---------- John Johny Robin
En SQLite, hay una serie de operadores relacionales que se pueden usar con la cláusula WHERE.
- SQLite GRUPO POR
En SQLite, la cláusula GROUP BY se usa para agregar datos en una sola fila donde se repite el valor de una o más columnas especificadas. Esta cláusula se usa con la cláusula WHERE en la instrucción SELECT y precede a la cláusula ORDER BY.
Sintaxis
SELECT result FROM [table-list] GROUP BY [expr-list]
SELECT NAME, ADDRESS FROM StudentInfo GROUP BY NAME; NAME ADDRESS ---------- ---------- Dean California John Norway Johny Norway Mitch Houston Robin Norway SAM Texas
Observe que el proceso de agrupación consta de dos pasos. Primero, la expresión GROUP BY se usa para organizar las filas de la tabla en diferentes grupos. Una vez que se definen los grupos, la declaración SELECT define cómo esos grupos se aplanan en una sola fila.
- SQLite ORDENAR POR
Por lo general, las tablas de SQLite almacenan datos en un orden no especificado y devolverán registros en el mismo orden no especificado mientras obtienen datos mediante la declaración de selección de SQLite. En tales casos, puede usar la cláusula ORDER BY para ordenar los registros de columna en orden ascendente o descendente. En el siguiente ejemplo, he agrupado y ordenado (en orden descendente) los datos según la dirección.
Sintaxis
SELECT expressions FROM tables-list [WHERE conditions] ORDER BY column1, column2,... [ ASC | DESC ];
Ejemplo
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS ORDER BY ADDRESS DESC; ADDRESS COUNT(ADDRESS) ---------- -------------- Texas 1 Norway 3 Houston 1 California 1
- SQLite TENIENDO POR
En SQLite, HAVING la cláusula es idéntica a WHERE cláusula. La cláusula HAVING es una condición adicional que se aplica después de que se lleva a cabo la agregación junto con el grupo en la declaración de selección. Generalmente en SQLite, DÓNDE se usa para aplicar una condición a elementos individuales en una tabla y HAVING La cláusula se usa para agregar condiciones de filtro basadas en los grupos creados por la cláusula Group By.
Ejemplo
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS HAVING COUNT(*)>1; ADDRESS COUNT(ADDRESS) ---------- -------------- Norway 3
- Cláusula de límite de SQLite
En SQLite, la cláusula LIMIT se usa para establecer un límite para los registros devueltos por la declaración de selección. Consideremos un ejemplo para entender el concepto.
Sintaxis
SELECT expressions FROM tables-list [WHERE conditions] LIMIT number_rows OFFSET offset_value;
Ejemplo
SELECT NAME, ADDRESS FROM StudentInfo LIMIT 4 OFFSET 2; NAME ADDRESS ---------- ---------- Mitch Houston SAM Texas Johny Norway Robin Norway
OFFSET es opcional y define cuántas filas omitir al comienzo del conjunto de resultados según offset_value .
- SQLite Y &O
En SQLite, los operadores AND &OR se utilizan para realizar múltiples condiciones en declaraciones de selección, inserción, actualización y eliminación según nuestros requisitos. El operador AND de SQLite devolverá filas o registros que satisfagan las condiciones definidas mediante el operador AND.
Ejemplo1
SELECT NAME FROM StudentInfo WHERE AGE = 22 AND ADDRESS = 'Texas'; NAME ---------- SAM
La condición OR se usa para definir múltiples condiciones en declaraciones de SQLite y devolverá filas o registros de la declaración si se cumple alguna de las condiciones.
Ejemplo2
SELECT NAME FROM StudentInfo WHERE (AGE = 22 AND ADDRESS = 'Norway') OR ADDRESS = 'Norway'; NAME ---------- John Johny Robin
- Operador GLOB de SQLite
En SQLite, el operador GLOB se usa para verificar si el valor de la cadena dada coincide con un patrón específico o no. En caso de que el valor de la cadena coincida con el valor del patrón, devolverá verdadero y es similar al operador LIKE. Además, GLOB distingue entre mayúsculas y minúsculas.
Sintaxis
SELECT * FROM table_name WHERE column_name GLOB 'search-expression'
Ejemplo
SELECT *FROM StudentInfo WHERE NAME GLOB 'Joh*'; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ------------ ---------- 3 John 23 Norway 1 923******* 5 Johny 23 Norway 2 945*******
- SQLite Distinto
En SQLite, la palabra clave DISTINCT escaneará el conjunto de resultados de la instrucción SELECT y eliminará las filas duplicadas. Además, los valores NULL se consideran duplicados, por lo que si usamos la cláusula DISTINCT con una columna que tiene valores NULL, solo mantendrá una fila de un valor NULL. Cuando aplica DISTINCT para varias columnas, la declaración devuelve cada combinación única de coulnm1 y columna 2.
Ejemplo
SELECT DISTINCT AGE FROM StudentInfo; AGE ---------- 20 23 22
- Operador SQLite IN
En SQLite, el operador IN se usa para determinar si el valor dado coincide con una lista de valores dados o con el resultado devuelto por la subconsulta.
Ejemplo
SELECT NAME FROM StudentInfo WHERE ADDRESS IN ('Texas', 'Houston');
NAME
----------
Mitch
SAM - SQLite UNIÓN Y UNIÓN TODO
En SQLite, el operador UNION se usa para combinar los conjuntos de resultados de 2 o más sentencias SELECT y elimina las filas duplicadas entre las diversas sentencias SELECT. Recuerde que las declaraciones SELECT que usamos con el operador UNION deben tener la misma cantidad de campos en los conjuntos de resultados con tipos de datos similares.
Sintaxis
SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions] UNION / UNION ALL SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions];
Ejemplo
SELECT DEPARTMENTID FROM StudentInfo UNION SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 2 3 4 5
El operador UNION ALL se usa para combinar los conjuntos de resultados de 2 o más declaraciones SELECT y devolverá todas las filas, incluidos los duplicados.
Ejemplo
SELECT DEPARTMENTID FROM StudentInfo UNION ALL SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 1 2 2 2 2 3 3 4 4 5
Con esto, hemos cubierto los comandos más básicos que podría tener que usar cuando trabaje con SQLite. Avanzando con este tutorial de SQLite, veamos la declaración de unión en SQLite.
Únete a SQLite
En SQLite, las combinaciones se utilizan para combinar registros de dos o más tablas en una base de datos y obtener registros según nuestros requisitos. Los diferentes tipos de JOINS disponibles en SQLite son:
- Unión interna – INNER JOIN se usa para combinar y devolver solo registros coincidentes de varias tablas en función de las condiciones definidas en las declaraciones de SQLite.
- Unión externa – SQLite Outer Join seleccionará filas coincidentes de varias tablas al igual que Inner Join y algunas otras filas fuera de la relación. En términos simples, podemos decir que SQLite OUTER JOIN es una adición de INNER JOIN. En general, tenemos tres tipos de uniones externas en el estándar SQL:uniones externas IZQUIERDA, DERECHA y COMPLETA, pero SQLite solo admite la UNIÓN EXTERNA IZQUIERDA.
- Unión cruzada – Se utiliza para obtener el producto cartesiano de filas haciendo coincidir cada fila de la primera tabla con cada fila de la segunda tabla.
- Unión automática – Se utiliza para unir una misma tabla consigo misma. Para usar Self Join, necesitamos crear diferentes nombres de alias para la misma tabla para realizar operaciones según nuestros requisitos.
El concepto es similar al de otros sistemas de bases de datos relacionales como SQL. Por lo tanto, para obtener más información, puede consultar este artículo sobre SQL Joins.
Con esto, hemos cubierto los comandos básicos de SQLite. Los conceptos avanzados no se tratan aquí. Entonces, esté atento a otro artículo sobre conceptos avanzados de SQLite. Incluso con todas las buenas características que ofrece SQLite, también tiene ciertas desventajas.
Tutorial SQLite:Desventajas de SQLite
A continuación se enumeran las desventajas de usar SQLite:
- No funciona bien en arquitectura cliente/servidor.
- El tamaño de una base de datos SQLite está limitado a 2 GB en la mayoría de los casos.
- SQLite no ha implementado RIGHT OUTER JOIN y FULL OUTER JOIN. Con SQLite, solo podemos implementar LEFT OUTER JOIN.
- Las vistas en SQLite son de solo lectura. No podemos usar instrucciones DML (Insertar, Actualizar y Eliminar) con Vistas.
- No podemos usar sentencias GRANT y REVOKE con SQLite.
Con esto, llegamos al final de este tutorial de SQLite.
Si desea obtener más información sobre MySQL y conocer esta base de datos relacional de código abierto, consulte nuestra Capacitación para la certificación de MySQL DBA que viene con capacitación en vivo dirigida por un instructor y experiencia en proyectos de la vida real. Esta capacitación lo ayudará a comprender MySQL en profundidad y lo ayudará a dominar el tema.
¿Tiene alguna pregunta para nosotros? Menciónelo en la sección de comentarios de este tutorial de SQLite y me pondré en contacto con usted.
