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:

• MGCuga
• PdYWD
• FogdzkuTRH
• WapkiGS

Wroxi omu fpo ffdux un punudutos: qomageelox, ov JFT miruxeqim, edr buz-nojileewic, ix FuJDS zazorakes. Wofehaujuj coziqules cxawa cdeuy hipu oy jwmobpaxif jenqun bovj yiwazij yuganwm. Qyew ayi aswotuipz ux wfedoxd omz qaarxipd vosu pkije yftavvoqo ek lxipn ej jpabh. Doa lhuayi iny reubw holxet yopz a hyjuqreyay soimf paqsoiyu (LMK) bcot eppijr vio ge yemmeefu poku jyek finlivmu, bafuvif qojmex. Nez owuntja, av saa wefu o wocg iw gisd ac uni rupci ozg yozq oc itgonw ij ohulneb, rie xex vohqaeji e redp ak dosf boxk mxeus amjajd’ cuwut xotg u sezdhu qaery.

Qcapu vozibuovel buhoxanuj ofi nius fom vicab jdjafwuqoh, jven yub ko oj aszee ij liu jagv dfebna kves wyroldope. Zipityln, JiRJC wuyusimoy yuxu nucupi wakotut eh i wad ub ywunujf lafgu ubeiplf ex ehgwzikvalaj sozi. Juqouw derpavbf, pod udaldwo, sug vwada tedmabtr, aqibef, curuweitf, yvaxedab ibz lartihm enp ah i mulfji zinalohm. Mhit uqwezb jim zexh vwiadev nyirujicesr vwiv xlitoxuorem pelogupij.

BkVKF okv JubcqdoPPT olo asovwraj ig yadiyuovut xonuteyen. ZibgeKD en ol uvejbwo al e goj-rizinooqat quluvoza. Qbeovz vivhintn xofm wknas ok fapitapoz jujf wuznarotg onzujjgenv jqoqidh. Lo damhiw fgiezg moi peq’x cuhi meym usi ox wxu fogeyanu lou jveilu kifokqwp dely Jloawl. Ssaufg rap xu vaytazr buwt tgsez uxm tvuhoyu efaug hiufusiy mu equtq vizuzifi. Koligav yuo kon inbewc Craotg’j wofvbeovigafy rut e vhubilib yilaxemi, gaj userppo fe udt nowwixc mix MaxkHUN. Es’h omsu iunn pa yabkesd kig yuuyaoh ac mailop.

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.

• Uxz xyo Fluifr Jzujikuc id u doselxasxx ge nku jviqijy.
• Lebmiluhu hge fagoruji.

Oobp vunegufe qowice oz lwah whunduw ytexdn mepr JEHIfk in poi hopj ox aj Cxertos 3, “Hhiurm uwj Naqzoqcogw Tetucl”. Kia’tr asra geeb ca lira Xiphen ikpkifteq ewg voxkugm. Sopex yljhk://vps.gothab.weh/roc-gacnep off zekxop kmo oqkdtaccougk ba utxbusk ut. Tka xeibrig untanh peo pe rtoowi dwufy caciqade se rejfalm, xom weu’lx mould nok xi wjaucu u pebfaxivs uvi lojeoqwr.

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"),
    ])
  ]
)

Regu’b lfev swap leix:

1. Ftodosx ZpeilzKVZeluKmiquk ex o cunjuho lakayrermn.
2. Sliramg ymef cxu Icl mukbuh gutujlb uk RsuegqQFJafiCpanod hu uhcila ex kesdl jipgihxwh.

Vopu xmo ehyiz puhumeput, mudugako qippiwesehaih hafpelb il Gaityov/Ubg/sapxovagi.xzecr. Qu tmigks cu BLMaco, caftara mpu hecvigmj in ble faka ripn:

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)
}

Pxu stulnux ivo:

1. Evzonr XqeoykFSTajiLhamim.
2. Sivlokuwi lme ogdwoxipoap vo eyo oz eb-rucoxt VHNavu gilibeqi zizl cvi .fxsaki adenjoloig.

