Se hai lavorato con sistemi di database relazionali, è probabile che tu abbia sentito parlare di sistemi di database popolari come MySQL , 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 SQLite insegna i concetti di base che è necessario conoscere con l'aiuto di pratiche pratiche estese.
Gli argomenti discussi in questo articolo sono:
Tutorial SQLite: che cos'è SQLite?
Ecco la definizione standard del settore di SQLite:
SQLite è un motore di database relazionale per transazioni open source, a configurazione zero, autonomo, autonomo, progettato per essere incorporato in un'applicazione.Puoi considerare SQLite come un ' accendino 'Versione di altri RDBMS complessi (Oracle, , ecc.), dove è configurato il suo motore di database elaborazione indipendente (libreria in-process) cioè un senza server, 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:
- Serverless: Maggior parte Database SQL sono implementati come un processo server separato, ma SQLite non ha un processo server separato. È un motore di database senza server. Legge e scrive direttamente sui normali file del disco.
- Configurazione zero: Itnon richiede alcuna configurazione per farlo funzionare. Ciò significa che non è necessario avviare, arrestare o configurare alcun processo server 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. Nota che ci sono alcune eccezioni a questa regola.
- Leggero: Come il nome suggerisce, la libreria SQLite è molto leggera. Il fatto è che, sebbene lo spazio che utilizza varia a seconda del sistema in cui è installato, può occupare meno di 600 KiB di spazio.
- Portatile: A differenza di altri DBMS, un filel'intero database SQLite è archiviato in un unico file.Questo file può essere condiviso molto facilmente tramite supporto rimovibile o protocollo di trasferimento file.
- Scelta diversificata: Molti linguaggi di programmazione forniscono collegamenti per SQLite, incluso , , C # , , , Rubino , , e molti altri.
- Gratuito: SQLite è gratuito e open source. Per lavorare con SQLite non è necessaria 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 di SQLite, vediamo come installare SQLite sul tuo sistema.
Tutorial SQLite: installazione di SQLite su Windows
I passaggi da seguire sono:
Passo 1: Vai al SQLite ufficiale sito Web e fare clic sul collegamento appropriato per il downloadbinari precompilati.
Passo 2: Scarica il file zip della riga di comando SQLite (qui: sqlite-tools-win32-x86-3270200.zip) ed espandi questi file in una cartella a tua scelta.
Questo strumento della riga di comando SQLite conterrà i seguenti prodotti SQLite
- Nucleo SQLite : Il core SQLite contiene il motore di database effettivo e l'API pubblica.
- 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 applicati.
- Strumento di analisi SQLite : Lo strumento di analisi SQLite viene utilizzato per analizzare i file di database.
Step3: Dopodiché, avviare la riga di comando SQLite è semplice come fare clic sull'applicazione sqlite3, che farà apparire la riga di comando.
Se vuoi testare ulteriormente, digita semplicemente .Aiuto comando da sqlite> prompt per 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 verranno eliminate al termine della sessione.
Abbastanza semplice, vero? Quindi, iniziamo con i comandi SQLite.
Tutorial SQLite: comandi SQLite
Questa sezione del tutorial SQLite presenta le istruzioni SQL di base che è possibile utilizzare con SQLite.
Nota: I comandi SQLite terminano con un punto e virgola (). Indica a SQLite che il tuo comando è completo e dovrebbe essere eseguito.Inoltre, puoi distribuire il tuo 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, è sufficiente immettere sqlite3 seguito dal nome del file che si desidera utilizzare per il database. TIl codice seguente crea un file di database chiamato StudentDetails.db:
Esempio
sqlite3 StudentDetails.db sqlite> .databases main: D: sqliteStudentDetails.db
- Database di collegamento SQLite
Quando si dispone di più database, è possibile utilizzarne solo uno alla volta. In SQLite, l'istruzione ATTACH DATABASE viene utilizzata per collegare un database particolare per la connessione corrente. UNDopo 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
- SQLite Scollega database
In SQLite, l'istruzione DETACH DATABASE viene utilizzata per scollegare il database con nome alias da una connessione al database precedentemente collegata utilizzando 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 completamente distrutti e il contenuto andrà perso.
Esempio
sqlite> .databases main: D: sqliteStudentDetails.db Department: D: sqliteDepartmentDetails.db Studente: D: sqliteStudentDetails.db DeptInformation: D: sqliteDepartmentDetails.db sqlite> DETACH DATABASE 'Department' sqlite> .database mainStudent: D: sqliteDepartmentDetails.db Studente: D: sqliteStudentDetails.db DeptInformation: D: sqliteDepartmentDetails.db
Comandi da tavolo
Qui impareremo come gestire le tabelle quando si utilizza SQLite.
- SQL Crea tabella
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 definirne la colonna ei tipi di dati di ciascuna colonna.
Sintassi:
CREATE TABLE nome_tabella (Colonna1 tipo_colonna [vincoli] Colonna2 tipo_colonna [vincoli] [.....])
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))
È possibile verificare se la tabella è stata creata o meno utilizzando il file .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 di chiave esterna per la tabella Studenti.
sqlite> .tables StudentInfo Contatti Emp_Master
- SQLite Drop Table
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 eventuali indici e trigger associati. Se è presente un vincolo di chiave esterna abilitato su quella tabella, verrà rimosso in modo equivalente per ogni riga nella tabella e verranno eliminati anche eventuali trigger associati alla tabella.
Sintassi
DROP TABLE [IF EXISTS] nome_tabella
Esempio
DROP TABLE Errore di dipartimento: nessuna tabella di questo tipo: Department DROP TABLE Company sqlite> .tables StudentInfo
Nota: SE ESISTE, è una clausola opzionale. Se specificato, l'istruzione DROP TABLE non genererà un errore se una delle tabelle non esiste.
Inoltre, c'è un file 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 Insert Into per creare nuove righe nella tabella specificata. Esistono due forme significative dell'istruzione di inserimento SQLite. La prima forma utilizza una clausola VALUES per specificare un elenco di valori da inserire.
Sintassi
programma java per controllare palindromo
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 *******')
Produzione
SELEZIONA * da StudentInfo ID NOME ETÀ INDIRIZZO ID DIPARTIMENTO TELEFONO ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2934 *******
Qui, viene creata una singola nuova riga e ogni valore viene registrato nella rispettiva colonna. Nota che entrambi gli elenchi devono avere l'estensione stesso numero di articoli. Qui, il elenco delle colonne è opzionale. Possiamo anche inserire dati nella tabella senza specificare l'elenco delle colonne .
Esempio
INSERT INTO StudentInfo VALUES (2, 'SAM', 22, 'Texas', 2, '976 *******')
Produzione
SELEZIONA * da StudentInfo ID NOME ETÀ INDIRIZZO ID DIPARTIMENTO TELEFONO ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2934 ******* 2 SAM 22 Texas 2976 *******
SQLite offre anche una funzionalità per inserire più righe in una singola istruzione INSERT. La sintassi è come mostrato di seguito.
Esempio
INSERT INTO StudentInfo VALUES (3, 'John', 23, 'Norway', 1, '923 *******'), (4, 'Mitch', 22, 'Houston', 3, '934 ** ***** ')
Produzione
Seleziona * da StudentInfo 1 | Dean | 20 | California | 2 | 934 ******* 2 | SAM | 22 | Texas | 2 | 976 ******* 3 | John | 23 | Norvegia | 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 modifica il formato dell'output in SQLite? Formattiamo l'output in modo che i nostri risultati siano un po 'più facili da leggere.
- Formare
È possibile utilizzare .mode per modificare la modalità di output. L'esempio sopra usa .modalità list, che visualizza i risultati come un elenco. Inoltre, puoi usare .headers istruzione per specificare se visualizzare o meno le intestazioni di colonna. Dopo aver apportato le modifiche, è possibile visualizzare l'impostazione utilizzando .spettacolo comando.
Esempio
sqlite> .mode 'column' sqlite> .headers su sqlite> .show echo: off eqp: off spiega: auto header: on mode: column nullvalue: '' output: stdout colseparator: '|' rowseparator: 'n' stats: off width: filename: StudentDetails.db
Produzione
SELEZIONA * DA StudentInfo ID NOME ETÀ INDIRIZZO TELEFONO DIPARTIMENTO ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2934 ******* 2 SAM 22 Texas 2976 ******* 3 John 23 Norvegia 1923 ******* 4 Mitch 22 Houston 3934 *******
- SQLite Select Query
In SQLite, viene utilizzata l'istruzione Selectper recuperare i dati da una tabella, che restituisce i dati sotto forma di una tabella dei risultati. Queste tabelle dei risultati sono anche chiamate risultato imposta. 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
SELEZIONA [TUTTO | DISTINCT] risultato [FROM table-list] [WHERE expr]
- DISTINTO - Quando usiamo una parola chiave distinta in un'istruzione select, restituisce solo righe di dati distinte.
- TUTTI - Se usiamo la parola chiave ALL in un'istruzione select, restituisce tutte le righe di dati anche se è duplicata.
- DA tabella-lista - È un elenco di tabelle da cui desideri ottenere dati.
- DOVE espressione - L'espressione WHERE viene utilizzata per definire le nostre condizioni personalizzate per ottenere i dati richiesti dalle tabelle.
Esempio 1
SELEZIONA ID, NOME DA StudentInfo DOVE ETÀ<21
Produzione
NOME ID ---------- ---------- 1 Dean
Esempio 2
Seleziona NAME FROM StudentInfo WHERE DEPARTMENTID = (SELECT DeptID FROM DepartmentInfo WHERE DeptName = 'Psychology')
Produzione
// recupera le persone dal dipartimento il cui ID è 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. È possibile aggiornare facilmente tutte le righe, alcune righe o nessuna, a seconda delle condizioni di filtro applicate dalla clausola WHERE.
Sintassi
come creare una stringa casuale in java
AGGIORNA nome_tabella SET colonna1 = valore1, colonna2 = valore2 ...., colonnaN = valoreN WHERE [condizione]
Esempio
AGGIORNAMENTO StudentInfo SET DEPARTMENTID = 4 WHERE ID = '2'
Produzione
SELEZIONA * DA StudentInfo ID NOME ETÀ INDIRIZZO ID DIPARTIMENTO TELEFONO ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2934 ******* 2 SAM 22 Texas 4 976 ******* 3 John 23 Norvegia 1923 ******* 4 Mitch 22 Houston 3934 *******
- SQLite Elimina query
In SQLite, l'istruzione DELETE può essere utilizzata per eliminare il record dalla tabella. È possibile eliminare facilmente tutte le righe, alcune righe o nessuna, a seconda delle condizioni di filtro applicate dalla clausola WHERE.
Esempio
ELIMINA DA DepartmentInfo WHERE DeptName = 'Science'
Produzione
SELEZIONA * DA DepartmentInfo DeptID DeptName ---------- ----------- 1 Matematica 2 Psicologia 3 Sport 4 Musica
Se si tenta di eliminare un record a cui fa riferimento una chiave esterna, verrà visualizzato un errore. Sarà necessario eliminare prima i record di chiave esterna, prima di eliminare il record di chiave primaria. Proviamo a eliminare il dipartimento di scienze.
Esempio
DELETE FROM DepartmentInfo WHERE DeptName = Errore 'Music': vincolo FOREIGN KEY non riuscito
Quindi, dobbiamo eliminare i record della 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 Matematica 2 Psicologia 3 Sport SELEZIONA * DA StudentInfo ID NOME ETÀ INDIRIZZO ID DIPARTIMENTO TELEFONO ---------- ---------- ---------- ------- --- ------------ ---------- 1 Dean 20 California 2934 ******* 3 John 23 Norvegia 1923 ****** * 4 Mitch 22 Houston 3934 *******
Ora sai come modificare i record nella tabella del database SQLite. Andando oltre in questo blog tutorial su SQLite, discutiamo le diverse clausole e condizioni che incontri più di frequente in SQLite.
Clausole / condizioni SQLite
Prima di iniziare con le clausole, ecco la sintassi completa dell'istruzione SELECT in SQLite.
Sintassi
SELEZIONA [TUTTO | DISTINCT] risultato [FROM table-list] [WHERE expr] [GROUP BY expr-list] [HAVING expr] [compound-op select] * [ORDER BY sort-expr-list] [LIMIT intero [(OFFSET |,) intero ]]
Nota: ho aggiornato le tabelle StudentInfo e DepartmentInfo come mostrato di seguito.
// ID Tavolo Studente NOME ETÀ INDIRIZZO ID DIPARTIMENTO TELEFONO ---------- ---------- ---------- ---------- ------------ ---------- 1 Dean 20 California 2934 ******* 3 John 23 Norvegia 1923 ******* 4 Mitch 22 Houston 3934 ******* 2 SAM 22 Texas 4 976 ******* 5 Johny 23 Norvegia 2945 ******* 6 Robin 23 Norvegia 2 UNKNOWN // Dettagli dipartimento DeptID DeptName - --------- ----------- 1 Matematica 2 Psicologia 3 Sport 4 Musica 5 Scienza
- SQLite WHERE
In SQLite, la clausola WHERE viene utilizzata per imporre restrizioni sull'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 anche utilizzata nell'istruzione UPDATE, DELETE, ecc.
Esempio
SELEZIONA NOME DA StudentInfo DOVE ETÀ = 23 NOME ---------- John Johny Robin
In SQLite, esistono numerosi operatori relazionali che possono essere utilizzati con la clausola WHERE.
- SQLite GROUP BY
In SQLite, la clausola GROUP BY viene utilizzata per aggregare i dati in una singola 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
SELEZIONA risultato DA [table-list] GROUP BY [expr-list]
SELEZIONA NOME, INDIRIZZO DA StudentInfo GRUPPO PER NOME NOME INDIRIZZO ---------- ---------- Dean California John Norway Johny Norway Mitch Houston Robin Norvegia SAM Texas
Notare che il processo di raggruppamento prevede 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 una singola riga.
- SQLite ORDER BY
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 di selezione SQLite. 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 ordinato9 in ordine decrescente) i dati in base all'indirizzo.
Sintassi
SELEZIONA le espressioni DALLA lista-tabelle [WHERE condizioni] ORDER BY colonna1, colonna2, ... [ASC | DESC]
Esempio
SELEZIONA INDIRIZZO, COUNT (ADDRESS) DA StudentInfo GRUPPO PER INDIRIZZO ORDINA PER INDIRIZZO DESC ADDRESS COUNT (ADDRESS) ---------- -------------- Texas 1 Norvegia 3 Houston 1 California 1
- SQLite AVENDO DA
In SQLite, il AVERE la clausola è identica a DOVE clausola. La clausola HAVING è un'ulteriore condizione applicata dopo che l'aggregazione è avvenuta insieme al group by nell'istruzione select. Generalmente in SQLite, DOVE la clausola viene utilizzata per applicare una condizione a singoli elementi in una tabella eil AVERE viene utilizzata per aggiungere condizioni di filtro in base ai gruppi creati dalla clausola Group By.
Esempio
SELEZIONA INDIRIZZO, COUNT (ADDRESS) DA StudentInfo GROUP PER INDIRIZZO HAVING COUNT (*)> 1 ADDRESS COUNT (ADDRESS) ---------- -------------- Norvegia 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
SELEZIONA espressioni DALLA lista-tabelle [WHERE condizioni] LIMIT numero_riga OFFSET valore_offset
Esempio
SELEZIONA NOME, INDIRIZZO DA StudentInfo LIMITE 4 OFFSET 2 NOME INDIRIZZO ---------- ---------- Mitch Houston SAM Texas Johny Norvegia Robin Norvegia
COMPENSAREè opzionale e definisce quante righe saltare all'inizio del set di risultati in base a offset_value .
- SQLite AND & OR
In SQLite, gli operatori AND e OR vengono utilizzati per eseguire più condizioni per selezionare, inserire, aggiornare ed eliminare le istruzioni in base ai nostri requisiti. L'operatore AND SQLite restituirà righe o record che soddisfano le condizioni definite utilizzando l'operatore AND.
Esempio 1
SELEZIONA NOME DA StudentInfo DOVE ETÀ = 22 E INDIRIZZO = NOME 'Texas' ---------- SAM
La condizione OR viene utilizzata per definire più condizioni nelle istruzioni SQLite e restituirà righe o record dall'istruzione se una qualsiasi di una condizione è soddisfatta.
Esempio 2
SELEZIONA NOME DA StudentInfo DOVE (ETÀ = 22 E INDIRIZZO = 'Norvegia') O INDIRIZZO = NOME 'Norvegia' ---------- John Johny Robin
- Operatore GLOB SQLite
In SQLite, l'operatore GLOB viene utilizzato per verificare se il valore di stringa specificato corrisponde o meno a un modello specifico. Nel caso in cui il valore della stringa corrisponda al valore del modello, verrà restituito vero ed è simile all'operatore LIKE. Inoltre, GLOB lo è maiuscole e minuscole.
Sintassi
SELEZIONA * DA nome_tabella WHERE nome_colonna GLOB 'espressione di ricerca'
Esempio
SELEZIONA * DA StudentInfo DOVE NOME GLOB 'Joh *' ID NOME ETÀ INDIRIZZO ID DIPARTIMENTO TELEFONO ---------- ---------- ---------- --- ------- ------------ ---------- 3 Giovanni 23 Norvegia 1923 ******* 5 Johny 23 Norvegia 2945 ** *****
- SQLite Distinct
In SQLite, la parola chiave DISTINCT analizzerà il set di risultati dell'istruzione SELECT ed eliminerà tutte le righe duplicate. Inoltre, i valori NULL sono considerati duplicati, quindi se usiamo la clausola DISTINCT con una colonna che ha valori NULL, manterrà solo una riga di un valore NULL. Quando applichi DISTINCT a più colonne, l'istruzione restituisce ogni combinazione univoca di coulnm1 e colonna2.
Esempio
SELEZIONA ETÀ DISTINTA DA StudentInfo AGE ---------- 20 23 22
- Operatore SQLite IN
In SQLite, l'operatore IN viene utilizzato per determinare se il valore dato corrisponde a un elenco di valori dati o il risultato restituito dalla sottoquery.
Esempio
SELEZIONA NOME DA StudentInfo DOVE INDIRIZZO IN ('Texas', 'Houston') NOME ---------- 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
SELEZIONA espressione1, espressione2, ... espressione_n FROM tabelle [WHERE condizioni] UNION / UNION ALL SELEZIONA espressione1, espressione2, ... espressione_n FROM tabelle [WHERE condizioni]
Esempio
SELEZIONA DEPARTMENTID DA StudentInfo UNION SELEZIONA DEPARTMENTID DA DepartmentInfo ORDINA PER 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
SELEZIONA DEPARTMENTID DA StudentInfo UNION ALL SELEZIONA DEPARTMENTID DA DepartmentInfo ORDINA PER 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 SQLite, diamo un'occhiata all'istruzione join in SQLite.
Si unisce a SQLite
In SQLite, i join sonoutilizzato per combinare record da due o più tabelle in un database e ottenere record in base ai nostri requisiti. Di tipi diversi 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.
- Outer Join -SQLite Outer Join selezionerà le righe corrispondenti da più tabelle allo stesso modo di Inner Join e alcune altre righe al di fuori della relazione.In termini semplici, possiamo dire SQLiteOUTER JOINè un'aggiunta diINNER JOIN . In generale, abbiamo tre tipi di Outer Join nello standard SQL, ovvero LEFT, RIGHT e FULL Outer Join, ma SQLite supporta solo LEFT OUTER JOIN.
- Cross Join -Viene utilizzato per ottenere il prodotto cartesiano di righefacendo corrispondere ogni riga della prima tabella con ogni riga della seconda tabella.
- Self Join - Itviene utilizzato per unire lo stesso tavolo con se stesso. Per utilizzare Self Join dobbiamo creare diversi nomi alias 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 su .
Con questo, abbiamo coperto i comandi SQLite di base. I concetti avanzati non sono trattati qui. Quindi, rimanete sintonizzati per un altro articolo sui concetti avanzati di SQLite. Anche con 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.
- La dimensione di un database SQLite è limitata a 2 GB nella maggior parte dei casi.
- 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 istruzioni DML (Insert, Update e Delete) con le visualizzazioni.
- Non è possibile utilizzare le istruzioni GRANT e REVOKE con SQLite.
Con questo, arriviamo alla fine di questo tutorial su SQLite.
Se desideri saperne di più su MySQL e impara a conoscere questo database relazionale open source, quindi dai un'occhiata al nostro che viene fornito con formazione dal vivo con istruttore e esperienza di progetto nella vita reale. Questa formazione ti aiuterà a comprendere in profondità MySQL e a raggiungere la padronanza dell'argomento.
Hai domande per noi? Si prega di menzionarlo nella sezione commenti di questo tutorial SQLite e ti ricontatterò.