SQL to język do obsługi baz danych; obejmuje tworzenie bazy danych, usuwanie, pobieranie wierszy, modyfikowanie wierszy itp. SQL to plikANSI (American National Standards Institute), ale istnieje wiele różnych wersji języka SQL.

Co to jest SQL?

SQL to Structured Query Language, który jest językiem komputerowym służącym do przechowywania, manipulowania i pobierania danych przechowywanych w relacyjnej bazie danych.

SQL jest standardowym językiem dla systemu relacyjnych baz danych. Wszystkie systemy zarządzania relacyjnymi bazami danych (RDMS), takie jak MySQL, MS Access, Oracle, Sybase, Informix, Postgres i SQL Server, używają SQL jako standardowego języka bazy danych.

Ponadto używają różnych dialektów, takich jak -

• MS SQL Server wykorzystujący T-SQL,
• Oracle przy użyciu PL / SQL,
• Wersja SQL MS Access nazywa się JET SQL (format natywny) itp.

Dlaczego SQL?

SQL jest bardzo popularny, ponieważ oferuje następujące korzyści -

• Umożliwia użytkownikom dostęp do danych w systemach zarządzania relacyjnymi bazami danych.

• Umożliwia użytkownikom opisywanie danych.

• Umożliwia użytkownikom definiowanie danych w bazie danych i manipulowanie tymi danymi.

• Umożliwia osadzanie w innych językach przy użyciu modułów SQL, bibliotek i prekompilatorów.

• Umożliwia użytkownikom tworzenie i usuwanie baz danych i tabel.

• Umożliwia użytkownikom tworzenie widoków, procedur składowanych, funkcji w bazie danych.

• Umożliwia użytkownikom ustawianie uprawnień do tabel, procedur i widoków.

Krótka historia SQL

• 1970- Dr Edgar F. „Ted” Codd z IBM jest znany jako ojciec relacyjnych baz danych. Opisał model relacyjny dla baz danych.

• 1974 - Pojawił się Structured Query Language.

• 1978 - IBM pracował nad opracowaniem pomysłów Codda i wydał produkt o nazwie System / R.

• 1986- IBM opracował pierwszy prototyp relacyjnej bazy danych i został ustandaryzowany przez ANSI. Pierwsza relacyjna baza danych została wydana przez firmę Relational Software, która później została nazwana Oracle.

Proces SQL

Podczas wykonywania polecenia SQL dla dowolnego systemu RDBMS system określa najlepszy sposób wykonania żądania, a silnik SQL oblicza sposób interpretacji zadania.

Ten proces obejmuje różne elementy.

Te komponenty to -

• Wysyłający zapytania
• Silniki optymalizacji
• Klasyczny silnik zapytań
• Silnik zapytań SQL itp.

Klasyczny silnik zapytań obsługuje wszystkie zapytania inne niż SQL, ale silnik zapytań SQL nie obsługuje plików logicznych.

Poniżej znajduje się prosty diagram przedstawiający architekturę SQL -

Polecenia SQL

Standardowe polecenia SQL do interakcji z relacyjnymi bazami danych to CREATE, SELECT, INSERT, UPDATE, DELETE i DROP. Polecenia te można podzielić na następujące grupy w zależności od ich charakteru -

DDL - język definicji danych

Sr.No.	Polecenie i opis
1	CREATE Tworzy nową tabelę, widok tabeli lub inny obiekt w bazie danych.
2	ALTER Modyfikuje istniejący obiekt bazy danych, taki jak tabela.
3	DROP Usuwa całą tabelę, widok tabeli lub inne obiekty w bazie danych.

DML - język manipulacji danymi

Sr.No.	Polecenie i opis
1	SELECT Pobiera określone rekordy z co najmniej jednej tabeli.
2	INSERT Tworzy rekord.
3	UPDATE Modyfikuje rekordy.
4	DELETE Usuwa rekordy.

DCL - Data Control Language

Sr.No.	Polecenie i opis
1	GRANT Daje uprawnienie użytkownikowi.
2	REVOKE Odbiera uprawnienia nadane użytkownikowi.

Co to jest RDBMS?

RDBMS oznacza Rpodniosły Database Mzaręczyny System. RDBMS jest podstawą SQL i wszystkich nowoczesnych systemów baz danych, takich jak MS SQL Server, IBM DB2, Oracle, MySQL i Microsoft Access.

System zarządzania relacyjnymi bazami danych (RDBMS) to system zarządzania bazą danych (DBMS) oparty na modelu relacyjnym wprowadzonym przez EF Codda.

Co to jest stół?

Dane w RDBMS są przechowywane w obiektach bazy danych o nazwie tables. Ta tabela jest w zasadzie zbiorem powiązanych wpisów danych i składa się z wielu kolumn i wierszy.

Pamiętaj, tabela jest najpowszechniejszą i najprostszą formą przechowywania danych w relacyjnej bazie danych. Poniższy program jest przykładem tabeli CUSTOMERS -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Co to jest pole?

Każda tabela jest podzielona na mniejsze jednostki zwane polami. Pola w tabeli KLIENCI zawierają ID, IMIĘ, WIEK, ADRES i WYNAGRODZENIE.

Pole to kolumna w tabeli, której zadaniem jest przechowywanie określonych informacji o każdym rekordzie w tabeli.

Co to jest rekord lub wiersz?

Rekord nazywany jest również wierszem danych, czyli każdym pojedynczym wpisem istniejącym w tabeli. Na przykład w powyższej tabeli KLIENCI znajduje się 7 rekordów. Poniżej znajduje się pojedynczy wiersz danych lub rekord w tabeli CUSTOMERS -

+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Rekord to pozioma jednostka w tabeli.

Co to jest kolumna?

Kolumna to pionowa jednostka w tabeli zawierająca wszystkie informacje powiązane z określonym polem w tabeli.

Na przykład kolumna w tabeli CUSTOMERS to ADDRESS, która reprezentuje opis lokalizacji i wyglądałaby tak, jak pokazano poniżej -

+-----------+
| ADDRESS   |
+-----------+
| Ahmedabad |
| Delhi     |
| Kota      |
| Mumbai    |
| Bhopal    |
| MP        |
| Indore    |
+----+------+

Co to jest wartość NULL?

Wartość NULL w tabeli to wartość w polu, które wydaje się puste, co oznacza, że ​​pole z wartością NULL jest polem bez wartości.

Bardzo ważne jest, aby zrozumieć, że wartość NULL różni się od wartości zerowej lub pola zawierającego spacje. Pole z wartością NULL to takie, które zostało puste podczas tworzenia rekordu.

Ograniczenia SQL

Ograniczenia to reguły wymuszane na kolumnach danych w tabeli. Służą one do ograniczenia typu danych, które mogą zostać umieszczone w tabeli. Zapewnia to dokładność i wiarygodność danych w bazie danych.

Ograniczenia mogą być na poziomie kolumny lub tabeli. Ograniczenia na poziomie kolumny są stosowane tylko do jednej kolumny, podczas gdy ograniczenia na poziomie tabeli są stosowane do całej tabeli.

Poniżej przedstawiono niektóre z najczęściej używanych ograniczeń dostępnych w języku SQL -

• Ograniczenie NOT NULL - zapewnia, że ​​kolumna nie może mieć wartości NULL.

• DEFAULT Constraint - dostarcza domyślną wartość dla kolumny, gdy żadna nie jest określona.

• UNIQUE Constraint - zapewnia, że ​​wszystkie wartości w kolumnie są różne.

• Klucz PRIMARY - jednoznacznie identyfikuje każdy wiersz / rekord w tabeli bazy danych.

• Klucz OBCY - jednoznacznie identyfikuje wiersz / rekord w dowolnej innej tabeli bazy danych.

• Ograniczenie CHECK - ograniczenie CHECK zapewnia, że ​​wszystkie wartości w kolumnie spełniają określone warunki.

• INDEKS - Służy do bardzo szybkiego tworzenia i pobierania danych z bazy danych.

Integralność danych

W każdym systemie RDBMS istnieją następujące kategorie integralności danych -

• Entity Integrity − W tabeli nie ma zduplikowanych wierszy.

• Domain Integrity − Wymusza prawidłowe wpisy dla danej kolumny, ograniczając typ, format lub zakres wartości.

• Referential integrity − Nie można usunąć wierszy, które są używane przez inne rekordy.

• User-Defined Integrity − Wymusza określone reguły biznesowe, które nie dotyczą integralności encji, domeny ani referencji.

Normalizacja bazy danych

Normalizacja bazy danych to proces efektywnego organizowania danych w bazie danych. Istnieją dwa powody tego procesu normalizacji -

• Eliminacja zbędnych danych, na przykład przechowywanie tych samych danych w więcej niż jednej tabeli.

• Zapewnienie zależności danych ma sens.

Oba te powody są wartościowymi celami, ponieważ zmniejszają ilość miejsca zużywanego przez bazę danych i zapewniają logiczne przechowywanie danych. Normalizacja składa się z szeregu wskazówek, które pomagają w tworzeniu dobrej struktury bazy danych.

Wytyczne normalizacyjne są podzielone na normalne formy; pomyśl o formularzu jako formacie lub sposobie rozplanowania struktury bazy danych. Celem form normalnych jest takie uporządkowanie struktury bazy danych, aby była zgodna z regułami pierwszej postaci normalnej, następnie drugiej postaci normalnej i wreszcie trzeciej postaci normalnej.

Twoim wyborem jest pójście dalej i przejście do czwartej postaci normalnej, piątej postaci normalnej i tak dalej, ale ogólnie trzecia postać normalna jest więcej niż wystarczająca.

• Pierwsza postać normalna (1NF)
• Druga postać normalna (2NF)
• Trzecia postać normalna (3NF)

Istnieje wiele popularnych RDBMS, z którymi można pracować. Ten samouczek zawiera krótki przegląd niektórych najpopularniejszych systemów RDBMS. Pomogłoby to w porównaniu ich podstawowych funkcji.

MySQL

MySQL to baza danych SQL typu open source, która została opracowana przez szwedzką firmę MySQL AB. MySQL jest wymawiane jako „my ess-que-ell”, w przeciwieństwie do SQL, wymawiane jako „sequel”.

MySQL obsługuje wiele różnych platform, w tym Microsoft Windows, główne dystrybucje Linuksa, UNIX i Mac OS X.

MySQL ma wersje bezpłatne i płatne, w zależności od jego zastosowania (niekomercyjne / komercyjne) i funkcji. MySQL zawiera bardzo szybki, wielowątkowy, wielostanowiskowy i niezawodny serwer bazy danych SQL.

Historia

• Rozwój MySQL przez Michaela Wideniusa i Davida Axmarka od 1994 roku.

• Pierwszy wewnętrzny uwolnienie 23 ^rd maja 1995 r.

• Wersja dla systemu Windows została wydana na 8 ^th stycznia 1998 dla Windows 95 i NT.

• Wersja 3.23: beta od czerwca 2000 r., Wydanie produkcyjne styczeń 2001 r.

• Wersja 4.0: beta od sierpnia 2002 r., Wydanie produkcyjne marzec 2003 r. (Związki).

• Wersja 4.1: beta od czerwca 2004 r., Wydanie produkcyjne październik 2004 r.

• Wersja 5.0: beta od marca 2005 r., Wydanie produkcyjne październik 2005 r.

• Sun Microsystems MySQL AB nabył w dniu 26 ^th lutego 2008 r.

• Wersja 5.1: uwolnienie produkcji 27 ^th listopada 2008 r.

funkcje

• Wysoka wydajność.
• Duża dostępność.
• Skalowalność i elastyczność Uruchom wszystko.
• Solidne wsparcie transakcyjne.
• Mocne strony sieci Web i hurtowni danych.
• Silna ochrona danych.
• Kompleksowe tworzenie aplikacji.
• Łatwość zarządzania.
• Wolność oprogramowania typu open source i wsparcie 24 x 7.
• Najniższy całkowity koszt posiadania.

MS SQL Server

MS SQL Server to system zarządzania relacyjnymi bazami danych opracowany przez firmę Microsoft Inc. Jego podstawowe języki zapytań to -

• T-SQL
• ANSI SQL

Historia

• 1987 - Sybase wypuszcza SQL Server dla UNIX.

• 1988 - Microsoft, Sybase i Aston-Tate przenoszą SQL Server do OS / 2.

• 1989 - Microsoft, Sybase i Aston-Tate wypuszczają SQL Server 1.0 dla OS / 2.

• 1990 - zostaje wydany SQL Server 1.1 z obsługą klientów Windows 3.0.

• Aston - Tate rezygnuje z rozwoju SQL Server.

• 2000 - Microsoft wypuszcza SQL Server 2000.

• 2001 - Microsoft udostępnia XML dla SQL Server Web Release 1 (do pobrania).

• 2002 - Microsoft wypuszcza SQLXML 2.0 (zmieniono nazwę z XML dla SQL Server).

• 2002 - Microsoft wypuszcza SQLXML 3.0.

• 2005 - Microsoft wypuszcza SQL Server 2005 7 listopada 2005.

funkcje

• Wysoka wydajność
• Duża dostępność
• Dublowanie bazy danych
• Migawki bazy danych
• Integracja z CLR
• Service Broker
• Wyzwalacze DDL
• Funkcje rankingowe
• Poziomy izolacji oparte na wersjach wiersza
• Integracja XML
• TRY...CATCH
• Poczta bazy danych

WYROCZNIA

Jest to bardzo duży system zarządzania bazą danych dla wielu użytkowników. Oracle to system zarządzania relacyjnymi bazami danych opracowany przez „Oracle Corporation”.

Oracle pracuje nad efektywnym zarządzaniem swoimi zasobami, bazą danych zawierającą informacje wielu klientów żądających i wysyłających dane w sieci.

Jest to doskonały wybór serwera bazy danych do obliczeń typu klient / serwer. Oracle obsługuje wszystkie główne systemy operacyjne zarówno dla klientów, jak i dla serwerów, w tym MSDOS, NetWare, UnixWare, OS / 2 i większość wersji UNIX.

Historia

Firma Oracle powstała w 1977 roku i świętuje swoje 32 wspaniałe lata w branży (od 1977 do 2009).

• 1977 - Larry Ellison, Bob Miner i Ed Oates założyli Software Development Laboratories w celu podjęcia prac rozwojowych.

• 1979 - wypuszczono wersję 2.0 Oracle, która stała się pierwszą komercyjną relacyjną bazą danych i pierwszą bazą danych SQL. Firma zmieniła nazwę na Relational Software Inc. (RSI).

• 1981 - RSI rozpoczyna tworzenie narzędzi dla Oracle.

• 1982 - RSI została przemianowana na Oracle Corporation.

• 1983 - Oracle wypuściło wersję 3.0, przepisaną w języku C i działającą na wielu platformach.

• 1984 - wydano Oracle w wersji 4.0. Zawierał funkcje, takie jak kontrola współbieżności - spójność odczytu wielu wersji itp.

• 1985 - wydano wersję Oracle 4.0. Zawierał funkcje, takie jak kontrola współbieżności - spójność odczytu wielu wersji itp.

• 2007 - Oracle wypuściło Oracle11g. Nowa wersja skupiła się na lepszym partycjonowaniu, łatwej migracji itp.

funkcje

• Concurrency
• Przeczytaj spójność
• Mechanizmy blokujące
• Baza danych Quiesce
• Portability
• Samodzielna baza danych
• SQL*Plus
• ASM
• Scheduler
• Menedżer zasobów
• Magazyn danych
• Zmaterializowane widoki
• Indeksy bitmapowe
• Kompresja tabeli
• Wykonywanie równoległe
• Analityczny SQL
• Eksploracja danych
• Partitioning

DOSTĘP MS

To jeden z najpopularniejszych produktów firmy Microsoft. Microsoft Access to podstawowe oprogramowanie do zarządzania bazami danych. Baza danych MS Access to nie tylko niedroga, ale także potężna baza danych dla projektów na małą skalę.

MS Access korzysta z silnika bazy danych Jet, który wykorzystuje określony dialekt języka SQL (czasami nazywany Jet SQL).

MS Access jest dostarczany z profesjonalną edycją pakietu MS Office. MS Access posiada łatwy w obsłudze intuicyjny interfejs graficzny.

• 1992 - Wydano Access w wersji 1.0.

• 1993 - Wydanie Access 1.1 w celu poprawy kompatybilności z włączeniem języka programowania Access Basic.

• Najbardziej znaczące przejście z Access 97 na Access 2000.

• 2007 - Access 2007, nowy format bazy danych ACCDB, który obsługuje złożone typy danych, takie jak pola wielowartościowe i załączniki.

funkcje

• Użytkownicy mogą tworzyć tabele, zapytania, formularze i raporty oraz łączyć je razem za pomocą makr.

• Możliwość importu i eksportu danych do wielu formatów, w tym Excel, Outlook, ASCII, dBase, Paradox, FoxPro, SQL Server, Oracle, ODBC itp.

• Istnieje również format Jet Database (MDB lub ACCDB w Access 2007), który może zawierać aplikację i dane w jednym pliku. To sprawia, że ​​bardzo wygodna jest dystrybucja całej aplikacji do innego użytkownika, który może uruchomić ją w rozłączonych środowiskach.

• Microsoft Access oferuje sparametryzowane zapytania. Do tych zapytań i tabel programu Access można się odwoływać z innych programów, takich jak VB6 i .NET, poprzez DAO lub ADO.

• Wersje desktopowe Microsoft SQL Server mogą być używane z programem Access jako alternatywa dla aparatu bazy danych Jet.

• Microsoft Access to baza danych oparta na serwerze plików. W przeciwieństwie do systemów zarządzania relacyjnymi bazami danych klient-serwer (RDBMS) program Microsoft Access nie implementuje wyzwalaczy baz danych, procedur składowanych ani rejestrowania transakcji.

SQL - składnia

Po SQL następuje unikalny zestaw reguł i wskazówek zwany Składnią. Ten samouczek umożliwia szybkie rozpoczęcie pracy z językiem SQL, wymieniając całą podstawową składnię SQL.

Wszystkie instrukcje SQL zaczynają się od dowolnego ze słów kluczowych, takich jak SELECT, INSERT, UPDATE, DELETE, ALTER, DROP, CREATE, USE, SHOW, a wszystkie instrukcje kończą się średnikiem (;).

Najważniejszą rzeczą, na którą należy tutaj zwrócić uwagę, jest to, że SQL nie rozróżnia wielkości liter, co oznacza, że ​​SELECT i select mają takie samo znaczenie w instrukcjach SQL. Natomiast MySQL robi różnicę w nazwach tabel. Tak więc, jeśli pracujesz z MySQL, musisz podać nazwy tabel tak, jak istnieją w bazie danych.

Różne składnie w języku SQL

Wszystkie przykłady podane w tym samouczku zostały przetestowane z serwerem MySQL.

Instrukcja SQL SELECT

SELECT column1, column2....columnN
FROM   table_name;

Klauzula SQL DISTINCT

SELECT DISTINCT column1, column2....columnN
FROM   table_name;

Klauzula SQL WHERE

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION;

Klauzula SQL AND / OR

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION-1 {AND|OR} CONDITION-2;

Klauzula SQL IN

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name IN (val-1, val-2,...val-N);

Klauzula SQL BETWEEN

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name BETWEEN val-1 AND val-2;

