SQL înseamnă Structured Query Language. Comenzile SQL sunt instrucțiunile utilizate pentru a comunica cu o bază de date pentru a efectua sarcini, funcții și interogări cu date.

Comenzile SQL pot fi utilizate pentru a căuta în baza de date și pentru a face alte funcții, cum ar fi crearea de tabele, adăugarea de date în tabele, modificarea datelor și eliminarea tabelelor.

Iată o listă de comenzi SQL de bază (uneori numite clauze) pe care ar trebui să le știți dacă aveți de gând să lucrați cu SQL.

SELECTAȚI ȘI DE LA

SELECT o parte a unei interogări determină ce coloane din date să se afișeze în rezultate. Există, de asemenea, opțiuni pe care le puteți aplica pentru a afișa date care nu sunt o coloană de tabel.

Citește mai multCum se face o promisiune dintr-o funcție de apel invers în JavaScript

Exemplul de mai jos prezintă trei coloane SELECTed FROM tabelul „student” și o coloană calculată. Baza de date stochează studentID, prenume și prenume ale studentului. Putem combina coloanele Prenume și Numele de familie pentru a crea coloana calculată FullName.

SELECT studentID, FirstName, LastName, FirstName + ' ' + LastName AS FullName
FROM student;
+-----------+-------------------+------------+------------------------+
| studentID | FirstName         | LastName   | FullName               |
+-----------+-------------------+------------+------------------------+
|         1 | Monique           | Davis      | Monique Davis          |
|         2 | Teri              | Gutierrez  | Teri Gutierrez         |
|         3 | Spencer           | Pautier    | Spencer Pautier        |
|         4 | Louis             | Ramsey     | Louis Ramsey           |
|         5 | Alvin             | Greene     | Alvin Greene           |
|         6 | Sophie            | Freeman    | Sophie Freeman         |
|         7 | Edgar Frank "Ted" | Codd       | Edgar Frank "Ted" Codd |
|         8 | Donald D.         | Chamberlin | Donald D. Chamberlin   |
|         9 | Raymond F.        | Boyce      | Raymond F. Boyce       |
+-----------+-------------------+------------+------------------------+
9 rows in set (0.00 sec)

CREAȚI TABEL

CREATE TABLE face exact ceea ce sună: creează un tabel în baza de date. Puteți specifica numele tabelului și coloanele care ar trebui să fie în tabel.

CREATE TABLE table_name (
    column_1 datatype,
    column_2 datatype,
    column_3 datatype
);

TABEL ALTER

ALTER TABLE modifică structura unui tabel. Iată cum ați adăuga o coloană la o bază de date:

ALTER TABLE table_name
ADD column_name datatype;

VERIFICA

CHECK constrângerea este utilizată pentru a limita intervalul de valori care poate fi plasat într-o coloană.

Dacă definiți un CHECK constrângere pe o singură coloană permite doar anumite valori pentru această coloană. Dacă definiți un CHECK constrângerea unui tabel poate limita valorile din anumite coloane pe baza valorilor din alte coloane din rând.

Citește mai multCum se generează un fișier de reducere GitHub din Microsoft Word utilizând TypeScript

Următorul SQL creează un CHECK constrângere pe coloana „Vârstă” când se creează tabelul „Persoane”. CHECK constrângerea vă asigură că nu puteți avea nicio persoană sub 18 ani.

CREATE TABLE Persons (
    ID int NOT NULL,
    LastName varchar(255) NOT NULL,
    FirstName varchar(255),
    Age int,
    CHECK (Age>=18)
);

Pentru a permite denumirea unui CHECK constrângere și pentru definirea a CHECK constrângere pe mai multe coloane, utilizați următoarea sintaxă SQL:

CREATE TABLE Persons (
    ID int NOT NULL,
    LastName varchar(255) NOT NULL,
    FirstName varchar(255),
    Age int,
    City varchar(255),
    CONSTRAINT CHK_Person CHECK (Age>=18 AND City='Sandnes')
);

UNDE

(AND, OR, IN, BETWEEN, și LIKE)

