Scala för backendutveckling och funktionell programmering · Lektion

Infogningar och uppdateringar

Skriv data funktionellt.

Lektion 3 av 413 steg

Infogningar och uppdateringar är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Scala för backendutveckling och funktionell programmering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Update0 för skrivningar

Skrivningar använder samma sql-interpolator, men du anropar .update för att få en Update0 i stället för .query.

När du kör .run på en Update0 returneras en ConnectionIO[Int]: antalet påverkade rader.

import doobie.implicits._

def insert(name: String, age: Int): ConnectionIO[Int] =
  sql"insert into users (name, age) values ($name, $age)".update.run

Antal påverkade rader

Int-värdet från .run är JDBC:s uppdateringsantal. För en UPDATE eller DELETE anger det hur många rader som matchade.

Du kan använda värdet i villkor för att till exempel upptäcka en uppdatering som inte matchade några rader.

def deactivate(id: Long): ConnectionIO[Int] =
  sql"update users set active = false where id = $id".update.run

Returnera genererade nycklar

Om du vill hämta en automatiskt genererad primärnyckel använder du .withUniqueGeneratedKeys och anger vilka kolumner databasen returnerar.

Detta kör infogningen och läser tillbaka de genererade värdena i en enda rundresa.

def insertReturningId(name: String, age: Int): ConnectionIO[Long] =
  sql"insert into users (name, age) values ($name, $age)"
    .update
    .withUniqueGeneratedKeys[Long]("id")

Returnera en hel rad

Du kan returnera flera genererade eller standardiserade kolumner samtidigt genom att läsa in dem i en tupel eller case-klass.

Det är praktiskt för att direkt efter en infogning fånga upp serverbaserade standardvärden, till exempel tidsstämplar.

case class User(id: Long, name: String, createdAt: java.time.Instant)

def create(name: String): ConnectionIO[User] =
  sql"insert into users (name) values ($name)"
    .update
    .withUniqueGeneratedKeys[User]("id", "name", "created_at")

Update-klassen för batchkörningar

Update[A] är en förberedd, parameteriserad sats som du kan köra många gånger. Du definierar SQL en gång med platshållare i form av ? och tillhandahåller värden av typen A.

Den byggs från en SQL-sträng samt en Write[A]-instans.

val ins: Update[(String, Int)] =
  Update[(String, Int)]("insert into users (name, age) values (?, ?)")

Effektiva batchinfogningar

updateMany skickar en hel samling i en enda JDBC-batch, vilket är mycket snabbare än att loopa över enskilda infogningar.

Den returnerar det totala antalet påverkade rader. Använd den när du läser in många rader samtidigt.

val rows = List(("Ada", 36), ("Linus", 54))

val batch: ConnectionIO[Int] = ins.updateMany(rows)

Batchinfogning med nycklar

Update kan även strömma genererade nycklar för en batch via updateManyWithGeneratedKeys och returnera en rad för varje infogad post.

Detta kombinerar massinläsning med att läsa tillbaka tilldelade identifierare.

import fs2.Stream

val keyed: Stream[ConnectionIO, Long] =
  ins.updateManyWithGeneratedKeys[Long]("id")(rows)

Upserts med ON CONFLICT

Databasspecifika upserts fungerar bra via Doobie. I PostgreSQL skriver du insert ... on conflict ... do update som vanlig SQL.

Doobie binder bara dina parametrar; upsert-semantiken hanteras av databasen.

def upsert(email: String, name: String): ConnectionIO[Int] =
  sql"""insert into accounts (email, name) values ($email, $name)
         on conflict (email) do update set name = excluded.name"""
    .update.run

Write-instanser och standardvärden

Parametrar kodas med typklassen Write[A], som härleds för primitiva typer, tupler och case-klasser. Varje fält behöver en Put-instans.

Om du utelämnar en kolumn vid infogningen använder databasen dess DEFAULT-värde, vilket är så genererade tidsstämplar uppkommer.

case class NewUser(name: String, age: Int)

val mk = Update[NewUser](
  "insert into users (name, age) values (?, ?)"
)

Anpassade kolumnmappningar med Meta

Om du vill lagra en anpassad typ definierar du en Meta[A] genom att mappa den till en befintlig kolumntyp med imap (eller timap).

En Meta tillhandahåller både läsning och skrivning, så typen fungerar lika bra i frågor som i uppdateringar.

import doobie.util.meta.Meta

case class UserId(value: Long)

implicit val uidMeta: Meta[UserId] =
  Meta[Long].imap(UserId.apply)(_.value)

DELETE är också uppdateringar

DELETE-satser använder också .update.run och returnerar antalet borttagna rader.

Genom att behandla infogningar, uppdateringar och borttagningar enhetligt som Update0 hålls API:t litet och lätt att komponera.

def purgeInactive: ConnectionIO[Int] =
  sql"delete from users where active = false".update.run

Snabb kontroll

Välj den effektivaste metoden.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Skrivningar använder .update för att skapa en Update0; .run returnerar påverkade rader och .withUniqueGeneratedKeys läser tillbaka genererade värden.

För massbearbetning batchkör Update[A].updateMany effektivt. Anpassade typer får Meta-instanser, och upserts är vanlig databasspecifik SQL där Doobie binder parametrarna.

Gratis att börja

Lär dig Scala med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 39
Lektioner: 143

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Infogningar och uppdateringar” gratis?

Ja – hela texten till ”Infogningar och uppdateringar” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Scala för backendutveckling och funktionell programmering, kan Ni uppgradera till CoddyKit PRO. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Vad lär jag mig i ”Infogningar och uppdateringar”?

Skriv data funktionellt. Ni övar på Scala för backendutveckling och funktionell programmering med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Scala för backendutveckling och funktionell programmering?

Du behöver inga förkunskaper. Utbildningen i Scala för backendutveckling och funktionell programmering på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Infogningar och uppdateringar”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Scala för backendutveckling och funktionell programmering-lektionen?

Ja. Varje Scala för backendutveckling och funktionell programmering-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Scala för backendutveckling och funktionell programmering