Klauzula SQL LIKE

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name LIKE { PATTERN };

Klauzula SQL ORDER BY

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION
ORDER BY column_name {ASC|DESC};

Klauzula SQL GROUP BY

SELECT SUM(column_name)
FROM   table_name
WHERE  CONDITION
GROUP BY column_name;

Klauzula SQL COUNT

SELECT COUNT(column_name)
FROM   table_name
WHERE  CONDITION;

Klauzula SQL HAVING

SELECT SUM(column_name)
FROM   table_name
WHERE  CONDITION
GROUP BY column_name
HAVING (arithematic function condition);

Instrukcja SQL CREATE TABLE

CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);

Instrukcja SQL DROP TABLE

DROP TABLE table_name;

Instrukcja SQL CREATE INDEX

CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);

Instrukcja SQL DROP INDEX

ALTER TABLE table_name
DROP INDEX index_name;

Instrukcja SQL DESC

DESC table_name;

Instrukcja SQL TRUNCATE TABLE

TRUNCATE TABLE table_name;

Instrukcja SQL ALTER TABLE

ALTER TABLE table_name {ADD|DROP|MODIFY} column_name {data_ype};

Instrukcja SQL ALTER TABLE (zmiana nazwy)

ALTER TABLE table_name RENAME TO new_table_name;

Instrukcja SQL INSERT INTO

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);

Instrukcja SQL UPDATE

UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE  CONDITION ];

Instrukcja SQL DELETE

DELETE FROM table_name
WHERE  {CONDITION};

Instrukcja SQL CREATE DATABASE

CREATE DATABASE database_name;

Instrukcja SQL DROP DATABASE

DROP DATABASE database_name;

Instrukcja SQL USE

USE database_name;

Instrukcja SQL COMMIT

COMMIT;

Instrukcja SQL ROLLBACK

ROLLBACK;

SQL - typy danych

Typ danych SQL to atrybut, który określa typ danych dowolnego obiektu. Każda kolumna, zmienna i wyrażenie ma powiązany typ danych w języku SQL. Podczas tworzenia tabel można używać tych typów danych. Możesz wybrać typ danych dla kolumny tabeli w oparciu o swoje wymagania.

SQL Server oferuje sześć kategorii typów danych do użytku, które są wymienione poniżej -

Dokładne numeryczne typy danych

TYP DANYCH	OD	DO
bigint	-9,223,372,036,854,775,808	9.223.372.036.854.775.807
int	-2,147,483,648	2,147,483,647
smallint	-32,768	32,767
tinyint	0	255
kawałek	0	1
dziesiętny	-10 ^ 38 +1	10 ^ 38 -1
numeryczny	-10 ^ 38 +1	10 ^ 38 -1
pieniądze	-922,337,203,685,477,5808	+922,337,203,685,477,5807
małe pieniądze	-214,748,3648	+214,748,3647

Przybliżone numeryczne typy danych

TYP DANYCH	OD	DO
pływak	-1,79E + 308	1,79E + 308
real	-3,40E + 38	3,40E + 38

Typy danych daty i godziny

TYP DANYCH	OD	DO
datetime	1 stycznia 1753	31 grudnia 9999
smalldatetime	1 sty 1900	6 czerwca 2079
data	Przechowuje datę, na przykład 30 czerwca 1991 r
czas	Przechowuje godzinę, na przykład 12:30

Note - Tutaj datetime ma dokładność 3,33 milisekundy, podczas gdy tak samo jak mała dataetime ma dokładność 1 minuty.

Typy danych ciągów znaków

Sr.No.	RODZAJ I OPIS DANYCH
1	char Maksymalna długość 8000 znaków. (Stała długość znaków innych niż Unicode)
2	varchar Maksymalnie 8 000 znaków (dane o zmiennej długości inne niż Unicode).
3	varchar(max) Maksymalna długość 2E + 31 znaków, zmienna długość danych innych niż Unicode (tylko SQL Server 2005).
4	text Dane inne niż Unicode o zmiennej długości, o maksymalnej długości 2 147 483 647 znaków.

Typy danych ciągów znaków Unicode

Sr.No.	RODZAJ I OPIS DANYCH
1	nchar Maksymalna długość 4000 znaków. (Unicode o stałej długości)
2	nvarchar Maksymalna długość 4000 znaków (Unicode o zmiennej długości)
3	nvarchar(max) Maksymalna długość 2E + 31 znaków (tylko SQL Server 2005). (Zmienna długość Unicode)
4	ntext Maksymalna długość 1 073 741 823 znaków. (Unicode o zmiennej długości)

Binarne typy danych

Sr.No.	RODZAJ I OPIS DANYCH
1	binary Maksymalna długość 8000 bajtów (dane binarne o stałej długości)
2	varbinary Maksymalna długość 8000 bajtów (dane binarne o zmiennej długości)
3	varbinary(max) Maksymalna długość 2E + 31 bajtów (tylko SQL Server 2005). (Dane binarne o zmiennej długości)
4	image Maksymalna długość 2 147 483 647 bajtów. (Dane binarne o zmiennej długości)

Różne typy danych

Sr.No.	RODZAJ I OPIS DANYCH
1	sql_variant Przechowuje wartości różnych typów danych obsługiwanych przez SQL Server, z wyjątkiem text, ntext i timestamp.
2	timestamp Przechowuje unikalny numer w całej bazie danych, który jest aktualizowany za każdym razem, gdy aktualizowany jest wiersz
3	uniqueidentifier Przechowuje globalnie unikalny identyfikator (GUID)
4	xml Przechowuje dane XML. Wystąpienia XML można przechowywać w kolumnie lub zmiennej (tylko SQL Server 2005).
5	cursor Odniesienie do obiektu kursora
6	table Przechowuje zestaw wyników do późniejszego przetwarzania

SQL - operatory

Co to jest operator w SQL?

Operator jest słowem zastrzeżonym lub znakiem używanym głównie w klauzuli WHERE instrukcji SQL do wykonywania operacji, takich jak porównania i operacje arytmetyczne. Te operatory służą do określania warunków w instrukcji SQL i służą jako spójniki dla wielu warunków w instrukcji.

• Operatory arytmetyczne
• Operatory porównania
• Operatory logiczne
• Operatory używane do negowania warunków

Operatory arytmetyczne SQL

Założyć 'variable a' mieści 10 i 'variable b' mieści 20, a następnie -

Pokaż przykłady

Operator	Opis	Przykład
+ (Dodawanie)	Dodaje wartości po obu stronach operatora.	a + b da 30
- (odejmowanie)	Odejmuje operand po prawej stronie od operandu po lewej stronie.	a - b da -10
* (Mnożenie)	Mnoży wartości po obu stronach operatora.	a * b da 200
/ (Podział)	Dzieli operand lewej ręki przez operand prawej ręki.	b / a da 2
% (Moduł)	Dzieli operand po lewej stronie przez operand po prawej stronie i zwraca resztę.	b% a da 0

Operatory porównania SQL

Założyć 'variable a' mieści 10 i 'variable b' mieści 20, a następnie -

Pokaż przykłady

Operator	Opis	Przykład
=	Sprawdza, czy wartości dwóch operandów są równe, czy nie, jeśli tak, warunek staje się prawdziwy.	(a = b) nie jest prawdą.
! =	Sprawdza, czy wartości dwóch operandów są równe, czy nie, jeśli wartości nie są równe, warunek staje się prawdziwy.	(a! = b) jest prawdą.
<>	Sprawdza, czy wartości dwóch operandów są równe, czy nie, jeśli wartości nie są równe, warunek staje się prawdziwy.	(a <> b) jest prawdą.
>	Sprawdza, czy wartość lewego operandu jest większa niż wartość prawego operandu, jeśli tak, warunek staje się prawdziwy.	(a> b) nie jest prawdą.
<	Sprawdza, czy wartość lewego operandu jest mniejsza niż wartość prawego operandu, jeśli tak, warunek staje się prawdziwy.	(a <b) jest prawdą.
> =	Sprawdza, czy wartość lewego operandu jest większa lub równa wartości prawego operandu, jeśli tak, warunek staje się prawdziwy.	(a> = b) nie jest prawdą.
<=	Sprawdza, czy wartość lewego operandu jest mniejsza lub równa wartości prawego operandu, jeśli tak, warunek staje się prawdziwy.	(a <= b) jest prawdą.
! <	Sprawdza, czy wartość lewego operandu nie jest mniejsza niż wartość prawego operandu, jeśli tak, warunek staje się prawdziwy.	(a! <b) jest fałszem.
!>	Sprawdza, czy wartość lewego operandu nie jest większa niż wartość prawego operandu, jeśli tak, warunek staje się prawdziwy.	(a!> b) jest prawdą.

Operatory logiczne SQL

Oto lista wszystkich operatorów logicznych dostępnych w SQL.

Pokaż przykłady

Sr.No.	Operator i opis
1	ALL Operator ALL służy do porównywania wartości ze wszystkimi wartościami w innym zestawie wartości.
2	AND Operator AND dopuszcza istnienie wielu warunków w klauzuli WHERE instrukcji SQL.
3	ANY Operator ANY służy do porównywania wartości z dowolną odpowiednią wartością na liście zgodnie z warunkiem.
4	BETWEEN Operator BETWEEN służy do wyszukiwania wartości mieszczących się w zbiorze wartości, dla których określono wartość minimalną i maksymalną.
5	EXISTS Operator EXISTS służy do wyszukiwania obecności wiersza w określonej tabeli, który spełnia określone kryterium.
6	IN Operator IN służy do porównywania wartości z listą wartości literałów, które zostały określone.
7	LIKE Operator LIKE służy do porównywania wartości z podobnymi wartościami za pomocą operatorów symboli wieloznacznych.
8	NOT Operator NOT odwraca znaczenie operatora logicznego, z którym jest używany. Np .: NIE ISTNIEJE, NIE MA MIĘDZY, NIE MA W itd.This is a negate operator.
9	OR Operator OR służy do łączenia wielu warunków w klauzuli WHERE instrukcji SQL.
10	IS NULL Operator NULL służy do porównywania wartości z wartością NULL.
11	UNIQUE Operator UNIQUE przeszukuje każdy wiersz określonej tabeli pod kątem unikalności (bez duplikatów).

SQL - wyrażenia

Wyrażenie to kombinacja jednej lub więcej wartości, operatorów i funkcji SQL, których wynikiem jest wartość. Te WYRAŻENIA SQL są podobne do formuł i są napisane w języku zapytań. Można ich również używać do wysyłania zapytań do bazy danych o określony zestaw danych.

Składnia

Rozważmy podstawową składnię instrukcji SELECT w następujący sposób -

SELECT column1, column2, columnN 
FROM table_name 
WHERE [CONDITION|EXPRESSION];

Istnieją różne typy wyrażeń SQL, które wymieniono poniżej -

• Boolean
• Numeric
• Date

Omówmy teraz szczegółowo każdą z nich.

Wyrażenia logiczne

SQL Boolean Expressions pobierają dane na podstawie dopasowania pojedynczej wartości. Poniżej znajduje się składnia -

SELECT column1, column2, columnN 
FROM table_name 
WHERE SINGLE VALUE MATCHING EXPRESSION;

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+
7 rows in set (0.00 sec)

Poniższa tabela to prosty przykład pokazujący użycie różnych wyrażeń logicznych SQL -

SQL> SELECT * FROM CUSTOMERS WHERE SALARY = 10000;
+----+-------+-----+---------+----------+
| ID | NAME  | AGE | ADDRESS | SALARY   |
+----+-------+-----+---------+----------+
|  7 | Muffy |  24 | Indore  | 10000.00 |
+----+-------+-----+---------+----------+
1 row in set (0.00 sec)

Wyrażenie liczbowe

Te wyrażenia służą do wykonywania wszelkich operacji matematycznych w dowolnym zapytaniu. Poniżej znajduje się składnia -

SELECT numerical_expression as  OPERATION_NAME
[FROM table_name
WHERE CONDITION] ;

Tutaj numerical_expression jest używany do wyrażenia matematycznego lub dowolnej formuły. Poniżej znajduje się prosty przykład pokazujący użycie wyrażeń liczbowych SQL -

SQL> SELECT (15 + 6) AS ADDITION
+----------+
| ADDITION |
+----------+
|       21 |
+----------+
1 row in set (0.00 sec)

Istnieje kilka wbudowanych funkcji, takich jak avg (), sum (), count () itp., Które służą do wykonywania tak zwanych obliczeń danych zagregowanych w tabeli lub określonej kolumnie tabeli.

SQL> SELECT COUNT(*) AS "RECORDS" FROM CUSTOMERS; 
+---------+
| RECORDS |
+---------+
|       7 |
+---------+
1 row in set (0.00 sec)

Wyrażenia dat

Wyrażenia daty zwracają bieżące wartości daty i godziny systemowej -

SQL>  SELECT CURRENT_TIMESTAMP;
+---------------------+
| Current_Timestamp   |
+---------------------+
| 2009-11-12 06:40:23 |
+---------------------+
1 row in set (0.00 sec)

Inne wyrażenie daty jest pokazane poniżej -

SQL>  SELECT  GETDATE();;
+-------------------------+
| GETDATE                 |
+-------------------------+
| 2009-10-22 12:07:18.140 |
+-------------------------+
1 row in set (0.00 sec)

SQL - TWORZENIE bazy danych

SQL CREATE DATABASE instrukcja służy do tworzenia nowej bazy danych SQL.

Składnia

Podstawowa składnia tej instrukcji CREATE DATABASE jest następująca -

CREATE DATABASE DatabaseName;

Zawsze nazwa bazy danych powinna być unikalna w RDBMS.

Przykład

Jeśli chcesz utworzyć nową bazę danych <testDB>, instrukcja CREATE DATABASE będzie wyglądać tak, jak pokazano poniżej -

SQL> CREATE DATABASE testDB;

Przed utworzeniem jakiejkolwiek bazy danych upewnij się, że masz uprawnienia administratora. Po utworzeniu bazy danych możesz sprawdzić ją na liście baz danych w następujący sposób -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
| testDB             |
+--------------------+
7 rows in set (0.00 sec)

SQL - DROP lub DELETE Database

SQL DROP DATABASE instrukcja służy do usuwania istniejącej bazy danych w schemacie SQL.

Składnia

Podstawowa składnia instrukcji DROP DATABASE jest następująca -

DROP DATABASE DatabaseName;

Zawsze nazwa bazy danych powinna być unikalna w RDBMS.

Przykład

Jeśli chcesz usunąć istniejącą bazę danych <testDB>, instrukcja DROP DATABASE będzie wyglądać tak, jak pokazano poniżej -

SQL> DROP DATABASE testDB;

NOTE - Zachowaj ostrożność przed użyciem tej operacji, ponieważ usunięcie istniejącej bazy danych spowodowałoby utratę wszystkich informacji przechowywanych w bazie danych.

Przed upuszczeniem jakiejkolwiek bazy danych upewnij się, że masz uprawnienia administratora. Po upuszczeniu bazy danych możesz sprawdzić ją na liście baz danych, jak pokazano poniżej -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
+--------------------+
6 rows in set (0.00 sec)

Baza danych SQL - SELECT, instrukcja USE

Jeśli masz wiele baz danych w schemacie SQL, to przed rozpoczęciem operacji musisz wybrać bazę danych, w której będą wykonywane wszystkie operacje.

SQL USE instrukcja służy do wyboru dowolnej istniejącej bazy danych w schemacie SQL.

Składnia

Podstawowa składnia instrukcji USE jest pokazana poniżej -

USE DatabaseName;

Zawsze nazwa bazy danych powinna być unikalna w RDBMS.

Przykład

Możesz sprawdzić dostępne bazy danych, jak pokazano poniżej -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
+--------------------+
6 rows in set (0.00 sec)

Teraz, jeśli chcesz pracować z bazą danych AMROOD, możesz wykonać następujące polecenie SQL i rozpocząć pracę z bazą danych AMROOD.

SQL> USE AMROOD;

SQL - TWORZENIE tabeli

Tworzenie podstawowej tabeli obejmuje nazwanie tabeli i zdefiniowanie jej kolumn oraz typu danych każdej kolumny.

SQL CREATE TABLE instrukcja służy do tworzenia nowej tabeli.

Składnia

Podstawowa składnia instrukcji CREATE TABLE jest następująca -

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
   PRIMARY KEY( one or more columns )
);

CREATE TABLE jest słowem kluczowym informującym system bazy danych, co chcesz zrobić. W takim przypadku chcesz utworzyć nową tabelę. Unikalna nazwa lub identyfikator tabeli następuje po instrukcji CREATE TABLE.

Następnie w nawiasach pojawia się lista określająca każdą kolumnę w tabeli i jaki to typ danych. Poniższy przykład sprawia, że ​​składnia staje się jaśniejsza.

Kopię istniejącej tabeli można utworzyć za pomocą kombinacji instrukcji CREATE TABLE i instrukcji SELECT. Pełne szczegóły można znaleźć w sekcji Tworzenie tabeli przy użyciu innej tabeli.

Przykład

Poniższy blok kodu jest przykładem, który tworzy tabelę CUSTOMERS z identyfikatorem jako kluczem podstawowym i NIE NULL to ograniczenia pokazujące, że te pola nie mogą mieć wartości NULL podczas tworzenia rekordów w tej tabeli -

SQL> CREATE TABLE CUSTOMERS(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25) ,
   SALARY   DECIMAL (18, 2),       
   PRIMARY KEY (ID)
);

Możesz sprawdzić, czy Twoja tabela została pomyślnie utworzona, patrząc na komunikat wyświetlany przez serwer SQL, w przeciwnym razie możesz użyć DESC polecenie w następujący sposób -

SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field   | Type          | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID      | int(11)       | NO   | PRI |         |       |
| NAME    | varchar(20)   | NO   |     |         |       |
| AGE     | int(11)       | NO   |     |         |       |
| ADDRESS | char(25)      | YES  |     | NULL    |       |
| SALARY  | decimal(18,2) | YES  |     | NULL    |       |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

Teraz masz w swojej bazie danych tabelę CUSTOMERS, w której możesz przechowywać wymagane informacje o klientach.

SQL - DROP lub DELETE Table

SQL DROP TABLE Instrukcja służy do usuwania definicji tabeli i wszystkich danych, indeksów, wyzwalaczy, ograniczeń i specyfikacji uprawnień dla tej tabeli.

NOTE - Należy być bardzo ostrożnym podczas korzystania z tego polecenia, ponieważ po usunięciu tabeli wszystkie informacje dostępne w tej tabeli również zostaną utracone na zawsze.

Składnia

Podstawowa składnia tej instrukcji DROP TABLE jest następująca -

DROP TABLE table_name;

Przykład

Najpierw zweryfikujmy tabelę CUSTOMERS, a następnie usuniemy ją z bazy danych, jak pokazano poniżej -

SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field   | Type          | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID      | int(11)       | NO   | PRI |         |       |
| NAME    | varchar(20)   | NO   |     |         |       |
| AGE     | int(11)       | NO   |     |         |       |
| ADDRESS | char(25)      | YES  |     | NULL    |       |
| SALARY  | decimal(18,2) | YES  |     | NULL    |       |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

Oznacza to, że tabela CUSTOMERS jest dostępna w bazie danych, więc upuśćmy ją teraz, jak pokazano poniżej.

