SQL Cheat Sheet: Snabbguide till viktiga kommandon

Som programmerare eller dataanalytiker kommer du ofta att arbeta med stora mängder data. Ett av de mest kraftfulla verktygen till ditt förfogande är SQL (Structured Query Language).

Detta SQL-fuskblad ger dig de vanligaste SQL-objekten och -kommandona, inklusive datatyper, DML- och DDL-satser, aggregerade funktioner, sträng- och datumfunktioner och underfrågor.

Den är utformad för att vara en snabb och praktisk referens som du kan nå när du interagerar med en relationsdatabas.

Om du är som oss och vill ladda ner och skriva ut eller lagra fuskbladet på din dator kan du ladda ner det nedan.

Innehållsförteckning

• SQL-datatyper
  • 1. Numeriska typer
  • 2. Datum- och tidstyper
  • 3. Strängtyper
• VÄLJ uttalande
• VAR Klausul
• BESTÄLL MED Klausul
• Sammanfoga flera tabeller i SQL
  • 1. INRE JOIN
  • 2. VÄNSTER JOIN
  • 3. RÄTT GÅ MED
  • 4. FULLKOMMEN
• SQL-aggregatfunktioner
  • 1. COUNT-funktion
  • 2. SUM-funktion
  • 3. AVG-funktion
  • 4. MAX-funktion
  • 5. MIN-funktion
• Vanliga strängfunktioner
• Vanliga numeriska funktioner
• Vanliga datumfunktioner
• GRUPPERA EFTER OCH HA
  • 1. Gruppera efter klausul
  • 2. Att ha klausul
  • Snabba tips
• Underfrågor
  • 1. IN-operatör
  • 2. FINNS Operatör
  • 3. NÅGON operatör
  • 4. ALLA Operatör
• Datamanipulation (DML)
  • 1. INFOGA uttalande
  • 2. UPPDATERING
  • 3. DELETE Statement
• Databashantering med DDL
  • 1. SKAPA uttalande
  • 2. ALTER-uttalande
    • LÄGG TILL EN NY KOLUMN
    • Ändra en kolumns datatyp
    • Släpp en kolumn
    • Lägg till en unik begränsning
    • Lägg till en främmande nyckel mellan tabeller
  • 3. DROP Statement
• Transaktioner
  • 1. BÖRJA
  • 2. ÅTAGANDE
  • 3. ÅTERVÄNDNING
• Slutgiltiga tankar

SQL-datatyper

Datatyperna för specifika databashanteringssystem (DBMS) kan variera (t.ex. Microsoft SQL Server vs MySQL ). Det finns dock flera som finns på de flesta system. Du kan dela upp dessa i tre kategorier:

1. Numerisk

2. Datum och tid

3. Sträng

1. Numeriska typer

Dessa är de vanligaste numeriska typerna:

• HELTAL : Ett heltal utan decimalkomma.

• SMALLINT : Ett mindre område av heltal

• BIGINT : Ett större antal heltal.

• DECIMAL(p, s) eller NUMERISK(p, s) : Till exempel skulle en decimal(5,2) passa 123,45.

• REAL : Ett flyttalstal, med en precision på minst 6 decimalsiffror.

• FLOAT(n) : Ett flyttalstal, med en precision på minst n siffror.

2. Datum- och tidstyper

• DATUM : Ett datumvärde, vanligtvis i formatet 'ÅÅÅÅ-MM-DD'.

• TID : Ett tidsvärde, vanligtvis i formatet 'TT:MM:SS'.

• DATETIME eller TIMESTAMP : En kombination av datum- och tidsvärden.

3. Strängtyper

• CHAR(n) : En sträng med fast längd med n tecken.

• VARCHAR(n) eller CHARACTER VARYING(n) : En sträng med variabel längd.

• TEXT : En sträng med variabel längd med en maximal längd som bestäms av DBMS.

VÄLJ uttalande

SELECT-satsen används för att hämta data från en eller flera tabeller. Du kan ange vilka kolumner du vill hämta och från vilken tabell. En grundläggande SELECT-sats ser ut så här:

SELECT column1, column2
FROM table;

För att hämta alla poster från kolumnerna 'name' och 'country_id' från 'city'-tabellen ser din SQL-fråga ut så här:

SELECT name, country_id
FROM city;

VAR Klausul

WHERE-satsen låter dig filtrera resultaten av en SELECT-sats baserat på specifika villkor.

SELECT column1, column2
FROM table
WHERE condition;

För att hämta poster från "stad"-tabellen där "befolkningen" är större än 1 000 000, ser din fråga ut så här:

SELECT name, population
FROM city
WHERE population > 1000000;

BESTÄLL MED Klausul

ORDER BY-satsen låter dig sortera resultaten av en SELECT-sats efter en eller flera kolumner. Du kan sortera resultaten i stigande (ASC) eller fallande (DESC) ordning:

SELECT column1, column2
FROM table
ORDER BY column1 ASC, column2 DESC;

Till exempel, för att hämta poster från "stad"-tabellen sorterade efter "population" i fallande ordning, ser din fråga ut så här:

SELECT name, population
FROM city
ORDER BY population DESC;

Sammanfoga flera tabeller i SQL

Det finns fyra vanliga joins i SQL:

1. INRE KOPPLING

2. VÄNSTER GÅ MED

3. HÖGER GÅ MED

4. FULL GÅ MED

1. INRE JOIN

En INNER JOIN hämtar poster som har matchande värden i båda tabellerna.

Låt oss ta ett exempel på en databas med artister och album, och du vill hitta alla artist- och albumkombinationer. Detta är INNER JOIN:

SELECT *
FROM artists AS a
INNER JOIN albums AS b
ON a.artist_id = b.artist_id;

Med en INNER JOIN kommer endast raderna med matchande värden i de angivna fälten att returneras i resultaten.

2. VÄNSTER JOIN

EN LEFT OUTER JOIN är också känd som en LEFT OUTER JOIN. Den returnerar alla poster från den vänstra tabellen och de matchade posterna från den högra tabellen. Om det inte finns någon matchning i den högra tabellen kommer resultatet att innehålla NULL-värden.

Till exempel, för att få en lista över alla artister och deras respektive album (om de har några), kan du använda en LEFT JOIN:

SELECT *
FROM artists AS a
LEFT JOIN albums AS b
ON a.artist_id = b.artist_id;

Den här frågan returnerar alla artister, även om de inte har några album kopplade till sig i albumtabellen.

3. RÄTT GÅ MED

EN RIGHT OUTER JOIN är också känd som en RIGHT OUTER JOIN. Den returnerar alla poster från den högra tabellen och de matchade posterna från den vänstra tabellen. Om det inte finns någon matchning i den vänstra tabellen kommer resultatet att innehålla NULL-värden.

Till exempel, för att få information om alla album och deras associerade artister (om de finns), skulle du använda en RIGHT JOIN:

SELECT *
FROM artists AS a
RIGHT JOIN albums AS b
ON a.artist_id = b.artist_id;

Den här frågan returnerar alla album, även om de inte har associerade artister i artisttabellen.

4. FULLKOMMEN

EN FULL JOIN är också känd som en FULL YTTRE JOIN. Den kombinerar resultaten av både LEFT och RIGHT joins. Med andra ord returnerar den alla rader från vänster och höger tabeller och fyller i de saknade värdena med NULLs när det inte finns någon matchning.

Här är ett exempel med hjälp av artist- och albumtabellerna:

SELECT *
FROM artists AS a
FULL JOIN albums AS b
ON a.artist_id = b.artist_id;

Denna fråga returnerar alla rader från båda tabellerna och fyller i NULLs där det inte finns någon matchning i någon av tabellen.

SQL-aggregatfunktioner

Aggregatfunktioner används för att beräkna ett enda resultat från en uppsättning indatavärden. De kallas "sammanlagda" eftersom de tar flera ingångar och returnerar en enda utdata. De vanligaste är:

1. RÄKNA

2. BELOPP

3. AVG

4. MAX

5. MIN

1. COUNT-funktion

Funktionen COUNT låter dig räkna antalet rader i ett frågeresultat. Du kan använda den här aggregatfunktionen för att bestämma det totala antalet poster i en tabell eller antalet poster som matchar specifika kriterier.

Här är ett exempel:

SELECT COUNT(*) FROM employees;

Denna fråga returnerar det totala antalet anställda i tabellen "anställda". Tänk på att om du lägger till en WHERE-sats kan du förfina dina resultat:

SELECT COUNT(*) FROM employees WHERE department = 'HR';

2. SUM-funktion

SUM-funktionen beräknar den totala summan av en numerisk kolumn. Det är användbart när du behöver beräkna det totala värdet av ett visst numeriskt fält. Till exempel returnerar den här frågan den totala summan av alla anställdas löner:

SELECT SUM(salary) FROM employees;

3. AVG-funktion

AVG-funktionen beräknar medelvärdet för en numerisk kolumn. Den här funktionen är användbar när du vill hitta medelvärdet för ett visst numeriskt fält. Till exempel returnerar den här frågan den genomsnittliga lönen för alla anställda:

SELECT AVG(salary) FROM employees;

4. MAX-funktion

MAX-funktionen hittar maxvärdet för en kolumn. Detta används ofta för att hitta det högsta värdet i ett numeriskt fält eller det senaste datumet i ett datetime-fält. Till exempel returnerar den här frågan den högsta lönen:

SELECT MAX(salary) FROM employees;

5. MIN-funktion

Slutligen hjälper MIN-funktionen dig att hitta minimivärdet för en kolumn. Till exempel returnerar den här frågan den lägsta lönen:

SELECT MIN(salary) FROM employees;

Kom ihåg att du kan använda WHERE-satser i dessa frågor och JOIN med flera tabeller.

Vanliga strängfunktioner

Här är de vanligaste strängfunktionerna som finns i de flesta SQL-dialekter (den exakta syntaxen kan variera):

1. LEN eller LENGTH(sträng) : Returnerar längden på en sträng.

2. UPPER(sträng) : Konverterar en sträng till versaler.

3. LOWER(string) : Konverterar en sträng till gemener.

4. SUBSTR eller SUBSTRING(sträng, start, längd) : Extraherar en del från en sträng.

5. TRIM(sträng) : Tar bort inledande och efterföljande mellanslag från en sträng.

6. LTRIM(sträng) : Tar bort inledande mellanslag från en sträng.

7. RTRIM(sträng) : Tar bort mellanslag från en sträng.

Vanliga numeriska funktioner

Här är de vanligaste numeriska funktionerna som finns i de flesta SQL-dialekter (den exakta syntaxen kan variera):

1. ABS(tal) : Returnerar det absoluta värdet av ett tal.

2. ROUND(tal; decimaler) : Avrundar ett tal till ett visst antal decimaler.

3. FLOOR(tal) : Avrundar talet nedåt till närmaste heltal.

4. CEIL eller CEILING(tal) : Avrundar talet uppåt till närmaste heltal.

5. RAND() : Returnerar ett slumpmässigt flytvärde från 0 till 1.

6. MOD(n, m) : Returnerar resten av n dividerat med m.

7. POWER(bas, exponent) : Höjer ett tal till potensen av ett annat tal.

8. LOG(tal) : Returnerar den naturliga logaritmen för ett tal.

Vanliga datumfunktioner

Här är de vanligaste datumfunktionerna som finns i de flesta SQL-dialekter (den exakta syntaxen kan variera):

1. NOW() : Returnerar aktuellt datum och tid.

2. DATE(datetime) : Extraherar datumdelen av ett datum- eller datetime-uttryck.

3. TIME(datetime) : Extraherar tidsdelen av ett datum- eller datetime-uttryck.

4. YEAR(date) : Returnerar årsdelen.

5. MONTH(date) : Returnerar månadsdelen.

6. DAY(datum): Returnerar delen av dagen i månaden.

7. HOUR(tid) : Returnerar timdelen från en tid.

8. MINUTE(tid) : Returnerar minutdelen från en tid.

9. SEKUND(tid): Returnerar den andra delen från en tid.

GRUPPERA EFTER OCH HA

When working with SQL queries, you may want to further summarize and filter your aggregated data. The GROUP BY and HAVING clauses provide this functionality.

1. Group By Clause

The GROUP BY clause allows you to group rows that share the same values in specified columns. It is commonly used with aggregate functions. This is the syntax:

SELECT column1, column2, aggregate_function(column3)
FROM table_name
WHERE condition
GROUP BY column1, column2;

For example, if you want to calculate the total sales amount for each product category, this is the query:

SELECT product_category, SUM(sales_amount)
FROM sales_data
GROUP BY product_category;

TIP: Combining GROUP BY and COUNT is a good way of finding duplicate values.

2. Having Clause

If you want to filter the aggregated results further, you can use the HAVING clause. The syntax is:

SELECT column1, column2, aggregate_function(column3)
FROM table_name
WHERE condition
GROUP BY column1, column2
HAVING condition;

If you want to find product categories with total sales of more than $1,000,000, you would write:

SELECT product_category, SUM(sales_amount)
FROM sales_data
GROUP BY product_category
HAVING SUM(sales_amount) > 1000000;

Quick Tips

• Always use the GROUP BY clause before the HAVING clause.

• The SELECT statement can only contain specified column names, aggregate functions, constants, and expressions.

• When using the HAVING clause, filter conditions should be applied to the aggregate functions rather than directly to the grouped columns.

By understanding and properly applying the GROUP BY and HAVING clauses, you can better organize and analyze your data using SQL.

Subqueries

A subquery is also known as an inner or nested query. This is a query embedded within another SQL statement (such as a SELECT statement) or even inside another subquery.

Subqueries allow you to retrieve data based on the output of another query. The most common operators used with subqueries are:

1. IN

2. EXISTS

3. ANY

4. ALL

1. IN Operator

The IN operator tests if a value is within a set of values generated by the inner query. The syntax for using the IN operator with a subquery is as follows:

SELECT column_name(s)
FROM table_name
WHERE column_name IN (SELECT column_name FROM other_table);

This returns rows from the outer query where the specified column value matches any of the values provided by the subquery.

Suppose you have an employee table and a departments table. You want to find employees who work in departments based at the head office. Here is a sample query

SELECT first_name, last_name
FROM employee
WHERE department IN (SELECT department FROM departments
                     WHERE location = "HQ");

For a more in-depth look, check out our article on the syntax.

2. EXISTS Operator

The EXISTS operator checks if there is at least one row resulting from the subquery. You can use the EXISTS operator to filter rows based on the existence of related data in another table. This is the syntax:

SELECT column_name(s)
FROM table_name
WHERE EXISTS (SELECT column_name FROM other_table WHERE condition);

When the subquery returns at least one row, the EXISTS operator returns true, and the relevant rows from the outer query are included in the result.

3. ANY Operator

The ANY operator is used to compare a value to any value in a set of values provided by a subquery. It’s commonly used with comparison operators like =, <, >, <=, or >=.

This is the syntax:

SELECT column_name(s)
FROM table_name
WHERE column_name operator ANY (SELECT column_name FROM other_table WHERE condition);

This will return rows from the outer query where the specified column value meets the condition against any value from the subquery.

4. ALL Operator

The ALL operator compares a value to all values within a set of values provided by a subquery. The conditions must be true for every value in the subquery’s result. This is the syntax:

SELECT column_name(s)
FROM table_name
WHERE column_name operator ALL (SELECT column_name FROM other_table WHERE condition);

This returns rows from the outer query only if the specified column value satisfies the condition against all values in the subquery’s output.

Data Manipulation (DML)

Data Manipulation Language (DML) is a sub-language within SQL for managing and updating data. The most common statements are:

1. INSERT

2. UPDATE

3. DELETE

1. INSERT Statement

The INSERT statement allows you to insert rows into a table. Here’s the basic syntax:

INSERT INTO table_name (column1, column2, column3, ...)
VALUES (value1, value2, value3, ...);

For example, if you want to insert a new row into a ‘users’ table with columns ‘id’, ‘name’, and ’email’, you would use the following query:

INSERT INTO users (id, name, email)
VALUES (1, 'John Doe', '[email protected]');

2. UPDATE Statement

The UPDATE statement allows you to modify existing row data in a table. This is the syntax:

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

For example, if you want to update the email address of a user with the id ‘1’ in the ‘users’ table, your query would look like this:

UPDATE users
SET email = '[email protected]'
WHERE id = 1;

TIP: remember to include a WHERE clause to avoid updating all rows in the table by mistake.

3. DELETE Statement

The DELETE statement allows you to remove rows from a table. Here’s the syntax:

DELETE FROM table_name
WHERE condition;

