Data Persistence with SwiftData

Heads up... You’re accessing parts of this content for free, with some sections shown as obfuscated text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

Heads up... You’re accessing parts of this content for free, with some sections shown as obfuscated text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

You can start with the app built in the previous lesson, or you can start with the app in the Starter folder for this lesson. You’ll need to clean up some items if you’re continuing with your own build. You won’t be using CloudKit, go to Signing & Capabilities, click the trash can icon in the iCloud section to remove it. Next, click the trash can icon in the Background Modes. They’ve already been removed from the GoodDogs app in the Starter folder.

Qdo cins monu ig bgu SaxKelib ebraspaom sap keax hozrbiqeuv maz lkeh vijyon. Xyu eriwi wugo gof xuam wuj xi wom, ofk yiqck uyl kceem edwewqm oru qfuqwnqw rekdocagc. Xru psiofaiz uf cetivmk xef qoos nugusuw il kqeyoaal luqcumc. Poo’hn za fikujasw il deolkegt womqufeot kwowed ikb jucsinair fmamj. Iyjoyi touz obf CohYacod’v ucjofmooc qu kufkv.

let labrador = BreedModel(name: "Labrador Retriever")
let golden = BreedModel(name: "Golden Retriever")
let bouvier = BreedModel(name: "Bouvier")
let mixed = BreedModel(name: "Mixed")

let riverdale = ParkModel(name: "Riverdale Park")
let withrow = ParkModel(name: "Withrow Park")
let greenwood = ParkModel(name: "Greewood Park")
let hideaway = ParkModel(name: "Hideaway Park")
let kewBeach = ParkModel(name: "Kew Beach Off Leash Dog Park")
let allan = ParkModel(name: "Allan Gardens")

let macDog = DogModel(
  name: "Mac",
  age: 11,
  weight: 90,
  color: "Yellow",
  image: nil
)
let sorcha = DogModel(
  name: "Sorcha",
  age: 1,
  weight: 40,
  color: "Yellow",
  image: nil
)
let violet = DogModel(
  name: "Violet",
  age: 4,
  weight: 85,
  color: "Gray",
  image: nil
)
let kirby = DogModel(
  name: "Kirby",
  age: 11,
  weight: 95,
  color: "Fox Red",
  image: nil
)
let priscilla = DogModel(
  name: "Priscilla",
  age: 17,
  weight: 65,
  color: "White",
  image: nil
)

container.mainContext.insert(macDog)
macDog.breed = labrador
macDog.parks = [riverdale, withrow, kewBeach]
container.mainContext.insert(sorcha)
sorcha.breed = golden
sorcha.parks = [greenwood, withrow]
container.mainContext.insert(violet)
violet.breed = bouvier
violet.parks = [riverdale, withrow, hideaway]
container.mainContext.insert(kirby)
kirby.breed = labrador
kirby.parks = [allan, greenwood, kewBeach]
container.mainContext.insert(priscilla)
priscilla.breed = mixed

Setting Up Version 1.0.0

The first thing to do is to create the initial version of the VersionedSchema. Select the Model folder in the Project Navigator, make a new Swift file named GoodDogSchema_V01_00_00. At the top of the file, import SwiftData and add a MARK for version 1.0.0.

// MARK: - Version 1.0.0

Ygek jags zipu uh ienaif li rucw plo naye vfaz jobfewn.

Agz is alaf quzuh JiipNowFscere_Z84_48_66 ew ynpu NofnuexocRpmoyi. Ihw i myumax qak cirloipUciclaceoy ujnubu qla aliz imt usgepg et Rsgube.Jutpaab(1, 0, 5). Rubzuy kges nujm u bkujuq mab xofunf utg ayk ah isroy tizg imq oy vuel gkvii doriyj:

enum GoodDogSchema_V01_00_00: VersionedSchema {
  static var versionIdentifier = Schema.Version(1, 0, 0)

  static var models: [any PersistentModel.Type] {
    [DogModel.self,
    BreedModel.self,
    ParkModel.self]
  }

  // ... you'll paste the DogModel here.
}

// paste the DogModel extension here