SQL> DROP TABLE CUSTOMERS;
Query OK, 0 rows affected (0.01 sec)

Teraz, jeśli spróbujesz polecenia DESC, pojawi się następujący błąd -

SQL> DESC CUSTOMERS;
ERROR 1146 (42S02): Table 'TEST.CUSTOMERS' doesn't exist

Tutaj TEST jest nazwą bazy danych, której używamy w naszych przykładach.

SQL - WSTAW zapytanie

SQL INSERT INTO Instrukcja służy do dodawania nowych wierszy danych do tabeli w bazie danych.

Składnia

Istnieją dwie podstawowe składnie instrukcji INSERT INTO, które są pokazane poniżej.

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)  
VALUES (value1, value2, value3,...valueN);

Tutaj kolumna1, kolumna2, kolumna3, ... kolumnaN to nazwy kolumn w tabeli, do których chcesz wstawić dane.

W przypadku dodawania wartości do wszystkich kolumn tabeli może nie być konieczne określanie nazw kolumn w zapytaniu SQL. Ale upewnij się, że kolejność wartości jest taka sama, jak kolejność kolumn w tabeli.

Plik SQL INSERT INTO składnia będzie następująca -

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

Przykład

Poniższe instrukcje utworzą sześć rekordów w tabeli CUSTOMERS.

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Khilan', 25, 'Delhi', 1500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'kaushik', 23, 'Kota', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Chaitali', 25, 'Mumbai', 6500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'Hardik', 27, 'Bhopal', 8500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Komal', 22, 'MP', 4500.00 );

Możesz utworzyć rekord w tabeli CUSTOMERS, używając drugiej składni, jak pokazano poniżej.

INSERT INTO CUSTOMERS 
VALUES (7, 'Muffy', 24, 'Indore', 10000.00 );

Wszystkie powyższe stwierdzenia dałyby następujące rekordy w tabeli KLIENCI, jak pokazano poniżej.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Wypełnij jedną tabelę za pomocą innej tabeli

Możesz wypełnić dane w tabeli za pomocą instrukcji select umieszczonej w innej tabeli; pod warunkiem, że druga tabela zawiera zestaw pól, które są wymagane do wypełnienia pierwszej tabeli.

Oto składnia -

INSERT INTO first_table_name [(column1, column2, ... columnN)] 
   SELECT column1, column2, ...columnN 
   FROM second_table_name
   [WHERE condition];

SQL - zapytanie SELECT

SQL SELECTinstrukcja służy do pobierania danych z tabeli bazy danych, która zwraca te dane w postaci tabeli wynikowej. Te tabele wynikowe nazywane są zestawami wyników.

Składnia

Podstawowa składnia instrukcji SELECT jest następująca -

SELECT column1, column2, columnN FROM table_name;

Tutaj kolumna1, kolumna2 ... to pola tabeli, których wartości chcesz pobrać. Jeśli chcesz pobrać wszystkie pola dostępne w polu, możesz użyć następującej składni.

SELECT * FROM table_name;

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniższy kod jest przykładem, który pobrałby pola ID, Imię i Wynagrodzenie klientów dostępne w tabeli CUSTOMERS.

SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS;

Dałoby to następujący wynik -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  1 | Ramesh   |  2000.00 |
|  2 | Khilan   |  1500.00 |
|  3 | kaushik  |  2000.00 |
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

Jeśli chcesz pobrać wszystkie pola tabeli CUSTOMERS, użyj następującego zapytania.

SQL> SELECT * FROM CUSTOMERS;

Dałoby to wynik, jak pokazano poniżej.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

SQL - WHERE Klauzula

SQL WHEREKlauzula służy do określenia warunku podczas pobierania danych z pojedynczej tabeli lub poprzez połączenie z wieloma tabelami. Jeśli podany warunek jest spełniony, to tylko on zwraca określoną wartość z tabeli. Do filtrowania rekordów i pobierania tylko niezbędnych rekordów należy używać klauzuli WHERE.

Klauzula WHERE jest używana nie tylko w instrukcji SELECT, ale jest również używana w instrukcjach UPDATE, DELETE itp., Które będziemy badać w kolejnych rozdziałach.

Składnia

Podstawowa składnia instrukcji SELECT z klauzulą ​​WHERE jest przedstawiona poniżej.

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition]

Możesz określić warunek za pomocą porównania lub operatorów logicznych, takich jak>, <, =,LIKE, NOTitd. Poniższe przykłady wyjaśniają tę koncepcję.

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniższy kod jest przykładem, który pobierałby pola ID, Imię i wynagrodzenie z tabeli KLIENCI, gdzie pensja jest większa niż 2000 -

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000;

Dałoby to następujący wynik -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

Poniższe zapytanie jest przykładem, które pobrałoby pola ID, Nazwisko i Wynagrodzenie z tabeli CUSTOMERS dla klienta o nazwisku Hardik.

W tym miejscu należy zauważyć, że wszystkie ciągi znaków należy podać w apostrofach („”). Natomiast wartości liczbowe należy podawać bez cudzysłowu, jak w powyższym przykładzie.

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE NAME = 'Hardik';

Dałoby to następujący wynik -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  5 | Hardik   |  8500.00 |
+----+----------+----------+

Operatory koniunkcyjne SQL - AND i OR

SQL AND & ORoperatory służą do łączenia wielu warunków w celu zawężenia danych w instrukcji SQL. Te dwa operatory nazywane są operatorami koniunkcyjnymi.

Operatory te umożliwiają dokonywanie wielu porównań z różnymi operatorami w tej samej instrukcji SQL.

Operator AND

Plik AND Operator zezwala na istnienie wielu warunków w klauzuli WHERE instrukcji SQL.

Składnia

Podstawowa składnia operatora AND z klauzulą ​​WHERE jest następująca -

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

Możesz połączyć liczbę N warunków za pomocą operatora AND. Aby instrukcja SQL mogła wykonać akcję, niezależnie od tego, czy jest to transakcja, czy zapytanie, wszystkie warunki oddzielone znakiem AND muszą mieć wartość TRUE.

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniżej znajduje się przykład, który mógłby pobrać pola ID, Imię i wynagrodzenie z tabeli KLIENCI, gdzie pensja jest większa niż 2000, a wiek jest mniejszy niż 25 lat -

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000 AND age < 25;

Dałoby to następujący wynik -

+----+-------+----------+
| ID | NAME  | SALARY   |
+----+-------+----------+
|  6 | Komal |  4500.00 |
|  7 | Muffy | 10000.00 |
+----+-------+----------+

Operator OR

Operator OR służy do łączenia wielu warunków w klauzuli WHERE instrukcji SQL.

Składnia

Podstawowa składnia operatora OR z klauzulą ​​WHERE jest następująca -

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

Możesz połączyć liczbę N warunków za pomocą operatora OR. Aby instrukcja SQL mogła wykonać akcję, niezależnie od tego, czy będzie to transakcja, czy zapytanie, jedyny JEDEN z warunków oddzielonych znakiem LUB musi mieć wartość PRAWDA.

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniższy blok kodu zawiera zapytanie, które pobrałoby pola ID, Nazwisko i Wynagrodzenie z tabeli CUSTOMERS, gdzie pensja jest większa niż 2000 LUB wiek jest mniejszy niż 25 lat.

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000 OR age < 25;

Dałoby to następujący wynik -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  3 | kaushik  |  2000.00 |
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

Zapytanie SQL - UPDATE

SQL UPDATEZapytanie służy do modyfikowania istniejących rekordów w tabeli. Możesz użyć klauzuli WHERE z zapytaniem UPDATE, aby zaktualizować wybrane wiersze, w przeciwnym razie wpłynie to na wszystkie wiersze.

Składnia

Podstawowa składnia zapytania UPDATE z klauzulą ​​WHERE jest następująca -

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

Możesz łączyć liczbę N warunków za pomocą operatorów AND lub OR.

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Następujące zapytanie zaktualizuje ADRES klienta, którego numer identyfikacyjny to 6 w tabeli.

SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune'
WHERE ID = 6;

Teraz tabela CUSTOMERS będzie miała następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | Pune      |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Jeśli chcesz zmodyfikować wszystkie wartości kolumn ADDRESS i SALARY w tabeli CUSTOMERS, nie musisz używać klauzuli WHERE, ponieważ wystarczy zapytanie UPDATE, jak pokazano w poniższym bloku kodu.

SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune', SALARY = 1000.00;

Teraz tabela CUSTOMERS będzie miała następujące rekordy -

+----+----------+-----+---------+---------+
| ID | NAME     | AGE | ADDRESS | SALARY  |
+----+----------+-----+---------+---------+
|  1 | Ramesh   |  32 | Pune    | 1000.00 |
|  2 | Khilan   |  25 | Pune    | 1000.00 |
|  3 | kaushik  |  23 | Pune    | 1000.00 |
|  4 | Chaitali |  25 | Pune    | 1000.00 |
|  5 | Hardik   |  27 | Pune    | 1000.00 |
|  6 | Komal    |  22 | Pune    | 1000.00 |
|  7 | Muffy    |  24 | Pune    | 1000.00 |
+----+----------+-----+---------+---------+

SQL - USUŃ zapytanie

Zapytanie SQL DELETE służy do usuwania istniejących rekordów z tabeli.

Możesz użyć klauzuli WHERE z zapytaniem DELETE, aby usunąć wybrane wiersze, w przeciwnym razie wszystkie rekordy zostaną usunięte.

Składnia

Podstawowa składnia zapytania DELETE z klauzulą ​​WHERE jest następująca -

DELETE FROM table_name
WHERE [condition];

Możesz łączyć liczbę N warunków za pomocą operatorów AND lub OR.

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniższy kod zawiera zapytanie, które spowoduje USUNIĘCIE klienta o identyfikatorze 6.

SQL> DELETE FROM CUSTOMERS
WHERE ID = 6;

Teraz tabela CUSTOMERS miałaby następujące rekordy.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Jeśli chcesz usunąć wszystkie rekordy z tabeli CUSTOMERS, nie musisz używać klauzuli WHERE, a zapytanie DELETE wyglądałoby następująco -

SQL> DELETE FROM CUSTOMERS;

Teraz tabela CUSTOMERS nie miałaby żadnego rekordu.

Klauzula SQL - LIKE

SQL LIKEklauzula służy do porównywania wartości z podobnymi wartościami za pomocą operatorów symboli wieloznacznych. W połączeniu z operatorem LIKE są używane dwa symbole wieloznaczne.

• Znak procentu (%)
• Podkreślenie (_)

Znak procentu oznacza zero, jeden lub wiele znaków. Podkreślenie reprezentuje pojedynczą liczbę lub znak. Symbole te mogą być używane w kombinacjach.

Składnia

Podstawowa składnia% i _ jest następująca -

SELECT FROM table_name
WHERE column LIKE 'XXXX%'

or 

SELECT FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX_'

Możesz łączyć liczbę N warunków za pomocą operatorów AND lub OR. Tutaj XXXX może być dowolną wartością liczbową lub ciągiem znaków.

Przykład

Poniższa tabela zawiera kilka przykładów pokazujących część WHERE mającą inną klauzulę LIKE z operatorami „%” i „_” -

Sr.No.	Oświadczenie i opis
1	WHERE SALARY LIKE '200%' Znajduje wartości zaczynające się od 200.
2	WHERE SALARY LIKE '%200%' Znajduje wartości, które mają 200 na dowolnej pozycji.
3	WHERE SALARY LIKE '_00%' Znajduje wszystkie wartości, które mają 00 na drugiej i trzeciej pozycji.
4	WHERE SALARY LIKE '2_%_%' Znajduje wszystkie wartości, które zaczynają się od 2 i mają co najmniej 3 znaki.
5	WHERE SALARY LIKE '%2' Znajduje wszystkie wartości kończące się na 2.
6	WHERE SALARY LIKE '_2%3' Znajduje wszystkie wartości, które mają 2 na drugiej pozycji i kończą się 3.
7	WHERE SALARY LIKE '2___3' Znajduje wszystkie wartości w liczbie pięciocyfrowej, która zaczyna się od 2 i kończy na 3.

Weźmy prawdziwy przykład, rozważmy tabelę CUSTOMERS zawierającą rekordy pokazane poniżej.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniżej znajduje się przykład, w którym zostaną wyświetlone wszystkie rekordy z tabeli CUSTOMERS, w której PŁATNOŚĆ zaczyna się od 200.

SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

Dałoby to następujący wynik -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
+----+----------+-----+-----------+----------+

Klauzula SQL - TOP, LIMIT lub ROWNUM

SQL TOP Klauzula służy do pobrania z tabeli liczby TOP N lub rekordów X procent.

Note- Żadne bazy danych nie obsługują klauzuli TOP. Na przykład MySQL obsługuje rozszerzenieLIMIT klauzula do pobrania ograniczonej liczby rekordów, podczas gdy Oracle używa ROWNUM polecenie pobrania ograniczonej liczby rekordów.

Składnia

Podstawowa składnia klauzuli TOP z instrukcją SELECT byłaby następująca.

SELECT TOP number|percent column_name(s)
FROM table_name
WHERE [condition]

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniższe zapytanie jest przykładem na serwerze SQL, który pobrałby 3 pierwsze rekordy z tabeli CUSTOMERS.

SQL> SELECT TOP 3 * FROM CUSTOMERS;

Dałoby to następujący wynik -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

Jeśli używasz serwera MySQL, oto równoważny przykład -

SQL> SELECT * FROM CUSTOMERS
LIMIT 3;

Dałoby to następujący wynik -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

Jeśli używasz serwera Oracle, poniższy blok kodu zawiera równoważny przykład.

SQL> SELECT * FROM CUSTOMERS
WHERE ROWNUM <= 3;

Dałoby to następujący wynik -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

SQL - klauzula ORDER BY

SQL ORDER BYKlauzula służy do sortowania danych w kolejności rosnącej lub malejącej na podstawie jednej lub więcej kolumn. Niektóre bazy danych domyślnie sortują wyniki zapytania w kolejności rosnącej.

Składnia

Podstawowa składnia klauzuli ORDER BY jest następująca -

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

W klauzuli ORDER BY można użyć więcej niż jednej kolumny. Upewnij się, że kolumna, której używasz do sortowania, powinna znajdować się na liście kolumn.

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniższy blok kodu zawiera przykład, który posortowałby wynik w kolejności rosnącej według NAZWY i PŁATNOŚCI -

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME, SALARY;

Dałoby to następujący wynik -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Poniższy blok kodu zawiera przykład, który posortowałby wynik w kolejności malejącej według nazwy.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME DESC;

Dałoby to następujący wynik -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+----+----------+-----+-----------+----------+

SQL - Grupuj według

SQL GROUP BYKlauzula jest używana we współpracy z instrukcją SELECT w celu uporządkowania identycznych danych w grupy. Ta klauzula GROUP BY następuje po klauzuli WHERE w instrukcji SELECT i poprzedza klauzulę ORDER BY.

Składnia

Podstawowa składnia klauzuli GROUP BY została przedstawiona w poniższym bloku kodu. Klauzula GROUP BY musi być zgodna z warunkami w klauzuli WHERE i musi poprzedzać klauzulę ORDER BY, jeśli jest używana.

SELECT column1, column2
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2

Przykład

Rozważmy, że tabela CUSTOMERS zawiera następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Jeśli chcesz poznać całkowitą kwotę wynagrodzenia dla każdego klienta, zapytanie GROUP BY byłoby następujące.

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
   GROUP BY NAME;

Dałoby to następujący wynik -

+----------+-------------+
| NAME     | SUM(SALARY) |
+----------+-------------+
| Chaitali |     6500.00 |
| Hardik   |     8500.00 |
| kaushik  |     2000.00 |
| Khilan   |     1500.00 |
| Komal    |     4500.00 |
| Muffy    |    10000.00 |
| Ramesh   |     2000.00 |
+----------+-------------+

Przyjrzyjmy się teraz tabeli, w której tabela CUSTOMERS zawiera następujące rekordy ze zduplikowanymi nazwami -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Ramesh   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | kaushik  |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Teraz znowu, jeśli chcesz poznać całkowitą kwotę wynagrodzenia dla każdego klienta, zapytanie GROUP BY byłoby następujące -

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
   GROUP BY NAME;

Dałoby to następujący wynik -

+---------+-------------+
| NAME    | SUM(SALARY) |
+---------+-------------+
| Hardik  |     8500.00 |
| kaushik |     8500.00 |
| Komal   |     4500.00 |
| Muffy   |    10000.00 |
| Ramesh  |     3500.00 |
+---------+-------------+

SQL - odrębne słowo kluczowe

SQL DISTINCT słowo kluczowe jest używane w połączeniu z instrukcją SELECT, aby wyeliminować wszystkie zduplikowane rekordy i pobrać tylko unikatowe rekordy.

Może wystąpić sytuacja, w której masz wiele zduplikowanych rekordów w tabeli. Podczas pobierania takich rekordów bardziej sensowne jest pobieranie tylko tych unikalnych rekordów, zamiast pobierania zduplikowanych rekordów.

Składnia

Podstawowa składnia słowa kluczowego DISTINCT w celu wyeliminowania zduplikowanych rekordów jest następująca:

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Najpierw zobaczmy, jak poniższe zapytanie SELECT zwraca zduplikowane rekordy wynagrodzenia.

SQL> SELECT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Dałoby to następujący wynik, w którym pensja (2000) jest dwukrotnie wyższa, co jest duplikatem rekordu z oryginalnej tabeli.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

Teraz użyjmy słowa kluczowego DISTINCT z powyższym zapytaniem SELECT, a następnie zobaczmy wynik.

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Dałoby to następujący wynik, gdy nie mamy żadnego zduplikowanego wpisu.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

SQL - SORTOWANIE wyników

SQL ORDER BYKlauzula służy do sortowania danych w kolejności rosnącej lub malejącej na podstawie jednej lub więcej kolumn. Niektóre bazy danych domyślnie sortują wyniki zapytania w kolejności rosnącej.

Składnia

Podstawowa składnia klauzuli ORDER BY, która byłaby używana do sortowania wyniku w porządku rosnącym lub malejącym, jest następująca:

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

W klauzuli ORDER BY można użyć więcej niż jednej kolumny. Upewnij się, że niezależnie od kolumny, której używasz do sortowania, ta kolumna powinna znajdować się na liście kolumn.

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniżej znajduje się przykład, który posortowałby wynik w kolejności rosnącej według NAZWISKA i WYNAGRODZENIA.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME, SALARY;

Dałoby to następujący wynik -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Poniższy blok kodu zawiera przykład, który posortowałby wynik w kolejności malejącej według nazwy.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME DESC;

Dałoby to następujący wynik -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+----+----------+-----+-----------+----------+

Aby pobrać wiersze z ich własną preferowaną kolejnością, użyte zapytanie SELECT wyglądałoby następująco:

SQL> SELECT * FROM CUSTOMERS
   ORDER BY (CASE ADDRESS
   WHEN 'DELHI' 	 THEN 1
   WHEN 'BHOPAL' 	 THEN 2
   WHEN 'KOTA' 	 THEN 3
   WHEN 'AHMEDABAD' THEN 4
   WHEN 'MP' 	THEN 5
   ELSE 100 END) ASC, ADDRESS DESC;

Dałoby to następujący wynik -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

