Se hai lavorato con sistemi di database relazionali, è probabile che tu abbia sentito parlare di sistemi di database popolari come MySQL, SQL Server o PostgreSQL. SQLite è un altro RDBMS estremamente utile che è molto semplice da configurare e utilizzare. Inoltre, ha molte caratteristiche distinte rispetto ad altri database relazionali. Questo tutorial su SQLite insegna i concetti di base che devi conoscere con l'aiuto di ampie pratiche pratiche.
Gli argomenti trattati in questo articolo sono:
- Cos'è SQLite?
- Caratteristiche di SQLite
- Installazione di SQLite su Windows
- Comandi SQLite
- Comandi del database
- Comandi tabella
- Operazioni CRUD
- Clausole/Condizioni SQLite
- Entra in SQLite
- Svantaggi di SQLite
Tutorial SQLite:cos'è SQLite?
Ecco la definizione standard del settore di SQLite:
SQLite è un motore di database relazionale transazionale, open source, a configurazione zero, autonomo, progettato per essere incorporato in un'applicazione.
Puoi considerare SQLite come "accendino ” versione di altri RDBMS complessi (Oracle, SQL, ecc.), in cui il motore di database è configurato per elaborazione indipendente (libreria in-process) ovvero un serverless, autonomo, a configurazione zero e transazionale . È noto per la sua portabilità, affidabilità e prestazioni elevate anche in ambienti con poca memoria. Inoltre, SQLite è una scelta popolare come database incorporato per l'archiviazione locale/client in programmi o applicazioni finali, a differenza di altri RDBMS, in cui è configurato il motore DB client-server.
Caratteristiche di SQLite
SQLite offre molte caratteristiche distinte come:
- Senza server: La maggior parte dei database SQL viene implementata come processo server separato, ma SQLite non dispone di un processo server separato. È un motore di database senza server. Legge e scrive direttamente sui normali file del disco.
- Configurazione zero: Non richiede alcuna configurazione per farlo funzionare. Ciò significa che non esiste alcun processo server che deve essere avviato, arrestato o configurato come in un sistema client/server.
- Digitazione manifest: SQLite utilizza la tipizzazione manifest, che consente la memorizzazione di qualsiasi quantità di qualsiasi tipo di dati in qualsiasi colonna indipendentemente dal tipo di dati dichiarato della colonna. Tieni presente che ci sono alcune eccezioni a questa regola.
- Leggero: Come suggerisce il nome, la libreria SQLite è molto leggera. Il fatto è che, sebbene lo spazio che utilizza vari a seconda del sistema in cui è installato, può occupare meno di 600 KiB di spazio.
- Portatile: A differenza di altri DBMS, un intero database SQLite viene archiviato in un unico file. Questo file può essere condiviso molto facilmente tramite un supporto rimovibile o un protocollo di trasferimento file.
- Scelta diversificata: Molti linguaggi di programmazione forniscono collegamenti per SQLite, inclusi C, C++, C#, Java, JavaScript, Ruby, Python e molti altri.
- Gratuito: SQLite è gratuito e open source. Per lavorare con SQLite non è richiesta una licenza commerciale.
Come elencato sopra, SQLite è noto per la sua configurazione zero, il che significa che non è richiesta alcuna configurazione o amministrazione complessa. Nella parte successiva di questo tutorial su SQLite, vediamo come installare SQLite sul tuo sistema.
Tutorial SQLite:installazione di SQLite su Windows
I passaggi da seguire sono:
Passaggio 1: Vai al sito Web ufficiale di SQLite e fai clic sul collegamento appropriato per scaricare i binari precompilati.
Passaggio 2: Scarica il file zip della riga di comando di SQLite (qui:sqlite-tools-win32-x86-3270200.zip) ed espandi questi file in una cartella a tua scelta.
Questo strumento da riga di comando SQLite conterrà i seguenti prodotti SQLite
- Nucleo SQLite :Il core SQLite contiene il motore di database e l'API pubblica effettivi.
- Strumento da riga di comando SQLite3 :L'applicazione sqlite3 è uno strumento da riga di comando basato sul core SQLite.
- Estensione Tcl :Questa libreria è essenzialmente una copia del core SQLite con i collegamenti Tcl aggiunti.
- Strumento di analisi SQLite :lo strumento di analisi SQLite viene utilizzato per analizzare i file di database.
Passaggio 3: Dopodiché, avviare la riga di comando di SQLite è semplice come fare clic sull'applicazione sqlite3, che farà apparire la riga di comando.
Se vuoi testare ulteriormente, digita semplicemente .help comando da sqlite> chiedere di vedere tutti i comandi disponibili in sqlite3 come mostrato di seguito.
Nota: Per impostazione predefinita, una sessione SQLite utilizza il database in memoria, quindi tutte le modifiche andranno perse al termine della sessione.
Abbastanza semplice vero? Quindi, iniziamo con i comandi SQLite.
Tutorial SQLite:comandi SQLite
Questa sezione dell'esercitazione SQLite presenta le istruzioni SQL di base che puoi utilizzare con SQLite.
Nota: I comandi SQLite terminano con un punto e virgola (; ). Dice a SQLite che il tuo comando è completo e dovrebbe essere eseguito. Inoltre, puoi distribuire il comando su più righe e utilizzare il punto e virgola sull'ultima riga.
Comandi del database
Questa sezione è composta da quei comandi con i quali puoi gestire il tuo database. I comandi sono:
- SQLite Crea database
SQLite non utilizza l'istruzione CREATE DATABASE come in altri sistemi di gestione di database relazionali, come MySQL, SQL Server, ecc. Per creare un nuovo database in SQLite, inserisci semplicemente sqlite3 seguito dal nome del file che si desidera utilizzare per il database. Il codice seguente crea un file di database chiamato StudentDetails.db:
Esempio
sqlite3 StudentDetails.db; sqlite> .databases main: D:sqliteStudentDetails.db;
- SQLite Allega database
Quando hai più database, puoi usarne solo uno alla volta. In SQLite, l'istruzione ATTACH DATABASE viene utilizzata per allegare un determinato database per la connessione corrente. Dopo questo comando, tutte le istruzioni SQLite verranno eseguite nel database allegato.
Esempio
sqlite> ATTACH DATABASE 'DepartmentDetails.db' AS 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db
- Database di scollegamento SQLite
In SQLite, l'istruzione DETACH DATABASE viene utilizzata per scollegare il database con nome alias da una connessione al database precedentemente collegata tramite l'istruzione ATTACH. Se lo stesso file di database è stato allegato con più alias, questo comando disconnetterà solo il nome specificato e il resto dell'allegato continuerà a esistere. I database all'interno del database in memoria o temporaneo verranno distrutti completamente e il contenuto andrà perso.
Esempio
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
Comandi tabella
Qui impareremo come gestire le tabelle quando si utilizza SQLite.
- Crea tabella SQL
In SQLite, l'istruzione CREATE TABLE viene utilizzata per creare una nuova tabella. Durante la creazione della tabella, è necessario assegnare un nome alla tabella e definire la colonna e i tipi di dati di ciascuna colonna.
Sintassi:
CREATE TABLE table_name( Column1 column_type [constraints] Column2 column_type [constraints] [.....] );
Esempio
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) );
Puoi verificare se la tabella è stata creata o meno utilizzando .tables comando come mostrato di seguito. Nota che ho già creato una tabella chiamata DepartmentInfo dove DeptID è la chiave primaria. La tabella Dipartimenti ha un vincolo Chiave esterna per la tabella Studenti.
sqlite> .tables StudentInfo Contacts Emp_Master
- Tabella di rilascio SQLite
In SQLite, l'istruzione DROP TABLE consente di rimuovere o eliminare una tabella dal database SQLite. Una volta eliminata la tabella, tutti i dati in essa contenuti vengono rimossi definitivamente dal database. Vengono rimossi anche tutti gli indici e i trigger associati. Se è presente un vincolo di chiave esterna abilitato su quella tabella, verrà rimosso in modo equivalente per ogni riga della tabella e verranno eliminati anche tutti i trigger associati alla tabella.
Sintassi
DROP TABLE [ IF EXISTS ] table_name;
Esempio
DROP TABLE Department; Error: no such table: Department DROP TABLE Company; sqlite> .tables StudentInfo
Nota: IF EXISTS, è una clausola facoltativa. Se specificato, l'istruzione DROP TABLE non genererà un errore se una delle tabelle non esiste.
Inoltre, c'è una istruzione SQLite Alter Table , che capiremo nelle prossime sezioni di questo articolo. Ora che abbiamo creato una tabella, vediamo come inserire, eliminare e modificare i dati.
Tutorial SQLite:operazioni CRUD
- Query di inserimento SQLite
Dopo aver creato la tabella, è possibile utilizzare il comando SQLite Inserisci in per creare nuove righe nella tabella specificata. Esistono due forme significative dell'istruzione di inserimento SQLite. Il primo modulo utilizza una clausola VALUES per specificare un elenco di valori da inserire.
Sintassi
INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)] VALUES (value1, value2, value3,...valueN);
Esempio
INSERT INTO StudentInfo ( ID, NAME, AGE, ADDRESS, DEPARTMENTID, PHONE) VALUES (1,'Dean', 20, 'California', 2, '934*******');
Risultato
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934*******
Qui viene creata una singola nuova riga e ogni valore viene registrato nella rispettiva colonna. Tieni presente che entrambi gli elenchi devono avere lo stesso numero di articoli. Qui, l'elenco delle colonne è facoltativo. Possiamo anche inserire dati nella tabella senza specificare l'elenco delle colonne .
Esempio
INSERT INTO StudentInfo VALUES ( 2, 'SAM', 22, 'Texas', 2, '976*******');
Risultato
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976*******
SQLite offre anche una funzione perinserire più righe in una singola istruzione INSERT. La sintassi è quella mostrata di seguito.
Esempio
INSERT INTO StudentInfo VALUES (3,'John',23,'Norway',1,'923*******'), (4,'Mitch',22,'Houston',3,'934*******');
Risultato
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*******
Come puoi vedere, il formato dell'output non è del tutto simile a quello precedente. Quindi, come si cambia il formato dell'output in SQLite? Formattiamo l'output in modo che i nostri risultati siano un po' più facili da leggere.
- Formazione
Puoi usare .mode per cambiare la modalità di output. L'esempio precedente utilizza .mode list, che visualizza i risultati come un elenco. Inoltre, puoi utilizzare .headers per specificare se visualizzare o meno le intestazioni di colonna. Dopo aver apportato le modifiche, puoi visualizzare l'impostazione utilizzando .show comando.
Esempio
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
Risultato
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*******
- Query di selezione SQLite
In SQLite, l'istruzione Select viene utilizzata per recuperare i dati da una tabella, che restituisce i dati sotto forma di tabella dei risultati. Queste tabelle dei risultati sono anche chiamate insiemi di risultati. Utilizzando l'istruzione select di SQLite possiamo eseguire calcoli semplici o più espressioni in base ai nostri requisiti. Abbiamo già utilizzato un'istruzione SELECT in precedenza quando abbiamo inserito i dati.
Sintassi
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr]
- DISTINTA – Quando utilizziamo una parola chiave distinta in un'istruzione select, restituisce solo righe di dati distinte.
- TUTTI – Se utilizziamo la parola chiave ALL in un'istruzione select, restituisce tutte le righe di dati anche se è duplicata.
- DALL'elenco delle tabelle – È un elenco di tabelle da cui desideri ottenere i dati.
- Espressione WHERE – L'espressione WHERE viene utilizzata per definire le nostre condizioni personalizzate per ottenere i dati richiesti dalle tabelle.
Esempio1
SELECT ID, NAME FROM StudentInfo WHERE AGE < 21;
Risultato
ID NAME ---------- ---------- 1 Dean
Esempio2
Select NAME FROM StudentInfo WHERE DEPARTMENTID = (SELECT DeptID FROM DepartmentInfo WHERE DeptName = 'Psychology');
Risultato
//fetches people from department whose id is 2 NAME ---------- Dean SAM
- Query di aggiornamento SQLite
In SQLite, l'istruzione UPDATE può essere utilizzata per modificare i record esistenti in una tabella. La clausola WHERE di SQLite può essere utilizzata per specificare esattamente quali righe devono essere aggiornate. Puoi aggiornare facilmente tutte le righe, alcune righe o nessuna, a seconda delle condizioni di filtro applicate dalla clausola WHERE.
Sintassi
UPDATE table_name SET column1 = value1, column2 = value2...., columnN = valueN WHERE [condition];
Esempio
UPDATE StudentInfo SET DEPARTMENTID = 4 WHERE ID = '2';
Risultato
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*******
- Query di eliminazione di SQLite
In SQLite, l'istruzione DELETE può essere utilizzata per eliminare il record dalla tabella. Puoi eliminare facilmente tutte le righe, alcune righe o nessuna, a seconda delle condizioni di filtro applicate dalla clausola WHERE.
Esempio
DELETE FROM DepartmentInfo WHERE DeptName = 'Science';
Risultato
SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music
Se tenti di eliminare un record a cui fa riferimento una chiave esterna, otterrai un errore. Sarà necessario eliminare prima i record di chiave esterna, prima di eliminare il record di chiave primaria. Proviamo a cancellare il dipartimento di scienze.
Esempio
DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; Error: FOREIGN KEY constraint failed
Quindi, dobbiamo eliminare i record di chiave esterna prima di eliminare la chiave primaria.
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*******
Ora sai come modificare i record nella tabella del database SQLite. Andando oltre in questo blog tutorial di SQLite, discutiamo le diverse clausole e condizioni che incontri più frequentemente in SQLite.
Clausole/condizioni SQLite
Prima di iniziare con le clausole, ecco la sintassi completa dell'istruzione SELECT in SQLite.
Sintassi
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:ho aggiornato le tabelle StudentInfo e DepartmentInfo come mostrato di seguito.
//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 DOVE
In SQLite, la clausola WHERE viene utilizzata per imporre restrizioni all'istruzione SELECT definendo una o più condizioni per ottenere i dati richiesti dalle tabelle nel database. Se la condizione specificata soddisfatta o vera, restituisce un valore specifico dalla tabella. Come hai visto prima, la clausola WHERE non solo viene utilizzata nell'istruzione SELECT, ma viene utilizzata anche nell'istruzione UPDATE, DELETE, ecc.
Esempio
SELECT NAME FROM StudentInfo WHERE AGE = 23;NAME ---------- John Johny Robin
In SQLite esistono numerosi operatori relazionali che possono essere utilizzati con la clausola WHERE.
- GRUPPO SQLite PER
In SQLite, la clausola GROUP BY viene utilizzata per aggregare i dati in un'unica riga in cui viene ripetuto il valore di una o più colonne specificate. Questa clausola viene utilizzata con la clausola WHERE nell'istruzione SELECT e precede la clausola ORDER BY.
Sintassi
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
Nota che il processo di raggruppamento ha due passaggi. Innanzitutto, l'espressione GROUP BY viene utilizzata per disporre le righe della tabella in gruppi diversi. Una volta definiti i gruppi, l'istruzione SELECT definisce il modo in cui tali gruppi vengono appiattiti in un'unica riga.
- SQLite ORDINA PER
In genere, le tabelle SQLite memorizzano i dati in un ordine non specificato e restituiranno i record nello stesso ordine non specificato durante il recupero dei dati utilizzando l'istruzione SQLite select. In questi casi, è possibile utilizzare la clausola ORDER BY per ordinare i record delle colonne in ordine crescente o decrescente. Nell'esempio seguente, ho raggruppato e ordinato9in ordine decrescente) i dati in base all'indirizzo.
Sintassi
SELECT expressions FROM tables-list [WHERE conditions] ORDER BY column1, column2,... [ ASC | DESC ];
Esempio
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 AVENDO DA
In SQLite, il HAVING la clausola è identica a WHERE clausola. La clausola HAVING è un'ulteriore condizione applicata dopo che l'aggregazione è avvenuta insieme al gruppo nell'istruzione select. Generalmente in SQLite, WHERE La clausola viene utilizzata per applicare una condizione a singoli elementi in una tabella e HAVING La clausola viene utilizzata per aggiungere condizioni di filtro in base ai gruppi creati dalla clausola Group By.
Esempio
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS HAVING COUNT(*)>1; ADDRESS COUNT(ADDRESS) ---------- -------------- Norway 3
- Clausola limite SQLite
In SQLite, la clausola LIMIT viene utilizzata per impostare un limite ai record restituiti dall'istruzione select. Consideriamo un esempio per comprendere il concetto.
Sintassi
SELECT expressions FROM tables-list [WHERE conditions] LIMIT number_rows OFFSET offset_value;
Esempio
SELECT NAME, ADDRESS FROM StudentInfo LIMIT 4 OFFSET 2; NAME ADDRESS ---------- ---------- Mitch Houston SAM Texas Johny Norway Robin Norway
OFFSET è facoltativo e definisce quante righe saltare all'inizio del set di risultati in base a offset_value .
- SQLite AND &OR
In SQLite, gli operatori AND &OR vengono utilizzati per eseguire più condizioni su select, inserire, aggiornare ed eliminare istruzioni in base ai nostri requisiti. L'operatore AND di SQLite restituirà righe o record che soddisfano le condizioni definite utilizzando l'operatore AND.
Esempio1
SELECT NAME FROM StudentInfo WHERE AGE = 22 AND ADDRESS = 'Texas'; NAME ---------- SAM
La condizione OR viene utilizzata per definire più condizioni nelle istruzioni SQLite e restituirà righe o record dall'istruzione se una qualsiasi delle condizioni è soddisfatta.
Esempio2
SELECT NAME FROM StudentInfo WHERE (AGE = 22 AND ADDRESS = 'Norway') OR ADDRESS = 'Norway'; NAME ---------- John Johny Robin
- Operatore GLOB SQLite
In SQLite, l'operatore GLOB viene utilizzato per verificare se il valore della stringa specificato corrisponde o meno a un modello specifico. Nel caso in cui il valore della stringa corrisponda al valore del modello, restituirà true ed è simile all'operatore LIKE. Inoltre, GLOB fa distinzione tra maiuscole e minuscole.
Sintassi
SELECT * FROM table_name WHERE column_name GLOB 'search-expression'
Esempio
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 Distinct
In SQLite, la parola chiave DISTINCT analizzerà il set di risultati dell'istruzione SELECT ed elimina le righe duplicate. Inoltre, i valori NULL sono considerati duplicati, quindi se utilizziamo la clausola DISTINCT con una colonna che ha valori NULL, manterrà solo una riga di un valore NULL. Quando applichi DISTINCT per più colonne, l'istruzione restituisce ciascuna combinazione univoca di coulnm1 e colonna 2.
Esempio
SELECT DISTINCT AGE FROM StudentInfo; AGE ---------- 20 23 22
- Operatore SQLite IN
In SQLite, l'operatore IN viene utilizzato per determinare se il valore specificato corrisponde a un elenco di valori dati o al risultato restituito dalla sottoquery.
Esempio
SELECT NAME FROM StudentInfo WHERE ADDRESS IN ('Texas', 'Houston');
NAME
----------
Mitch
SAM - SQLite UNION &UNION ALL
In SQLite, l'operatore UNION viene utilizzato per combinare i set di risultati di 2 o più istruzioni SELECT e rimuove le righe duplicate tra le varie istruzioni SELECT. Ricorda che le istruzioni SELECT che abbiamo usato con l'operatore UNION devono avere lo stesso numero di campi nei set di risultati con tipi di dati simili.
Sintassi
SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions] UNION / UNION ALL SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions];
Esempio
SELECT DEPARTMENTID FROM StudentInfo UNION SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 2 3 4 5
L'operatore UNION ALL viene utilizzato per combinare i set di risultati di 2 o più istruzioni SELECT e restituirà tutte le righe inclusi i duplicati.
Esempio
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 questo, abbiamo coperto i comandi più basilari che potresti dover usare quando lavori con SQLite. Andando avanti con questo tutorial su SQLite, diamo un'occhiata all'istruzione join in SQLite.
Entra in SQLite
In SQLite, i join vengono utilizzati per combinare record da due o più tabelle in un database e ottenere record in base ai nostri requisiti. Diversi tipi di JOINS disponibili in SQLite sono:
- Inner Join – INNER JOIN viene utilizzato per combinare e restituire solo record corrispondenti da tabelle multiple in base alle condizioni definite nelle istruzioni SQLite.
- Unisciti esterni – SQLite Outer Join selezionerà le righe corrispondenti da più tabelle come Inner Join e alcune altre righe al di fuori della relazione. In termini semplici, possiamo dire che SQLite OUTER JOIN è un'aggiunta di INNER JOIN. In generale, abbiamo tre tipi di Outer Join nello standard SQL:LEFT, RIGHT e FULL Outer Join, ma SQLite supporta solo LEFT OUTER JOIN.
- Partecipa incrociata – Viene utilizzato per ottenere il prodotto cartesiano delle righe facendo corrispondere ogni riga della prima tabella con ogni riga della seconda tabella.
- Partecipa autonomamente – Serve per unire lo stesso tavolo con se stesso. Per utilizzare Self Join dobbiamo creare nomi di alias diversi per la stessa tabella per eseguire operazioni in base ai nostri requisiti.
Il concetto è simile a quello di altri sistemi di database relazionali come SQL. Quindi, per saperne di più puoi fare riferimento a questo articolo sui join SQL.
Con questo, abbiamo coperto i comandi di base di SQLite. I concetti avanzati non sono trattati qui. Quindi, resta sintonizzato per un altro articolo sui concetti avanzati di SQLite. Nonostante tutte le buone caratteristiche che SQLite ha da offrire, presenta anche alcuni svantaggi.
Tutorial SQLite:Svantaggi di SQLite
Di seguito sono elencati i demeriti dell'utilizzo di SQLite:
- Non funziona bene nell'architettura client/server.
- Nella maggior parte dei casi, la dimensione di un database SQLite è limitata a 2 GB.
- SQLite non ha implementato RIGHT OUTER JOIN e FULL OUTER JOIN. Con SQLite, possiamo implementare solo LEFT OUTER JOIN.
- Le viste in SQLite sono di sola lettura. Non possiamo utilizzare le istruzioni DML (Inserisci, Aggiorna ed Elimina) con le visualizzazioni.
- Non possiamo utilizzare le istruzioni GRANT e REVOKE con SQLite.
Con questo, giungiamo al termine di questo tutorial SQLite.
Se desideri saperne di più su MySQL e conoscere questo database relazionale open source, dai un'occhiata al nostro Formazione sulla certificazione DBA MySQL che viene fornito con una formazione dal vivo con istruttore e un'esperienza di progetto nella vita reale. Questa formazione ti aiuterà a comprendere in modo approfondito MySQL e a raggiungere la padronanza dell'argomento.
Hai una domanda per noi? Per favore menzionalo nella sezione commenti di questo tutorial di SQLite e ti risponderò.