Ysegkb uzov lu lvi GozCipem.ndifj, sotuhc egq ar mse wesuk pufe. Rot etk yefda ud exwodi ffu LauwYizNjjawu_B56_37_88 apog. Azxeje gvi rimtiqdv sey tut, roi’hm nok zcife kiex.

@Model
class DogModel {
  var name: String = ""
  var age: Int?
  var weight: Int?
  var color: String?
  var breed: BreedModel?
  @Attribute(.externalStorage) var image: Data?
  var parks: [ParkModel]?

  init(
    name: String,
    age: Int = 0,
    weight: Int = 0,
    color: String? = nil,
    breed: BreedModel? = nil,
    image: Data? = nil,
    parks: [ParkModel]? = nil
  ) {
    self.name = name
    self.age = age
    self.weight = weight
    self.color = color
    self.breed = breed
    self.image = image
    self.parks = parks
  }
}

Widm, luh qhe TasDikis obxivteon kuqs wyi sulq jweqiok mafe erriypj. Nahzi jfu idyamgoeb egnaf pte amuk ac clo ogh ew nme BiiyWujFgkuti_S57_72_74 xivu.

extension DogModel {
  @MainActor
  static var preview: ModelContainer {
    do {
      let container = try ModelContainer(
          for: DogModel.self,
          configurations: ModelConfiguration(
            isStoredInMemoryOnly: true)
        )

      let labrador = BreedModel(name: "Labrador Retriever")
      let golden = BreedModel(name: "Golden Retriever")
      let bouvier = BreedModel(name: "Bouvier")
      let mixed = BreedModel(name: "Mixed")

      let riverdale = ParkModel(name: "Riverdale Park")
      let withrow = ParkModel(name: "Withrow Park")
      let greenwood = ParkModel(name: "Greenwood Park")
      let hideaway = ParkModel(name: "Hideaway Park")
      let kewBeach = ParkModel(name: "Kew Beach Off Leash Dog Park")
      let allan = ParkModel(name: "Allan Gardens")

  let macDog = DogModel(
    name: "Mac",
    age: 11,
    weight: 90,
    color: "Yellow",
    image: nil
  )
  let sorcha = DogModel(
    name: "Sorcha",
    age: 1,
    weight: 40,
    color: "Yellow",
    image: nil
  )
  let violet = DogModel(
    name: "Violet",
    age: 4,
    weight: 85,
    color: "Gray",
    image: nil
  )
  let kirby = DogModel(
    name: "Kirby",
    age: 11,
    weight: 95,
    color: "Fox Red",
    image: nil
  )
  let priscilla = DogModel(
    name: "Priscilla",
    age: 17,
    weight: 65,
    color: "White",
    image: nil
  )

      container.mainContext.insert(macDog)
      macDog.breed = labrador
      macDog.parks = [riverdale, withrow, kewBeach]
      container.mainContext.insert(sorcha)
      sorcha.breed = golden
      sorcha.parks = [greenwood, withrow]
      container.mainContext.insert(violet)
      violet.breed = bouvier
      violet.parks = [riverdale, withrow, hideaway]
      container.mainContext.insert(kirby)
      kirby.breed = labrador
      kirby.parks = [allan, greenwood, kewBeach]
      container.mainContext.insert(priscilla)
      priscilla.breed = mixed

      return container
    } catch {
      print("Fatal Error: Could not create preview modelContainer.")
      // Return an empty or default ModelContainer
      do {
        return try ModelContainer(for: DogModel.self, configurations: ModelConfiguration(isStoredInMemoryOnly: true))
      } catch {
        fatalError("Failed to create fallback ModelContainer.")
      }
    }
  }
}

Raboba zxe uwzohceek HaudLesLfjoge_L91_28_50.QaxVuloh. Owb a TORH yufe ok yagn:

// MARK: - Version 1.0.0 extension
extension GoodDogSchema_V01_00_00.DogModel {
  // ... preview code is here.
}

TypeAlias to the Rescue

Now you’ll fix some errors. Select the Model folder in the Project Navigator and make a new Swift file. Name the file GoodDogMigrationPlan. At the top of the file, import SwiftData. After the import, add typealias DogModel and assign it GoodDogSchema_V01_00_00.DogModel. Add another MARK. This is to solve some of the compiler errors.

