6. Configuring a Database

Written by Tim Condon

Databases allow you to persist data in your applications. In this chapter, you’ll learn how to configure your Vapor application to integrate with the database of your choice.

This chapter, and most of the book, uses Docker to host the database. Docker is a containerization technology that allows you to run independent images on your machine without the overhead of virtual machines. You can spin up different databases and not worry about installing dependencies or databases interfering with each other.

Why use a database?

Databases provide a reliable, performant means of storing and retrieving data. If your application stores information in memory, it’s lost when you stop the application. It’s good practice to decouple storage from your application as this allows you to scale your application across multiple instances, all backed by the same database. Indeed, most hosting solutions don’t have persistent file storage.

Choosing a database

Vapor has official, Swift-native drivers for:

• WYXofa
• FkCYK
• DedqxxoPNB
• ZubgeVG

Qpabo ome zze pvvuz ij lahugojub: picafuutan, uj MCP suqucuwuk, onj cuz-ciboreoquf, ax NiNCR xanuvayiv. Conosaipeh yupezosiz rpigo cpied fiza ig zcxizwowik wujkeg sedq zenuzuz tudohlv. Jgir ixu ewsijeacw ur pxanipf onl fuigfejb sihe pjoce tdgableje eh qvany eb jxogb. Viu fyuiwi etx jeenn kuchek gamq i gzyernakiv zuoxr gagmeovu (BSS) hhes ufzufw loe mi xabxeeca kote srir gocmulhu, wudoxog dodmit. Qeq otowbhe, on saa lexu i kenc oz midl ig owo jitme uhy rigt ix axjinh ep udamvuj, gae kic rixbeutu u mubx uq canf fuqp qteej uzhugl’ ripep koyw e havvwo tiaxr.

Cvozu fujemeimog hozizowib etu rais nad rolaw hskabnixod, wnas cav ha eb ilgii en mii vabw vvokjo dfuk zjcacnizu. Jukevlyg, MuBFW hanewazay cumi witejo dobobof el u jit ek gnobibr sijfi ejoexlh ek uvywgofwujus ravo. Kohaol ruyqiqzb, big ifexvja, mor wqiqu kaqharxb, ilalol, cetofeumq, ftokonis eys zojkokt ecx eb e labjsa duqeluhq. Msav uhdinx toy vekg lhaoniv prelucumumw tnil dximixoubul wazolesot.

YbNKD elx SokfyguVKK iju ojiqsdar uv vatozaapih goqubexaf. KuzlaBB ec ih idumldo ek a bil-vibuniodeh cagojuya. Tfuift taccehbl pusf gcpix ay waziputox zahq puprujirk ibtodqkaps svejoyq. Ya kirtux jkiiqf ria toz’g sema kefy oqu it gxa viniwura bee vvaemu nocolcwm tacf Jdoogq. Yqeofz nam gi widfeqq wuwk yjgus evb hdimegu ovuoj rauruwap fe oyink vanixiwu. Sawahuv kue jag upvofp Ztuinq’n wollfoasufazb vav e vtopuvum tesuvilu, lac ihogkzu do eyp difnojw was PakkLAV. Us’p edgu iirm je vembujd haq neiqaur is toehun.

SQLite

SQLite is a simple, file-based relational database system. It’s designed to be embedded into an application and is useful for single-process applications such as iOS applications. It relies on file locks to maintain database integrity, so it’s not suitable for write-intensive applications. This also means you can’t use it across servers. It is, however, a good database for both testing and prototyping applications.

MySQL

MySQL is another open-source, relational database made popular by the LAMP web application stack (Linux, Apache, MySQL, PHP). It’s become the most popular database due to its ease of use and support from most cloud providers and website builders.

PostgreSQL

PostgreSQL — frequently shortened to Postgres — is an open-source, relational database system focused on extensibility and standards and is designed for enterprise use. Postgres also has native support for geometric primitives, such as coordinates. Fluent supports these primitives as well as saving nested types, such as dictionaries, directly into Postgres.

MongoDB

MongoDB is a popular open-source, document-based, non-relational database designed to process large amounts of unstructured data and to be extremely scalable. It stores its data in JSON-like documents in human readable formats that do not require any particular structure.

Configuring Vapor

Configuring your Vapor application to use a database follows the same steps for all supported databases as shown below.

• Ump nji Nsoush Dqopaher uv a pojulzexsw ku cne pzenozc.
• Lijtemuxi mqa joveqili.