To posortuje klientów według ADRESU w Twoim ownoOrderpierwszeństwo w pierwszej kolejności iw naturalnej kolejności dla pozostałych adresów. Pozostałe adresy zostaną posortowane w odwrotnej kolejności alfabetycznej.

SQL - ograniczenia

Ograniczenia to reguły wymuszane w kolumnach danych tabeli. Służą one do ograniczenia typu danych, które mogą zostać umieszczone w tabeli. Zapewnia to dokładność i wiarygodność danych w bazie danych.

Ograniczenia mogą znajdować się na poziomie kolumny lub tabeli. Ograniczenia na poziomie kolumny są stosowane tylko do jednej kolumny, podczas gdy ograniczenia na poziomie tabeli są stosowane do całej tabeli.

Poniżej przedstawiono niektóre z najczęściej używanych ograniczeń dostępnych w języku SQL. Te ograniczenia zostały już omówione w rozdziale SQL - Koncepcje RDBMS , ale warto je w tym miejscu zmienić.

• Ograniczenie NOT NULL - zapewnia, że ​​kolumna nie może mieć wartości NULL.

• DEFAULT Constraint - dostarcza domyślną wartość dla kolumny, gdy żadna nie jest określona.

• UNIQUE Constraint - zapewnia, że ​​wszystkie wartości w kolumnie są różne.

• Klucz PRIMARY - jednoznacznie identyfikuje każdy wiersz / rekord w tabeli bazy danych.

• Klucz OBCY - jednoznacznie identyfikuje wiersz / rekord w dowolnej z danej tabeli bazy danych.

• Ograniczenie CHECK - ograniczenie CHECK zapewnia, że ​​wszystkie wartości w kolumnie spełniają określone warunki.

• INDEKS - Służy do bardzo szybkiego tworzenia i pobierania danych z bazy danych.

Ograniczenia można określić, gdy tabela jest tworzona za pomocą instrukcji CREATE TABLE lub można użyć instrukcji ALTER TABLE, aby utworzyć ograniczenia nawet po utworzeniu tabeli.

Porzucanie ograniczeń

Każde zdefiniowane ograniczenie można usunąć za pomocą polecenia ALTER TABLE z opcją DROP CONSTRAINT.

Na przykład, aby usunąć ograniczenie klucza podstawowego w tabeli EMPLOYEES, możesz użyć następującego polecenia.

ALTER TABLE EMPLOYEES DROP CONSTRAINT EMPLOYEES_PK;

Niektóre implementacje mogą udostępniać skróty do usuwania pewnych ograniczeń. Na przykład, aby usunąć ograniczenie klucza podstawowego dla tabeli w Oracle, możesz użyć następującego polecenia.

ALTER TABLE EMPLOYEES DROP PRIMARY KEY;

Niektóre implementacje umożliwiają wyłączenie ograniczeń. Zamiast trwale usuwać ograniczenie z bazy danych, możesz tymczasowo wyłączyć ograniczenie, a następnie włączyć je później.

Ograniczenia integralności

Ograniczenia integralności służą do zapewnienia dokładności i spójności danych w relacyjnej bazie danych. Integralność danych jest obsługiwana w relacyjnej bazie danych poprzez koncepcję integralności referencyjnej.

Istnieje wiele rodzajów ograniczeń integralności, które odgrywają rolę w programie Referential Integrity (RI). Te ograniczenia obejmują klucz podstawowy, klucz obcy, ograniczenia unikalne i inne ograniczenia, o których mowa powyżej.

SQL - używanie połączeń

SQL JoinsKlauzula służy do łączenia rekordów z dwóch lub więcej tabel w bazie danych. JOIN to sposób łączenia pól z dwóch tabel przy użyciu wspólnych wartości.

Rozważ następujące dwie tabele -

Table 1 - STÓŁ KLIENCI

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - Tabela ZAMÓWIENIA

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Teraz połączmy te dwie tabele w naszej instrukcji SELECT, jak pokazano poniżej.

SQL> SELECT ID, NAME, AGE, AMOUNT
   FROM CUSTOMERS, ORDERS
   WHERE  CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Dałoby to następujący wynik.

+----+----------+-----+--------+
| ID | NAME     | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |   3000 |
|  3 | kaushik  |  23 |   1500 |
|  2 | Khilan   |  25 |   1560 |
|  4 | Chaitali |  25 |   2060 |
+----+----------+-----+--------+

Tutaj można zauważyć, że łączenie jest wykonywane w klauzuli WHERE. Do łączenia tabel można użyć kilku operatorów, takich jak =, <,>, <>, <=,> =,! =, BETWEEN, LIKE i NOT; wszystkie mogą być używane do dołączania do stołów. Jednak najpowszechniejszym operatorem jest symbol równości.

W SQL są dostępne różne typy sprzężeń -

• INNER JOIN - zwraca wiersze, gdy występuje dopasowanie w obu tabelach.

• LEFT JOIN - zwraca wszystkie wiersze z lewej tabeli, nawet jeśli w prawej tabeli nie ma dopasowań.

• RIGHT JOIN - zwraca wszystkie wiersze z prawej tabeli, nawet jeśli nie ma dopasowań w lewej tabeli.

• FULL JOIN - zwraca wiersze w przypadku dopasowania w jednej z tabel.

• SELF JOIN - służy do łączenia tabeli ze sobą, tak jakby była to dwie tabele, tymczasowo zmieniając nazwę przynajmniej jednej tabeli w instrukcji SQL.

• CARTESIAN JOIN - zwraca iloczyn kartezjański zbiorów rekordów z dwóch lub więcej połączonych tabel.

Omówmy teraz szczegółowo każde z tych połączeń.

SQL - KLAUZULA UNII

Klauzula / operator SQL UNION służy do łączenia wyników dwóch lub więcej instrukcji SELECT bez zwracania zduplikowanych wierszy.

Aby użyć tej klauzuli UNION, każda instrukcja SELECT musi mieć

• Wybrano taką samą liczbę kolumn
• Taka sama liczba wyrażeń kolumnowych
• Ten sam typ danych i
• Miej je w tej samej kolejności

Ale nie muszą być tej samej długości.

Składnia

Podstawowa składnia UNION klauzula jest następująca -

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Tutaj podanym warunkiem może być dowolne wyrażenie oparte na twoim wymaganiu.

Przykład

Rozważ dwie poniższe tabele.

Table 1 - Tabela KLIENTÓW jest następująca.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - Tabela ZAMÓWIEŃ jest następująca.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Teraz połączmy te dwie tabele w naszej instrukcji SELECT w następujący sposób -

SQL> SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   LEFT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION
   SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   RIGHT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Dałoby to następujący wynik -

+------+----------+--------+---------------------+
| ID   | NAME     | AMOUNT | DATE                |
+------+----------+--------+---------------------+
|    1 | Ramesh   |   NULL | NULL                |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
|    5 | Hardik   |   NULL | NULL                |
|    6 | Komal    |   NULL | NULL                |
|    7 | Muffy    |   NULL | NULL                |
+------+----------+--------+---------------------+

Klauzula UNION ALL

Operator UNION ALL służy do łączenia wyników dwóch instrukcji SELECT, w tym zduplikowanych wierszy.

Te same zasady, które mają zastosowanie do klauzuli UNION, będą miały zastosowanie do operatora UNION ALL.

Składnia

Podstawowa składnia UNION ALL następująco.

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION ALL

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Tutaj podanym warunkiem może być dowolne wyrażenie oparte na twoim wymaganiu.

Przykład

Rozważ dwie poniższe tabele,

Table 1 - Tabela KLIENTÓW jest następująca.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - Tabela ZAMÓWIENIA jest następująca.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Teraz połączmy te dwie tabele w naszej instrukcji SELECT w następujący sposób -

SQL> SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   LEFT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION ALL
   SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   RIGHT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Dałoby to następujący wynik -

+------+----------+--------+---------------------+
| ID   | NAME     | AMOUNT | DATE                |
+------+----------+--------+---------------------+
|    1 | Ramesh   |   NULL | NULL                |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
|    5 | Hardik   |   NULL | NULL                |
|    6 | Komal    |   NULL | NULL                |
|    7 | Muffy    |   NULL | NULL                |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

Istnieją dwie inne klauzule (tj. Operatory), które są podobne do klauzuli UNION.

• Klauzula SQL INTERSECT - służy do łączenia dwóch instrukcji SELECT, ale zwraca tylko wiersze z pierwszej instrukcji SELECT, które są identyczne z wierszem w drugiej instrukcji SELECT.

• Klauzula SQL EXCEPT - łączy dwie instrukcje SELECT i zwraca wiersze z pierwszej instrukcji SELECT, które nie są zwracane przez drugą instrukcję SELECT.

SQL - wartości NULL

SQL NULLto termin używany do reprezentowania brakującej wartości. Wartość NULL w tabeli to wartość w polu, które wydaje się puste.

Pole z wartością NULL to pole bez wartości. Bardzo ważne jest, aby zrozumieć, że wartość NULL różni się od wartości zerowej lub pola zawierającego spacje.

Składnia

Podstawowa składnia NULL podczas tworzenia tabeli.

SQL> CREATE TABLE CUSTOMERS(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25) ,
   SALARY   DECIMAL (18, 2),       
   PRIMARY KEY (ID)
);

Tutaj, NOT NULLoznacza, że ​​kolumna powinna zawsze akceptować jawną wartość danego typu danych. Istnieją dwie kolumny, w których nie użyliśmy NOT NULL, co oznacza, że ​​te kolumny mogą mieć wartość NULL.

Pole z wartością NULL to takie, które zostało puste podczas tworzenia rekordu.

Przykład

Wartość NULL może powodować problemy podczas wybierania danych. Jednak ponieważ porównując nieznaną wartość z jakąkolwiek inną wartością, wynik jest zawsze nieznany i nie jest uwzględniany w wynikach. Musisz użyćIS NULL lub IS NOT NULL operatory do sprawdzenia wartości NULL.

Rozważ poniższą tabelę CUSTOMERS zawierającą rekordy pokazane poniżej.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |          |
|  7 | Muffy    |  24 | Indore    |          |
+----+----------+-----+-----------+----------+

Teraz, poniżej jest użycie IS NOT NULLoperator.

SQL> SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM CUSTOMERS
   WHERE SALARY IS NOT NULL;

Dałoby to następujący wynik -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
+----+----------+-----+-----------+----------+

Teraz, poniżej jest użycie IS NULL operator.

SQL> SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM CUSTOMERS
   WHERE SALARY IS NULL;

Dałoby to następujący wynik -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  6 | Komal    |  22 | MP        |          |
|  7 | Muffy    |  24 | Indore    |          |
+----+----------+-----+-----------+----------+

SQL - składnia aliasów

Możesz tymczasowo zmienić nazwę tabeli lub kolumny, nadając inną nazwę znaną jako Alias. Użycie aliasów tabel służy do zmiany nazwy tabeli w określonej instrukcji SQL. Zmiana nazwy jest zmianą tymczasową, a rzeczywista nazwa tabeli nie zmienia się w bazie danych. Aliasy kolumn służą do zmiany nazw kolumn tabeli na potrzeby konkretnego zapytania SQL.

Składnia

Podstawowa składnia table alias jest następujący.

SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];

Podstawowa składnia column alias jest następujący.

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

Przykład

Rozważ dwie poniższe tabele.

Table 1 - Tabela KLIENTÓW jest następująca.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - Tabela ZAMÓWIEŃ jest następująca.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Teraz poniższy blok kodu pokazuje użycie table alias.

SQL> SELECT C.ID, C.NAME, C.AGE, O.AMOUNT 
   FROM CUSTOMERS AS C, ORDERS AS O
   WHERE  C.ID = O.CUSTOMER_ID;

Dałoby to następujący wynik.

+----+----------+-----+--------+
| ID | NAME     | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |   3000 |
|  3 | kaushik  |  23 |   1500 |
|  2 | Khilan   |  25 |   1560 |
|  4 | Chaitali |  25 |   2060 |
+----+----------+-----+--------+

Poniżej przedstawiono użycie column alias.

SQL> SELECT  ID AS CUSTOMER_ID, NAME AS CUSTOMER_NAME
   FROM CUSTOMERS
   WHERE SALARY IS NOT NULL;

Dałoby to następujący wynik.

+-------------+---------------+
| CUSTOMER_ID | CUSTOMER_NAME |
+-------------+---------------+
|           1 | Ramesh        |
|           2 | Khilan        |
|           3 | kaushik       |
|           4 | Chaitali      |
|           5 | Hardik        |
|           6 | Komal         |
|           7 | Muffy         |
+-------------+---------------+

SQL - indeksy

Indeksy są special lookup tablesktóre wyszukiwarka bazy danych może wykorzystać do przyspieszenia wyszukiwania danych. Mówiąc najprościej, indeks jest wskaźnikiem do danych w tabeli. Indeks w bazie danych jest bardzo podobny do indeksu na końcu książki.

Na przykład, jeśli chcesz odwołać się do wszystkich stron w książce, która omawia określony temat, najpierw odwołaj się do indeksu, który zawiera listę wszystkich tematów alfabetycznie, a następnie odsyła się do jednego lub kilku określonych numerów stron.

Indeks pomaga przyspieszyć SELECT zapytania i WHERE klauzule, ale spowalnia wprowadzanie danych, z UPDATE i INSERTsprawozdania. Indeksy można tworzyć lub usuwać bez wpływu na dane.

Tworzenie indeksu obejmuje rozszerzenie CREATE INDEX instrukcja, która pozwala nazwać indeks, określić tabelę i kolumnę lub kolumny do indeksowania oraz wskazać, czy indeks jest w porządku rosnącym czy malejącym.

Indeksy mogą być również unikalne, takie jak UNIQUE ograniczenie polegające na tym, że indeks zapobiega zduplikowaniu wpisów w kolumnie lub kombinacji kolumn, w których znajduje się indeks.

Polecenie CREATE INDEX

Podstawowa składnia CREATE INDEX następująco.

CREATE INDEX index_name ON table_name;

Indeksy jednokolumnowe

Indeks jednokolumnowy jest tworzony na podstawie tylko jednej kolumny tabeli. Podstawowa składnia jest następująca.

CREATE INDEX index_name
ON table_name (column_name);

Unikalne indeksy

Unikalne indeksy służą nie tylko wydajności, ale także integralności danych. Unikalny indeks nie pozwala na wstawienie do tabeli żadnych zduplikowanych wartości. Podstawowa składnia jest następująca.

CREATE UNIQUE INDEX index_name
on table_name (column_name);

Indeksy złożone

Indeks złożony to indeks dwóch lub więcej kolumn tabeli. Jego podstawowa składnia jest następująca.

CREATE INDEX index_name
on table_name (column1, column2);

Niezależnie od tego, czy chcesz utworzyć indeks jednokolumnowy, czy indeks złożony, weź pod uwagę kolumny, których możesz często używać w klauzuli WHERE zapytania jako warunki filtru.

W przypadku użycia tylko jednej kolumny należy wybrać indeks jednokolumnowy. Jeśli w klauzuli WHERE są często używane dwie lub więcej kolumn jako filtry, najlepszym wyborem będzie indeks złożony.

Niejawne indeksy

Niejawne indeksy to indeksy, które są automatycznie tworzone przez serwer bazy danych podczas tworzenia obiektu. Indeksy są tworzone automatycznie dla ograniczeń klucza podstawowego i ograniczeń unikalności.

Polecenie DROP INDEX

Indeks można usunąć za pomocą SQL DROPKomenda. Należy zachować ostrożność podczas upuszczania indeksu, ponieważ wydajność może spowolnić lub poprawić.

Podstawowa składnia jest następująca -

DROP INDEX index_name;

Możesz zajrzeć do rozdziału Ograniczenie INDEKSU, aby zobaczyć rzeczywiste przykłady dotyczące indeksów.

Kiedy należy unikać indeksów?

Chociaż indeksy mają na celu zwiększenie wydajności bazy danych, są sytuacje, w których należy ich unikać.

Poniższe wytyczne wskazują, kiedy należy ponownie rozważyć użycie indeksu.

• Indeksów nie należy używać w przypadku małych tabel.

• Tabele, które mają częste, duże aktualizacje wsadowe lub operacje wstawiania.

• Indeksów nie należy używać w kolumnach, które zawierają dużą liczbę wartości NULL.

• Kolumny, które są często modyfikowane, nie powinny być indeksowane.

Polecenie SQL - ALTER TABLE

SQL ALTER TABLEPolecenie służy do dodawania, usuwania lub modyfikowania kolumn w istniejącej tabeli. Należy również użyć polecenia ALTER TABLE, aby dodać i usunąć różne ograniczenia w istniejącej tabeli.

Składnia

Podstawowa składnia polecenia ALTER TABLE w celu dodania pliku New Column w istniejącej tabeli wygląda następująco.

ALTER TABLE table_name ADD column_name datatype;

Podstawowa składnia polecenia ALTER TABLE do DROP COLUMN w istniejącej tabeli wygląda następująco.

ALTER TABLE table_name DROP COLUMN column_name;

Podstawowa składnia polecenia ALTER TABLE służąca do zmiany pliku DATA TYPE kolumny w tabeli jest następująca.

ALTER TABLE table_name MODIFY COLUMN column_name datatype;

Podstawowa składnia polecenia ALTER TABLE w celu dodania pliku NOT NULL ograniczenie do kolumny w tabeli jest następujące.

ALTER TABLE table_name MODIFY column_name datatype NOT NULL;

Podstawowa składnia ALTER TABLE to ADD UNIQUE CONSTRAINT do tabeli wygląda następująco.

ALTER TABLE table_name 
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);

Podstawowa składnia polecenia ALTER TABLE do ADD CHECK CONSTRAINT do tabeli wygląda następująco.

ALTER TABLE table_name 
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);

Podstawowa składnia polecenia ALTER TABLE do ADD PRIMARY KEY ograniczenie do tabeli jest następujące.

ALTER TABLE table_name 
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);

Podstawowa składnia polecenia ALTER TABLE do DROP CONSTRAINT z tabeli jest następująca.

ALTER TABLE table_name 
DROP CONSTRAINT MyUniqueConstraint;

Jeśli używasz MySQL, kod wygląda następująco -

ALTER TABLE table_name 
DROP INDEX MyUniqueConstraint;

Podstawowa składnia polecenia ALTER TABLE do DROP PRIMARY KEY ograniczenie z tabeli jest następujące.

ALTER TABLE table_name 
DROP CONSTRAINT MyPrimaryKey;

Jeśli używasz MySQL, kod wygląda następująco -

ALTER TABLE table_name 
DROP PRIMARY KEY;

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniżej znajduje się przykład dodawania pliku New Column do istniejącej tabeli -

ALTER TABLE CUSTOMERS ADD SEX char(1);

Teraz tabela CUSTOMERS została zmieniona, a następująca instrukcja byłaby wyprowadzana z instrukcji SELECT.