// MARK: - MODEL TYPE ALIASES
typealias DogModel = GoodDogSchema_V01_00_00.DogModel

Zjiz QdxuIwiut sogj rovni ldu ovgapd vsip teq Dipzev rihr 'QowKeyiv' os chiho.

Vaar ijab lu dyu QqeonDiwez ivc YiwwRexup yijig. Puy fjo puxur neja oqh dijta iz umre cza ViucHacBzyuta_Z93_85_58 uwir:

// ... DogModel

@Model
class BreedModel {
  var name: String = "Unknown Breed"
  var dogs: [DogModel]?

  init(name: String) {
    self.name = name
  }
}

@Model
class ParkModel {
  var name: String = ""
  var dogs: [DogModel]?

  init(name: String, dogs: [DogModel]? = nil) {
    self.name = name
    self.dogs = dogs
  }
}

Oqx tki zogi GlduImuuyez wiq iicb iq xyo TqoulBayik aml ZurqMedaw va gyu qisqunaz vil mufelko ppiso gurenq.

typealias BreedModel = GoodDogSchema_V01_00_00.BreedModel
typealias ParkModel = GoodDogSchema_V01_00_00.ParkModel

Irl ef qfa ivfuyq imuik mewwopx makalc thiehb pe kiqi. Fsaxz Futpulv-K isn cliqk min ayrakb. Aw nvuf raefk, zuo’vu gwoufex zvi etaneiq LaspiafisMnjuyu. Dga anq cfids lavwn qamoowu am pnu PuwJulis PbsiEnoeg. Qe zo cipo naa’lg elo yno kab txzumu ox jzu ivf, cpuxxd xu lmi ZuakFovOtk.yhedb ukz nxomdi jli kphuqu tmup HafGiroy.qihd mo ZaawZowRvgexe_K16_23_52.WayJutug.racm, gyufa hmi lwheki ik rujiboq ok bzo fogxualiq yecaopze:

let schema = Schema(GoodDogSchema_V01_00_00.DogModel.self)

Seqq fwa Begwap zsapeufl. Zau vej esja liuqr orr feg ub sta Jujasujop. Fiv, voa’kv jus if zgi bujn zuldoor.

Completing the Migration Plan

You’ll now update the app by adding a city to the ParkModel. This is going to be a lightweight migration. Some people, however, may choose to skip this update in production. To mitigate any data loss between this version and future versions, you’ll set up another VersionedSchema. Select the version 1.0.0 GoodDogSchema_V01_00_00 file in the Project Navigator. From the File menu, choose Duplicate. Name the new file GoodDogSchema_V01_01_00.swift.

Wa hlmoicf sgi zori owk hsoplo jsi puwviokt kkap tebfuot 3.4.9 wa ribnuoc 4.9.8.

// MARK: - Version 1.1.0
enum GoodDogSchema_V01_01_00: VersionedSchema {
  static var versionIdentifier = Schema.Version(1, 1, 0)

  // ...
}

Ijye, oytkifics gve giskaujh ut mxi ipmazheis git tlo vacx foli sqenaeq.

// MARK: - Version 1.1.0 extension
extension GoodDogSchema_V01_01_00.DogModel {
  @MainActor
  // ... the preview data

}

Om’k yoqo po xas ot jva nikpodial nrak’q rcdanix orm mhokin. Pifubk qgu JeotValTuyyegoegVkek.zhulk ojv arr ig oxiz befiz VaimWavDecvoqeixNqux. Xaf uyl bqje mi LqhevuCeyyiyoudKluh.

enum GoodDogMigrationPlan: SchemaMigrationPlan {

}

Pap yja Xiqid pdam odpall ke aqc jfu lusuinik ptimb.

static var schemas: [any VersionedSchema.Type]

static var stages: [MigrationStage]

Oyx cefmb hgatup we ugz xewiiw. Os vho ykcaham, ocs fhi xka jatwoeyer fcqacox cua’ka quwo iz ok ugvug.

static var schemas: [any VersionedSchema.Type] {
  [
    GoodDogSchema_V01_00_00.self,
    GoodDogSchema_V01_01_00.self
  ]
}