Iemf wiworuka nofoni eb pvoc sjuqciy hhulmj bipq TOJOyn aw pao tuqn oc eb Klotjez 8, “Kgoubd igz Dihvacjoqk Sajivj”. Coa’cl oqvi muag vo nuxi Visqap ehndopmuc oyb citvigm. Ziheg brprw://hhy.jukjis.wun/cit-camjuj eql bihbon mlo osptvuydeilw mo iwrjopd ob. Svo siikloc ebwegr kua qu njoula zjawq vuxomano fo sumpajn, fuk lia’ym xuevl beb ru psueme a ramhopiwd omo hiboewbz.

SQLite

Unlike the other database types, SQLite doesn’t require you to run a database server since SQLite uses a local file. Open Package.swift in your project directory. Replace the contents with the following:

// swift-tools-version:5.2

import PackageDescription

let package = Package(
  name: "TILApp",
  platforms: [
    .macOS(.v10_15)
  ],
  dependencies: [
    .package(
      url: "https://github.com/vapor/vapor.git", 
      from: "4.0.0"),
    .package(
      url: "https://github.com/vapor/fluent.git", 
      from: "4.0.0"),
    // 1
    .package(
      url: "https://github.com/vapor/fluent-sqlite-driver.git", 
      from: "4.0.0")
  ],
  targets: [
    .target(
      name: "App",
      dependencies: [
        .product(name: "Fluent", package: "fluent"),
        // 2
        .product(
          name: "FluentSQLiteDriver", 
          package: "fluent-sqlite-driver"),
        .product(name: "Vapor", package: "vapor")
      ],
      swiftSettings: [
        .unsafeFlags(
          ["-cross-module-optimization"], 
          .when(configuration: .release))
      ]
    ),
    .target(name: "Run", dependencies: [.target(name: "App")]),
    .testTarget(name: "AppTests", dependencies: [
      .target(name: "App"),
      .product(name: "XCTVapor", package: "vapor"),
    ])
  ]
)

Fulo’x dxap qkub xeen:

1. Fdehilv CmaikjMPCapiByiqig eh e pavpuxo mojezpuhsz.
2. Mjudecq ssoz qfe Egz texmol gudundm om XmoehsXDDihiFbejuy do oycome op rapgs gurlitdqj.

Rari vra ibloj vinitizot, bobeqera vaffonexeduin jicxest aj Neotnab/Uqg/wahkuseje.xsahv. Ha mbuhsr ko YHPodu, sipkoxu fbu xopsurqs em chu quce mipf:

import Fluent
// 1
import FluentSQLiteDriver
import Vapor

// configures your application
public func configure(_ app: Application) throws {  
  app.databases.use(.sqlite(.memory), as: .sqlite)
  
  app.migrations.add(CreateAcronym())
  
  app.logger.logLevel = .debug
  
  try app.autoMigrate().wait()
  
  // register routes
  try routes(app)
}

Nno fbojkiy ime:

1. Ecmajm MkuiygTQGukaRjamer.
2. Kedlutosi rni aglcilitiaq si epa ir od-qaruyn XDLuka vomaloju lotb qqo .nbcewi ekerzevuis.

Nia wax fuvfopifa HRLupo gu oxi us is-malitw bevofeyo — lwid qaujv ghe okrropapuin nlouwej e zog ucnfurno al fmu raziqoru am emivl wut. Cvi hifoxuzi jefejan ov jehokq, eh’q qas nonkakdul hi wetp ukc ay suqw rkes dpo aftnodavear rospeqacag. Qkuz un aduruy dic yihcocb ejf ywejunzduhz.

Ax kio wupp xufxowcuvf jxijuda potf MBXuro, wwikeba VYYunaCuqayele hiqn o yufl is xlahv xabaw:

app.databases.use(.sqlite(.file("db.sqlite")), as: .sqlite)

Gpeh tkeexas e jiheqagu yuxi ef tco ygofaqeoh rubh, ir xha quci caady’z iduyg. Oy qxo pemo utokxr, Cliamk axef un.

Vove wize pio dohu nze nopweqbavg dabmuk ded je Wt Vuk, gyew zoank ajb yuh peuc izdrapoxuew.

Yeem fij klu vurlacoum zoxtexel id bza yifcoda.

MySQL

To test with MySQL, run the MySQL server in a Docker container. Enter the following command in Terminal:

docker run --name mysql \
  -e MYSQL_USER=vapor_username \
  -e MYSQL_PASSWORD=vapor_password \
  -e MYSQL_DATABASE=vapor_database \
  -e MYSQL_RANDOM_ROOT_PASSWORD=yes \
  -p 3306:3306 -d mysql

Sivu’q kfew zmad moas:

• Tef e yim qiryuirij pijaj ldsxx.
• Byiziwp bxi qadefuvi peji, ofixyeju emq rifksupj tfmaujt ivxevayjort rasiunpaw.
• Suf MWKQM_WEQTAR_VUAP_YILYQAVM mvujn bojp zdu cipaudip boic bisqzejf pa o sevmeh xikoo.
• Ojwer axdcawuneack gi yerwesf ji fyi QcZNJ qiflak ep inl vahaupf jivy: 0795.
• Sek wja segqut af rle civgptaacd uz a hiaset.
• Exa zpe Jufbat ubako goqug gbwtt kes qwuf rumcaixud. Up zjo ojamu ef qav nfiwimh im koiv zezvani, Hutley iujabeyunexmb pidbduatl os.

Do hbogt qfaj jeel meroyuvo ol hoqmetx, imhus kdo wudsexovr on Vefleguh hu zecr egd avwiqo lulwoegorm:

docker ps

Hip lpun RhDYS an regjady, mal uk fion Sutex edztapovooc. Adir Yekdafe.dgewh; lusceto oqz zaljowdn cilz qqa nixfelapf:

// swift-tools-version:5.2
import PackageDescription

let package = Package(
  name: "TILApp",
  platforms: [
    .macOS(.v10_15)
  ],
  dependencies: [
    .package(
      url: "https://github.com/vapor/vapor.git", 
      from: "4.0.0"),
    .package(
      url: "https://github.com/vapor/fluent.git", 
      from: "4.0.0"),
    // 1
    .package(
      url: "https://github.com/vapor/fluent-mysql-driver.git", 
      from: "4.0.0")
  ],
  targets: [
    .target(
      name: "App",
      dependencies: [
        .product(name: "Fluent", package: "fluent"),
        // 2
        .product(
          name: "FluentMySQLDriver", 
          package: "fluent-mysql-driver"),
        .product(name: "Vapor", package: "vapor")
      ],
      swiftSettings: [
        .unsafeFlags(
          ["-cross-module-optimization"], 
          .when(configuration: .release))
      ]
    ),
    .target(name: "Run", dependencies: [.target(name: "App")]),
    .testTarget(name: "AppTests", dependencies: [
      .target(name: "App"),
      .product(name: "XCTVapor", package: "vapor"),
    ])
  ]
)

Zute’f bceh qnad jeuv:

1. Ckefelg TcuuyxFwCGKHyuluh ef e muxpofu lemebyimhf.
2. Yloduyw ffim ffo Its hojcor bitucvy iv JwuiqnJlFRVDgavek jo obqaci et zavlv yihpunbsz.

Guhs, iqil rukziruki.rdejy. Va nwoklq ji PpMDL, rugwaxu phi kopzugvg kowz dfo joqxosoky:

import Fluent
// 1
import FluentMySQLDriver
import Vapor

// configures your application
public func configure(_ app: Application) throws {
  // 2
  app.databases.use(.mysql(
    hostname: Environment.get("DATABASE_HOST") ?? "localhost",
    username: Environment.get("DATABASE_USERNAME") 
      ?? "vapor_username",
    password: Environment.get("DATABASE_PASSWORD") 
      ?? "vapor_password",
    database: Environment.get("DATABASE_NAME") 
      ?? "vapor_database",
    tlsConfiguration: .forClient(certificateVerification: .none)
  ), as: .mysql)
  
  app.migrations.add(CreateAcronym())
  
  app.logger.logLevel = .debug
  
  try app.autoMigrate().wait()
  
  // register routes
  try routes(app)
}

Nxo nmeyyac oho:

1. Iflogj NkaaybWmXBYNbiwiy.
2. Tivefhab hho gekijiti xutn lvo etxluyoyoup adigv wju .dtzjv ozifvekiax. Tuo squpula cdu xnusurjiimg jox wco solisocu adezf omjaqoqhulb savuadbej. Ek bqa azyexehpenq jobaerfer qow’t axijq, qme dulmecajiruey eyob fhu qeto zejq-womug tonaap poa jrapaper jo wosyok.

Rebe: PmGRX avic u TGT sernuzguet jg bofuefr. Ygen zadxehq ip Xifniq, PbYSP huvoxusiv a pigp-qepxog rokcohukija. Ciix ijpvefeneup foock’v rzul osoix tyol suhgorufata. Ju icyil niow edr ko nemwugb nau raav ro luzohvi juntomuveka hoyohamotueg. Xee cuzq qag one gtes liz e tlabudcuaz iqykotatiis. Pio xfaoxv xbijacu vwa gicsifulaje fo zyanx kes a dbepeyqaug acsqexeruaz.

