# Databaser

* Modellering
* Tabeller
* Relationer
* Normalisering
* Specifika databassystem
  * SQLite
  * MySQL


# Modellering

Att modellera en databas betyder att man bestämmer vilken data den ska innehålla och hur den datan ska organiseras.

Modellering sker generellt i tre steg – men stegen flyter ofta ihop:

* **Konceptuell modellering.** Man går från idé till en struktur, och bestämmer vilka koncept som ska vara med.
* **Logisk modellering.** Man tar strukturen och anpassar den efter en specifik databasmodell – oftast relationsmodellen.
* **Fysisk modellering.** Man tar den anpassade datastrukturen och skapar den i det faktiska databassystem som man ska använda, t.ex. MySQL eller SQLite.

Den konceptuella modelleringen följer normalt stegen nedan – man börjar med en beskrivning, en "story" som förklarar det system man ska modellera. Därifrån försöker man hitta alla objekt, alla relationer och alla egenskaper som ska modelleras, och hur de hänger ihop.

Ofta beskriver man allt detta i ett [ER-diagram](/modellering/er-diagram).

Den logiska modelleringen för relationsdatabaser handlar generellt om att [normalisera](/normalisering) modellen och eventuellt lägger till nycklar. Ofta sker det i samband med att man skapar databasens [tabeller](/tabeller).

## Beskrivning

Generellt börjar man med ett case; en beskrivning av det system som ska byggas och där databasen ska lagra informationen.

> **Exempel:** En hemsida för filmrecensioner. Användare kan registrera sig och logga in. Inloggade användare kan skriva recensioner och skriva kommentarer på andras recensioner. De kan också trycka "tumme upp" på andras kommentarer.
>
> Både inloggade och icke inloggade kan läsa recensioner.
>
> Det finns två grupper av användare; vanliga och admins. Admins kan ta bort andra användares recensioner/kommentarer, göra användare till admins, och lägga till nya filmer.

Beskrivningen bör vara så komplett och tydlig som möjligt, men det händer ofta att man senare upptäcker att den behöver kompletteras.

## Objekt eller entiteter

Vilka *saker* ska databasen hålla reda på? Leta i beskrivningen och försök hitta alla konkreta objekt eller entiteter. Gör en lista.

> **Exempel:** Användare, grupper, recensioner, kommentarer, filmer.

## Relationer

Hur hänger entiteterna ihop? Leta återigen i beskrivningen efter ledtrådar.

> **Exempel:** Användare och grupper har en relation: en grupp innehåller användare, användare ingår i grupper.
>
> Användare och kommentarer har en relation: varje kommentar är skriven av en användare, varje användare kan ha skrivit många kommentarer.

Det finns tre kategorier av relationer:

* **En-till-en (1:1):** Sällsynt, finns inte i recensions-hemsideexemplet. Men man kan t.ex. tänka sig en databas över anställda och kontorsrum, där varje person bara har ett rum och varje rum bara innehåller en person. Skrivs ibland som "1-1".
* **En-till-många (1:N):** Vanligast. Varje recension hör ihop med en film, men varje film kan ha många recensioner.
* **Många-till-många (N:M):** Varje kommentar kan få tumme upp från flera olika användare, och varje användare kan ge tumme upp till flera olika kommentarer.

## Egenskaper

Vilka egenskaper hos varje objekt ska databasen hålla reda på?&#x20;

> **Exempel:** en användares för- och efternamn, mailadress och lösenord. En films titel och synopsis.


# ER-diagram

ER står för "entity-relationship" och ER-diagram beskriver just objekt (eller *entiteter*) och vilka relationer de har.

Nedan används "kråkfots-notation" för att rita diagrammen. Notationerna bestämmer helt enkelt hur saker ritas och vilka symboler som används. Kråkfotsnotation är den vanligaste, och har fått sitt namn utifrån hur relationerna ritas – det kan se ut lite som kråkfötter.

## Entitet

Varje "sak" som ska lagras i databasen ritas som en rektangel. Varje rektangel ges ett namn.