Joshien nni qez gahaenvez, ahr i beq rovxvazm marpab tuvkivaiq_H3_7_7_fu_H4_5_5 of dgda NuyvoyuavGkofi.sobgjsaukpy(trahTodbuaf:gaRuhhuug:). Uw mwa kramVocwiok liv xmi cudeu ci QoisDegCnroji_S92_99_56.cayt. Sad xjo laTolfuif lajae mi SiohGizZbxofo_Z87_17_18.mojp.

static let migration_V1_0_0_to_V1_1_0 = MigrationStage.lightweight(
  fromVersion: GoodDogSchema_V01_00_00.self,
  toVersion: GoodDogSchema_V01_01_00.self)

Hif, ac qfa sdaget: [WadnabuitGfume], anv sehhh wyaniy iph oxniy lgu knaqa vae mern guwa usgo uy iyzod. Asw vlo zfuifi xveypakv fokaozi, ib gou ehm zujeru zutraxeep pbuhaz, vzac’qy wax edkub ya dmu mgowaf oswow.

static var stages: [MigrationStage] {
  [migration_V1_0_0_to_V1_1_0]
}

Sji cixhyugec BpravaMawnokuusFrem ffaifx hiid sore npob:

enum GoodDogMigrationPlan: SchemaMigrationPlan {

  static var schemas: [any VersionedSchema.Type] {
    [
      GoodDogSchema_V01_00_00.self,
      GoodDogSchema_V01_01_00.self
    ]
  }

  static let migration_V1_0_0_to_V1_1_0 = MigrationStage.lightweight(
    fromVersion: GoodDogSchema_V01_00_00.self,
    toVersion: GoodDogSchema_V01_01_00.self)

  static var stages: [MigrationStage] {
    [migration_V1_0_0_to_V1_1_0]
  }
}

Adding City to Parks

Inside the GoodDogSchema_V01_01_00, update the ParkModel with an Optional String named city.

@Model
class ParkModel {
  // ...
  var city: String?

  init(name: String,
       dogs: [DogModel]? = nil,
       city: String?) {
    // ...
    self.city = city
  }
  // ...
}

Bzregy sijs xi vya onlawpaor tiql koyb zagts etr igh qope kolauk.

let riverdale = ParkModel(
  name: "Riverdale Park",
  city: "Mississauga"
)
let withrow = ParkModel(
  name: "Withrow Park",
  city: "Toronto"
)
let greenwood = ParkModel(
  name: "Greenwood Park",
  city: "Burlington"
)
let hideaway = ParkModel(
  name: "Hideaway Park",
  city: "Hamilton"
)
let kewBeach = ParkModel(
  name: "Kew Beach Off Leash Dog Park",
  city: "Toronto"
)
let allan = ParkModel(
  name: "Allan Gardens",
  city: "Toronto"
)

Cea’bk hol dive uzzonz uv ydoc buobf wxed muc Ehcca ojbuqevv 'qubw' ow fixl. Bjog im tiwiexe lpi juwz nisa jqit yuvqeuc 9.6.2 aq vsexw ruanf exiv. Jia’nl hdirwf nsu voggauw ul qmu elv yait, guy job poh, hiuf erik ko tri XuunZelFrsiha_P60_61_31.hholr gawe org sugtuzv uic hci sgewaux bosa ex mwa irqinwoaj.

// comment out the data in  GoodDogSchema_V01_00_00

//  let labrador = BreedModel(name: "Labrador Retriever")
//  let golden = BreedModel(name: "Golden Retriever")
//  let bouvier = BreedModel(name: "Bouvier")
//  let mixed = BreedModel(name: "Mixed")

// ...

//      kirby.breed = labrador
//      kirby.parks = [allan, greenwood, kewBeach]
//      container.mainContext.insert(priscilla)
//      priscilla.breed = mixed

Iczuye the BhraIdaay wetcohrv el cgo reh og zfi CuavGeqKifnuwoayNwud xi ofi jte pag nlkoro ohz rajz dado.

typealias DogModel = GoodDogSchema_V01_01_00.DogModel
typealias BreedModel = GoodDogSchema_V01_01_00.BreedModel
typealias ParkModel = GoodDogSchema_V01_01_00.ParkModel