+----+---------+-----+-----------+----------+------+
| ID | NAME    | AGE | ADDRESS   | SALARY   | SEX  |
+----+---------+-----+-----------+----------+------+
|  1 | Ramesh  |  32 | Ahmedabad |  2000.00 | NULL |
|  2 | Ramesh  |  25 | Delhi     |  1500.00 | NULL |
|  3 | kaushik |  23 | Kota      |  2000.00 | NULL |
|  4 | kaushik |  25 | Mumbai    |  6500.00 | NULL |
|  5 | Hardik  |  27 | Bhopal    |  8500.00 | NULL |
|  6 | Komal   |  22 | MP        |  4500.00 | NULL |
|  7 | Muffy   |  24 | Indore    | 10000.00 | NULL |
+----+---------+-----+-----------+----------+------+

Poniżej znajduje się przykład DROP kolumny płci z istniejącej tabeli.

ALTER TABLE CUSTOMERS DROP SEX;

Teraz tabela CUSTOMERS została zmieniona, a następujące dane byłyby wynikiem instrukcji SELECT.

+----+---------+-----+-----------+----------+
| ID | NAME    | AGE | ADDRESS   | SALARY   |
+----+---------+-----+-----------+----------+
|  1 | Ramesh  |  32 | Ahmedabad |  2000.00 |
|  2 | Ramesh  |  25 | Delhi     |  1500.00 |
|  3 | kaushik |  23 | Kota      |  2000.00 |
|  4 | kaushik |  25 | Mumbai    |  6500.00 |
|  5 | Hardik  |  27 | Bhopal    |  8500.00 |
|  6 | Komal   |  22 | MP        |  4500.00 |
|  7 | Muffy   |  24 | Indore    | 10000.00 |
+----+---------+-----+-----------+----------+

Polecenie SQL - TRUNCATE TABLE

SQL TRUNCATE TABLE Polecenie służy do usuwania pełnych danych z istniejącej tabeli.

Możesz również użyć polecenia DROP TABLE, aby usunąć całą tabelę, ale spowoduje to usunięcie całej struktury tabeli z bazy danych i będziesz musiał ponownie utworzyć tę tabelę, jeśli chcesz przechowywać jakieś dane.

Składnia

Podstawowa składnia TRUNCATE TABLE polecenie jest następujące.

TRUNCATE TABLE  table_name;

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniżej znajduje się przykład polecenia Obetnij.

SQL > TRUNCATE TABLE CUSTOMERS;

Teraz tabela CUSTOMERS jest obcinana, a dane wyjściowe instrukcji SELECT będą wyglądać tak, jak pokazano w poniższym bloku kodu -

SQL> SELECT * FROM CUSTOMERS;
Empty set (0.00 sec)

SQL - używanie widoków

Widok to nic innego jak instrukcja SQL przechowywana w bazie danych ze skojarzoną nazwą. Widok jest w rzeczywistości kompozycją tabeli w postaci wstępnie zdefiniowanego zapytania SQL.

Widok może zawierać wszystkie wiersze tabeli lub wybierać wiersze z tabeli. Widok można utworzyć z jednej lub wielu tabel, w zależności od zapisanego zapytania SQL w celu utworzenia widoku.

Widoki, które są rodzajem wirtualnych tabel, umożliwiają użytkownikom wykonywanie następujących czynności -

• Strukturyzuj dane w sposób, który użytkownicy lub klasy użytkowników uznają za naturalny lub intuicyjny.

• Ogranicz dostęp do danych w taki sposób, aby użytkownik mógł zobaczyć i (czasami) zmodyfikować dokładnie to, czego potrzebuje, i nic więcej.

• Podsumuj dane z różnych tabel, które można wykorzystać do generowania raportów.

Tworzenie widoków

Widoki bazy danych są tworzone przy użyciu CREATE VIEWkomunikat. Widoki można tworzyć z pojedynczej tabeli, wielu tabel lub innego widoku.

Aby utworzyć widok, użytkownik musi mieć odpowiednie uprawnienia systemowe zgodnie z określoną implementacją.

Podstawy CREATE VIEW składnia jest następująca -

CREATE VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];

Możesz dołączyć wiele tabel do instrukcji SELECT w podobny sposób, jak używasz ich w zwykłym zapytaniu SQL SELECT.

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniżej znajduje się przykład tworzenia widoku z tabeli CUSTOMERS. Ten widok byłby używany do umieszczania nazwy i wieku klienta z tabeli CUSTOMERS.

SQL > CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM  CUSTOMERS;

Teraz możesz wysyłać zapytania do CUSTOMERS_VIEW w podobny sposób, jak w przypadku rzeczywistej tabeli. Poniżej znajduje się przykład tego samego.

SQL > SELECT * FROM CUSTOMERS_VIEW;

Dałoby to następujący wynik.

+----------+-----+
| name     | age |
+----------+-----+
| Ramesh   |  32 |
| Khilan   |  25 |
| kaushik  |  23 |
| Chaitali |  25 |
| Hardik   |  27 |
| Komal    |  22 |
| Muffy    |  24 |
+----------+-----+

OPCJA Z SPRAWDZENIEM

Opcja WITH CHECK jest opcją instrukcji CREATE VIEW. Celem opcji WITH CHECK OPTION jest zapewnienie, że wszystkie AKTUALIZACJE i WSTAWY spełniają warunek (warunki) w definicji widoku.

Jeśli nie spełniają warunków, polecenie UPDATE lub INSERT zwraca błąd.

Poniższy blok kodu zawiera przykład tworzenia tego samego widoku CUSTOMERS_VIEW z opcją WITH CHECK OPTION.

CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM  CUSTOMERS
WHERE age IS NOT NULL
WITH CHECK OPTION;

W tym przypadku opcja WITH CHECK powinna uniemożliwić wprowadzenie jakichkolwiek wartości NULL w kolumnie AGE widoku, ponieważ widok jest definiowany przez dane, które nie mają wartości NULL w kolumnie AGE.

Aktualizowanie widoku

Widok można zaktualizować pod pewnymi warunkami, które podano poniżej -

• Klauzula SELECT nie może zawierać słowa kluczowego DISTINCT.

• Klauzula SELECT nie może zawierać funkcji podsumowujących.

• Klauzula SELECT nie może zawierać funkcji zestawu.

• Klauzula SELECT nie może zawierać operatorów zestawów.

• Klauzula SELECT nie może zawierać klauzuli ORDER BY.

• Klauzula FROM nie może zawierać wielu tabel.

• Klauzula WHERE nie może zawierać podzapytań.

• Zapytanie nie może zawierać GROUP BY ani HAVING.

• Kolumny obliczeniowe nie mogą być aktualizowane.

• Wszystkie kolumny NOT NULL z tabeli podstawowej muszą być uwzględnione w widoku, aby zapytanie INSERT działało.

Tak więc, jeśli widok spełnia wszystkie powyższe zasady, możesz zaktualizować ten widok. Poniższy blok kodu zawiera przykład aktualizacji wieku Ramesha.

SQL > UPDATE CUSTOMERS_VIEW
   SET AGE = 35
   WHERE name = 'Ramesh';

To ostatecznie zaktualizowałoby tabelę bazową CUSTOMERS i to samo znalazłoby odzwierciedlenie w samym widoku. Teraz spróbuj wykonać zapytanie w tabeli podstawowej, a instrukcja SELECT dałaby następujący wynik.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Wstawianie wierszy do widoku

Do widoku można wstawiać wiersze danych. Te same zasady, które dotyczą polecenia UPDATE, odnoszą się również do polecenia WSTAW.

W tym przypadku nie możemy wstawiać wierszy w CUSTOMERS_VIEW, ponieważ nie uwzględniliśmy wszystkich kolumn NOT NULL w tym widoku, w przeciwnym razie można wstawiać wiersze w widoku w podobny sposób, jak wstawiamy je do tabeli.

Usuwanie wierszy do widoku

Wiersze danych można usunąć z widoku. Te same zasady, które dotyczą poleceń UPDATE i INSERT, dotyczą polecenia DELETE.

Poniżej znajduje się przykład usuwania rekordu mającego WIEK = 22.

SQL > DELETE FROM CUSTOMERS_VIEW
   WHERE age = 22;

To ostatecznie spowodowałoby usunięcie wiersza z tabeli bazowej CUSTOMERS i to samo znalazłoby odzwierciedlenie w samym widoku. Teraz spróbuj wykonać zapytanie w tabeli podstawowej, a instrukcja SELECT dałaby następujący wynik.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Upuszczanie widoków

Oczywiście, jeśli masz widok, potrzebujesz sposobu na usunięcie widoku, jeśli nie jest już potrzebny. Składnia jest bardzo prosta i została podana poniżej -

DROP VIEW view_name;

Poniżej znajduje się przykład usunięcia CUSTOMERS_VIEW z tabeli CUSTOMERS.

DROP VIEW CUSTOMERS_VIEW;

SQL - posiadanie klauzuli

Plik HAVING Clause umożliwia określenie warunków filtrujących wyniki grup, które pojawiają się w wynikach.

Klauzula WHERE umieszcza warunki w wybranych kolumnach, podczas gdy klauzula HAVING nakłada warunki na grupy utworzone przez klauzulę GROUP BY.

Składnia

Poniższy blok kodu przedstawia pozycję klauzuli HAVING w zapytaniu.

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

Klauzula HAVING musi występować po klauzuli GROUP BY w zapytaniu i musi również poprzedzać klauzulę ORDER BY, jeśli jest używana. Poniższy blok kodu ma składnię instrukcji SELECT, w tym klauzulę HAVING -

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

Przykład

Rozważmy tabelę CUSTOMERS zawierającą następujące rekordy.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniżej znajduje się przykład, który wyświetla rekord dla podobnej liczby wiekowej, która byłaby większa lub równa 2.

SQL > SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
GROUP BY age
HAVING COUNT(age) >= 2;

Dałoby to następujący wynik -

+----+--------+-----+---------+---------+
| ID | NAME   | AGE | ADDRESS | SALARY  |
+----+--------+-----+---------+---------+
|  2 | Khilan |  25 | Delhi   | 1500.00 |
+----+--------+-----+---------+---------+

SQL - transakcje

Transakcja to jednostka pracy wykonywana na bazie danych. Transakcje to jednostki lub sekwencje pracy wykonane w logicznej kolejności, czy to ręcznie przez użytkownika, czy automatycznie przez jakiś program bazodanowy.

Transakcja to propagacja jednej lub więcej zmian w bazie danych. Na przykład, jeśli tworzysz rekord lub aktualizujesz rekord lub usuwasz rekord z tabeli, to wykonujesz transakcję na tej tabeli. Kontrolowanie tych transakcji jest ważne, aby zapewnić integralność danych i obsługiwać błędy bazy danych.

W praktyce wiele zapytań SQL połączysz w grupę i wykonasz je wszystkie razem jako część transakcji.

Właściwości transakcji

Transakcje mają następujące cztery standardowe właściwości, zwykle określane akronimem ACID.

• Atomicity- zapewnia pomyślne zakończenie wszystkich operacji w jednostce pracy. W przeciwnym razie transakcja jest przerywana w momencie niepowodzenia, a wszystkie poprzednie operacje są przywracane do poprzedniego stanu.

• Consistency - zapewnia, że ​​baza danych prawidłowo zmienia stany po pomyślnym zatwierdzeniu transakcji.

• Isolation - umożliwia niezależne i przejrzyste transakcje transakcji.

• Durability - zapewnia, że ​​wynik lub skutek zatwierdzonej transakcji będzie trwał w przypadku awarii systemu.

Kontrola transakcji

Następujące polecenia służą do sterowania transakcjami.

• COMMIT - aby zapisać zmiany.

• ROLLBACK - cofnąć zmiany.

• SAVEPOINT - tworzy punkty w ramach grup transakcji, w których można ROLLBACK.

• SET TRANSACTION - Umieszcza nazwę na transakcji.

Polecenia kontroli transakcji

Polecenia sterujące transakcjami są używane tylko z DML Commandstakie jak - tylko INSERT, UPDATE i DELETE. Nie można ich używać podczas tworzenia tabel lub usuwania ich, ponieważ te operacje są automatycznie zatwierdzane w bazie danych.

Polecenie COMMIT

Polecenie COMMIT jest poleceniem transakcyjnym używanym do zapisywania zmian wywołanych przez transakcję w bazie danych.

Polecenie COMMIT jest poleceniem transakcyjnym używanym do zapisywania zmian wywołanych przez transakcję w bazie danych. Polecenie COMMIT zapisuje wszystkie transakcje w bazie danych od ostatniego polecenia COMMIT lub ROLLBACK.

Składnia polecenia COMMIT jest następująca.

COMMIT;

Example

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniżej znajduje się przykład, który usuwa te rekordy z tabeli, które mają wiek = 25, a następnie ZATWIERDZA zmiany w bazie danych.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE = 25;
SQL> COMMIT;

W ten sposób dwa wiersze z tabeli zostałyby usunięte, a instrukcja SELECT dałaby następujący wynik.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Polecenie ROLLBACK

Polecenie ROLLBACK jest poleceniem transakcyjnym używanym do cofania transakcji, które nie zostały jeszcze zapisane w bazie danych. Tego polecenia można używać tylko do cofania transakcji od czasu wydania ostatniego polecenia COMMIT lub ROLLBACK.

Składnia polecenia ROLLBACK jest następująca:

ROLLBACK;

Example

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniżej znajduje się przykład, który spowodowałby usunięcie tych rekordów z tabeli, które mają wiek = 25, a następnie Cofnięcie zmian w bazie danych.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE = 25;
SQL> ROLLBACK;

W związku z tym operacja usuwania nie wpłynie na tabelę, a instrukcja SELECT dałaby następujący wynik.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Polecenie SAVEPOINT

SAVEPOINT to punkt w transakcji, w którym można cofnąć transakcję do określonego punktu bez cofania całej transakcji.

Składnia polecenia SAVEPOINT jest przedstawiona poniżej.

SAVEPOINT SAVEPOINT_NAME;

To polecenie służy tylko do tworzenia SAVEPOINT wśród wszystkich instrukcji transakcyjnych. Polecenie ROLLBACK służy do cofania grupy transakcji.

Składnia przywracania do SAVEPOINT jest pokazana poniżej.

ROLLBACK TO SAVEPOINT_NAME;

Poniżej znajduje się przykład, w którym planujesz usunąć trzy różne rekordy z tabeli CUSTOMERS. Chcesz utworzyć SAVEPOINT przed każdym usunięciem, aby w dowolnym momencie można było ROLLBACK do dowolnego SAVEPOINT, aby przywrócić odpowiednie dane do ich pierwotnego stanu.

Example

Rozważmy tabelę CUSTOMERS zawierającą następujące rekordy.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniższy blok kodu zawiera serię operacji.

SQL> SAVEPOINT SP1;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=1;
1 row deleted.
SQL> SAVEPOINT SP2;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=2;
1 row deleted.
SQL> SAVEPOINT SP3;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=3;
1 row deleted.

Teraz, gdy te trzy usunięcia miały miejsce, załóżmy, że zmieniłeś zdanie i zdecydowałeś się ROLLBACK do SAVEPOINT, który zidentyfikowałeś jako SP2. Ponieważ dodatek SP2 został utworzony po pierwszym usunięciu, ostatnie dwa usunięcia są cofane -

SQL> ROLLBACK TO SP2;
Rollback complete.

Zauważ, że tylko pierwsze usunięcie miało miejsce od czasu przywrócenia dodatku SP2.

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+
6 rows selected.

Polecenie RELEASE SAVEPOINT

Polecenie RELEASE SAVEPOINT służy do usuwania utworzonego SAVEPOINT.

Składnia komendy RELEASE SAVEPOINT jest następująca.

RELEASE SAVEPOINT SAVEPOINT_NAME;

Po zwolnieniu SAVEPOINT nie można już używać komendy ROLLBACK do cofania transakcji wykonanych od ostatniego SAVEPOINT.

Polecenie SET TRANSACTION

Do zainicjowania transakcji bazy danych można użyć polecenia SET TRANSACTION. To polecenie służy do określania charakterystyk dla następującej transakcji. Na przykład można określić transakcję jako tylko do odczytu lub do odczytu i zapisu.

Składnia polecenia SET TRANSACTION jest następująca.

SET TRANSACTION [ READ WRITE | READ ONLY ];

SQL - operatory symboli wieloznacznych

Omówiliśmy już operację SQL LIKE, która służy do porównywania wartości z podobnymi wartościami za pomocą operatorów wieloznacznych.

SQL obsługuje dwa operatory symboli wieloznacznych w połączeniu z operatorem LIKE, które zostały szczegółowo wyjaśnione w poniższej tabeli.

Sr.No.	Symbol wieloznaczny i opis
1	The percent sign (%) Dopasowuje jeden lub więcej znaków. Note - MS Access używa znaku wieloznacznego gwiazdki (*) zamiast znaku wieloznacznego procentu (%).
2	The underscore (_) Dopasowuje jeden znak. Note - MS Access używa znaku zapytania (?) Zamiast podkreślenia (_) w celu dopasowania dowolnego znaku.

Znak procentu oznacza zero, jeden lub wiele znaków. Podkreślenie reprezentuje pojedynczą liczbę lub znak. Symbole te mogą być używane w kombinacjach.

Składnia

Podstawowa składnia operatorów „%” i „_” jest następująca.

SELECT * FROM table_name
WHERE column LIKE 'XXXX%'

or 

SELECT * FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT * FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT * FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT * FROM table_name
WHERE column LIKE '_XXXX_'

Możesz łączyć liczbę N warunków za pomocą operatorów AND lub OR. Tutaj XXXX może być dowolną wartością liczbową lub ciągiem znaków.

Przykład

Poniższa tabela zawiera kilka przykładów pokazujących część WHERE mającą różne klauzule LIKE z operatorami „%” i „_”.

Sr.No.	Oświadczenie i opis
1	WHERE SALARY LIKE '200%' Znajduje wartości zaczynające się od 200.
2	WHERE SALARY LIKE '%200%' Znajduje wartości, które mają 200 na dowolnej pozycji.
3	WHERE SALARY LIKE '_00%' Znajduje wszystkie wartości, które mają 00 na drugiej i trzeciej pozycji.
4	WHERE SALARY LIKE '2_%_%' Znajduje wszystkie wartości, które zaczynają się od 2 i mają co najmniej 3 znaki.
5	WHERE SALARY LIKE '%2' Znajduje wszystkie wartości kończące się na 2.
6	WHERE SALARY LIKE '_2%3' Znajduje wszystkie wartości, które mają 2 na drugiej pozycji i kończą się 3.
7	WHERE SALARY LIKE '2___3' Znajduje wszystkie wartości w liczbie pięciocyfrowej, która zaczyna się od 2 i kończy na 3.

Weźmy prawdziwy przykład, rozważmy tabelę CUSTOMERS zawierającą następujące rekordy.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Poniższy blok kodu jest przykładem, który wyświetli wszystkie rekordy z tabeli CUSTOMERS, w której PŁATNOŚĆ zaczyna się od 200.

SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

Dałoby to następujący wynik.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
+----+----------+-----+-----------+----------+

SQL - funkcje daty

Poniższa tabela zawiera listę wszystkich ważnych funkcji związanych z datą i godziną dostępnych w języku SQL. RDBMS obsługuje różne inne funkcje. Podana lista jest oparta na bazie danych MySQL RDBMS.