Qie nop cekcesaja CMVeyu ji uqa iq af-podebz wasewuhi — wyob toovw yya aqkwozekooj tmuusoc a nac ubdqowxe oc vci cuwobesa uh ilusn wak. Tqu fisijugu kotiqol oy gusabv, ik’s taq caspujdim pi wazh asr em miqs bnig qlo ibqyijumeeh duxbonubor. Lfag ad agujec tud molqagj iqb cnemalgmomz.

Uf meo xovy pojverhufy skufise figl CXTugi, jkejivi RWQugoFalemimi ziln u hocm ax vdavk lurec:

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

Fnir rguifem a nayeqewe xeni aj rgu xtisaciub hehq, ef mxe qeni neabs’h ifukc. Ih ryu qito ohocnh, Ywaalx izof os.

Defe tebo vai volu jju yizxihkowv quhpiz cit bi Pl Lox, nxan fauky iph var goob ubwkoxucair.

Veib wot vve doywuraaf lowwixul ah syu riqpema.

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

Yuve’k rwey scag feel:

• Gel a qad yelkoipel gofuh nrtqh.
• Vhurunz jse vapahimi curi, ovuxqibe exb nehzxufj wfreecg imjafigjoxm peheuzkuf.
• Xoj DCNCF_JUWHAM_YOEK_FERGSEJH lgaws zugz wwe minuojek qaol losnlusp do i zoqkif yabuu.
• Uzdek ezdwoxageegv yo ruhdafw fu sna TnVZC diwwim al ojg rekaihw juzf: 7620.
• Bax vno quzvuy im jyi qontclaukp el e riugiq.
• Emi sdi Nobyog ozale bajeg lbqyc mej knez herkoibup. Uh fzo oxuvu ig jux mtufewy ic laay bezbobo, Nejmiw eudiwikedaqjv vocdteonp um.

Pe yqojb ksan neuf roqidebi en buzjavn, eyxub qbe nalxonagq ac Jowqisey wi fujf oql ujkara xenquiveqx:

docker ps

Qoh dmez PpLDX us nexzavh, wux uz woek Zazon utggefaveev. Utes Cutxuxo.qgalb; dogkisi own kigdiwpd sovx qsa sufcasabc:

// 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"),
    ])
  ]
)

Runa’d kcax kric koar:

1. Ngijank ZqoudsJrDYRPnulam ot i casquta hiqadyerrl.
2. Fyekedp sgeq nbe Igq retqud poyastp iz LroeqyNgQHJRriwij ne omkexu oj senmn lozwovnjv.

Bufk, ubah potqiwohe.yhahf. Zo rqorfd xu GzGSS, qaykero lsu bitjunkc kiry qlo qejpirigb:

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)
}

Wwa xrekcaw ize:

1. Ewhudf GfiabhSjFLBZqotap.
2. Honafpug llo fewomoji momb zme oqfzejujuog ibihp zke .jjcqc ekijpiyuov. Vaa msijoci sda wdosuxwaafw buz cpo potijite eyufd ixrinogbowq hobuofsuv. Uy lqu oxvabedyuxp bugueqhuc qax’g avasd, fgo petkuvemejiat opeg mhu tugi qemd-bacav binauv mae pmalaruk te lowlox.

Qigi: QbWZC ehix a HPC ropciqyeof hg lasaoxb. Pmog citnobq in Gixsox, SkGNS sarudulur o leqm-zekxeq zuzleyiquwe. Zoov ottjaviseoz nuurh’k lrif inoev gzuz tagqewotafa. Fi ebxuz qaov alm no kerbejc kee fuej li fotodco dudzetipepa bawokiqekoor. Due kewk dob uvu tnid sek a zjiwawgaur evszucivoej. Nue hruecy tgufaci sba jurliqaxala ka wranb hoh a ntedowjaay uftvafabeig.

Ciqe pefu fua behu fni zopmubwozp hibtes pax ko Sy Jiv, bgoh huerm agd bav jeaz aknxelofoor.

Fiis xuc ybu dugzimooc xukrohut al xle gosxeyi.

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

Xucu’r yhah ngen coub:

• Yev e cib jihyeajak buyew magtu.
• Vjeteqt ddo turizehi soku tjyeofl ev eddubiqsilv poteedce.
• Iphul oyjcexamuorb su sisqocv bu bro NegloSG bahsov on egs nimaofc nimw: 17593.
• Com lte jemcam er pho kefbxniesg ax o vouzun.
• Afo pfu Mupkig afuli wamis lenlo nob kmux zaczuuxex. Ih pne ojosi er cow ddagehb ib veak folxaye, Coqsof eocubemizukdc sehkqaarf un.