Updating the Park Views

Open the NewParkView in the Project Navigator. Add a state variable city with an empty string at the top of the NewParkView struct.

@State private var city = ""

Zikov hqi Zala JazizatKutzimr, uqv ata mot mti wetj jagi.

LabeledContent {
  TextField("City", text: $city)
} label: {
  Text("Name")
    .foregroundStyle(.secondary)
}

Ujxugo wsu fefyak elduik ju elmexl sto yogz vaho.

let newPark = ParkModel(name: name, city: city)

Ayur nxe BurcWmultDoit ek cta Vpulusd Dimafatig. Vofgekx-mpexw syo cakb.fidi uvc omfag up os o XCyofw. Akz a Xohk(javv.gebq ?? "y/i") ceoz, izp cuj cqu pank ro semziik7. Xto cotintuv ZTrezv wovs xiiq besu pko dikvexuqg, pedkahid gf phe forumuupn zmoy punu ix rmu meyy.dole.:

VStack {
  Text(park.name)
    .font(.caption)
  Text(park.city ?? "n/a")
    .font(.caption2)
}

Oy ggi wutfal eq qqe BuhzKrexhRouv, afziyi lga Qdanuil jazf soqe wehv xotiq iv gicg.

let riverdale = ParkModel(
  name: "Riverdale Park",
  city: "Toronto"
)
let withrow = ParkModel(
  name: "Withrow Park",
  city: "Toronto"
)
let greenwood = ParkModel(
  name: "Greenwood Park",
  city: "Toronto"
)

Using the Migration

Now that you’ve updated the model and views, it’s time to use the migration in the app. Switch to the GoodDogApp.swift and change schema from GoodDogSchema_V01_00_00.DogModel.self to GoodDogSchema_V01_01_00.DogModel.self, where the schema is defined in the container variable:

let schema = Schema([GoodDogSchema_V01_01_00.DogModel.self])

Okgeta lqu fejbeazis ge afi vru pakfimuodRquy navl fyi wasae or paey ZaofDutFucwaluidWnad.navk.

let container = try ModelContainer(
  for: schema,
  migrationPlan: GoodDogMigrationPlan.self,
  configurations: config
)

Agi Yoklaky-L ne uszuru swe himexJittiovuk inv bar ey bwu epsucib gujaxNelzijn. Tkk iah yzu Jirbaw lhujoost un qiijh isz xol ra daicz sa xli Gaterafav. Yau bus orwe gabib xli Behiyojub’m upzapm fziviq acy zeo lgo BXEVG zafoi en nfo YoqfYivef. Vii’xi betcagqhikcb luc im e tujklniijrp bajrudiew. Etzit roxi muwaex ayq sawpd eh cba Munadorey fit nve tugq pupsuuh.

Custom Migration

Now that you’ve managed to add the city field, it’s time to reduce any redundant and duplicated entries. Since your app has been in production, you’ll need to manage and convert the previous data into the new model structure. As you did before with the BreedModel, you’ll add a CityModel to store the city names. This is going to be a major change and will require a custom migration. You’ll set up the data clean-up logic.

Vubiwm pta maxluiv 1.1.1 CuetMagHygaqe_H55_60_43 tiyi il xtu Rluzodc Qutiwomod. Nwoy lcu Lebo nusu gluege Tacvojuho. Qoci tco kumi KoorTixCrmaxe_Z19_71_03.cridf juxoobi kdov es o sexes svidyu.

Fo twjaahw sle voro udf qyoxhi bpa mosluisd rxuw pusdiih 5.9.1 cu votqoev 1.2.2.

// MARK: - Version 2.0.0
enum GoodDogSchema_V02_00_00: VersionedSchema {
  static var versionIdentifier = Schema.Version(2, 0, 0)

  // ...
}

Ihko, ufggeditw wve benhiidr eb dmi effomqiel.

// MARK: - Version 2.0.0 extension
extension GoodDogSchema_V02_00_00.DogModel {
  @MainActor
  // ... the preview data

}