{% @mermaid/diagram content="erDiagram
User
Group
Movie
Comment" %}

## Egenskap

Egenskaper skrivs inuti rektanglarna, under rektangeln. Ofta skriver man också vilken sorts information det rör sig om, t.ex. int för integer eller heltal, string för texter, date för datum etc.

{% @mermaid/diagram content="erDiagram
User {
string name
string surname
string email
}
Group {
string name
}
Movie {
string name
string description
}
Comment {
string text
}" %}

## Relation

Varje relation mellan två objekt ritas som ett streck. I mitten av strecket skriver man något som beskriver vad relationen är för något, och i ändarna ritar man symboler som visar dels vilken **typ** av relation det är (1:1, 1:N, N:M) och dels huruvida respektive entitet är **obligatorisk**.

*Typen* visas med en symbol närmast respektive entitet. Det finns två symboler – ett rakt streck ( | ) betyder "en", ett böjt eller vinklat ( > ) betyder "flera". Så om båda sidor har ett | så är relationen en 1:1-relation, om den har | på ena sidan och > på den andra så är det en 1:N-relation.

Huruvida entiteten är *obligatorisk* visas genom ett tecken längre ut på strecket. Det är antingen ett rakt streck ( | ) eller en cirkel ( o ).

I exemplet nedan så har alltså User och Group en relation.

* Relationen är en 1:N-relation, där varje användare bara har en grupp men där varje grupp kan innehålla flera användare.
* Varje användare måste ha en grupp, men det kan finnas grupper som inte har några användare.

{% @mermaid/diagram content="erDiagram
User {
string name
string surname
string email
}
Group {
string name
}

User}o--||Group : has" %}

## Mer komplett exempel

{% @mermaid/diagram content="erDiagram
User {
string name
string surname
string email
}
Group {
string name
}
Movie {
string name
string description
}
Review {
string text
int score
date created\_date
}

User }o--|| Group : Has
User ||--o{ Review : Wrote
Review }o--|| Movie : "Is about"
" %}


# Tabeller

En tabell är ett tvådimensionellt rutnät av celler. Den har *rader* och *kolumner*.

Normalt sett innehåller varje tabell **en sorts saker/entiteter**. Användare, kommentarer, filmer, highscores etc.

När man gör om ett ER-diagram till en databas…

* **Rektanglarna (entiteterna)** blir *tabeller*.
* **Egenskaperna** blir *kolumner*.
* **Relationerna** blir kolumner *eller* nya tabeller.
  * **1:1 och 1:N-relationer** blir kolumner med hänvisningar till andra tabeller.
  * **N:M-relationer** blir nya tabeller, med kolumner som har hänvisningar till två (eller flera?) tabeller.

Databasens struktur i ett databassystem, alltså vilka tabeller som finns och hur de är uppbyggda, kallas också för databasens **schema**.

## Rad/post

Varje rad i tabellen motsvarar **en sak/entitet** – en person, en kommentar, en film, ett highscore etc. De kallas också *poster*. Varje post innehåller en eller flera *attribut*.

## Kolumn/attribut

Varje kolumn i en databastabell motsvarar **en specifik egenskap** hos saken. De kallas också *attribut*.

Exempel på kolumner kan vara "username", "password" eller "description".

## Celler/värden

Där en rad och en kolumn möts ligger en cell – **ett specifikt värde** som en sak/entitet har i ett specifikt attribut. Exempel på värden kan vara "1", "micke" eller "Jupiter Ascending".

## Primärnyckel

En primärnnyckel är en kolumn eller kombination av kolumner som gör posten **unik**. I de flesta fall används en särskild "id"-kolumn som primärnyckel.

* Ingen rad får ha en tom primärnyckel.
* Två rader får inte ha samma primärnyckel.

Ofta markeras primärnyckel-kolumnen genom en lite nyckelsymbol, när en tabell visas grafiskt.

<table><thead><tr><th width="94.33333333333331">id🔑</th><th width="159">username</th><th>password</th></tr></thead><tbody><tr><td>1</td><td>micke</td><td>12345</td></tr><tr><td>2</td><td>karim</td><td>hello1</td></tr><tr><td>3</td><td>liv</td><td>PenguinHotdogBonanza</td></tr></tbody></table>

### Kandidatnyckel

En kandidatnyckel är en *potentiell primärnyckel*.

I tabellen med användare finns följande kandidatnycklar:

* id
* username
* id+username
* id+password
* username+password
* id+username+password

Varje användare måste (kan man anta) ha ett unikt namn, men flera användare kan ha samma lösenord – därför kan lösenord i sig inte vara en kandidatnyckel.

### Alternativ nyckel

Alla kandidatnycklar som inte är primärnyckeln kallas alternativa nycklar.

## Främmande nyckel

En främmande nyckel är en kolumn i vilken man fyller i primärnyckeln från en annan tabell. Det är på det viset man skapar *relationer* av typen 1:N i en relationell databas.

<table><thead><tr><th width="86">id🔑</th><th>comment</th><th>user_id</th></tr></thead><tbody><tr><td>1</td><td>Hej</td><td>1</td></tr><tr><td>2</td><td>Hej själv!</td><td>2</td></tr><tr><td>3</td><td>Vad händer?</td><td>2</td></tr></tbody></table>

Istället för att innehålla användarens namn både i användar-tabellen och i kommentars-tabellen så lägger man in ett id – där man kan se att användare 1 ("micke") skrivit första kommentaren och användare 2 ("karim") skrivit de nästkommande två.

## N:M-Relationer

1:N-relationer är enkla att skapa i tabellform – om en användare ska kunna skriva flera kommentarer, så behövs en tabell för användare och en för kommentarer. Eftersom varje kommentar bara kan skrivas av en användare är det lämpligast att lägga in en främmande nyckel i kommentars-tabellen som hänvisar till användare i användar-tabellen.

N:M är klurigare. Generellt bygger man en "mellan-tabell":

<table><thead><tr><th width="88">id🔑</th><th>club_name</th></tr></thead><tbody><tr><td>1</td><td>Hellhawkz</td></tr><tr><td>2</td><td>Everybody Loves Jazz</td></tr><tr><td>3</td><td>The 123s</td></tr></tbody></table>

<table><thead><tr><th width="88.33333333333331">id🔑</th><th>user_id</th><th>club_id</th></tr></thead><tbody><tr><td>1</td><td>1</td><td>1</td></tr><tr><td>2</td><td>1</td><td>2</td></tr><tr><td>3</td><td>2</td><td>2</td></tr></tbody></table>

Här är en tabell för klubbar. Varje användare kan vara med i flera klubbar och varje klubb kan ha flera användare. Då skapar man en tredje tabell som bara innehåller *den relationen*. Den har en primärnyckel samt två främmande nycklar – en som hänvisar till primärycklar i användartabellen och en som hänvisar på samma sätt till klubbtabellen.

Eventuellt skulle man här också kunna säga andra saker om relationen – t.ex. när användaren gick med.

För att undvika risken för duplicering av relationer skulle man också kunna ta bort id-kolumnen och göra kombinationen av user\_id och club\_id till primärnyckel.


# Normalisering\*

Att normalisera en relationsdatabas betyder att man justerar strukturen på sin data så att den följer vissa regler. De reglerna samlas i s.k. *normalformer*.

Syftet med normaliseringen är att undvika extraarbete i framtiden. Man vill inte att samma data ska finnas på flera olika ställen om det inte är absolut nödvändigt, och man vill att det ska vara hyfsat enkelt att bygga ut databasen senare.

Ett vanligt knep för att komma ihåg de tre normalformerna är att varje attribut som inte är en (primär)nyckel ska hänvisa till *nyckeln, hela nyckeln och ingenting annat än nyckeln*. Det är såklart en referens till den amerikanska eden där man svär att säga "the truth, the whole truth, and nothing but the truth".

Man normaliserar ofta i samband med att man omvandlar ett [ER-diagram](/modellering/er-diagram) till en [tabell](/tabeller).

## Första normalformen (1NF): Nyckeln

1NF säger att tabellen ska ha en [primärnyckel](/tabeller#primaernyckel), alltså en kolumn vars innehåll är unikt. Man kan tänka på det som att primärnyckeln ger varje rad/post en unik identitet.

1NF säger också att alla andra kolumner ska beskriva attribut som hänger ihop med nyckeln – och att varje kolumn bara ska innebära ett attributvärde.

* Det finns en primärnyckel
* Alla andra kolumner innehåller data som är kopplade till nyckeln
* (Bara att värde per kolumn)

## Andra normalformen (2NF): Hela nyckeln

2NF säger att kolumnerna som inte är del av primärnyckeln inte ska vara beroende av bara någon del av primärnyckeln, utan *hela*.

Det här kan alltså bara hända om man har en primärnyckel som består av flera kolumner/attribut. Håller man sig till primärnycklar som bara består av en kolumn så uppnår man 2NF automatiskt.

* 1NF plus…
* Alla kolumner som inte ingår i primärnyckeln innehåller bara data som är kopplade till *hela* primärnyckeln.

## Tredje normalformen (3NF): Ingenting annat än nyckeln

3NF säger att kolumnerna som inte är en del av primärnyckeln inte ska vara beroende av något annat än primärnyckeln. Ingen av kolumnerna ska alltså ha ett innehåll som beror på en annan icke-primärnyckel-kolumn.

* 2NF plus…
* Alla kolumner som inte ingår i primärnyckeln innehåller bara data som *bara* är kopplade till primärnyckeln

Ett enkelt sätt att tänka på 3NF är att man ser till att varje tabell bara innehåller information om *en kategori av saker*. Att varje post, varje rad, innehåller information om *en sak*.

Om man har en tabell med meddelanden som skickats, och bara behöver spara namnen på avsändare och mottagare, så funkar det. Men om man också vill hålla reda på personernas inloggningsuppgifter så bör man ha en separat tabell för *användare*. Och sedan använda kolumner med [främmande nycklar](/tabeller#fraemmande-nyckel).

## Dåliga exempel

Nedan finns exempel som bryter mot de olika normalformerna.

### 1NF

Den första regeln innebär att man till exempel aldrig gör tabeller som ser ut såhär:

<table><thead><tr><th width="94.33333333333331">id🔑</th><th width="159">username</th><th>comments</th></tr></thead><tbody><tr><td>1</td><td>micke</td><td>1,5</td></tr><tr><td>2</td><td>karim</td><td>2,3,4</td></tr><tr><td>3</td><td>liv</td><td>6,7</td></tr></tbody></table>

<table><thead><tr><th width="93.33333333333331">id🔑</th><th>comment</th></tr></thead><tbody><tr><td>1</td><td>Hej</td></tr><tr><td>2</td><td>Hej själv!</td></tr><tr><td>3</td><td>Vad händer?</td></tr></tbody></table>

I det fallet är ju relationen mellan en användare och en kommentar 1:N, det vill säga varje användare kan ha skrivit flera kommentarer men varje kommentar är bara skriven av en användare. Då är det enkelt att istället lagra upphovspersonens id i kommentarstabellen:

<table><thead><tr><th width="94.33333333333331">id🔑</th><th>comment</th><th>userid</th></tr></thead><tbody><tr><td>1</td><td>Hej</td><td>1</td></tr><tr><td>2</td><td>Hej själv!</td><td>2</td></tr><tr><td>3</td><td>Vad händer?</td><td>2</td></tr></tbody></table>

### 2NF

(Kommer…)

### 3NF

Nedanstående tabell följer inte 3NF, eftersom user\_name och user\_id beror på – hänger ihop med – varandra. Istället borde man ha en separat kolumn för användare.

<table><thead><tr><th width="95">id🔑</th><th width="363">comment_text</th><th width="106">user_id</th><th>user_name</th></tr></thead><tbody><tr><td>1</td><td>Hej</td><td>1</td><td>micke</td></tr><tr><td>2</td><td>Hej själv!</td><td>2</td><td>karim</td></tr><tr><td>3</td><td>Vad händer?</td><td>2</td><td>karim</td></tr></tbody></table>


# SQLite

SQLite är en databasmotor för relationsdatabaser. Till skillnad från till exempel MySQL, som generellt ligger och körs som en egen server som andra program skickar anrop till, så fungerar SQLite snarare som ett programmeringsbibliotek som läser från och skriver till databasfiler på hårddisken.

Fördelen är att det är snabbt och lätt att komma igång med. Nackdelen är att det jämfört med MySQL och andra liknande system är ganska begränsat; det finns en hel del SQL-kommandon man kanske är van vid om man arbetat i andra databaser som inte finns här. Man kan till exempel inte i efterhand ändra i tabeller hur som helst; ofta måste man skapa om tabellen från början.

\[ [Installera verktyg](/sqlite/installera-sqlite-verktyg) | [Kommandon ](/sqlite/kommandon)| [Relationer ](/sqlite/relationer)| [Joins ](/sqlite/joins)]

##


# Installera SQLite-verktyg

\[ [**Installera verktyg**](/sqlite/installera-sqlite-verktyg) | [Kommandon](/sqlite/kommandon) | [Relationer](/sqlite/relationer) | [Joins](/sqlite/joins) ]

Det finns bibliotek för många olika programmeringsspråk, till exempel [Microsoft.Data.SQLite](https://csharp.progdocs.se/annat/databaser/c-och-sqlite) till C#.

Man kan också skapa och redigera SQLite-databaser genom att använda separata program som är skapade för det syftet.

* [**SQLite-tools**](https://www.sqlite.org/download.html) är verktyg som körs i terminal eller kommandotolk, och man skriver in kommandon manuellt.
  * [Instruktioner](/sqlite/installera-sqlite-verktyg/sqlite-tools)
* [**SQLiteStudio**](https://sqlitestudio.pl/) är ett grafiskt program som är lite mer lättanvänt
  * [Instruktioner](/sqlite/installera-sqlite-verktyg/sqlitestudio)
* [**SQLiteOnline**](https://sqliteonline.com/) är ett onlineverktyg där man manuellt skriver in kommandon.
* [**SQLite extension**](https://marketplace.visualstudio.com/items?itemName=alexcvzz.vscode-sqlite) är ett tillägg till Visual Studio Code som låter en arbeta med SQLite-filer direkt i programmet.
  * [Instruktioner](/sqlite/installera-sqlite-verktyg/sqlite-extension-for-vscode)


# SQLite-tools\*

{% hint style="info" %}
**OBSERVERA:** SQLite-tools gör så att SQLite extension inte fungerar.
{% endhint %}

## Installation

Det finns ingen installations-exefil att ladda ner; allt som finns på SQLites nerladdningssida är en zipfil med exe-filer.

Det enklaste sättet att installera SQLite-tools på en dator så att sqlite3-kommandot kan köras från vilken mapp som helst är antagligen att göra det via [Chocolatey](https://community.chocolatey.org/).

```
choco install sqlite -y
```

## Kommandon

### .open

Öppnar en databasfil (skapar den om den inte finns), och gör så att man kan arbeta mot den genom att skriva [databaskommandon](/sqlite/kommandon).

```
.open gamedata.sqlite
```

### .save

Om man inte öppnat en databas med .open men ändå börjar skriva kommandon, så körs kommandona på en databas som bara finns i programmets minne och som förstörs när det stängs av. Med .save sparas databasen till en fil.

```
.save school.sqlite
```

### .tables

Skriver ut en lista med de tabeller som finns i databasen som är öppnad.

### .schema

### .headings

### .exit


# SQLiteStudio\*

## Öppna databaser

## Skapa tabell

### Främmande nycklar och relationer

## Lägga in data

## Hämta data


# SQLite extension för VSCode

{% hint style="info" %}
**OBSERVERA:** Om SQLite-tools är installerade och SQLite extension upptäcker det, så kommer extensionen att försöka använda tools istället för sina egna SQLite-filer. Det fungrar väldigt dåligt, så avinstallera SQLite-tools om du tänker använda SQLite extension.
{% endhint %}

Visual Studio Code har inget inbyggt stöd för SQLite, men det finns såklart bra extensions:

* [SQLite](https://marketplace.visualstudio.com/items?itemName=alexcvzz.vscode-sqlite) - gör att man kan öppna och utföra kommandon/queries mot en SQLite-databas

## Öppna en databas

Högerklicka på en sqlite-fil eller en db-fil och välj "Open database".

<figure><img src="https://283468762-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FHf7qrx19ytnUX7U6YUGb%2Fuploads%2F7lr4JAhowuK7InDb3yhQ%2Fimage.png?alt=media&amp;token=9e220afd-fea7-455f-9f68-fb2d2d2935e2" alt=""><figcaption></figcaption></figure>

Man kan också "öppna" tomma filer som SQLite-databaser – genom att sedan köra [CREATE TABLE](broken://pages/Uy1gdtEvcVEoTrgk6YJr#create-table) så görs den tomma filen till en databas.

När databasen är öppnad bör det dyka upp en "SQLite Explorer"-flik:

<figure><img src="https://283468762-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FHf7qrx19ytnUX7U6YUGb%2Fuploads%2FVvr1oK6wgt5r9nU41jFE%2Fimage.png?alt=media&amp;token=f551190f-f48b-497c-a03c-69c7c82af690" alt=""><figcaption></figcaption></figure>

Databasen i exemplet ovan innehåller en tabell som heter users, som i sin tur har kolumnerna id och name.

## Stäng en databas

Högerklicka på databasen i SQLite Explorer och välj "Close database".

## Köra ett kommando

Högerklicka på antingen databasen eller en av tabellerna i SQLite Explorer och välj "New query". För tabellen kan man välja mellan två färdigifyllda query-mallar: en för [INSERT INTO](broken://pages/Uy1gdtEvcVEoTrgk6YJr#insert-into) och en för [SELECT](broken://pages/Uy1gdtEvcVEoTrgk6YJr#select).

Det du får är en ny textfil som innehåller antingen ett tomt utrymme där du kan skriva en query, eller en ny textfil med förifyllda kommandon du kan redigera.

<figure><img src="https://283468762-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FHf7qrx19ytnUX7U6YUGb%2Fuploads%2Fhphu3K2urA4zd5ABsmoE%2Fimage.png?alt=media&amp;token=f55dce5c-103e-4f47-a11e-36eb7bdd3a02" alt=""><figcaption></figcaption></figure>

För att köra queryn, tryck på F1 och kör "SQLite: Run Query". Om det du körde var en [SELECT](/sqlite/kommandon#select)-query bör resultatet nu dyka upp i ett sidofönster.

## Skapa en databas

Skapa en tom fil, som du döper till något som slutar med .sqlite, t.ex. "database.sqlite".

Öppna filen som en databas, enligt ovan.

Högerklicka på databasen i SQLite, välj "New Query".

Lägg till en tabell genom att skriva in kommandot för [CREATE TABLE](/sqlite/kommandon#create-table).

Tryck F1 och välj "SQLite: Run Query".

## Titta på en tabell

Se till att databasen är öppnad.

Högerklicka på tabellen i SQLite Explorer, välj "Show Table".


# Kommandon

\[ [Installera verktyg](/sqlite/installera-sqlite-verktyg) | [**Kommandon**](/sqlite/kommandon) | [Relationer](/sqlite/relationer) | [Joins](/sqlite/joins) ]

## CREATE TABLE

Skapar en tabell.&#x20;

```sql
CREATE TABLE users (
	id INTEGER PRIMARY KEY AUTOINCREMENT,
	name TEXT NOT NULL,
	password TEXT NOT NULL,
	email TEXT NOT NULL
);
```

Ovanstående skapar tabellen **users** med kolumnerna **id**, **name**, **password** och **email**.

* **INTEGER** betyder att kolumnen bara kan innehålla siffror, på samma sätt som en integer-variabel i C#..
* **TEXT** betyder att kolumnen bara kan innehålla text, lite som en string.
* **PRIMARY KEY** betyder att det är värdet i den kolumnen som är unikt och används för att identifiera varje rad.
* **AUTOINCREMENT** betyder att om man lägger till en rad i tabellen utan att ange ett värde för denna kolumn så ges den ett automatiskt nytt värde.
* **NOT NULL** betyder att man inte får lämna kolumnen tom.

<table><thead><tr><th width="86">id🔑</th><th width="134">name</th><th width="153">password</th><th>email</th></tr></thead><tbody><tr><td></td><td></td><td></td><td></td></tr></tbody></table>

## DROP TABLE

Raderar en tabell.

```
DROP TABLE users;
```

## ALTER TABLE

Gör ändringar i en existerande tabell

### RENAME

Byter namn på tabellen.

```sql
ALTER TABLE users
RENAME TO students;
```

### ADD COLUMN

Lägger till en ny kolumn

```
ALTER TABLE users
ADD COLUMN twitter_handle TEXT;
```

### DROP COLUMN

Tar bort en kolumn (och all data som finns i den). Fungerar inte för alla kolumner – till exempel kan man inte ta bort de som är primärnycklar.

```
ALTER TABLE users
DROP COLUMN twitter_handle;
```

### RENAME COLUMN

Byter namn på en kolumn

```sql
ALTER TABLE users
RENAME COLUMN name TO username;
```

## INSERT INTO

Lägger till en rad i en tabell.

```sql
INSERT INTO users (name,password,email)
VALUES('Mikael Bergström','12345','fake@bullshit.com');
```

Ovanstående stoppar in en rad i tabellen **users**.

* **(name,password,email)** betyder att det är de tre kolumnerna som värden ska stoppas in i.
* **VALUES('Mikael Bergström','12345','<fake@bullshit.com>')** betyder att texten "Mikael Bergström" läggs in i den första angivna kolumnen (name), "12345" läggs in i den andra kolumnen (password) och att "<fake@bullshit.com>" läggs in i den tredje (email).

En av tabellens fyra kolumner, "id", anges inte och får inget värde. Eftersom den är AUTOINCREMENT får den ändå ett värde, automatiskt.

<table><thead><tr><th width="86">id🔑</th><th width="166">name</th><th width="153">password</th><th>email</th></tr></thead><tbody><tr><td>1</td><td>Mikael Bergström</td><td>12345</td><td>fake@bullshit.com</td></tr></tbody></table>

Observera att man använder ' för att avgränsa texter (strings).&#x20;

## SELECT

Hämtar data från en tabell

```sql
SELECT * FROM users;
```

Ovanstående hämtar alla rader och alla kolumner från tabellen.

<table><thead><tr><th width="86">id🔑</th><th width="166">name</th><th width="153">password</th><th>email</th></tr></thead><tbody><tr><td>1</td><td>Mikael Bergström</td><td>12345</td><td>fake@bullshit.com</td></tr><tr><td>2</td><td>Jacob Marley</td><td>money$</td><td>moneyman@scroogemarley.com</td></tr></tbody></table>

```sql
SELECT name,email FROM users;
```

Ovanstående hämtar alla rader, men bara kolumnerna **name** och **email**.

<table><thead><tr><th width="199">name</th><th>email</th></tr></thead><tbody><tr><td>Mikael Bergström</td><td>fake@bullshit.com</td></tr><tr><td>Jacob Marley</td><td>moneyman@scroogemarley.com</td></tr></tbody></table>

### AS

Gör att kolumner kan ges nya namn i resultatet.

```sql
SELECT name AS namn FROM users;
```

<table><thead><tr><th width="199">namn</th></tr></thead><tbody><tr><td>Mikael Bergström</td></tr><tr><td>Jacob Marley</td></tr></tbody></table>

### WHERE

Gör att man kan vara mer specifik med vilken eller vilka rader man vill läsa av.

```sql
SELECT name,email FROM users WHERE id=1;
```

Ovanstående hämtar bara kolumnerna name och email, och bara de rader där kolumnen id har värdet 0.

<table><thead><tr><th width="218">name</th><th>email</th></tr></thead><tbody><tr><td>Mikael Bergström</td><td>fake@bullshit.com</td></tr></tbody></table>

### AND

Gör att man kan sätta ihop flera olika kriterier i en WHERE.

```
SELECT name FROM users WHERE email='fake@bullshit.com' AND password='12345';
```

### COUNT

Räknar antalet rader som innehåller ett värde.

```sql
SELECT COUNT(*) FROM users WHERE id=0;
```

## DELETE

Tar bort en eller flera rader från en tabell, baserat på ett eller flera kriterier.

```sql
DELETE FROM users WHERE id=0;
```

Kriterierna anges via WHERE, precis som för SELECT.

## UPDATE

Ändrar information i en eller flera celler, baserat på ett eller flera kriterier.

```sql
UPDATE users
SET email = 'deep@fake.com'
WHERE id=0;
```

Ovanstående kod ändrar email-kolumnens data till "<deep@fake.com>" för alla rader där id-kolumnen innehåller en nolla.

<table><thead><tr><th width="86">id🔑</th><th width="166">name</th><th width="153">password</th><th>email</th></tr></thead><tbody><tr><td>0</td><td>Mikael Bergström</td><td>12345</td><td>deep@fake.com</td></tr><tr><td>1</td><td>Jacob Marley</td><td>money$</td><td>moneyman@scroogemarley.com</td></tr></tbody></table>


# Relationer

\[ [Installera verktyg](/sqlite/installera-sqlite-verktyg) | [Kommandon](/sqlite/kommandon) | [**Relationer**](/sqlite/relationer) | [Joins](/sqlite/joins) ]

Nedanstående tabeller är ett exempel på en 1:N-relation.

**students**

<table><thead><tr><th width="85.33333333333331">id🔑</th><th width="132">name</th><th width="134">surname</th><th>pnumber</th><th>classid</th></tr></thead><tbody><tr><td>1</td><td>Mikael</td><td>Bergström</td><td>XXXXXX-XXXX</td><td>1</td></tr><tr><td>2</td><td>Mohammad</td><td>Mohammadi</td><td>XXXXXX-XXXX</td><td>2</td></tr><tr><td>3</td><td>Anna-Karin</td><td>Karlsson</td><td>XXXXXX-XXXX</td><td>1</td></tr></tbody></table>

**classes**

<table><thead><tr><th width="88.33333333333331">id🔑</th><th width="141">name</th><th>mentor</th></tr></thead><tbody><tr><td>1</td><td>TE00A</td><td>Mira Belle</td></tr><tr><td>2</td><td>TE00B</td><td>Kevin McAllister</td></tr></tbody></table>

Här är relationen att kolumnen **classid** i tabellen **students** innehåller siffror som hör ihop med kolumnen **id** i tabellen **classes**. Observera att det är classes-tabellens **primärnyckel** som används.

För att hindra användare från att lägga in icke-giltiga värden classid-kolumnen så kan relationen skrivas in i tabellens definition när den skapas (det kan också göras i efterhand via [ALTER TABLE](/sqlite/kommandon#alter-table)):

```sql
CREATE TABLE classes (
	id INTEGER PRIMARY KEY AUTOINCREMENT,
	name TEXT NOT NULL,
	mentor TEXT NOT NULL
);

CREATE TABLE students (
	id INTEGER PRIMARY KEY AUTOINCREMENT,
	name TEXT NOT NULL,
	surname TEXT NOT NULL,
	pnumber TEXT NOT NULL,
	class_id INTEGER NOT NULL,
	FOREIGN KEY(classid) REFERENCES classes(id)
);
```

Med andra ord lägger man helt enkelt till `FOREIGN KEY(x) REFERENCES table(y)` för att koppla kolumnen x till kolumnen y i tabellen "table"


# Joins

\[ [Installera verktyg](/sqlite/installera-sqlite-verktyg) | [Kommandon](/sqlite/kommandon) | [Relationer](/sqlite/relationer) | [**Joins**](/sqlite/joins) ]

Exemplen utgår från de här tabellerna:

**students**

<table><thead><tr><th width="85.33333333333331">id🔑</th><th width="132">name</th><th width="134">surname</th><th>pnumber</th><th>classid</th></tr></thead><tbody><tr><td>1</td><td>Mikael</td><td>Bergström</td><td>XXXXXX-XXXX</td><td>1</td></tr><tr><td>2</td><td>Mohammad</td><td>Mohammadi</td><td>XXXXXX-XXXX</td><td>2</td></tr><tr><td>3</td><td>Anna-Karin</td><td>Karlsson</td><td>XXXXXX-XXXX</td><td>0</td></tr></tbody></table>

**classes**

<table><thead><tr><th width="88.33333333333331">id🔑</th><th width="141">name</th><th>mentor</th></tr></thead><tbody><tr><td>1</td><td>TE00A</td><td>Mira Belle</td></tr><tr><td>2</td><td>TE00B</td><td>Kevin McAllister</td></tr></tbody></table>

Joins är ett sätt att sätta ihop tabeller som har en relation, när man efterfrågar data med [SELECT](/sqlite/kommandon#select).

<pre class="language-sql"><code class="lang-sql">SELECT students.name AS student_name, classes.name AS class
<strong>	FROM students
</strong>	INNER JOIN classes
<strong>	ON students.classid = classes.id;
</strong></code></pre>

Det finns flera sorters JOIN, men INNER JOIN är den vanligaste. Man anger först som vanligt vilka kolumner man vill ha med, sedan FROM en första tabell. Sedan lägger man till INNER JOIN en annan tabell, och så ON vilka kolumner som ska kopplas ihop.

| student\_name | class |
| ------------- | ----- |
| Mikael        | TE00A |
| Mohammad      | TE00B |
| Anna-Karin    | TE00A |

Observera att man alltså måste specifiera vilken tabell varje kolumn kommer från i första delen av SELECT-kommandot, framför allt när kolumner i båda tabellerna har samma namn.

## INNER JOIN

Visar bara resultat där data finns i båda tabellerna.

```
SELECT students.name AS student_name, classes.name AS class
	FROM students
	INNER JOIN classes
	ON students.classid = classes.id;
```

| student\_name | class |
| ------------- | ----- |
| Mikael        | TE00A |
| Mohammad      | TE00B |

## LEFT JOIN

Visar ett resultat där alla rader från den första (vänstra) tabellen är med, oavsett om det finns något som sätts ihop med den i den andra tabellen.

| student\_name | class |
| ------------- | ----- |
| Mikael        | TE00A |
| Mohammad      | TE00B |
| Anna-Karin    |       |


# MySQL\*

MySQL är…

## Kommandon


# Bra länkar

* [Webbkurs om databaser](https://www.databasteknik.se/webbkursen/index.html). Mycket bra resurs, bra förklaringar och exempel.
* [Kokbok för databasmodellering](https://dbwebb.se/kunskap/kokbok-for-databasmodellering).