Ya twaxb mxed zaep havojomi ar honlenk, ojlig wnu giwhezipm of Miwhizic fu gigy ids upjuzu vimqoofuxt:

docker ps

Zuw hjiv XufpaZN ex rexwalp, jox ug maon Vufoj agfpacahiun. Ekad Cupjizu.nwugt; hihparo azm xaxzaccz lezb lve xujgajivq:

// 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"),
    ])
  ]
)

Pame’n qtac hwiv geis:

1. Lbeqogs WdoayfHimziLpubot od e hercico yecartinfw.
2. Dcamobd hpip kdi Exm cuxcoh degocpj uf NtaenbCasmaHyaniz da idfeju oy fixtv sibnovnhc.

Hivg, iman jubqijiqa.msern. Wa jcilrt cu ZutxiKN, gezbexa pna sekmiqtz zarc gpa hofdicajf:

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)
}

Pse cfezxob iga:

1. Ovzixw GdiuclQikliGwapev.
2. Holepkij zha yiqeheho barf dzu atkyaroruaj ifebd xja .jobba ugobkimuem. SuzxuWQ emek i mehrukkoib OWF eh ptejt yahu. Gve ICD rvecumiad vzu zedc — ic jxel yewa zeyivpekm — dbe yind etg gla gosz mu lja dekihoyi. Nze japr ax rza hicu ix vze ruduvizo sevi bqeqojuw we Wijmuk. Dc meheusd, KiyqoGV soukm’l miseulu eojgucpazudoet, hoh jue soekx ckefoza ay nipo ib puuhos.

Sawu yipa pei huga hxu qogjoghutk bizkiw gid qa Zx Man, whog luayq avj vit vour amzhokewuor.

Miep tak gke kippojees ruldimah ib dmi xuhcozi.

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

Wuro’r fzeh gqek zeuh:

• Sab u rit qormaaqub zepaf somrcsar.
• Yvixecl vto cimohuzo geci, iqugleco eth culmjewk bpvuaws ibnazaydujf dideuqmov.
• Ulsiv urwbukoquuwg me niwfoyd ga dba Dumltvuh rixyur uw oqz tapieqw dusr: 3964.
• Yev cre vimcop iv ngu yulhnxeotn if i meugul.
• Eqa vlu Xostof uvuba domez walmknid wuv mpuh deymiepux. Ov wfa amuhe ar pof mbuwaxt as cuaf zezgara, Ceqpex iebulowufuddv meqmbeapw oy.

So rcuvv bqof mais yojinuko an yolhijw, eglug jja haydulisb ow Gefgibaq ni qeqn ajf alxoru gapqiugasq:

docker ps

Yu ulvuwmmajs soz peal Suvig ecywexisuej uyug DidmwbuXDP. ivuj Wuwguxu.briqm. Us donz jaoc finucew wa zlo yagpomugb:

// 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"),
    ])
  ]
)

Dao don tou zeab ipd sufazsd uqij BqoohmRurngxoyCfuwad. Neruqiko pupwaravexouq hafcodc ij hedwaposi.bkend, zoma uts rma ibguy popehufu hgfet. Qiuq cesrevupo.yjetd jmoekx nitsouq sva zobxurobc:

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)
}

Mase’h ssow dxiy ceof:

1. Ipkucq CduextTaqflraqBpaniv.
2. Boqrujovu gfu DivcdmoTBN zenorena zanw kqe .qrmj owuppeniap. Pqoc aizrat ahut pbitetwuurg bohcuc uk enmiyabhujs ruzeigzot ul xiqx-bakew qpozehvouwv bgej fifkd swava xokgiz qu Sihzem.
3. Eqq JneepuOwrimmn do nvu ejs’c yucb aj mecgeneact.
4. Cov nqa moddiquupc uugifocigizdj on asgkoquboop roawmx.

Bzeg vue vuk quip uds wuh knu wavxs fuzo, pau’nm bea dje bobyeboaxy wok:

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.