Sr.No.	Opis funkcji
1	ADDDATE () Dodaje daty
2	DODAJ CZAS() Dodaje czas
3	CONVERT_TZ () Konwertuje z jednej strefy czasowej do drugiej
4	CURDATE () Zwraca bieżącą datę
5	CURRENT_DATE (), CURRENT_DATE Synonimy dla CURDATE ()
6	CURRENT_TIME (), CURRENT_TIME Synonimy dla CURTIME ()
7	CURRENT_TIMESTAMP (), CURRENT_TIMESTAMP Synonimy dla NOW ()
8	CURTIME () Zwraca aktualny czas
9	DATE_ADD () Dodaje dwie daty
10	FORMAT DATY() Formatuje datę jak określono
11	DATE_SUB () Odejmuje dwie daty
12	DATA() Wyodrębnia część daty z wyrażenia typu data lub godzina
13	DATEDIFF () Odejmuje dwie daty
14	DZIEŃ() Synonim dla DAYOFMONTH ()
15	DAYNAME () Zwraca nazwę dnia tygodnia
16	DZIEŃ MIESIĄCA() Zwraca dzień miesiąca (1-31)
17	DZIEŃ TYGODNIA() Zwraca indeks argumentu dnia tygodnia
18	DAYOFYEAR () Zwraca dzień roku (1-366)
19	WYCIĄG Wydobywa część daty
20	FROM_DAYS () Konwertuje numer dnia na datę
21	FROM_UNIXTIME () Formatuje datę jako znacznik czasu systemu UNIX
22	GODZINA() Wyodrębnia godzinę
23	OSTATNI DZIEŃ Zwraca ostatni dzień miesiąca dla argumentu
24	LOCALTIME (), LOCALTIME Synonim TERAZ ()
25	LOCALTIMESTAMP, LOCALTIMESTAMP () Synonim TERAZ ()
26	MAKEDATE () Tworzy datę na podstawie roku i dnia roku
27	MAKETIME MAKETIME ()
28	MIKROSEKUNDA() Zwraca mikrosekundy z argumentu
29	MINUTA() Zwraca minutę z argumentu
30	MIESIĄC() Zwróć miesiąc od minionej daty
31	NAZWA MIESIĄCA () Zwraca nazwę miesiąca
32	TERAZ() Zwraca bieżącą datę i godzinę
33	PERIOD_ADD () Dodaje okres do roku-miesiąca
34	PERIOD_DIFF () Zwraca liczbę miesięcy między okresami
35	JEDNA CZWARTA() Zwraca kwartał z argumentu daty
36	SEC_TO_TIME () Konwertuje sekundy na format „HH: MM: SS”
37	DRUGA() Zwraca sekundę (0-59)
38	STR_TO_DATE () Konwertuje ciąg na datę
39	SUBDATE () Wywołane z trzema argumentami jest synonimem DATE_SUB ()
40	SUBTIME () Odejmuje czasy
41	SYSDATE () Zwraca czas, w którym funkcja jest wykonywana
42	FORMAT CZASU() Formaty jako czas
43	TIME_TO_SEC () Zwraca argument przekonwertowany na sekundy
44	CZAS() Wyodrębnia część czasu z przekazanego wyrażenia
45	TIMEDIFF () Odejmuje czas
46	ZNAK CZASU() Za pomocą jednego argumentu funkcja zwraca datę lub wyrażenie typu data i godzina. Z dwoma argumentami, suma argumentów
47	TIMESTAMPADD () Dodaje interwał do wyrażenia datetime
48	TIMESTAMPDIFF () Odejmuje interwał z wyrażenia typu data-godzina
49	TO_DAYS () Zwraca argument daty przekonwertowany na dni
50	UNIX_TIMESTAMP () Zwraca znacznik czasu UNIX
51	UTC_DATE () Zwraca bieżącą datę UTC
52	UTC_TIME () Zwraca bieżący czas UTC
53	UTC_TIMESTAMP () Zwraca bieżącą datę i godzinę UTC
54	TYDZIEŃ() Zwraca numer tygodnia
55	DZIEŃ POWSZEDNI() Zwraca indeks dnia tygodnia
56	WEEKOFYEAR () Zwraca tydzień kalendarzowy z daty (1-53)
57	ROK() Zwraca rok
58	YEARWEEK () Zwraca rok i tydzień

ADDDATE (data, INTERVAL jednostka wyrażenia), ADDDATE (wyrażenie, dni)

Po wywołaniu z postacią INTERVAL drugiego argumentu ADDDATE () jest synonimem dla DATE_ADD (). Powiązana funkcja SUBDATE () jest synonimem DATE_SUB (). Aby uzyskać informacje na temat argumentu jednostki INTERVAL, zobacz dyskusję na temat DATE_ADD ().

mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| ADDDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Wywołany z postacią dni drugiego argumentu, MySQL traktuje go jako całkowitą liczbę dni, które mają być dodane do wyrażenia.

mysql> SELECT ADDDATE('1998-01-02', 31);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ADDTIME (wyr1; wyr2)

ADDTIME () dodaje wyrażenie 2 do wyrażenia 1 i zwraca wynik. Wyr1 jest wyrażeniem czasu lub daty i godziny, podczas gdy wyrażenie2 jest wyrażeniem czasu.

mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59.999999','1 1:1:1.000002') |
+---------------------------------------------------------+
| 1998-01-02 01:01:01.000001                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CONVERT_TZ (dt, from_tz, to_tz)

To konwertuje wartość datetime dt ze strefy czasowej podanej przez from_tz na strefę czasową podaną przez to_tz i zwraca wynikową wartość. Ta funkcja zwraca NULL, jeśli argumenty są nieprawidłowe.

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','GMT','MET')           |
+---------------------------------------------------------+
| 2004-01-01 13:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00')     |
+---------------------------------------------------------+
| 2004-01-01 22:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURDATE ()

Zwraca bieżącą datę jako wartość w formacie „RRRR-MM-DD” lub RRRRMMDD, w zależności od tego, czy funkcja jest używana w ciągu, czy w kontekście liczbowym.

mysql> SELECT CURDATE();
+---------------------------------------------------------+
| CURDATE()                                               |
+---------------------------------------------------------+
| 1997-12-15                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURDATE() + 0;
+---------------------------------------------------------+
| CURDATE() + 0                                           |
+---------------------------------------------------------+
| 19971215                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_DATE i CURRENT_DATE ()

CURRENT_DATE i CURRENT_DATE () są synonimami CURDATE ()

CURTIME ()

Zwraca bieżący czas jako wartość w formacie „HH: MM: SS” lub HHMMSS, w zależności od tego, czy funkcja jest używana w ciągu znaków, czy w kontekście liczbowym. Wartość jest wyrażona w aktualnej strefie czasowej.

mysql> SELECT CURTIME();
+---------------------------------------------------------+
| CURTIME()                                               |
+---------------------------------------------------------+
| 23:50:26                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURTIME() + 0;
+---------------------------------------------------------+
| CURTIME() + 0                                           |
+---------------------------------------------------------+
| 235026                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_TIME i CURRENT_TIME ()

CURRENT_TIME i CURRENT_TIME () są synonimami CURTIME ().

CURRENT_TIMESTAMP i CURRENT_TIMESTAMP ()

CURRENT_TIMESTAMP i CURRENT_TIMESTAMP () są synonimami terminu NOW ().

DATE (wyr)

Wyodrębnia część daty z wyrażenia daty lub daty i godziny.

mysql> SELECT DATE('2003-12-31 01:02:03');
+---------------------------------------------------------+
| DATE('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
|  2003-12-31                                             |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATEDIFF (wyr1; wyr2)

DATEDIFF () zwraca wyr1. wyrażenie2 wyrażone jako wartość w dniach od jednej daty do drugiej. Wyrażenie 1 i wyrażenie 2 są wyrażeniami daty lub daty i godziny. W obliczeniach używane są tylko części wartości dotyczące daty.

mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
+---------------------------------------------------------+
| DATEDIFF('1997-12-31 23:59:59','1997-12-30')            |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_ADD (data, jednostka wyrażenia INTERVAL), DATE_SUB (data, jednostka wyrażenia INTERVAL)

Te funkcje wykonują arytmetykę dat. Plikdateto wartość DATETIME lub DATE określająca datę początkową. Plikexprjest wyrażeniem określającym wartość interwału, która ma zostać dodana lub odjęta od daty początkowej. Wyrażenie jest łańcuchem; może zaczynać się od „-” dla przedziałów ujemnych.

ZA unit to słowo kluczowe wskazujące jednostki, w których powinno być interpretowane wyrażenie.

Plik INTERVAL słowo kluczowe i specyfikator jednostki nie uwzględniają wielkości liter.

W poniższej tabeli przedstawiono oczekiwaną postać argumentu wyrażenia dla każdej wartości jednostki.

wartość jednostki	Oczekiwano exprFormat
MIKROSEKUNDA	MIKROSEKUNDY
DRUGA	SEKUNDY
MINUTA	MINUTY
GODZINA	GODZINY
DZIEŃ	DNI
TYDZIEŃ	TYGODNIE
MIESIĄC	MIESIĘCY
JEDNA CZWARTA	MIESZKANIE
ROK	LAT
SECOND_MICROSECOND	„SECONDS.MICROSECONDS”
MINUTE_MICROSECOND	„MINUTY.MIKROSEKUND”
MINUTE_SECOND	„MINUTES: SECONDS”
HOUR_MICROSECOND	„HOURS.MICROSECONDS”
HOUR_SECOND	„HOURS: MINUTES: SECONDS”
HOUR_MINUTE	„HOURS: MINUTES”
DAY_MICROSECOND	„DNI.MIKROSEKUND”
DAY_SECOND	„DNI GODZ .: MINUTY: SEKUNDY”
DAY_MINUTE	„DNI GODZ .: MINUTY”
DAY_HOUR	„DNI GODZ.”
YEAR_MONTH	„LATA-MIESIĄCE”

Wartości QUARTER i WEEKsą dostępne w MySQL 5.0.0. wersja.

mysql> SELECT DATE_ADD('1997-12-31 23:59:59', 
   -> INTERVAL '1:1' MINUTE_SECOND);
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59', INTERVAL...             |
+---------------------------------------------------------+
| 1998-01-01 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);
+---------------------------------------------------------+
| DATE_ADD('1999-01-01', INTERVAL 1 HOUR)                 |
+---------------------------------------------------------+
| 1999-01-01 01:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_FORMAT (data, format)

To polecenie formatuje wartość daty zgodnie z ciągiem formatu.

Następujące specyfikatory mogą być używane w ciągu formatu. Znak „%” jest wymagany przed znakami specyfikatora formatu.

Sr.No.	Specyfikator i opis
1	%a Skrócona nazwa dnia tygodnia (niedz. Sobota)
2	%b Skrócona nazwa miesiąca (styczeń – grudzień)
3	%c Miesiąc, numerycznie (0..12)
4	%D Dzień miesiąca z angielskim sufiksem (0, 1, 2, 3,.)
5	%d Dzień miesiąca, numeryczny (00–31)
6	%e Dzień miesiąca, numerycznie (0..31)
7	%f Mikrosekundy (000000..999999)
8	%H Godzina (00–23)
9	%h Godzina (01..12)
10	%I Godzina (01..12)
11	%i Minuty, numeryczne (00–59)
12	%j Dzień roku (001..366)
13	%k Godzina (0–23)
14	%l Godzina (1–12)
15	%M Nazwa miesiąca (styczeń – grudzień)
16	%m Miesiąc, numerycznie (00..12)
17	%p Rano lub wieczorem
18	%r Czas, 12-godzinny (gg: mm: ss, a następnie AM lub PM)
19	%S Sekundy (00–59)
20	%s Sekundy (00–59)
21	%T Czas, 24-godzinny (gg: mm: ss)
22	%U Tydzień (00..53), gdzie niedziela jest pierwszym dniem tygodnia
23	%u Tydzień (00..53), gdzie poniedziałek jest pierwszym dniem tygodnia
24	%V Tydzień (01..53), gdzie niedziela jest pierwszym dniem tygodnia; używane z% X
25	%v Tydzień (01..53), gdzie poniedziałek jest pierwszym dniem tygodnia; używane z% x
26	%W Nazwa dnia tygodnia (niedziela… sobota)
27	%w Dzień tygodnia (0 = niedziela..6 = sobota)
28	%X Rok dla tygodnia, w którym niedziela jest pierwszym dniem tygodnia, numerycznie, cztery cyfry; używany z% V
29	%x Rok tygodnia, w którym poniedziałek jest pierwszym dniem tygodnia, numerycznie, cztery cyfry; używane z% v
30	%Y Rok, numeryczny, cztery cyfry
31	%y Rok, numeryczny (dwie cyfry)
32	%% Dosłowny.%. postać
33	%x x, dla any.x. nie wymienione powyżej

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y')          |
+---------------------------------------------------------+
| Saturday October 1997                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00'
   -> '%H %k %I %r %T %S %w');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00.......                 |
+---------------------------------------------------------+
|  22 22 10 10:23:00 PM 22:23:00 00 6                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_SUB (data, jednostka wyrażenia INTERVAL)

Jest to podobne do funkcji DATE_ADD ().

Data dnia)

DAY () jest synonimem funkcji DAYOFMONTH ().

DAYNAME (data)

Zwraca nazwę dnia tygodnia dla daty.

mysql> SELECT DAYNAME('1998-02-05');
+---------------------------------------------------------+
| DAYNAME('1998-02-05')                                   |
+---------------------------------------------------------+
| Thursday                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFMONTH (data)

Zwraca dzień miesiąca jako datę z zakresu od 0 do 31.

mysql> SELECT DAYOFMONTH('1998-02-03');
+---------------------------------------------------------+
| DAYOFMONTH('1998-02-03')                                |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFWEEK (data)

Zwraca indeks dni tygodnia dla daty (1 = niedziela, 2 = poniedziałek,., 7 = sobota). Te wartości indeksu odpowiadają standardowi ODBC.

mysql> SELECT DAYOFWEEK('1998-02-03');
+---------------------------------------------------------+
|DAYOFWEEK('1998-02-03')                                  |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFYEAR (data)

Zwraca dzień roku dla daty z zakresu od 1 do 366.

mysql> SELECT DAYOFYEAR('1998-02-03');
+---------------------------------------------------------+
| DAYOFYEAR('1998-02-03')                                 |
+---------------------------------------------------------+
| 34                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

EKSTRAKT (jednostka OD daty)

Funkcja EXTRACT () używa tego samego rodzaju specyfikatorów jednostek, co DATE_ADD () lub DATE_SUB (), ale wyodrębnia części z daty zamiast wykonywania arytmetyki na podstawie daty.

mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');
+---------------------------------------------------------+
| EXTRACT(YEAR FROM '1999-07-02')                         |
+---------------------------------------------------------+
| 1999                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');
+---------------------------------------------------------+
| EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03')          |
+---------------------------------------------------------+
| 199907                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

FROM_DAYS (N)

Biorąc pod uwagę numer dnia N, zwraca wartość DATA.

mysql> SELECT FROM_DAYS(729669);
+---------------------------------------------------------+
| FROM_DAYS(729669)                                       |
+---------------------------------------------------------+
| 1997-10-07                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Note- Używaj ostrożnie FROM_DAYS () w przypadku starych dat. Nie jest przeznaczony do stosowania z wartościami poprzedzającymi nadejście kalendarza gregoriańskiego (1582).

FROM_UNIXTIME (unix_timestamp)

FROM_UNIXTIME (unix_timestamp, format)

Zwraca reprezentację unix_timestampargument jako wartość w formacie „RRRR-MM-DD HH: MM: SS lub RRRRMMDDGGMMSS, w zależności od tego, czy funkcja jest używana w ciągu, czy w kontekście liczbowym. Wartość jest wyrażona w aktualnej strefie czasowej. Argument unix_timestamp to wewnętrzne wartości znacznika czasu, które są tworzone przezUNIX_TIMESTAMP() funkcjonować.

Jeśli podano format, wynik jest formatowany zgodnie z ciągiem formatu, który jest używany w taki sam sposób, jak podano we wpisie dla DATE_FORMAT() funkcjonować.

mysql> SELECT FROM_UNIXTIME(875996580);
+---------------------------------------------------------+
| FROM_UNIXTIME(875996580)                                |
+---------------------------------------------------------+
| 1997-10-04 22:23:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

HOUR (czas)

Zwraca godzinę dla czasu. Zakres zwracanej wartości wynosi od 0 do 23 dla wartości dotyczących pory dnia. Jednak zakres wartości CZAS jest w rzeczywistości znacznie większy, więc GODZINA może zwracać wartości większe niż 23.

mysql> SELECT HOUR('10:05:03');
+---------------------------------------------------------+
| HOUR('10:05:03')                                        |
+---------------------------------------------------------+
| 10                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LAST_DAY (data)

Pobiera wartość daty lub daty i godziny i zwraca odpowiednią wartość z ostatniego dnia miesiąca. Zwraca NULL, jeśli argument jest nieprawidłowy.

mysql> SELECT LAST_DAY('2003-02-05');
+---------------------------------------------------------+
| LAST_DAY('2003-02-05')                                  |
+---------------------------------------------------------+
| 2003-02-28                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LOCALTIME i LOCALTIME ()

LOCALTIME i LOCALTIME () to synonimy NOW ().

LOCALTIMESTAMP i LOCALTIMESTAMP ()

LOCALTIMESTAMP i LOCALTIMESTAMP () to synonimy NOW ().

MAKEDATE (rok, dzień roku)

Zwraca datę, podaną wartość roku i dnia roku. Wartość dayofyear musi być większa niż 0 lub wynik będzie miał wartość NULL.

mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
+---------------------------------------------------------+
| MAKEDATE(2001,31), MAKEDATE(2001,32)                    |
+---------------------------------------------------------+
| '2001-01-31', '2001-02-01'                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MAKETIME (godzina, minuta, sekunda)

Zwraca wartość czasu obliczoną na podstawie godzin, minut i sekund argumentów.

mysql> SELECT MAKETIME(12,15,30);
+---------------------------------------------------------+
| MAKETIME(12,15,30)                                      |
+---------------------------------------------------------+
| '12:15:30'                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MICROSECOND (wyrażenie)

Zwraca mikrosekundy z wyrażenia czasu lub daty i godziny (wyrażenia) jako liczbę z zakresu od 0 do 999999.

mysql> SELECT MICROSECOND('12:00:00.123456');
+---------------------------------------------------------+
| MICROSECOND('12:00:00.123456')                          |
+---------------------------------------------------------+
| 123456                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MINUTE (czas)

Zwraca minutę dla czasu z zakresu od 0 do 59.

mysql> SELECT MINUTE('98-02-03 10:05:03');
+---------------------------------------------------------+
| MINUTE('98-02-03 10:05:03')                             |
+---------------------------------------------------------+
| 5                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MIESIĄC (data)

Zwraca miesiąc dla daty z zakresu od 0 do 12.

mysql> SELECT MONTH('1998-02-03')
+---------------------------------------------------------+
| MONTH('1998-02-03')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MONTHNAME (data)

Zwraca pełną nazwę miesiąca dla daty.

mysql> SELECT MONTHNAME('1998-02-05');
+---------------------------------------------------------+
| MONTHNAME('1998-02-05')                                 |
+---------------------------------------------------------+
| February                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TERAZ()

Zwraca bieżącą datę i godzinę jako wartość w formacie „RRRR-MM-DD GG: MM: SS” lub RRRRMMDDGGMMSS, w zależności od tego, czy funkcja jest używana w kontekście ciągowym czy liczbowym. Ta wartość jest wyrażona w bieżącej strefie czasowej.