WHERE clauza este utilizată pentru a limita numărul de rânduri returnate.

Ca exemplu, mai întâi vă vom arăta un SELECT enunț și rezultate fără A WHERE afirmație. Apoi vom adăuga un WHERE declarație care folosește toate cele cinci calificative de mai sus.

SELECT studentID, FullName, sat_score, rcd_updated FROM student;
+-----------+------------------------+-----------+---------------------+
| studentID | FullName               | sat_score | rcd_updated         |
+-----------+------------------------+-----------+---------------------+
|         1 | Monique Davis          |       400 | 2017-08-16 15:34:50 |
|         2 | Teri Gutierrez         |       800 | 2017-08-16 15:34:50 |
|         3 | Spencer Pautier        |      1000 | 2017-08-16 15:34:50 |
|         4 | Louis Ramsey           |      1200 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene           |      1200 | 2017-08-16 15:34:50 |
|         6 | Sophie Freeman         |      1200 | 2017-08-16 15:34:50 |
|         7 | Edgar Frank "Ted" Codd |      2400 | 2017-08-16 15:35:33 |
|         8 | Donald D. Chamberlin   |      2400 | 2017-08-16 15:35:33 |
|         9 | Raymond F. Boyce       |      2400 | 2017-08-16 15:35:33 |
+-----------+------------------------+-----------+---------------------+
9 rows in set (0.00 sec)
Citește mai multAutentificare utilizând Google în ASP.NET Core 2.0

Acum, vom repeta SELECT interogare, dar vom limita rândurile returnate folosind un WHERE afirmație. 

STUDENT studentID, FullName, sat_score, recordUpdated
FROM student
WHERE (studentID BETWEEN 1 AND 5 OR studentID = 8)
        AND
        sat_score NOT IN (1000, 1400);
+-----------+----------------------+-----------+---------------------+
| studentID | FullName             | sat_score | rcd_updated         |
+-----------+----------------------+-----------+---------------------+
|         1 | Monique Davis        |       400 | 2017-08-16 15:34:50 |
|         2 | Teri Gutierrez       |       800 | 2017-08-16 15:34:50 |
|         4 | Louis Ramsey         |      1200 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene         |      1200 | 2017-08-16 15:34:50 |
|         8 | Donald D. Chamberlin |      2400 | 2017-08-16 15:35:33 |
+-----------+----------------------+-----------+---------------------+
5 rows in set (0.00 sec)

ACTUALIZAȚI

Pentru a actualiza o înregistrare într-un tabel, utilizați UPDATE afirmație.

Folosește WHERE condiție pentru a specifica ce înregistrări doriți să actualizați. Este posibil să actualizați una sau mai multe coloane odată. Sintaxa este:

UPDATE table_name
SET column1 = value1, 
    column2 = value2, ...
WHERE condition;

Iată un exemplu de actualizare a numelui înregistrării cu Id 4:

UPDATE Person
SET Name = “Elton John”
WHERE Id = 4;

De asemenea, puteți actualiza coloanele dintr-un tabel utilizând valori din alte tabele. Folosește JOIN pentru a obține date din mai multe tabele. Sintaxa este:

UPDATE table_name1
SET table_name1.column1 = table_name2.columnA
    table_name1.column2 = table_name2.columnB
FROM table_name1
JOIN table_name2 ON table_name1.ForeignKey = table_name2.Key

Iată un exemplu de actualizare a managerului tuturor înregistrărilor:

UPDATE Person
SET Person.Manager = Department.Manager
FROM Person
JOIN Department ON Person.DepartmentID = Department.ID

A SE GRUPA CU

GROUP BY vă permite să combinați rânduri și date agregate.

Iată sintaxa lui GROUP BY:

SELECT column_name, COUNT(*)
FROM table_name
GROUP BY column_name;

AVÂND

HAVING vă permite să filtrați datele agregate de GROUP BY clauză, astfel încât utilizatorul să poată vizualiza un set limitat de înregistrări.

Iată sintaxa lui HAVING:

SELECT column_name, COUNT(*)
FROM table_name
GROUP BY column_name
HAVING COUNT(*) > value;

