Jeśli pracowałeś z relacyjnymi systemami baz danych, prawdopodobnie słyszałeś o popularnych systemach baz danych, takich jak MySQL, SQL Server lub PostgreSQL. SQLite to kolejny niezwykle przydatny RDBMS, który jest bardzo prosty w konfiguracji i obsłudze. Ponadto ma wiele odrębnych funkcji w porównaniu z innymi relacyjnymi bazami danych. Ten samouczek SQLite uczy podstawowych pojęć, które musisz znać za pomocą obszernych praktycznych praktyk.
Tematy omawiane w tym artykule to:
- Co to jest SQLite?
- Funkcje SQLite
- Instalacja SQLite w systemie Windows
- Polecenia SQLite
- Polecenia bazy danych
- Polecenia tabeli
- Operacje CRUD
- Klauzule/warunki SQLite
- Dołączenia do SQLite
- Wady SQLite
Samouczek SQLite:Co to jest SQLite?
Oto branżowa standardowa definicja SQLite:
SQLite to open-source, bez konfiguracji, samowystarczalny, samodzielny, relacyjny silnik bazy danych transakcji, zaprojektowany do osadzania w aplikacji.
Możesz rozważyć SQLite jako „zapalniczka ” wersja innego złożonego RDBMS (Oracle, SQL, itp.), w którym jego silnik bazy danych jest skonfigurowany do niezależnego przetwarzania (biblioteka w procesie) tj. bezserwerowy, samowystarczalny, bezkonfiguracyjny i transakcyjny . Jest znany ze swojej przenośności, niezawodności i wysokiej wydajności nawet w środowiskach o małej ilości pamięci. Ponadto SQLite jest popularnym wyborem jako wbudowana baza danych do przechowywania lokalnego/klienta w programach końcowych lub aplikacjach, w przeciwieństwie do innych RDBMS, w których skonfigurowany jest silnik bazy danych klient-serwer.
Funkcje SQLite
SQLite oferuje wiele różnych funkcji, takich jak:
- Bez serwera: Większość baz danych SQL jest zaimplementowanych jako osobny proces serwera, ale SQLite nie ma oddzielnego procesu serwera. Jest to bezserwerowy silnik bazy danych. Odczytuje i zapisuje bezpośrednio do zwykłych plików na dysku.
- Konfiguracja zerowa: Nie wymaga żadnej konfiguracji do uruchomienia. Oznacza to, że nie ma procesu serwera, który wymagałby uruchomienia, zatrzymania lub skonfigurowania, jak w systemie klient/serwer.
- Wpisywanie manifestu: SQLite używa wpisywania manifestu, co pozwala na przechowywanie dowolnej ilości dowolnego typu danych w dowolnej kolumnie bez względu na zadeklarowany typ danych kolumny. Pamiętaj, że istnieją pewne wyjątki od tej reguły.
- Lekki: Jak sama nazwa wskazuje, biblioteka SQLite jest bardzo lekka. Rzecz w tym, że chociaż przestrzeń, którą wykorzystuje, różni się w zależności od systemu, w którym jest zainstalowany, może zająć mniej niż 600KiB miejsca.
- Przenośny: W przeciwieństwie do innych DBMS, cała baza danych SQLite jest przechowywana w jednym pliku. Ten plik można bardzo łatwo udostępnić za pomocą nośników wymiennych lub protokołu przesyłania plików.
- Zróżnicowany wybór: Wiele języków programowania zapewnia powiązania dla SQLite, w tym C, C++, C#, Java, JavaScript, Ruby, Python i wiele innych.
- Bezpłatne: SQLite jest darmowy i open-source. Do pracy z SQLite nie jest wymagana licencja komercyjna.
Jak wspomniano powyżej, SQLite jest znany z zerowej konfiguracji, co oznacza, że nie jest wymagana żadna skomplikowana konfiguracja ani administracja. W następnej części tego samouczka SQLite zobaczmy, jak zainstalować SQLite w swoim systemie.
Samouczek SQLite:Instalacja SQLite w systemie Windows
Kroki, które należy wykonać to:
Krok 1: Przejdź na oficjalną stronę SQLite i kliknij odpowiedni link, aby pobrać prekompilowane pliki binarne.
Krok 2: Pobierz plik zip wiersza poleceń SQLite (tutaj:sqlite-tools-win32-x86-3270200.zip) i rozwiń te pliki w wybranym folderze.
To narzędzie wiersza poleceń SQLite będzie zawierać następujące produkty SQLite
- Rdzeń SQLite :Rdzeń SQLite zawiera rzeczywisty silnik bazy danych i publiczne API.
- Narzędzie wiersza poleceń SQLite3 :Aplikacja sqlite3 to narzędzie wiersza poleceń, które jest zbudowane na rdzeniu SQLite.
- Rozszerzenie Tcl :Ta biblioteka jest zasadniczo kopią rdzenia SQLite z dołączonymi powiązaniami Tcl.
- Narzędzie do analizy SQLite :Analizator SQLite służy do analizy plików baz danych.
Krok 3: Następnie zainicjowanie wiersza poleceń SQLite jest tak proste, jak kliknięcie aplikacji sqlite3, co spowoduje wyświetlenie wiersza poleceń.
Jeśli chcesz dalej testować, po prostu wpisz .help polecenie z sqlite> monit, aby zobaczyć wszystkie dostępne polecenia w sqlite3 jak pokazano poniżej.
Uwaga: Domyślnie sesja SQLite korzysta z bazy danych w pamięci, dlatego wszystkie zmiany znikną po zakończeniu sesji.
Wystarczająco proste, prawda? Następnie zacznijmy od poleceń SQLite.
Samouczek SQLite:polecenia SQLite
Ta sekcja samouczka SQLite przedstawia podstawowe instrukcje SQL, których można używać z SQLite.
Uwaga: Polecenia SQLite kończą się średnikiem (; ). Mówi SQLite, że twoje polecenie jest kompletne i powinno zostać uruchomione. Możesz także rozłożyć polecenie na wiele wierszy i użyć średnika w ostatnim wierszu.
Polecenia bazy danych
Ta sekcja składa się z tych poleceń, za pomocą których możesz poradzić sobie z bazą danych. Polecenia to:
- Utwórz bazę danych SQLite
SQLite nie używa instrukcji CREATE DATABASE, jak w innych systemach zarządzania relacyjnymi bazami danych, takich jak MySQL, SQL Server itp. Aby utworzyć nową bazę danych w SQLite, po prostu wpisz sqlite3, a następnie nazwą pliku, którego chcesz użyć w bazie danych. Poniższy kod tworzy plik bazy danych o nazwie StudentDetails.db:
Przykład
sqlite3 StudentDetails.db; sqlite> .databases main: D:sqliteStudentDetails.db;
- Dołącz bazę danych SQLite
Jeśli masz wiele baz danych, możesz używać tylko jednej na raz. W SQLite instrukcja ATTACH DATABASE służy do dołączania określonej bazy danych dla bieżącego połączenia. Po tym poleceniu wszystkie instrukcje SQLite zostaną wykonane w dołączonej bazie danych.
Przykład
sqlite> ATTACH DATABASE 'DepartmentDetails.db' AS 'Department'; sqlite> .databases main: D:sqliteStudentDetails.db; Department: D:sqliteDepartmentDetails.db
- Odłącz bazę danych SQLite
W SQLite instrukcja DETACH DATABASE służy do odłączania bazy danych o nazwie aliasowej od połączenia z bazą danych, które zostało wcześniej dołączone za pomocą instrukcji ATTACH. Jeśli ten sam plik bazy danych został dołączony z wieloma aliasami, to polecenie odłączy tylko podaną nazwę, a reszta załącznika nadal będzie istnieć. Bazy danych w pamięci lub tymczasowej bazie danych zostaną całkowicie zniszczone, a zawartość utracona.
Przykład
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
Polecenia tabeli
Tutaj dowiemy się, jak radzić sobie z tabelami podczas korzystania z SQLite.
- Utwórz tabelę SQL
W SQLite instrukcja CREATE TABLE służy do tworzenia nowej tabeli. Podczas tworzenia tabeli musisz nazwać tabelę i zdefiniować jej kolumnę oraz typy danych każdej kolumny.
Składnia:
CREATE TABLE table_name( Column1 column_type [constraints] Column2 column_type [constraints] [.....] );
Przykład
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) );
Możesz sprawdzić, czy tabela została utworzona, czy nie, używając .tables polecenie, jak pokazano poniżej. Zauważ, że utworzyłem już tabelę o nazwie Informacje o dziale gdzie DeptID jest kluczem podstawowym. Tabela Departments ma ograniczenie klucza obcego do tabeli Studenci.
sqlite> .tables StudentInfo Contacts Emp_Master
- Tabela upuszczania SQLite
W SQLite instrukcja DROP TABLE pozwala usunąć lub usunąć tabelę z bazy danych SQLite. Po usunięciu tabeli wszystkie zawarte w niej dane są trwale usuwane z bazy danych. Wszelkie powiązane indeksy i wyzwalacze są również usuwane. Jeśli w tej tabeli jest włączone jakiekolwiek ograniczenie klucza obcego, spowoduje to równoważne usunięcie każdego wiersza w tabeli, a wszelkie wyzwalacze powiązane z tabelą również zostaną usunięte.
Składnia
DROP TABLE [ IF EXISTS ] table_name;
Przykład
DROP TABLE Department; Error: no such table: Department DROP TABLE Company; sqlite> .tables StudentInfo
Uwaga: IF EXISTS jest klauzulą opcjonalną. Jeśli zostanie określony, instrukcja DROP TABLE nie zgłosi błędu, jeśli jedna z tabel nie istnieje.
Istnieje również instrukcja SQLite Alter Table , co zrozumiemy w kilku następnych rozdziałach tego artykułu. Teraz, gdy stworzyliśmy tabelę, sprawdźmy, jak wstawiać, usuwać i zmieniać dane.
Samouczek SQLite:operacje CRUD
- Wstaw zapytanie SQLite
Po utworzeniu tabeli polecenie SQLite Insert Into może zostać użyte do utworzenia nowych wierszy w określonej tabeli. Istnieją dwie znaczące formy instrukcji wstawiania SQLite. Pierwsza forma używa klauzuli VALUES do określenia listy wartości do wstawienia.
Składnia
INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)] VALUES (value1, value2, value3,...valueN);
Przykład
INSERT INTO StudentInfo ( ID, NAME, AGE, ADDRESS, DEPARTMENTID, PHONE) VALUES (1,'Dean', 20, 'California', 2, '934*******');
Wyjście
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934*******
Tutaj tworzony jest jeden nowy wiersz, a każda wartość jest zapisywana w odpowiedniej kolumnie. Pamiętaj, że obie listy muszą mieć takie same Liczba przedmiotów. Tutaj lista kolumn jest opcjonalne. Możemy również wstawić dane do tabeli bez określania listy kolumn .
Przykład
INSERT INTO StudentInfo VALUES ( 2, 'SAM', 22, 'Texas', 2, '976*******');
Wyjście
SELECT *from StudentInfo; ID NAME AGE ADDRESS DEPARTMENTID PHONE ---------- ---------- ---------- ---------- ---------- ---------- 1 Dean 20 California 2 934******* 2 SAM 22 Texas 2 976*******
SQLite oferuje również funkcję wstawiania wielu wierszy w jednej instrukcji INSERT. Składnia jest pokazana poniżej.
Przykład
INSERT INTO StudentInfo VALUES (3,'John',23,'Norway',1,'923*******'), (4,'Mitch',22,'Houston',3,'934*******');
Wyjście
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*******
Jak widać, format wyjścia nie jest całkiem podobny do poprzedniego. Jak więc zmienić format danych wyjściowych w SQLite? Sformatujmy dane wyjściowe, aby nasze wyniki były nieco łatwiejsze do odczytania.
- Formatowanie
Możesz użyć .mode do zmiany trybu wyjściowego. Powyższy przykład używa .mode lista, która wyświetla wyniki w postaci listy. Możesz także użyć .headers instrukcja, aby określić, czy wyświetlać nagłówki kolumn. Po wprowadzeniu zmian możesz wyświetlić ustawienie za pomocą .show polecenie.
Przykład
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
Wyjście
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*******
- Zapytanie wyboru SQLite
W SQLite instrukcja Select służy do pobierania danych z tabeli, która zwraca dane w postaci tabeli wynikowej. Te tabele wyników są również nazywane zestawami wyników. Korzystając z instrukcji SQLite select możemy wykonać proste obliczenia lub wiele wyrażeń w oparciu o nasze wymagania. Już wcześniej użyliśmy instrukcji SELECT, kiedy wstawialiśmy dane.
Składnia
SELECT [ALL | DISTINCT] result [FROM table-list] [WHERE expr]
- ODRÓŻNE – Kiedy używamy odrębnego słowa kluczowego w instrukcji select, zwraca ona tylko różne wiersze danych.
- WSZYSTKIE – Jeśli użyjemy słowa kluczowego ALL w instrukcji select, zwróci ona wszystkie wiersze danych, nawet jeśli są zduplikowane.
- Z listy tabel – Jest to lista tabel, z których chcesz uzyskać dane.
- GDZIE wyrażenie – Wyrażenie WHERE służy do zdefiniowania naszych niestandardowych warunków, aby uzyskać wymagane dane z tabel.
Przykład 1
SELECT ID, NAME FROM StudentInfo WHERE AGE < 21;
Wyjście
ID NAME ---------- ---------- 1 Dean
Przykład2
Select NAME FROM StudentInfo WHERE DEPARTMENTID = (SELECT DeptID FROM DepartmentInfo WHERE DeptName = 'Psychology');
Wyjście
//fetches people from department whose id is 2 NAME ---------- Dean SAM
- Zapytanie o aktualizację SQLite
W SQLite instrukcja UPDATE może służyć do modyfikowania istniejących rekordów w tabeli. Klauzula WHERE programu SQLite może być użyta w celu dokładnego określenia, które wiersze powinny zostać zaktualizowane. Możesz łatwo zaktualizować wszystkie wiersze, niektóre wiersze lub żaden, w zależności od warunków filtrowania zastosowanych przez klauzulę WHERE.
Składnia
UPDATE table_name SET column1 = value1, column2 = value2...., columnN = valueN WHERE [condition];
Przykład
UPDATE StudentInfo SET DEPARTMENTID = 4 WHERE ID = '2';
Wyjście
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*******
- Zapytanie usuwania SQLite
W SQLite do usunięcia rekordu z tabeli można użyć instrukcji DELETE. Możesz łatwo usunąć wszystkie wiersze, niektóre wiersze lub żaden, w zależności od warunków filtrowania zastosowanych przez klauzulę WHERE.
Przykład
DELETE FROM DepartmentInfo WHERE DeptName = 'Science';
Wyjście
SELECT *FROM DepartmentInfo; DeptID DeptName ---------- ----------- 1 Mathematics 2 Psychology 3 Sports 4 Music
Jeśli spróbujesz usunąć rekord, do którego odwołuje się klucz obcy, otrzymasz błąd. Przed usunięciem rekordu klucza podstawowego musisz najpierw usunąć rekordy klucza obcego. Spróbujmy usunąć dział nauki.
Przykład
DELETE FROM DepartmentInfo WHERE DeptName = 'Music'; Error: FOREIGN KEY constraint failed
Dlatego musimy usunąć rekordy klucza obcego, zanim usuniemy klucz podstawowy.
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*******
Teraz wiesz, jak edytować rekordy w tabeli bazy danych SQLite. Idąc dalej w tym samouczkowym blogu SQLite, omówmy różne klauzule i warunki, z którymi najczęściej spotykasz się w SQLite.
Klauzule/warunki SQLite
Zanim zaczniesz pracę z klauzulami, oto pełna składnia instrukcji SELECT w SQLite.
Składnia
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]]
Uwaga:Zaktualizowałem tabele StudentInfo i DepartmentInfo, jak pokazano poniżej.
//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 GDZIE
W SQLite klauzula WHERE służy do nakładania ograniczeń na instrukcję SELECT poprzez zdefiniowanie jednego lub więcej warunków, aby uzyskać wymagane dane z tabel w bazie danych. Jeśli określony warunek jest spełniony lub spełniony, zwraca określoną wartość z tabeli. Jak widzieliście wcześniej, Klauzula WHERE jest używana nie tylko w instrukcji SELECT, ale także w instrukcji UPDATE, DELETE itp.
Przykład
SELECT NAME FROM StudentInfo WHERE AGE = 23;NAME ---------- John Johny Robin
W SQLite istnieje wiele operatorów relacyjnych, których można używać z klauzulą WHERE.
- GRUPA SQLite WG
W SQLite klauzula GROUP BY służy do agregowania danych w pojedynczym wierszu, w którym powtarza się wartość jednej lub więcej określonych kolumn. Ta klauzula jest używana z klauzulą WHERE w instrukcji SELECT i poprzedza klauzulę ORDER BY.
Składnia
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
Zauważ, że proces grupowania składa się z dwóch etapów. Po pierwsze, wyrażenie GROUP BY służy do porządkowania wierszy tabeli w różne grupy. Po zdefiniowaniu grup instrukcja SELECT definiuje sposób, w jaki te grupy są spłaszczane do jednego wiersza.
- SQLite ZAMÓW PRZEZ
Ogólnie rzecz biorąc, tabele SQLite przechowują dane w nieokreślonej kolejności i będą zwracać rekordy w tej samej nieokreślonej kolejności podczas pobierania danych za pomocą instrukcji SQLite select. W takich przypadkach można użyć klauzuli ORDER BY, która służy do sortowania rekordów kolumn w kolejności rosnącej lub malejącej. W poniższym przykładzie pogrupowałem i uporządkowałem9w porządku malejącym) dane na podstawie adresu.
Składnia
SELECT expressions FROM tables-list [WHERE conditions] ORDER BY column1, column2,... [ ASC | DESC ];
Przykład
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 Mając BY
W SQLite POSIADAJĄC klauzula jest identyczna z WHERE klauzula. Klauzula HAVING to kolejny warunek stosowany po agregacji z grupą by w instrukcji select. Ogólnie w SQLite, GDZIE klauzula służy do zastosowania warunku do poszczególnych elementów w tabeli, a POSIADAJĄCY Klauzula służy do dodawania warunków filtrowania na podstawie grup utworzonych przez klauzulę Group By.
Przykład
SELECT ADDRESS, COUNT(ADDRESS) FROM StudentInfo GROUP BY ADDRESS HAVING COUNT(*)>1; ADDRESS COUNT(ADDRESS) ---------- -------------- Norway 3
- Klauzula limitu SQLite
W SQLite klauzula LIMIT służy do ustawienia limitu rekordów zwracanych przez instrukcję SELECT. Rozważmy przykład, aby zrozumieć tę koncepcję.
Składnia
SELECT expressions FROM tables-list [WHERE conditions] LIMIT number_rows OFFSET offset_value;
Przykład
SELECT NAME, ADDRESS FROM StudentInfo LIMIT 4 OFFSET 2; NAME ADDRESS ---------- ---------- Mitch Houston SAM Texas Johny Norway Robin Norway
PRZESUNIĘCIE jest opcjonalne i określa, ile wierszy należy pominąć na początku zestawu wyników na podstawie wartości_przesunięcia .
- SQLite ORAZ I LUB
W SQLite operatory AND i OR są używane do wykonywania wielu warunków na instrukcjach wyboru, wstawiania, aktualizowania i usuwania w oparciu o nasze wymagania. Operator AND SQLite zwróci wiersze lub rekordy, które spełniają warunki zdefiniowane za pomocą operatora AND.
Przykład 1
SELECT NAME FROM StudentInfo WHERE AGE = 22 AND ADDRESS = 'Texas'; NAME ---------- SAM
Warunek LUB służy do zdefiniowania wielu warunków w instrukcjach SQLite i zwróci wiersze lub rekordy z instrukcji, jeśli którykolwiek z warunków zostanie spełniony.
Przykład2
SELECT NAME FROM StudentInfo WHERE (AGE = 22 AND ADDRESS = 'Norway') OR ADDRESS = 'Norway'; NAME ---------- John Johny Robin
- Operator SQLite GLOB
W SQLite operator GLOB służy do sprawdzania, czy dana wartość ciągu pasuje do określonego wzorca, czy nie. W przypadku, gdy wartość ciągu pasuje do wartości wzorca, zwróci prawda i jest podobny do operatora LIKE. Ponadto GLOB rozróżnia wielkość liter.
Składnia
SELECT * FROM table_name WHERE column_name GLOB 'search-expression'
Przykład
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*******
- Odróżnienie SQLite
W SQLite słowo kluczowe DISTINCT przeskanuje zestaw wyników instrukcji SELECT i wyeliminuje zduplikowane wiersze. Ponadto wartości NULL są uważane za duplikaty, więc jeśli użyjemy klauzuli DISTINCT z kolumną, która ma wartości NULL, zachowa tylko jeden wiersz wartości NULL. Gdy zastosujesz DISTINCT dla wielu kolumn, instrukcja zwróci każdą unikalną kombinację kolumna1 i kolumnę2.
Przykład
SELECT DISTINCT AGE FROM StudentInfo; AGE ---------- 20 23 22
- Operator SQLite IN
W SQLite operator IN jest używany do określenia, czy dana wartość pasuje do listy podanych wartości, czy do wyniku zwróconego przez podzapytanie.
Przykład
SELECT NAME FROM StudentInfo WHERE ADDRESS IN ('Texas', 'Houston');
NAME
----------
Mitch
SAM - SQLite UNION &UNION ALL
W SQLite operator UNION służy do łączenia zestawów wyników 2 lub więcej instrukcji SELECT i usuwa zduplikowane wiersze między różnymi instrukcjami SELECT. Pamiętaj, że instrukcje SELECT, których użyliśmy z operatorem UNION, muszą mieć taką samą liczbę pól w zbiorach wyników o podobnych typach danych.
Składnia
SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions] UNION / UNION ALL SELECT expression1, expression2,... expression_n FROM tables [WHERE conditions];
Przykład
SELECT DEPARTMENTID FROM StudentInfo UNION SELECT DeptId FROM DepartmentInfo ORDER BY DEPARTMENTID ASC; DEPARTMENTID ------------ 1 2 3 4 5
Operator UNION ALL służy do łączenia zestawów wyników składających się z 2 lub więcej instrukcji SELECT i zwróci wszystkie wiersze, w tym duplikaty.
Przykład
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
Dzięki temu omówiliśmy najbardziej podstawowe polecenia, których możesz potrzebować podczas pracy z SQLite. Idąc dalej z tym samouczkiem SQLite, sprawdźmy instrukcję join w SQLite.
Dołączenia do SQLite
W SQLite złączenia są używane do łączenia rekordów z dwóch lub więcej tabel w bazie danych i uzyskiwania rekordów na podstawie naszych wymagań. Różne typy JOINS dostępne w SQLite to:
- Łączenie wewnętrzne – INNER JOIN służy do łączenia i zwracania tylko pasujących rekordów z wielu tabel na podstawie warunków zdefiniowanych w instrukcjach SQLite.
- Połączenie zewnętrzne – SQLite Outer Join wybierze pasujące wiersze z wielu tabel, tak samo jak Inner Join i kilka innych wierszy poza relacją. W uproszczeniu możemy powiedzieć, że SQLite OUTER JOIN jest dodatkiem INNER JOIN. Ogólnie rzecz biorąc, w standardzie SQL mamy trzy typy złączeń zewnętrznych:LEFT, RIGHT i FULL Outer Joins, ale SQLite obsługuje tylko LEFT OUTER JOIN.
- Połączenie krzyżowe – Służy do uzyskania iloczynu kartezjańskiego wierszy, dopasowując każdy wiersz pierwszej tabeli do każdego wiersza drugiej tabeli.
- Dołącz do siebie – Służy do łączenia ze sobą tego samego stołu. Aby użyć Self Join, musimy utworzyć różne nazwy aliasów dla tej samej tabeli, aby wykonywać operacje w oparciu o nasze wymagania.
Koncepcja jest podobna do innych relacyjnych systemów baz danych, takich jak SQL. Aby dowiedzieć się więcej, zapoznaj się z tym artykułem na temat złączeń SQL.
Dzięki temu omówiliśmy podstawowe polecenia SQLite. Zaawansowane koncepcje nie są tutaj omówione. Więc czekaj na kolejny artykuł na temat zaawansowanych koncepcji SQLite. Nawet przy wszystkich dobrych funkcjach, które ma do zaoferowania SQLite, ma on również pewne wady.
Samouczek SQLite:Wady SQLite
Poniżej wymieniono wady używania SQLite:
- Nie działa dobrze w architekturze klient/serwer.
- W większości przypadków rozmiar bazy danych SQLite jest ograniczony do 2 GB.
- SQLite nie zaimplementował RIGHT OUTER JOIN i FULL OUTER JOIN. W SQLite możemy zaimplementować tylko LEFT OUTER JOIN.
- Widoki w SQLite są tylko do odczytu. Nie możemy używać instrukcji DML (wstaw, aktualizuj i usuń) z widokami.
- Nie możemy używać instrukcji GRANT i REVOKE z SQLite.
Na tym kończymy samouczek SQLite.
Jeśli chcesz dowiedzieć się więcej o MySQL i poznać tę relacyjną bazę danych typu open source, zapoznaj się z naszym Szkoleniem certyfikacyjnym MySQL DBA który jest dostarczany z prowadzonym przez instruktora szkoleniem na żywo i doświadczeniem w rzeczywistych projektach. To szkolenie pomoże ci dogłębnie zrozumieć MySQL i pomoże ci osiągnąć mistrzostwo w tym temacie.
Masz do nas pytanie? Proszę wspomnieć o tym w sekcji komentarzy tego samouczka SQLite, a ja odezwę się do Ciebie.
