hasMany(_:through:using:key:)

Creates a HasManyThroughAssociation between Self and the destination TableRecord type.

static func hasMany<Pivot, Target>(_ destination: Target.RowDecoder.Type, through pivot: Pivot, using target: Target, key: String? = nil) -> HasManyThroughAssociation<Self, Target.RowDecoder> where Self == Pivot.OriginRowDecoder, Pivot : Association, Target : Association, Pivot.RowDecoder == Target.OriginRowDecoder

Mangled symbol

s4GRDB11TableRecordPAAE7hasMany_7through5using3keyAA03HasE18ThroughAssociationVyx10RowDecoderQyd_0_GAKm_qd__qd_0_SSSgt06OriginlM0Qyd__RszAA0K0Rd__AaPRd_0_ANQyd_0_AJRtd__r0_lFZ

What are these?

FNV24 hash: 73J6B

Parameters

destination: The record type at the other side of the association.
pivot: An association from Self to the intermediate type.
target: A target association from the intermediate type to the destination type.
key: The association key. By default, it is the key of the target.

For example:

struct Citizen: TableRecord { }

struct Passport: TableRecord {
    static let citizen = belongsTo(Citizen.self)
}

struct Country: TableRecord {
    static let passports = hasMany(Passport.self)
    static let citizens = hasMany(Citizen.self,
                                  through: passports,
                                  using: Passport.citizen)
}

The association lets you define requests that involve both the source and the destination type.

For example, we can fetch all countries with all their citizens:

struct CountryInfo: FetchableRecord, Decodable {
    var country: Country
    var citizens: [Citizen]
}

try dbQueue.read { db in
    let request = Country
        .including(all: Country.citizens)
        .asRequest(of: CountryInfo.self)
    let countryInfos = try request.fetchAll(db)
    for countryInfo in countryInfos {
        print("\(countryInfo.country.name) has \(countryInfo.citizens.count) citizens")
    }
}

The association can also help fetching associated records:

try dbQueue.read { db in
    let country: Country = ...
    let citizens: [Citizen] = country
        .request(for: Country.citizens)
        .fetchAll(db)
}

For more information about this association, see HasManyThroughAssociation.

Methods that build requests involving associations are defined in the JoinableRequest protocol.