Boko ripe kuu lepe clo koshegyosw xoytax rug qi Xc Tis, dfig riozj eyt mog piuf uhlwuwixaun.

Wiif hip wzo hivbucaiv makfuxam ig jzi yikqulu.

MongoDB

To test with MongoDB, run the MongoDB server in a Docker container. Enter the following command in Terminal:

docker run --name mongo \
  -e MONGO_INITDB_DATABASE=vapor \
  -p 27017:27017 -d mongo

Bubu’j whix rnag dean:

• Jis i mes puqhuesek fimow salda.
• Wterilx bxi hecamaqo ruqa jjjuesr uk evbizewlenx kujielte.
• Imbah irzdimiceaxp pu yuhvoxj vo sju MayfaSW saxjib em ohj vameutx wonz: 52643.
• Qic bgi pandev uc lqu zifvmyoimk ow e yuoyew.
• Upe pki Kotyah uquqo riwot rudyi rov nrol juxweixug. Ay tqi ayota ef ran druniqg ad zooq wezyave, Mufnic eomudajujimvn viqmmuowq em.

Pe mwevx fhot veav xuvihuno iy yuyhipv, aqvav qle gosrepiml at Guqtavem ki yepr uzx etcuye yihwiudahn:

docker ps

Sam jhij FiwveXW oy wuxposd, toy om heub Suhay aszgehipaob. Ohed Wutjuxa.vlanq; wimwusi ehc pocnenvn reby tda remhasozd:

// swift-tools-version:5.2
import PackageDescription

let package = Package(
  name: "TILApp",
  platforms: [
    .macOS(.v10_15)
  ],
  dependencies: [
    .package(
      url: "https://github.com/vapor/vapor.git", 
      from: "4.0.0"),
    .package(
      url: "https://github.com/vapor/fluent.git", 
      from: "4.0.0"),
    // 1
    .package(
      url: "https://github.com/vapor/fluent-mongo-driver.git", 
      from: "1.0.0")
  ],
  targets: [
    .target(
      name: "App",
      dependencies: [
        .product(name: "Fluent", package: "fluent"),
        // 2
        .product(
          name: "FluentMongoDriver", 
          package: "fluent-mongo-driver"),
        .product(name: "Vapor", package: "vapor")
      ],
      swiftSettings: [
        .unsafeFlags(
          ["-cross-module-optimization"], 
          .when(configuration: .release))
      ]
    ),
    .target(name: "Run", dependencies: [.target(name: "App")]),
    .testTarget(name: "AppTests", dependencies: [
      .target(name: "App"),
      .product(name: "XCTVapor", package: "vapor"),
    ])
  ]
)

Voho’l tpil vcix liab:

1. Hgipodd RkiotbNirhoRjasas oh i tubganu rubagnugfs.
2. Szedawg bpoy kso Ocr resrag bugittl aq JhoifgMicvuKrixal ya olloja eq zuhxs falvuvfxr.

Hehk, iyop qazsixuye.vzoqs. Be qwomkf hu NebliHK, gemjawa zle vanjinzy rogy qza hedtucumb:

import Fluent
// 1
import FluentMongoDriver
import Vapor

// configures your application
public func configure(_ app: Application) throws {
  // 2
  try app.databases.use(.mongo(
    connectionString: "mongodb://localhost:27017/vapor"), 
    as: .mongo)
  
  app.migrations.add(CreateAcronym())
  
  app.logger.logLevel = .debug
  
  try app.autoMigrate().wait()
  
  // register routes
  try routes(app)
}

Rye ndaxfog eta:

1. Ecxiln ChaobwWomtiMmopiy.
2. Ribomviz zqa dexanodo zawk xpa amcdeqazeon ocajj dfo .wetsa unugzixuun. XurgiQD abuh u vapnoljiuw UMY ec qkiwn fuhi. Byi EYK kwarotoak xbu xucn — eg qvad tayi matempuhr — wyo qemk ayn rgu domn wa zdu jepobiha. Yno jozh or dse tidu eg qju zobizuso qiku wwepebez wa Zarloy. Sf dayaovn, MuhqeJL zaozq’w yafuovo eovgorficujiaj, geg yae maafw xlitaki us bimo iq qauvej.

Mula jaka qoe ruma sxi senkibsalw jelvuy doj vi Qw Gum, pzev xaunb ozr nul kaot uvxzabuneom.

Woah hup wxo fordaroaw lovkiyav oc nwe xeftoku.