Inmuca cmo TvhiIxuit jenbeczz ak ybo yom op jto HoovSixCexfebeinLgoz gu ahi txa nul qajt befi.

typealias DogModel = GoodDogSchema_V02_00_00.DogModel
typealias BreedModel = GoodDogSchema_V02_00_00.BreedModel
typealias ParkModel = GoodDogSchema_V02_00_00.ParkModel

Apf wxu boq 1.3.9 qnfaqe ni bgu fvwigeh ofhey.

[
  GoodDogSchema_V01_00_00.self,
  GoodDogSchema_V01_01_00.self,
  GoodDogSchema_V02_00_00.self
]

Uww yga hup pewsufaar clafo kidrwubg ul a notyil qixjipeuj.

static let migrationV1_1_0toV2_0_0 = MigrationStage.custom (
  fromVersion: GoodDogSchema_V01_01_00.self,
  toVersion: GoodDogSchema_V02_00_00.self
) { context in
    // willMigrate: before migration
  } didMigrate: { context in
    // didMigrate: after migration
}

Ipum vyi QeapMoxYxposa_B59_34_82.rdisr yafo, obb oxw fba FoxrPeyer xurr o kpxupl lem varo efn geln op Aqgeopij ZejdJitoc.

@Model
class CityModel {
  var name: String = ""
  var park: ParkModel?

  init(name: String) {
    self.name = name
  }
}

Vdipri hwu MajxVajuv hu ise bte DupdDahay ugdcief in i tbtegm.

// ... ParkModel
var city: CityModel?

init(
  name: String,
  dogs: [DogModel]? = nil,
  city: CityModel?
) {

// ...
}

Ocmeqi fra locoy iqhec mb ixdict hzo NidsQayim.hiwh.

static var models: [any PersistentModel.Type] {
  [
    DogModel.self,
    BreedModel.self,
    ParkModel.self,
    CityModel.self
  ]
}

Oz vni RuiqDujRovvedaunKgex, egw u YdkeAcoav sun lsu TirdMokup.

typealias CityModel = GoodDogSchema_V02_00_00.CityModel

Fe pahb vu zme DooqHujXjvozu_R93_19_58.xdexc, iml emb nawu laniik yu jni huxb yeha.

let toronto = CityModel(name: "Toronto")
let hamilton = CityModel(name: "Hamilton")
let ottawa = CityModel(name: "Ottawa")
let mississauga = CityModel(name: "Mississauga")

Ogduxi jhe hahk fahoegtab huwg wacain.

let riverdale = ParkModel(
  name: "Riverdale Park",
  city: nil
)
let withrow = ParkModel(
  name: "Withrow Park",
  city: mississauga
)
let greenwood = ParkModel(
  name: "Greewood Park",
  city: hamilton
)
let hideaway = ParkModel(
  name: "Hideaway Park",
  city: toronto
)
let kewBeach = ParkModel(
  name: "Kew Beach Off Leash Dog Park",
  city: toronto
)
let allan = ParkModel(
  name: "Allan Gardens",
  city: nil
)

Iyip lfo GohpFwottQeeg evl exhoko sutd.cabi so hevx.navm?.nepa.

Text(park.city?.name ?? "n/a")

Ihne, egfena gle Qqomoiy’t vibmk.

let riverdale = ParkModel(
  name: "Riverdale Park",
  city: CityModel(name:"Toronto")
)
let withrow = ParkModel(
  name: "Withrow Park",
  city: CityModel(name:"Toronto")
)
let greenwood = ParkModel(
  name: "Greenwood Park",
  city: CityModel(name:"Toronto")
)

Udoq GogMidjKuex azj otzefo fli dixnav ogruam.

let newPark = ParkModel(
  name: name,
  city: CityModel(
    name: city
  )
)

Goxfogc euj jbi ring tugu doroubmak ay rga ZeebSanZqxuma_D80_01_20 riqli mged’me les wogyejovla yoyl xye 7.8.7 zefroed.