AVG ()

„Media” este utilizată pentru a calcula media unei coloane numerice din setul de rânduri returnate de o instrucțiune SQL.

Iată sintaxa pentru utilizarea funcției:

SELECT groupingField, AVG(num_field)
FROM table1
GROUP BY groupingField

Iată un exemplu care folosește tabelul studenților:

SELECT studentID, FullName, AVG(sat_score) 
FROM student 
GROUP BY studentID, FullName;

LA FEL DE

AS vă permite să redenumiți o coloană sau un tabel folosind un alias.

SELECT user_only_num1 AS AgeOfServer, (user_only_num1 - warranty_period) AS NonWarrantyPeriod FROM server_table

Acest lucru are ca rezultat rezultatele prezentate mai jos.

+-------------+------------------------+
| AgeOfServer | NonWarrantyPeriod      | 
+-------------+------------------------+
|         36  |                     24 |
|         24  |                     12 | 
|         61  |                     49 |
|         12  |                      0 | 
|          6  |                     -6 |
|          0  |                    -12 | 
|         36  |                     24 |
|         36  |                     24 | 
|         24  |                     12 | 
+-------------+------------------------+

De asemenea, puteți utiliza AS pentru a atribui un nume unui tabel pentru a face mai ușoară referința în jonctiuni.

SELECT ord.product, ord.ord_number, ord.price, cust.cust_name, cust.cust_number FROM customer_table AS cust

JOIN order_table AS ord ON cust.cust_number = ord.cust_number

Acest lucru are ca rezultat rezultatele prezentate mai jos.

+-------------+------------+-----------+-----------------+--------------+
| product     | ord_number | price     | cust_name       | cust_number  |
+-------------+------------+-----------+-----------------+--------------+
|     RAM     |   12345    |       124 | John Smith      |  20          |
|     CPU     |   12346    |       212 | Mia X           |  22          |
|     USB     |   12347    |        49 | Elise Beth      |  21          |
|     Cable   |   12348    |         0 | Paul Fort       |  19          |
|     Mouse   |   12349    |        66 | Nats Back       |  15          |
|     Laptop  |   12350    |       612 | Mel S           |  36          |
|     Keyboard|   12351    |        24 | George Z        |  95          |
|     Keyboard|   12352    |        24 | Ally B          |  55          |
|     Air     |   12353    |        12 | Maria Trust     |  11          |
+-------------+------------+-----------+-----------------+--------------+

COMANDA DE

ORDER BY ne oferă o modalitate de a sorta rezultatul setat de unul sau mai multe dintre elementele din SELECT secțiune. Iată un SQL care sortează elevii după FullName în ordine descrescătoare. Ordinea de sortare implicită este crescătoare (ASC) dar pentru a sorta în ordinea opusă (descrescătoare) pe care o folosiți DESC.

SELECT studentID, FullName, sat_score
FROM student
ORDER BY FullName DESC;

NUMARA

COUNT va număra numărul de rânduri și va returna care se numără ca o coloană în setul de rezultate.

Iată exemple pentru ce ați folosi COUNT:

  • Numărarea tuturor rândurilor dintr-un tabel (nu este necesar un grup)
  • Numărarea totalelor subgrupurilor de date (necesită o secțiune Grupă după declarație)

Această instrucțiune SQL oferă un număr de toate rândurile. Rețineți că puteți da coloanei COUNT rezultate un nume folosind „AS”.

SELECT count(*) AS studentCount FROM student;

ȘTERGE

DELETE este folosit pentru a șterge o înregistrare dintr-un tabel.

Ai grija. Puteți șterge toate înregistrările din tabel sau doar câteva. Folosește WHERE condiție pentru a specifica ce înregistrări doriți să ștergeți. Sintaxa este:

DELETE FROM table_name
WHERE condition;

Iată un exemplu de ștergere din tabelul Persoană a înregistrării cu Id 3:

DELETE FROM Person
WHERE Id = 3;

INTERIOR ÎNSCRIEȚI-VĂ