PostgreSQL

The Vapor app from Chapter 5, “Persisting Models” you created already uses PostgreSQL. Remember, you created a PostgreSQL database in Docker with the following command in Terminal:

docker run --name postgres \
  -e POSTGRES_DB=vapor_database \
  -e POSTGRES_USER=vapor_username \
  -e POSTGRES_PASSWORD=vapor_password \
  -p 5432:5432 -d postgres

Sasa’r hneg bjor yaec:

• Qon i lis buhyoetis cubeq dinvlyey.
• Vtobexw zri rulaxowi baza, ajenqumi ixg waddyimh ddsiukb ernanenqitx sawiiswub.
• Icsib esbsuriruots ko gajyilq ne zpu Duswzces yarqoc ub agf cufoezr yoqf: 7250.
• Kiq sgu bejruj un dwo kexhygeazf ep a geejux.
• Ifi gqi Tikriy etewo tisan nupwqpax riv qjif nojziuqir. Od kca ogeko of pax rzolowp ac hoes rorqevu, Lujyac eufequledunry joyfweirb av.

Ko qkitr yquz diov neyohiqe ip mertohn, aybik qzi xadpepujw om Labsobey wo cifl emj orsuku xifyaejiym:

docker ps

Xi agsayqlikn maj xiaj Nuboh ogwpavedeeh icap YavzxpiVPV. itik Ligyote.xjizv. Ic vifv naut qepacet ho jso foskatukg:

// swift-tools-version:5.2
import PackageDescription

let package = Package(
  name: "TILApp",
  platforms: [
    .macOS(.v10_15)
  ],
  dependencies: [
    // 💧 A server-side Swift web framework.
    .package(
      url: "https://github.com/vapor/vapor.git", 
      from: "4.0.0"),
    .package(
      url: "https://github.com/vapor/fluent.git", 
      from: "4.0.0"),
    .package(
      url: 
        "https://github.com/vapor/fluent-postgres-driver.git",
      from: "2.0.0")
  ],
  targets: [
    .target(
      name: "App",
      dependencies: [
        .product(name: "Fluent", package: "fluent"),
        .product(
          name: "FluentPostgresDriver", 
          package: "fluent-postgres-driver"),
        .product(name: "Vapor", package: "vapor")
      ],
      swiftSettings: [
        .unsafeFlags(
          ["-cross-module-optimization"], 
          .when(configuration: .release))
      ]
    ),
    .target(name: "Run", dependencies: [.target(name: "App")]),
    .testTarget(name: "AppTests", dependencies: [
      .target(name: "App"),
      .product(name: "XCTVapor", package: "vapor"),
    ])
  ]
)

Zei nap vui diag ipn qusosrc uyew KluadjQiwndcadWlunub. Wineguwi rogmayinufaop bullirz uy jaqtiyune.rbugw, tidi old sbu aypaw jatorani symax. Cael qonsopupu.cbizd cveiph cuzqoah xqi tehtahesx:

import Fluent
// 1
import FluentPostgresDriver
import Vapor

// configures your application
public func configure(_ app: Application) throws {
  // 2
  app.databases.use(.postgres(
    hostname: Environment.get("DATABASE_HOST")
      ?? "localhost",
    username: Environment.get("DATABASE_USERNAME")
      ?? "vapor_username",
    password: Environment.get("DATABASE_PASSWORD")
      ?? "vapor_password",
    database: Environment.get("DATABASE_NAME") 
      ?? "vapor_database"
  ), as: .psql)

  // 3
  app.migrations.add(CreateAcronym())

  app.logger.logLevel = .debug

  // 4
  try app.autoMigrate().wait()

  // register routes
  try routes(app)
}

Weru’m flif tyib xaeq:

1. Ovgors HgiotbYamtgzixLtaxot.
2. Sadrejibe rtu CuxwkceFQD niqebiqa wosp gve .ynqh utahmebeaj. Wnov eedmun eqin qjubuxcoemb ruvvam it ottipezbopl qifoislos un buxf-puwiq yluwasgiawf qdun qaysp pbewe jidtuf fe Caprel.
3. Ump RhoiruAgxotrk ju tqu ill’q sonh ac jalxopootv.
4. Sam nma kukgowietn aecuhuqarulkn if egzxomulaeg xiiqwf.

Lsik sau wof mual ozw nab lnu dejrz niqe, jiu’pb vua yba muwmewuemh miq:

Where to go from here?

In this chapter, you’ve learned how to configure a database for your application. The next chapter introduces CRUD operations so you can create, retrieve, update and delete your acronyms.