mysql> SELECT NOW();
+---------------------------------------------------------+
| NOW()                                                   |
+---------------------------------------------------------+
| 1997-12-15 23:50:26                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_ADD (P, N)

Dodaje N miesięcy do okresu P (w formacie RRMM lub RRRRMM). Zwraca wartość w formacie RRRRMM. Zauważ, że argument okresu P nie jest wartością daty.

mysql> SELECT PERIOD_ADD(9801,2);
+---------------------------------------------------------+
| PERIOD_ADD(9801,2)                                      |
+---------------------------------------------------------+
| 199803                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_DIFF (P1; P2)

Zwraca liczbę miesięcy między okresami P1 i P2. Okresy P1 i P2 powinny mieć format RRMM lub RRRRMM. Zwróć uwagę, że argumenty okresu P1 i P2 nie są wartościami dat.

mysql> SELECT PERIOD_DIFF(9802,199703);
+---------------------------------------------------------+
| PERIOD_DIFF(9802,199703)                                |
+---------------------------------------------------------+
| 11                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

KWARTAŁ (data)

Zwraca kwartał roku dla daty z zakresu od 1 do 4.

mysql> SELECT QUARTER('98-04-01');
+---------------------------------------------------------+
| QUARTER('98-04-01')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Drugi raz)

Zwraca sekundę dla czasu z zakresu od 0 do 59.

mysql> SELECT SECOND('10:05:03');
+---------------------------------------------------------+
| SECOND('10:05:03')                                      |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SEC_TO_TIME (sekundy)

Zwraca argument sekund po konwersji na godziny, minuty i sekundy jako wartość w formacie „HH: MM: SS” lub HHMMSS, w zależności od tego, czy funkcja jest używana w kontekście ciągowym, czy liczbowym.

mysql> SELECT SEC_TO_TIME(2378);
+---------------------------------------------------------+
| SEC_TO_TIME(2378)                                       |
+---------------------------------------------------------+
| 00:39:38                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

STR_TO_DATE (str, format)

To jest odwrotność funkcji DATE_FORMAT (). Pobiera ciąg znaków i format ciągu formatu. Funkcja STR_TO_DATE () zwraca wartość DATETIME, jeśli łańcuch formatu zawiera zarówno części daty, jak i godziny. W przeciwnym razie zwraca wartość DATA lub CZAS, jeśli ciąg zawiera tylko części daty lub godziny.

mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');
+---------------------------------------------------------+
| STR_TO_DATE('04/31/2004', '%m/%d/%Y')                   |
+---------------------------------------------------------+
| 2004-04-31                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBDATE (data, INTERVAL jednostka wyrażenia) i SUBDATE (wyrażenie, dni)

Po wywołaniu w postaci INTERVAL drugiego argumentu SUBDATE () jest synonimem DATE_SUB (). Aby uzyskać informacje na temat argumentu jednostki INTERVAL, zobacz dyskusję na temat DATE_ADD ().

mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_SUB('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| SUBDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBTIME (wyr1; wyr2)

Funkcja SUBTIME () zwraca wyrażenie1. wyrażenie2 wyrażone jako wartość w tym samym formacie co wyrażenie1. Wartość wyraż1 jest wyrażeniem czasu lub daty i godziny, a wartość wyraż2 jest wyrażeniem czasu.

mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999',
   -> '1 1:1:1.000002');
+---------------------------------------------------------+
| SUBTIME('1997-12-31 23:59:59.999999'...                 |
+---------------------------------------------------------+
| 1997-12-30 22:58:58.999997                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SYSDATE ()

Zwraca bieżącą datę i godzinę jako wartość w formacie „RRRR-MM-DD GG: MM: SS” lub RRRRMMDDGGMMSS, w zależności od tego, czy funkcja jest używana w ciągu, czy w kontekście liczbowym.

mysql> SELECT SYSDATE();
+---------------------------------------------------------+
| SYSDATE()                                               |
+---------------------------------------------------------+
| 2006-04-12 13:47:44                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CZAS (wyrażenie)

Wyodrębnia część czasu z wyrażenia czasu lub daty i godziny expr i zwraca go jako ciąg.

mysql> SELECT TIME('2003-12-31 01:02:03');
+---------------------------------------------------------+
| TIME('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
| 01:02:03                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMEDIFF (wyr1; wyr2)

Funkcja TIMEDIFF () zwraca wyrażenie1. wyrażenie2 wyrażone jako wartość czasu. Te wartości wyr1 i wyr2 są wyrażeniami czasu lub daty i godziny, ale obie muszą być tego samego typu.

mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',
   -> '1997-12-30 01:01:01.000002');
+---------------------------------------------------------+
| TIMEDIFF('1997-12-31 23:59:59.000001'.....              |
+---------------------------------------------------------+
|  46:58:57.999999                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMP (wyrażenie), TIMESTAMP (wyrażenie1, wyrażenie2)

Z jednym argumentem ta funkcja zwraca wyrażenie daty lub daty i godziny jako wartość typu data-godzina. Z dwoma argumentami dodaje wyrażenie czasu wyrażenie2 do wyrażenia daty lub daty i godzinyexpr1 i zwraca wynik jako wartość typu data-godzina.

mysql> SELECT TIMESTAMP('2003-12-31');
+---------------------------------------------------------+
| TIMESTAMP('2003-12-31')                                 |
+---------------------------------------------------------+
| 2003-12-31 00:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPADD (jednostka; interwał; datetime_expr)

Ta funkcja dodaje interwał wyrażenia liczb całkowitych do wyrażenia daty lub daty i godziny datetime_expr. Jednostka dla interwału jest określona przez argument jednostki, który powinien być jedną z następujących wartości -

• FRAC_SECOND
• SECOND, MINUTE
• GODZINA, DZIEŃ
• WEEK
• MONTH
• KWARTAŁ lub
• YEAR

Wartość jednostki można określić za pomocą jednego ze słów kluczowych, jak pokazano, lub z przedrostkiem SQL_TSI_.

Na przykład DAY i SQL_TSI_DAY oba są dozwolone.

mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
+---------------------------------------------------------+
| TIMESTAMPADD(MINUTE,1,'2003-01-02')                     |
+---------------------------------------------------------+
| 2003-01-02 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPDIFF (jednostka; datetime_expr1; datetime_expr2)

Zwraca całkowitą różnicę między wyrażeniami daty lub daty i godziny datetime_expr1 i datetime_expr2. Jednostka wyniku jest określona przez argument jednostki. Dopuszczalne wartości jednostki są takie same, jak podane w opisie funkcji TIMESTAMPADD ().

mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
+---------------------------------------------------------+
| TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01')          |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_FORMAT (czas, format)

Ta funkcja jest używana podobnie jak funkcja DATE_FORMAT (), ale ciąg formatu może zawierać specyfikatory formatu tylko dla godzin, minut i sekund.

Jeśli wartość czasu zawiera część godzinową większą niż 23,%H i %k specyfikatory formatu godziny dają wartość większą niż zwykły zakres od 0 do 23. Inne specyfikatory formatu godziny tworzą wartość godziny modulo 12.

mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
+---------------------------------------------------------+
| TIME_FORMAT('100:00:00', '%H %k %h %I %l')              |
+---------------------------------------------------------+
| 100 100 04 04 4                                         |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_TO_SEC (czas)

Zwraca argument czasu przekonwertowany na sekundy.

mysql> SELECT TIME_TO_SEC('22:23:00');
+---------------------------------------------------------+
| TIME_TO_SEC('22:23:00')                                 |
+---------------------------------------------------------+
| 80580                                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Dzisiejsza data)

Podana data zwraca numer dnia (liczbę dni od roku 0).

mysql> SELECT TO_DAYS(950501);
+---------------------------------------------------------+
| TO_DAYS(950501)                                         |
+---------------------------------------------------------+
| 728779                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UNIX_TIMESTAMP (), UNIX_TIMESTAMP (data)

Jeśli zostanie wywołana bez argumentu, ta funkcja zwraca uniksowy znacznik czasu (sekundy od czasu UTC „1970-01-01 00:00:00”) jako liczbę całkowitą bez znaku. Jeśli funkcja UNIX_TIMESTAMP () zostanie wywołana z argumentem daty, zwraca wartość argumentu w sekundach od czasu UTC „1970-01-01 00:00:00”. data może być ciągiem DATA, ciągiem DATETIME, TIMESTAMP lub liczbą w formacie RRMMDD lub RRRRMMDD.

mysql> SELECT UNIX_TIMESTAMP();
+---------------------------------------------------------+
| UNIX_TIMESTAMP()                                        |
+---------------------------------------------------------+
| 882226357                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
+---------------------------------------------------------+
| UNIX_TIMESTAMP('1997-10-04 22:23:00')                   |
+---------------------------------------------------------+
| 875996580                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_DATE, UTC_DATE ()

Zwraca bieżącą datę UTC jako wartość w formacie „RRRR-MM-DD” lub RRRRMMDD, w zależności od tego, czy funkcja jest używana w kontekście ciągowym, czy liczbowym.

mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
+---------------------------------------------------------+
| UTC_DATE(), UTC_DATE() + 0                              |
+---------------------------------------------------------+
| 2003-08-14, 20030814                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIME, UTC_TIME ()

Zwraca bieżący czas UTC jako wartość w formacie „HH: MM: SS” lub HHMMSS, w zależności od tego, czy funkcja jest używana w kontekście ciągowym, czy liczbowym.

mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
+---------------------------------------------------------+
| UTC_TIME(), UTC_TIME() + 0                              |
+---------------------------------------------------------+
| 18:07:53, 180753                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIMESTAMP, UTC_TIMESTAMP ()

Zwraca bieżącą datę i godzinę UTC jako wartość w formacie „RRRR-MM-DD GG: MM: SS” lub RRRRMMDDGGMMSS, w zależności od tego, czy funkcja jest używana w ciągu, czy w kontekście liczbowym.

mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
+---------------------------------------------------------+
| UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0                    |
+---------------------------------------------------------+
| 2003-08-14 18:08:04, 20030814180804                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TYDZIEŃ (data [, tryb])

Ta funkcja zwraca numer tygodnia dla daty. Dwuargumentowa postać TYGODNIA () pozwala określić, czy tydzień zaczyna się w niedzielę, czy w poniedziałek i czy wartość zwracana powinna mieścić się w zakresie od 0 do 53 czy od 1 do 53. Jeśli argument mode zostanie pominięty, używana jest wartość zmiennej systemowej default_week_format

Tryb	Pierwszy dzień tygodnia	Zasięg	Tydzień 1 to pierwszy tydzień.
0	niedziela	0-53	z niedzielą w tym roku
1	poniedziałek	0-53	z więcej niż 3 dniami w tym roku
2	niedziela	1-53	z niedzielą w tym roku
3	poniedziałek	1-53	z więcej niż 3 dniami w tym roku
4	niedziela	0-53	z więcej niż 3 dniami w tym roku
5	poniedziałek	0-53	z poniedziałkiem w tym roku
6	niedziela	1-53	z więcej niż 3 dniami w tym roku
7	poniedziałek	1-53	z poniedziałkiem w tym roku

mysql> SELECT WEEK('1998-02-20');
+---------------------------------------------------------+
| WEEK('1998-02-20')                                      |
+---------------------------------------------------------+
| 7                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WEEKDAY (data)

Zwraca indeks dni tygodnia dla daty (0 = poniedziałek, 1 = wtorek,. 6 = niedziela).

mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
+---------------------------------------------------------+
| WEEKDAY('1998-02-03 22:23:00')                          |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WEEKOFYEAR (data)

Zwraca tydzień kalendarzowy dla daty jako liczbę z zakresu od 1 do 53. WEEKOFYEAR () to funkcja zgodności, która jest odpowiednikiem WEEK (data, 3).

mysql> SELECT WEEKOFYEAR('1998-02-20');
+---------------------------------------------------------+
| WEEKOFYEAR('1998-02-20')                                |
+---------------------------------------------------------+
| 8                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ROK (data)

Zwraca rok dla daty z zakresu od 1000 do 9999 lub 0 dla wartości zero. data.

mysql> SELECT YEAR('98-02-03');
+---------------------------------------------------------+
| YEAR('98-02-03')                                        |
+---------------------------------------------------------+
| 1998                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

YEARWEEK (data), YEARWEEK (data, tryb)

Zwraca rok i tydzień dla daty. Argument trybu działa dokładnie tak samo, jak argument trybu funkcji WEEK (). Wynikowy rok może różnić się od roku w argumencie data dla pierwszego i ostatniego tygodnia roku.

mysql> SELECT YEARWEEK('1987-01-01');
+---------------------------------------------------------+
| YEAR('98-02-03')YEARWEEK('1987-01-01')                  |
+---------------------------------------------------------+
| 198653                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Note - Numer tygodnia różni się od tego, co funkcja WEEK () zwróciłaby (0) dla opcjonalnych argumentów 0 lub 1, ponieważ WEEK () zwraca następnie tydzień w kontekście danego roku.

SQL - tabele tymczasowe

Co to są tabele tymczasowe?

Istnieją RDBMS, które obsługują tabele tymczasowe. Tabele tymczasowe to świetna funkcja, która pozwalastore and process intermediate results korzystając z tych samych możliwości wyboru, aktualizacji i łączenia, których można używać w przypadku typowych tabel programu SQL Server.

Tabele tymczasowe mogą być bardzo przydatne w niektórych przypadkach do przechowywania danych tymczasowych. Najważniejszą rzeczą, o której należy wiedzieć w przypadku tabel tymczasowych, jest to, że zostaną one usunięte po zakończeniu bieżącej sesji klienta.

Tabele tymczasowe są dostępne od wersji MySQL 3.23 i nowszych. Jeśli używasz starszej wersji MySQL niż 3.23, nie możesz używać tabel tymczasowych, ale możesz użyćheap tables.

Jak wspomniano wcześniej, tymczasowe tabele będą działać tylko tak długo, jak długo trwa sesja. Jeśli uruchomisz kod w skrypcie PHP, tabela tymczasowa zostanie automatycznie zniszczona po zakończeniu wykonywania skryptu. Jeśli łączysz się z serwerem bazy danych MySQL za pośrednictwem programu klienta MySQL, tabela tymczasowa będzie istnieć do momentu zamknięcia klienta lub ręcznego zniszczenia tabeli.

Przykład

Oto przykład pokazujący użycie tabeli tymczasowej.

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SALESSUMMARY
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SALESSUMMARY;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber     |      100.25 |          90.00 |                2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)

Kiedy wydasz polecenie SHOW TABLES, twoja tymczasowa tabela nie pojawi się na liście. Teraz, jeśli wylogujesz się z sesji MySQL, a następnie wydasz polecenie SELECT, w bazie danych nie znajdziesz żadnych danych. Nawet twój tymczasowy stół nie będzie istniał.

Upuszczanie tabel tymczasowych

Domyślnie wszystkie tabele tymczasowe są usuwane przez MySQL po zerwaniu połączenia z bazą danych. Jeśli jednak chcesz je usunąć w międzyczasie, możesz to zrobić, wydając plikDROP TABLE Komenda.

Poniżej znajduje się przykład usuwania tabeli tymczasowej.

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SALESSUMMARY
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SALESSUMMARY;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber     |      100.25 |          90.00 |                2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)
mysql> DROP TABLE SALESSUMMARY;
mysql>  SELECT * FROM SALESSUMMARY;
ERROR 1146: Table 'TUTORIALS.SALESSUMMARY' doesn't exist

SQL - Clone Tables

Może zaistnieć sytuacja, w której potrzebujesz dokładnej kopii tabeli, a polecenia CREATE TABLE ... lub SELECT ... nie będą odpowiadać twoim celom, ponieważ kopia musi zawierać te same indeksy, wartości domyślne i tak dalej.

Jeśli używasz MySQL RDBMS, możesz poradzić sobie z tą sytuacją, postępując zgodnie z instrukcjami podanymi poniżej -

• Użyj polecenia SHOW CREATE TABLE, aby uzyskać instrukcję CREATE TABLE, która określa strukturę tabeli źródłowej, indeksy i wszystko.

• Zmodyfikuj instrukcję, aby zmienić nazwę tabeli na nazwę tabeli klonowania i wykonaj instrukcję. W ten sposób będziesz mieć dokładną tabelę klonów.

• Opcjonalnie, jeśli chcesz również skopiować zawartość tabeli, wydaj instrukcję INSERT INTO lub SELECT.

Przykład

Wypróbuj następujący przykład, aby utworzyć tabelę klonów dla TUTORIALS_TBL którego struktura jest następująca -

Step 1 - Uzyskaj pełną strukturę stołu.

SQL> SHOW CREATE TABLE TUTORIALS_TBL \G; 
*************************** 1. row *************************** 
      Table: TUTORIALS_TBL 
Create Table: CREATE TABLE 'TUTORIALS_TBL' ( 
  'tutorial_id' int(11) NOT NULL auto_increment, 
  'tutorial_title' varchar(100) NOT NULL default '', 
  'tutorial_author' varchar(40) NOT NULL default '', 
  'submission_date' date default NULL, 
  PRIMARY KEY  ('tutorial_id'), 
  UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author') 
) TYPE = MyISAM 
1 row in set (0.00 sec)

Step 2 - Zmień nazwę tej tabeli i utwórz inną tabelę.