JOIN, numit și Inner Join, selectează înregistrările care au valori potrivite în două tabele.

SELECT * FROM A x JOIN B y ON y.aId = x.Id

ÎNREGISTRARE STÂNGA

A LEFT JOIN returnează toate rândurile din tabelul din stânga și rândurile potrivite din tabelul din dreapta. Rândurile din tabelul din stânga vor fi returnate chiar dacă nu a existat nicio potrivire în tabelul din dreapta. Rândurile din tabelul din stânga fără potrivire în tabelul din dreapta vor avea null pentru valori de tabel corecte.

SELECT * FROM A x LEFT JOIN B y ON y.aId = x.Id

ÎNREGISTRARE DREPTĂ

A RIGHT JOIN returnează toate rândurile din tabelul din dreapta și rândurile potrivite din tabelul din stânga. În fața unei îmbinări la stânga, aceasta va returna toate rândurile din tabelul din dreapta chiar și acolo unde nu există nicio potrivire în tabelul din stânga. Rândurile din tabelul din dreapta care nu au nicio potrivire în tabelul din stânga vor avea null valori pentru coloanele din tabelul din stânga.

SELECT * FROM A x RIGHT JOIN B y ON y.aId = x.Id

ÎNREGISTRARE COMPLETĂ

A FULL OUTER JOIN returnează toate rândurile pentru care există o potrivire în oricare dintre tabele. Deci, dacă există rânduri în tabelul din stânga care nu au potriviri în tabelul din dreapta, acestea vor fi incluse. De asemenea, dacă există rânduri în tabelul din dreapta care nu au potriviri în tabelul din stânga, acestea vor fi incluse.

SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
FULL OUTER JOIN Orders
ON Customers.CustomerID=Orders.CustomerID
ORDER BY Customers.CustomerName

INTRODUCE

INSERT este o modalitate de a insera date într-un tabel.

INSERT INTO table_name (column_1, column_2, column_3) 
VALUES (value_1, 'value_2', value_3);

CA

LIKE este folosit într-un WHERE sau HAVING (ca parte a GROUP BY) pentru a limita rândurile selectate la elemente atunci când o coloană are un anumit tipar de caractere conținute în ea.

Acest SQL va selecta studenții care au FullName începând cu „Monique” sau terminând cu „Greene”.

SELECT studentID, FullName, sat_score, rcd_updated
FROM student 
WHERE 
    FullName LIKE 'Monique%' OR 
    FullName LIKE '%Greene'; 
+-----------+---------------+-----------+---------------------+
| studentID | FullName      | sat_score | rcd_updated         |
+-----------+---------------+-----------+---------------------+
|         1 | Monique Davis |       400 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene  |      1200 | 2017-08-16 15:34:50 |
+-----------+---------------+-----------+---------------------+
2 rows in set (0.00 sec)

Puteți plasa NOT inainte de LIKE pentru a exclude rândurile cu șirul în loc să le selectați. Acest SQL exclude înregistrările care conțin „cer Pau” și „Ted” în coloana FullName.

SELECT studentID, FullName, sat_score, rcd_updated
FROM student 
WHERE FullName NOT LIKE '%cer Pau%' AND FullName NOT LIKE '%"Ted"%';
+-----------+----------------------+-----------+---------------------+
| studentID | FullName             | sat_score | rcd_updated         |
+-----------+----------------------+-----------+---------------------+
|         1 | Monique Davis        |       400 | 2017-08-16 15:34:50 |
|         2 | Teri Gutierrez       |       800 | 2017-08-16 15:34:50 |
|         4 | Louis Ramsey         |      1200 | 2017-08-16 15:34:50 |
|         5 | Alvin Greene         |      1200 | 2017-08-16 15:34:50 |
|         6 | Sophie Freeman       |      1200 | 2017-08-16 15:34:50 |
|         8 | Donald D. Chamberlin |      2400 | 2017-08-16 15:35:33 |
|         9 | Raymond F. Boyce     |      2400 | 2017-08-16 15:35:33 |
+-----------+----------------------+-----------+---------------------+
7 rows in set (0.00 sec)