Om du till exempel vill ta bort en användare med id '1' från tabellen 'användare', skulle din fråga se ut så här:

DELETE FROM users
WHERE id = 1;

TIPS : inkludera alltid en WHERE-sats för att specificera vilka rader som ska tas bort och för att undvika att radera alla rader i tabellen.

Databashantering med DDL

Data Definition Language (DDL) är det SQL-underspråk som används för att skapa och ändra tabeller och själva databasen. De vanligaste DDL-satserna är:

1. SKAPA

2. ÄNDRA

3. SLÄPPA

1. SKAPA uttalande

CREATE-satsen låter dig skapa nya databasobjekt, till exempel nya tabeller, vyer eller index. När du skapar en ny tabell måste du definiera kolumnerna, deras datatyper och eventuella begränsningar.

Här är ett exempel på hur du skapar en ordertabell:

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    product VARCHAR(255) NOT NULL,
    customer_id INT NOT NULL
);

TIPS: välj lämpliga datatyper och begränsningar för att säkerställa dataintegriteten i dina tabeller.

För en mer detaljerad titt, kolla in vår artikel om .

2. ALTER-uttalande

ALTER-satsen hjälper dig att ändra befintliga databasobjekt. Vanliga användningsområden inkluderar:

• lägga till, ändra eller ta bort kolumner.

• lägga till eller ta bort begränsningar från en befintlig tabell.

• lägga till primära och främmande nycklar.

LÄGG TILL EN NY KOLUMN

ALTER TABLE users ADD COLUMN age INTEGER;

Ändra en kolumns datatyp

ALTER TABLE users ALTER COLUMN age TYPE FLOAT;

Släpp en kolumn

ALTER TABLE users DROP COLUMN age;

Lägg till en unik begränsning

ALTER TABLE users ADD CONSTRAINT users_email_unique UNIQUE(email);

Lägg till en främmande nyckel mellan tabeller

ALTER TABLE users ADD FOREIGN KEY (country_id) REFERENCES Country(country_id);

3. DROP Statement

Med DROP-satsen kan du ta bort databasobjekt som tabeller, vyer eller index. Använd den med försiktighet, eftersom den kommer att radera det angivna objektet och alla dess data permanent.

Här är ett exempel:

DROP TABLE users;

TIPS : Se till att du har ordentliga säkerhetskopior på plats innan du kör en DROP-sats.

Om du vill lära dig mer om datamodellering, kolla in den här videon:

Transaktioner

Transaktioner spelar en avgörande roll för att upprätthålla databasens integritet , särskilt när flera relaterade operationer utförs samtidigt. Det finns tre grundläggande operationer för att hantera transaktioner:

1. BÖRJA

2. BEGÅ

3. RULLA TILLBAKA

1. BÖRJA

BEGIN-satsen anger början på en transaktion. När du kör det här kommandot skapar du en startpunkt för din uppsättning SQL-satser.

BEGIN;

2. ÅTAGANDE

För att slutföra dina ändringar och behålla dem i databasen, använd COMMIT-satsen. Detta säkerställer att alla operationer inom transaktionen utförs framgångsrikt och permanent.

COMMIT;

Här är ett exempel på en fullständig transaktion med det klassiska exemplet på att överföra pengar mellan konton:

BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;
COMMIT;

3. ÅTERVÄNDNING

När man arbetar med transaktioner är det också viktigt att veta hur man ångrar ändringar när ett fel uppstår. ROLLBACK-satsen återställer alla ändringar som gjorts sedan transaktionens början:

ROLLBACK;

Här är ett exempel på en transaktion med felhantering med ROLLBACK:

BEGIN;
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;
IF @@ERROR <> 0
    ROLLBACK;
ELSE
    COMMIT;

Slutgiltiga tankar

Som du har sett i det här SQL-fuskbladet erbjuder SQL en mängd kommandon och funktioner som låter dig skapa, manipulera och fråga data i en relationsdatabas.

Från de grundläggande kommandona som SELECT, INSERT, UPDATE och DELETE, till de mer komplexa konstruktionerna som JOINs och subqueries, till de aggregerade funktionerna vi har täckt, ger SQL flexibiliteten att hantera ett brett utbud av datauppgifter.

Fortsätt komma tillbaka till detta fuskblad för att snabba upp din !