SQL> CREATE TABLE `CLONE_TBL` ( 
  -> 'tutorial_id' int(11) NOT NULL auto_increment, 
  -> 'tutorial_title' varchar(100) NOT NULL default '', 
  -> 'tutorial_author' varchar(40) NOT NULL default '', 
  -> 'submission_date' date default NULL, 
  -> PRIMARY KEY  (`tutorial_id'), 
  -> UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author') 
-> ) TYPE = MyISAM; 
Query OK, 0 rows affected (1.80 sec)

Step 3- Po wykonaniu kroku 2 sklonujesz tabelę w swojej bazie danych. Jeśli chcesz skopiować dane ze starej tabeli, możesz to zrobić za pomocą instrukcji INSERT INTO ... SELECT.

SQL> INSERT INTO CLONE_TBL (tutorial_id, 
   ->                        tutorial_title, 
   ->                        tutorial_author, 
   ->                        submission_date) 
   -> SELECT tutorial_id,tutorial_title, 
   ->        tutorial_author,submission_date, 
   -> FROM TUTORIALS_TBL; 
Query OK, 3 rows affected (0.07 sec) 
Records: 3  Duplicates: 0  Warnings: 0

Wreszcie będziesz mieć dokładną tabelę klonów, jaką chciałeś mieć.

SQL - zapytania podrzędne

Zapytanie podzapytanie lub zapytanie wewnętrzne lub zapytanie zagnieżdżone to zapytanie zawarte w innym zapytaniu SQL i osadzone w klauzuli WHERE.

Podzapytanie służy do zwracania danych, które będą używane w zapytaniu głównym jako warunek dalszego ograniczenia danych do pobrania.

Podzapytań można używać z instrukcjami SELECT, INSERT, UPDATE i DELETE wraz z operatorami takimi jak =, <,>,> =, <=, IN, BETWEEN itd.

Istnieje kilka zasad, których muszą przestrzegać podzapytania -

• Podzapytania muszą być zawarte w nawiasach.

• Podzapytanie może mieć tylko jedną kolumnę w klauzuli SELECT, chyba że w głównym zapytaniu dla podzapytania znajduje się wiele kolumn w celu porównania wybranych kolumn.

• Polecenie ORDER BY nie może być użyte w podzapytaniu, chociaż główne zapytanie może używać polecenia ORDER BY. Polecenia GROUP BY można użyć do wykonania tej samej funkcji, co ORDER BY w podzapytaniu.

• Podkwerendy, które zwracają więcej niż jeden wiersz, mogą być używane tylko z wieloma operatorami wartości, takimi jak operator IN.

• Lista SELECT nie może zawierać żadnych odniesień do wartości, których wynikiem jest BLOB, ARRAY, CLOB lub NCLOB.

• Podzapytania nie można od razu zamknąć w funkcji zestawu.

• Operator BETWEEN nie może być używany z podzapytaniem. Jednak w podzapytaniu można użyć operatora BETWEEN.

Podzapytania z instrukcją SELECT

Podkwerendy są najczęściej używane z instrukcją SELECT. Podstawowa składnia jest następująca -

SELECT column_name [, column_name ]
FROM   table1 [, table2 ]
WHERE  column_name OPERATOR
   (SELECT column_name [, column_name ]
   FROM table1 [, table2 ]
   [WHERE])

Przykład

Rozważ tabelę CUSTOMERS zawierającą następujące rekordy -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Teraz sprawdźmy następujące podzapytanie za pomocą instrukcji SELECT.

SQL> SELECT * 
   FROM CUSTOMERS 
   WHERE ID IN (SELECT ID 
         FROM CUSTOMERS 
         WHERE SALARY > 4500) ;

Dałoby to następujący wynik.

+----+----------+-----+---------+----------+
| ID | NAME     | AGE | ADDRESS | SALARY   |
+----+----------+-----+---------+----------+
|  4 | Chaitali |  25 | Mumbai  |  6500.00 |
|  5 | Hardik   |  27 | Bhopal  |  8500.00 |
|  7 | Muffy    |  24 | Indore  | 10000.00 |
+----+----------+-----+---------+----------+

Podzapytania z instrukcją INSERT

Podzapytań można również używać z instrukcjami INSERT. Instrukcja INSERT wykorzystuje dane zwrócone z podzapytania do wstawienia do innej tabeli. Wybrane dane w podzapytaniu można modyfikować za pomocą dowolnej funkcji znakowej, daty lub liczby.

Podstawowa składnia jest następująca.

INSERT INTO table_name [ (column1 [, column2 ]) ]
   SELECT [ *|column1 [, column2 ]
   FROM table1 [, table2 ]
   [ WHERE VALUE OPERATOR ]

Przykład

Rozważ tabelę CUSTOMERS_BKP o podobnej strukturze jak tabela CUSTOMERS. Teraz, aby skopiować całą tabelę CUSTOMERS do tabeli CUSTOMERS_BKP, możesz użyć następującej składni.

SQL> INSERT INTO CUSTOMERS_BKP
   SELECT * FROM CUSTOMERS 
   WHERE ID IN (SELECT ID 
   FROM CUSTOMERS) ;

Podzapytania z instrukcją UPDATE

Podzapytanie może być używane w połączeniu z instrukcją UPDATE. Za pomocą podzapytania z instrukcją UPDATE można zaktualizować jedną lub wiele kolumn w tabeli.

Podstawowa składnia jest następująca.

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Przykład

Zakładając, że mamy dostępną tabelę CUSTOMERS_BKP, która jest kopią zapasową tabeli CUSTOMERS. Poniższy przykład aktualizuje PŁACĘ o 0,25 razy w tabeli CUSTOMERS dla wszystkich klientów, których WIEK jest większy lub równy 27.

SQL> UPDATE CUSTOMERS
   SET SALARY = SALARY * 0.25
   WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
      WHERE AGE >= 27 );

Miałoby to wpływ na dwa wiersze i ostatecznie tabela CUSTOMERS miałaby następujące rekordy.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |   125.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  2125.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Podzapytania z instrukcją DELETE

Podzapytanie może być używane w połączeniu z instrukcją DELETE, tak jak z każdą inną instrukcją wymienioną powyżej.

Podstawowa składnia jest następująca.

DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Przykład

Zakładając, że mamy dostępną tabelę CUSTOMERS_BKP, która jest kopią zapasową tabeli CUSTOMERS. Poniższy przykład usuwa rekordy z tabeli CUSTOMERS dla wszystkich klientów, których wiek jest większy lub równy 27.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
      WHERE AGE >= 27 );

Wpłynęłoby to na dwa wiersze i ostatecznie tabela CUSTOMERS miałaby następujące rekordy.

+----+----------+-----+---------+----------+
| ID | NAME     | AGE | ADDRESS | SALARY   |
+----+----------+-----+---------+----------+
|  2 | Khilan   |  25 | Delhi   |  1500.00 |
|  3 | kaushik  |  23 | Kota    |  2000.00 |
|  4 | Chaitali |  25 | Mumbai  |  6500.00 |
|  6 | Komal    |  22 | MP      |  4500.00 |
|  7 | Muffy    |  24 | Indore  | 10000.00 |
+----+----------+-----+---------+----------+

SQL - użycie sekwencji

Sekwencja to zbiór liczb całkowitych 1, 2, 3, ..., które są generowane w kolejności na żądanie. Sekwencje są często używane w bazach danych, ponieważ wiele aplikacji wymaga, aby każdy wiersz w tabeli zawierał unikatową wartość, a sekwencje zapewniają łatwy sposób ich generowania.

W tym rozdziale opisano, jak używać sekwencji w MySQL.

Używam kolumny AUTO_INCREMENT

Najprostszym sposobem użycia sekwencji w MySQL jest zdefiniowanie kolumny jako AUTO_INCREMENT, a resztę należy pozostawić MySQL.

Przykład

Wypróbuj następujący przykład. Spowoduje to utworzenie tabeli, a następnie wstawi kilka wierszy do tej tabeli, w których nie jest wymagane podawanie identyfikatora rekordu, ponieważ jest on automatycznie zwiększany przez MySQL.

mysql> CREATE TABLE INSECT
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);
Query OK, 0 rows affected (0.02 sec)
mysql> INSERT INTO INSECT (id,name,date,origin) VALUES
   -> (NULL,'housefly','2001-09-10','kitchen'),
   -> (NULL,'millipede','2001-09-10','driveway'),
   -> (NULL,'grasshopper','2001-09-10','front yard');
Query OK, 3 rows affected (0.02 sec)
Records: 3  Duplicates: 0  Warnings: 0
mysql> SELECT * FROM INSECT ORDER BY id;
+----+-------------+------------+------------+
| id | name        | date       | origin     |
+----+-------------+------------+------------+
|  1 | housefly    | 2001-09-10 | kitchen    |
|  2 | millipede   | 2001-09-10 | driveway   |
|  3 | grasshopper | 2001-09-10 | front yard |
+----+-------------+------------+------------+
3 rows in set (0.00 sec)

Uzyskaj wartości AUTO_INCREMENT

LAST_INSERT_ID () jest funkcją SQL, więc można jej używać z poziomu dowolnego klienta, który rozumie, jak wydawać instrukcje SQL. W przeciwnym razie skrypty PERL i PHP zapewniają ekskluzywne funkcje do pobierania automatycznie zwiększonej wartości ostatniego rekordu.

Przykład PERL

Użyj mysql_insertidatrybut, aby uzyskać wartość AUTO_INCREMENT wygenerowaną przez zapytanie. Dostęp do tego atrybutu uzyskuje się za pośrednictwem uchwytu bazy danych lub uchwytu instrukcji, w zależności od sposobu wysłania zapytania. Poniższy przykład odwołuje się do niego za pośrednictwem uchwytu bazy danych.

$dbh->do ("INSERT INTO INSECT (name,date,origin) VALUES('moth','2001-09-14','windowsill')"); my $seq = $dbh->{mysql_insertid};

Przykład PHP

Po wysłaniu zapytania, które generuje wartość AUTO_INCREMENT, pobierz wartość, wywołując metodę mysql_insert_id( ) funkcjonować.

mysql_query ("INSERT INTO INSECT (name,date,origin)
VALUES('moth','2001-09-14','windowsill')", $conn_id);
$seq = mysql_insert_id ($conn_id);

Renumeracja istniejącej sekwencji

Może wystąpić sytuacja, w której usunięto wiele rekordów z tabeli i chcesz ponownie ustawić kolejność wszystkich rekordów. Można to zrobić za pomocą prostej sztuczki, ale należy być bardzo ostrożnym, aby to zrobić i sprawdzić, czy Twój stół ma połączenie z innym stołem, czy nie.

Jeśli stwierdzisz, że ponowne sekwencjonowanie kolumny AUTO_INCREMENT jest nieuniknione, sposobem na to jest usunięcie kolumny z tabeli, a następnie dodanie jej ponownie.

Poniższy przykład pokazuje, jak przenumerować wartości identyfikatorów w tabeli owadów przy użyciu tej techniki.

mysql> ALTER TABLE INSECT DROP id;
mysql> ALTER TABLE insect
   -> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
   -> ADD PRIMARY KEY (id);

Rozpoczynanie sekwencji o określonej wartości

Domyślnie MySQL rozpocznie sekwencję od 1, ale możesz podać również dowolną inną liczbę w momencie tworzenia tabeli.

Poniższy blok kodu zawiera przykład, w którym MySQL rozpocznie sekwencję od 100.

mysql> CREATE TABLE INSECT
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT = 100,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);

Alternatywnie możesz utworzyć tabelę, a następnie ustawić początkową wartość sekwencji za pomocą ALTER TABLE.

mysql> ALTER TABLE t AUTO_INCREMENT = 100;

SQL - obsługa duplikatów

Może wystąpić sytuacja, w której masz wiele zduplikowanych rekordów w tabeli. Podczas pobierania takich rekordów bardziej sensowne jest pobieranie tylko unikalnych rekordów, zamiast pobierania zduplikowanych rekordów.

SQL DISTINCT Słowo kluczowe, które już omówiliśmy, jest używane w połączeniu z instrukcją SELECT w celu wyeliminowania wszystkich zduplikowanych rekordów i pobrania tylko unikalnych rekordów.

Składnia

Podstawowa składnia słowa kluczowego DISTINCT służąca do eliminacji zduplikowanych rekordów jest następująca.

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

Przykład

Rozważmy tabelę CUSTOMERS zawierającą następujące rekordy.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Najpierw zobaczmy, jak poniższe zapytanie SELECT zwraca zduplikowane rekordy wynagrodzenia.

SQL> SELECT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Dałoby to następujący wynik, w którym pensja w wysokości 2000 jest dwukrotnie wyższa, co jest powtórzeniem rekordu z oryginalnej tabeli.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

Teraz użyjmy słowa kluczowego DISTINCT z powyższym zapytaniem SELECT i zobaczmy wynik.

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Dałoby to następujący wynik, gdy nie mamy żadnego zduplikowanego wpisu.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

SQL - wtrysk

Jeśli weźmiesz dane wejściowe użytkownika za pośrednictwem strony internetowej i wstawisz je do bazy danych SQL, istnieje szansa, że ​​pozostawiłeś się szeroko otwarty na problem bezpieczeństwa znany jako SQL Injection. W tym rozdziale nauczysz się, jak temu zapobiec i jak zabezpieczyć skrypty i instrukcje SQL w skryptach po stronie serwera, takich jak skrypt PERL.

Wstrzyknięcie zwykle występuje, gdy poprosisz użytkownika o wprowadzenie danych, na przykład jego imię i nazwisko, a zamiast nazwy podają ci instrukcję SQL, którą nieświadomie uruchomisz w swojej bazie danych. Nigdy nie ufaj danym dostarczonym przez użytkownika, przetwarzaj te dane dopiero po weryfikacji; z reguły odbywa się to przezPattern Matching.

W poniższym przykładzie name jest ograniczona do znaków alfanumerycznych i podkreślenia oraz do długości od 8 do 20 znaków (zmodyfikuj te zasady w razie potrzeby).

if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)) { $result = mysql_query("SELECT * FROM CUSTOMERS 
      WHERE name = $matches[0]");
} else {
   echo "user name not accepted";
}

Aby zademonstrować problem, rozważ ten fragment -

// supposed input
$name = "Qadir'; DELETE FROM CUSTOMERS;";
mysql_query("SELECT * FROM CUSTOMSRS WHERE name='{$name}'");

Wywołanie funkcji ma na celu pobranie rekordu z tabeli CUSTOMERS, w której kolumna name odpowiada nazwie określonej przez użytkownika. W normalnych okolicznościach,$namebędzie zawierać tylko znaki alfanumeryczne i być może spacje, takie jak ciąg ilia. Ale tutaj, dołączając zupełnie nowe zapytanie do $ name, wywołanie bazy danych zamienia się w katastrofę; wstrzyknięte zapytanie DELETE usuwa wszystkie rekordy z tabeli CUSTOMERS.

Na szczęście, jeśli używasz MySQL, rozszerzenie mysql_query()funkcja nie zezwala na zestawianie zapytań ani wykonywanie wielu zapytań SQL w jednym wywołaniu funkcji. Jeśli spróbujesz zestawić zapytania, wywołanie nie powiedzie się.

Jednak inne rozszerzenia baz danych PHP, takie jak SQLite i PostgreSQL szczęśliwie wykonuj zapytania skumulowane, wykonując wszystkie zapytania dostarczone w jednym ciągu i tworząc poważny problem z bezpieczeństwem.

Zapobieganie iniekcji SQL

Możesz inteligentnie obsługiwać wszystkie znaki ucieczki w językach skryptowych, takich jak PERL i PHP. Rozszerzenie MySQL dla PHP zapewnia tę funkcjęmysql_real_escape_string() aby uniknąć znaków wejściowych, które są specjalne dla MySQL.

if (get_magic_quotes_gpc()) {
   $name = stripslashes($name); } $name = mysql_real_escape_string($name); mysql_query("SELECT * FROM CUSTOMERS WHERE name='{$name}'");

LIKE Quandary

Aby rozwiązać dylemat LIKE, niestandardowy mechanizm zmiany znaczenia musi konwertować dostarczone przez użytkownika znaki „%” i „_” na literały. Posługiwać sięaddcslashes(), funkcja, która pozwala określić zakres znaków do zmiany znaczenia.

$sub = addcslashes(mysql_real_escape_string("%str"), "%_"); // $sub == \%str\_
mysql_query("SELECT * FROM messages 
   WHERE subject LIKE '{$sub}%'");

SQL - tuning bazy danych

Aby zostać ekspertem ds. Baz danych lub ekspertem ds. Administratorów baz danych, potrzeba czasu. Wszystko to wiąże się z dużym doświadczeniem w tworzeniu różnych projektów baz danych i dobrymi szkoleniami.

Ale poniższa lista może być pomocna dla początkujących, aby uzyskać dobrą wydajność bazy danych -

• Użyj projektu bazy danych 3BNF wyjaśnionego w tym samouczku w rozdziale Pojęcia dotyczące RDBMS.

• Unikaj konwersji liczby na znak, ponieważ liczby i znaki są różnie porównywane i prowadzą do obniżenia wydajności.

• Używając instrukcji SELECT, pobieraj tylko wymagane informacje i unikaj używania * w zapytaniach SELECT, ponieważ niepotrzebnie ładowałoby to system.

• Starannie twórz indeksy dla wszystkich tabel, w których często przeprowadzasz operacje wyszukiwania. Unikaj indeksowania w tabelach, w których masz mniejszą liczbę operacji wyszukiwania i większą liczbę operacji wstawiania i aktualizowania.

• Pełne skanowanie tabeli ma miejsce, gdy kolumny w klauzuli WHERE nie mają skojarzonego z nimi indeksu. Można uniknąć skanowania całej tabeli, tworząc indeks dla kolumn, które są używane jako warunki w klauzuli WHERE instrukcji SQL.

• Należy bardzo uważać na operatory równości z liczbami rzeczywistymi i wartościami daty / godziny. Oba mogą mieć niewielkie różnice, które nie są oczywiste dla oka, ale które uniemożliwiają dokładne dopasowanie, uniemożliwiając w ten sposób zwracanie wierszy przez zapytania.

• Używaj rozsądnie dopasowywania wzorców. LIKE COL% jest prawidłowym warunkiem WHERE, redukującym zwracany zestaw tylko do tych rekordów, których dane zaczynają się od łańcucha COL. Jednak COL% Y nie zmniejsza dalej zwracanego zestawu wyników, ponieważ% Y nie może być skutecznie oszacowany. Wysiłek potrzebny do przeprowadzenia oceny jest zbyt duży, aby można go było wziąć pod uwagę. W tym przypadku używany jest COL%, ale% Y jest odrzucany. Z tego samego powodu wiodący symbol wieloznaczny% COL skutecznie zapobiega użyciu całego filtra.

• Dostosuj swoje zapytania SQL, badając strukturę zapytań (i podzapytań), składnię SQL, aby odkryć, czy zaprojektowałeś swoje tabele do obsługi szybkiej manipulacji danymi i napisałeś zapytanie w optymalny sposób, umożliwiając Twojemu DBMS efektywne manipulowanie danymi .

• W przypadku zapytań, które są wykonywane regularnie, spróbuj użyć procedur. Procedura to potencjalnie duża grupa instrukcji SQL. Procedury są kompilowane przez silnik bazy danych, a następnie wykonywane. W przeciwieństwie do instrukcji SQL silnik bazy danych nie musi optymalizować procedury przed jej wykonaniem.

• Jeśli to możliwe, unikaj używania operatora logicznego OR w zapytaniu. LUB nieuchronnie spowalnia prawie każde zapytanie skierowane do tabeli o znacznej wielkości.

• Możesz zoptymalizować ładowanie zbiorcze danych, upuszczając indeksy. Wyobraź sobie tabelę historii zawierającą wiele tysięcy wierszy. Ta tabela historii może również zawierać jeden lub więcej indeksów. Kiedy myślisz o indeksie, zwykle myślisz o szybszym dostępie do tabeli, ale w przypadku ładowania wsadowego możesz skorzystać z porzucenia indeksów.

• Podczas wykonywania transakcji wsadowych, wykonaj polecenie COMMIT o po utworzeniu odpowiedniej liczby rekordów, zamiast tworzyć je po każdym utworzeniu rekordu.

• Zaplanuj regularną defragmentację bazy danych, nawet jeśli oznacza to opracowanie cotygodniowej procedury.

Wbudowane narzędzia do strojenia

Oracle ma wiele narzędzi do zarządzania wydajnością instrukcji SQL, ale spośród nich dwa są bardzo popularne. Te dwa narzędzia to -

• Explain plan - narzędzie identyfikuje ścieżkę dostępu, która zostanie wybrana po wykonaniu instrukcji SQL.

• tkprof - mierzy wydajność na podstawie czasu, jaki upłynął podczas każdej fazy przetwarzania instrukcji SQL.

Jeśli chcesz po prostu zmierzyć czas, który upłynął od zapytania w Oracle, możesz użyć polecenia SQL * Plus SET TIMING ON.

Sprawdź dokumentację RDBMS, aby uzyskać więcej informacji na temat wyżej wymienionych narzędzi i defragmentacji bazy danych.