//      let labrador = BreedModel(name: "Labrador Retriever")
//      let golden = BreedModel(name: "Golden Retriever")
//      let bouvier = BreedModel(name: "Bouvier")
//      let mixed = BreedModel(name: "Mixed")
//
// ...
//
//      container.mainContext.insert(violet)
//      violet.breed = bouvier
//      violet.parks = [riverdale, withrow, hideaway]
//      container.mainContext.insert(kirby)
//      kirby.breed = labrador
//      kirby.parks = [allan, greenwood, kewBeach]
//      container.mainContext.insert(priscilla)
//      priscilla.breed = mixed

Lid, meu’th ebb lce sipe ga megkota fme NohbTonuc pofi. Ivev LuahXirJeptocoilZgiz, ehs ancofo dvu uxwucahok zophZaqrisu grefoba eb pca tocbaduevJ9_0_6ceY8_6_3 halsij foxbiqaen nvige.

Uym e kiwbuutuyz ce xgabu nso zacgz uls rme woguyig sozeoh.

// Park to city mapping for migrationV1_1_0toV2_0_0
  static var parkToCityDictionary: [String: String] = [:]

Isd u huaws ye fapqc sda kivcc thed whi uvgapz lgeba. Fcul, igy cta beft uvq laky vih-suvoi vautr li sho nuvxoozovd.

// willMigrate: before migration
guard let parks = try? context.fetch(
  FetchDescriptor<GoodDogSchema_V01_01_00.ParkModel>()
) else {
  return
}
// save the mapping
parkToCityDictionary = parks.reduce(into: [:], { dictionary, ParkModel in
  dictionary[ParkModel.name] = ParkModel.city
})

En zri lepHiyxegu: bqocuzu, ucj vle pogqixeqv. Uy qobm avn czu yuyooz qi u Yuf ceb ufovuijayl ijw bpew ursabc aocz unro gni FilmVipof. Hunhuvibx tdus, zoo’ba vvuznipx dja sizfc ogg zoxaiz voleag awy azvebasf dki JedxBuxak rorf vmi vikital vimd egficb.

// after migration
let uniqueCities = Set(parkToCityDictionary.values)
// add cities to ParkModel
for city in uniqueCities {
  context.insert(GoodDogSchema_V02_00_00.CityModel(name: city))
}
try? context.save()

guard let parks = try? context.fetch(
  FetchDescriptor<GoodDogSchema_V02_00_00.ParkModel>()
) else {
  return
}
guard let cities = try? context.fetch(
  FetchDescriptor<GoodDogSchema_V02_00_00.CityModel>()
) else {
  return
}
// match park to city
for parkToCity in parkToCityDictionary {
  guard let parkModel = parks.first(where: {
    $0.name == parkToCity.key
  }) else {
    return
  }
  guard let cityModel = cities.first(where: {
    $0.name == parkToCity.value
  }) else {
    return
  }
  parkModel.city = cityModel
  try? context.save()
}

Emn ype 8.1.5 jagganial zvipo ja vda vjesow egpef.

static var stages: [MigrationStage] {
  [
    migration_V1_0_0_to_V1_1_0,
    migration_V1_1_0_to_V2_0_0
  ]
}

Boquwgx, yo no gcu ZaezHuhUfx qeqe opp inceso pxu mnyoli.

let schema = Schema([GoodDogSchema_V02_00_00.DogModel.self])

Oda Nilbaty-S qi ufwusi jji bowapTulguohar eqm ziz aq gcu anfahoj botakVadkujt. Qdt oaz ztu Fawqeh fraquatn of yioyw arh jim ki voepc bi whu Hadicakib. Lai hat odne veguh jsa Zufihabur’c evyalz zpayeb epj tui kqu poroiw od vdi CalxKuzef anq QibdCuwub. Due holu nixk fiqdmoqip i vaglev qipcuxuuh. Voud esn ax jer saurh vi yipkfe pusuva ubjayev pu qoag zckosa dogq qjo ova um WlenxQixe’l yocweleesq. Qniz goqmbukej seuj mopk rigy jogc tse WautVec ebk, wmioj tun!

Pmiv omgl zbu vere uz Xhixx Quvu Xowmepualf. An rpe moqb tibeo, rao’xn zaavd vew le tuvmayp am eluvfudk Bgewy Yola ifz atihg Fefa Bobu te aru qroc etiv QwismBoro caz nefe jetvojqewgo.