Pagrindinės SQL komandos - duomenų bazių užklausų ir teiginių, kuriuos turėtumėte žinoti, sąrašas
SQL reiškia struktūrinę užklausų kalbą. SQL komandos yra instrukcijos, naudojamos bendrauti su duomenų baze, kad būtų atliekamos užduotys, funkcijos ir užklausos su duomenimis.
SQL komandos gali būti naudojamos paieškai duomenų bazėje ir kitoms funkcijoms atlikti, pvz., Lentelių kūrimui, duomenų pridėjimui prie lentelių, duomenų modifikavimui ir lentelių numetimui.
Čia pateikiamas pagrindinių SQL komandų (kartais vadinamų klausimais) sąrašas, kurį turėtumėte žinoti, jei ketinate dirbti su SQL.
PASIRINKITE ir IŠ
SELECT
Iš užklausą dalis nustato, kokius stulpelius duomenų parodyti rezultatus. Taip pat yra parinkčių, kurias galite naudoti rodydami duomenis, kurie nėra lentelės stulpeliai.
Toliau rodo pavyzdys trys stulpeliai SELECT
ed FROM
į "studentas" lentelę ir vieną apskaičiuotą stulpelį. Duomenų bazėje saugomi studento ID, vardas ir pavardė. Mes galime sujungti stulpelius „Vardas“ ir „Pavardė“, kad sukurtume „FullName“ apskaičiuotą stulpelį.
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)
SUKURTI LENTEL.
CREATE TABLE
daro tik tai, kaip skamba: duomenų bazėje sukuria lentelę. Galite nurodyti lentelės pavadinimą ir stulpelius, kurie turėtų būti lentelėje.
CREATE TABLE table_name ( column_1 datatype, column_2 datatype, column_3 datatype );
KEITIMO LENTELĖ
ALTER TABLE
keičia lentelės struktūrą. Štai kaip jūs pridėtumėte stulpelį prie duomenų bazės:
ALTER TABLE table_name ADD column_name datatype;
PATIKRINTI
CHECK
Apribojimas yra naudojamos siekiant apriboti vertės intervalą, kuris gali būti dedamas į kolonėlę.
Jei apibrėžiate CHECK
vieno stulpelio apribojimą, šiam stulpeliui leidžiama naudoti tik tam tikras vertes. Jei CHECK
lentelėje apibrėžiate apribojimą, tai gali apriboti tam tikrų stulpelių vertes pagal kitų eilutės stulpelių vertes.
Ši SQL sukuria CHECK
apribojimą stulpelyje „Amžius“, kai sukuriama lentelė „Asmenys“. Į CHECK
apribojimas užtikrina, kad jūs negalite turėti bet kuris jaunesnis nei 18 metų asmuo.
CREATE TABLE Persons ( ID int NOT NULL, LastName varchar(255) NOT NULL, FirstName varchar(255), Age int, CHECK (Age>=18) );
Norėdami leisti įvesti CHECK
apribojimą ir apibrėžti CHECK
apribojimą keliuose stulpeliuose, naudokite šią SQL sintaksę:
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") );
KUR
(AND
,OR
, IN
, BETWEEN
, Ir LIKE
)
WHERE
Sąlyga yra naudojamas apriboti eilučių grąžinti skaičių.
Pavyzdžiui, pirmą kartą mes parodysime jums SELECT
pareiškimą ir rezultatus , be tam WHERE
ataskaitoje. Tada pridėsime WHERE
teiginį, kuriame naudojami visi penki aukščiau nurodyti kvalifikaciniai etapai.
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)
Dabar pakartosime SELECT
užklausą, bet mes apribosime eilučių grąžinimą naudodami WHERE
teiginį.
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)
ATNAUJINTI
Norėdami atnaujinti įrašą lentelėje, naudokite UPDATE
teiginį.
Naudodami WHERE
sąlygą nurodykite, kuriuos įrašus norite atnaujinti. Vienu metu galima atnaujinti vieną ar daugiau stulpelių. Sintaksė yra:
UPDATE table_name SET column1 = value1, column2 = value2, ... WHERE condition;
Čia pateikiamas įrašo pavadinimo atnaujinimo ID 4 pavyzdys:
UPDATE Person SET Name = “Elton John” WHERE Id = 4;
Taip pat galite atnaujinti lentelės stulpelius naudodami kitų lentelių reikšmes. Norėdami JOIN
gauti duomenis iš kelių lentelių, naudokite sąlygą. Sintaksė yra:
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
Štai visų įrašų tvarkytuvės atnaujinimo pavyzdys:
UPDATE Person SET Person.Manager = Department.Manager FROM Person JOIN Department ON Person.DepartmentID = Department.ID
GRUPUOTI PAGAL
GROUP BY
leidžia sujungti eiles ir kaupti duomenis.
Čia yra sintaksė GROUP BY
:
SELECT column_name, COUNT(*) FROM table_name GROUP BY column_name;
TURI
HAVING
leidžia filtruoti duomenis, kaupiamus pagal GROUP BY
sąlygą, kad vartotojas gautų ribotą įrašų rinkinį.
Čia yra sintaksė HAVING
:
SELECT column_name, COUNT(*) FROM table_name GROUP BY column_name HAVING COUNT(*) > value;
AVG ()
„Vidutinis“ naudojamas skaičiuojant stulpelio vidurkį iš eilučių rinkinio, kurį grąžina SQL sakinys.
Čia yra funkcijos naudojimo sintaksė:
SELECT groupingField, AVG(num_field) FROM table1 GROUP BY groupingField
Štai pavyzdys naudojant studentų lentelę:
SELECT studentID, FullName, AVG(sat_score) FROM student GROUP BY studentID, FullName;
AS
AS
leidžia pervadinti stulpelį ar lentelę, naudojant slapyvardį.
SELECT user_only_num1 AS AgeOfServer, (user_only_num1 - warranty_period) AS NonWarrantyPeriod FROM server_table
Dėl to gaunama tokia produkcija, kaip nurodyta toliau.
+-------------+------------------------+ | AgeOfServer | NonWarrantyPeriod | +-------------+------------------------+ | 36 | 24 | | 24 | 12 | | 61 | 49 | | 12 | 0 | | 6 | -6 | | 0 | -12 | | 36 | 24 | | 36 | 24 | | 24 | 12 | +-------------+------------------------+
Taip pat galite naudoti AS, norėdami priskirti vardą lentelei, kad būtų lengviau remtis prisijungiant.
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
Dėl to gaunama tokia produkcija, kaip nurodyta toliau.
+-------------+------------+-----------+-----------------+--------------+ | 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 | +-------------+------------+-----------+-----------------+--------------+
RŪŠIUOTI PAGAL
ORDER BY
gives us a way to sort the result set by one or more of the items in the SELECT
section. Here is an SQL sorting the students by FullName in descending order. The default sort order is ascending (ASC
) but to sort in the opposite order (descending) you use DESC
.
SELECT studentID, FullName, sat_score FROM student ORDER BY FullName DESC;
COUNT
COUNT
will count the number of rows and return that count as a column in the result set.
Here are examples of what you would use COUNT for:
- Counting all rows in a table (no group by required)
- Counting the totals of subsets of data (requires a Group By section of the statement)
This SQL statement provides a count of all rows. Note that you can give the resulting COUNT column a name using “AS”.
SELECT count(*) AS studentCount FROM student;
DELETE
DELETE
is used to delete a record in a table.
Be careful. You can delete all records of the table or just a few. Use the WHERE
condition to specify which records you want to delete. The syntax is:
DELETE FROM table_name WHERE condition;
Here is an example deleting from the table Person the record with Id 3:
DELETE FROM Person WHERE Id = 3;
INNER JOIN
JOIN
, also called Inner Join, selects records that have matching values in two tables.
SELECT * FROM A x JOIN B y ON y.aId = x.Id
LEFT JOIN
A LEFT JOIN
returns all rows from the left table, and the matched rows from the right table. Rows in the left table will be returned even if there was no match in the right table. The rows from the left table with no match in the right table will have null
for right table values.
SELECT * FROM A x LEFT JOIN B y ON y.aId = x.Id
RIGHT JOIN
A RIGHT JOIN
returns all rows from the right table, and the matched rows from the left table. Opposite of a left join, this will return all rows from the right table even where there is no match in the left table. Rows in the right table that have no match in the left table will have null
values for left table columns.
SELECT * FROM A x RIGHT JOIN B y ON y.aId = x.Id
FULL OUTER JOIN
A FULL OUTER JOIN
returns all rows for which there is a match in either of the tables. So if there are rows in the left table that do not have matches in the right table, those will be included. Also, if there are rows in the right table that do not have matches in the left table, those will be included.
SELECT Customers.CustomerName, Orders.OrderID FROM Customers FULL OUTER JOIN Orders ON Customers.CustomerID=Orders.CustomerID ORDER BY Customers.CustomerName
INSERT
INSERT
is a way to insert data into a table.
INSERT INTO table_name (column_1, column_2, column_3) VALUES (value_1, 'value_2', value_3);
LIKE
LIKE
yra naudojamas WHERE
arba HAVING
(kaip dalis GROUP BY
) apriboti pasirinktas eilutes iki elementų, kai stulpelyje yra tam tikras rašmenų modelis.
Ši SQL parinks studentus, FullName
prasidedančius raide „Monique“ arba baigiančius „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)
Jūs galite įdėti NOT
anksčiau, LIKE
kad neįtrauktumėte eilučių su eilutės modeliu, užuot jas pasirinkę. Ši SQL neįtraukia įrašų, kuriuose stulpelyje „FullName“ yra „cer Pau“ ir „Ted“.
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)