Would the Sharing-GRDB Lib allow me to model Class Inheritance?

[davidakoontz]

I've been working off & on with a Stock App idea. And after many starts and restarts... decided to try a different approach to my killer feature. Instead of working on the Charting of stocks with my personal buy/sell transactions plotted on the stock chart. I changed tacks... thought if I could just get the transactions in the App that charting would flow easily...

Well the first big hurdle I've come to is in modeling the basics of Stocks <-> Transaction ( a 1 to Many relationship ) which SwiftData handles just fine. It is when I split the Transactions by "type" or "kind" ( type appears to be already used keyword) either "Buy" or "Sell" kinds. I could not find a Predicate to put the Transaction in the proper list. I modeled 2 list buyTransation [Transaction] & sellTransaction [Transaction] in the Stock class.

So with the code running I would end up will ALL transactions in each list. Weird! Even though I would enter the transaction in just one list - when fetched the transactions were in both Buy/Sell list.

So I thought - I will have to make a base class Transaction & two inheritance classes BuyTransaction & SellTransaction in the SwiftData model. That did NOT work out. From what I've researched SwiftData does NOT support model inheritance. I don't know if this is still true/valid. I didn't get it to work.

Then I tried a Protocol attempt... not so good either. So then I've done the caveman approach... 2 Transaction tables in SwiftData. It works and allows me to continue design/coding.

So then I saw your release of Sharing Lib. It looks great. Would I have better luck switching persistance strategies mid-stream?
Does your solution allow Inheritance?

I also assume it would be simple SQL to write the Query for BuyTransaction or SellTransaction and use the Enum Kind to distinguish the list.

[mbrandonw]

Hi @davidakoontz, this library doesn't provide any tools that either help nor hinder using inheritance for domain modeling. However, I will say that I think inheritance is not the way to go for this. It is better to denormalize your schema into separate tables, which is just generally recommended for SQL databases.

But also, I'm not sure I see how you are wanting to use inheritance in your current domain, and it seems like SwiftData is more than capable of handling this kind of data. Can you share some actual data types that represent what you want to model?

It also seems this question is more about our new SharingGRBD, which uses Sharing but is a separate library. I am going to transfer the discussion to that repo.

[davidakoontz]

Oh... an expert is saying the caveman approach of denormalized schema is recommended - cool!

I'm a novice at all of this... but quite sure my DBA colleagues back in the Java days would frown and reject my TWO Transaction table solution. Here's some of my models...

Stock model

//
// MyPortfolio by David Koontz 2025-01-29

import Foundation
import SwiftData

@Model
class Stock: Identifiable {
    var symbol: String = ""
    var name: String = ""
    var note: String = ""
    
    @Relationship(deleteRule: .cascade)
        var currentQuote: Quote?      // Optional
    
    @Relationship(deleteRule: .cascade)
        var eventList: [Event]?      // Optional
            // company events: Split, Dividend, etc.
    
    
    @Relationship(deleteRule: .cascade, inverse: \EquityBuyTransaction.stockRef)
        var buyList: [EquityBuyTransaction]?   // Buy/Sell transactions - Optional
    
    @Relationship(deleteRule: .cascade, inverse: \EquitySellTransaction.stockRef)
        var sellList: [EquitySellTransaction]?      // Optional
    
    @Relationship(deleteRule: .cascade)
        var notesArray: [Note]?                 // Optional
    
    var creationDate: Date = Date.now
    var id: UUID = UUID()       // Identifiable conformance
    var accountRef: Account?        // Optional inverse relationship
    
    
    init(name: String, symbol: String, note: String = "") {
        self.name = name
        self.symbol = symbol
        self.note = note
        self.id = UUID()
        self.currentQuote = nil
        self.eventList = nil     // empty
        self.buyList = nil
        self.sellList = nil
    }
    
    init() {
        self.name = "Apple Inc."
        self.note = "Tim's fruit stand."
        self.symbol = "AAPL"
        self.currentQuote = nil
        self.eventList = nil    // empty
        self.buyList = nil
        self.sellList = nil
        self.notesArray = nil
        self.accountRef = nil
        
        self.id = UUID()
    }
    
    init(name: String, symbol: String, note: String = "", list: [EquityBuyTransaction] ) {
        self.name = name
        self.symbol = symbol
        self.note = note
        self.id = UUID()
        self.currentQuote = nil
        self.eventList = nil     // empty
        self.buyList = list
        self.sellList = nil
    }
    
    static let AppleStock = Stock(name: "Apple Inc.", symbol: "AAPL", note: "Tim's fruit stand.",
    list: [EquityBuyTransaction.AppleBuy] )

}

EquityBuyTransaction - very similar to EquitySellTransaction (diff by Kind.Sell)

//
//  EquityBuyTransaction.swift
//  MyPortfolio
//
//  Created by David on 2/14/25.
//

import Foundation
import SwiftData
import SwiftUI

// A Child class - Inheriting everything from Parent; except Kind
@Model
class EquityBuyTransaction: EquityTransactionProtocol {
    
    var kind: Kind = Kind.Other       // Type is some reserved word
    var symbol: String = ""
    var date: Date = Date.now
    var shares: Double = 0.0
    var price: Double = 0.0
    
    var fees: Double = 0.0
    var commission: Double = 0.0
    
    var total: Double = 0.0
    
    var id: UUID = UUID()           // Identifiable conformance
    var stockRef: Stock?            // Optional backRef to associated Stock in 1-to-Many
    
    init() {
        
        self.kind = Kind.Buy
        self.symbol = ""
        self.date = Date.now
        self.shares = 0.0
        self.price = 0.0
        self.fees = 0.0
        self.commission = 0.0
        self.total = 0.0
        self.stockRef = nil
        self.id = UUID()
    }
    
    init(kind: Kind, ticker: String) {
        
        self.kind = kind
        self.symbol = ticker
        self.date = Date.now
        self.shares = 0.0
        self.price = 0.0
        self.fees = 0.0
        self.commission = 0.0
        self.total = 0.0
        self.stockRef = nil
        self.id = UUID()
    }
    
    
    init(kind: Kind, symbol: String, date: Date, shares: Double, price: Double, fees: Double = 0.0, commission: Double = 0.0, total: Double, stockRef: Stock?) {
        
        self.kind = kind
        self.symbol = symbol
        self.date = date
        self.shares = shares
        self.price = price
        self.fees = fees
        self.commission = commission
        self.total = total
        self.stockRef = stockRef
        self.id = UUID()

    }
    
    
    
    
    static let AppleBuy = EquityBuyTransaction(kind: .Buy, symbol: "AAPL", date: Date.now, shares: 100.0, price: 242.50, fees: 0.00, commission: 9.98, total: 24259.98, stockRef: nil)
    
    
}

Then this View - AccountsList - which has my Query - that's driving all the SwiftData stuff...

//
// MyPortfolio by David Koontz 2025-01-29

import SwiftUI
import SwiftData

// AccountList_View - presents AccountsList() view
// NavLink -> StockList_View()
struct AccountsList: View {

    @Environment(\.modelContext) private var context
    @Query private var portfolio: [Account]

    @State private var isPresentingEdit = false
    @State private var selectedAccount: Account?  // pass $selectedAccount
    // as a binding to an optional - I guess you handle nil in the called obj.
    // init(selection: Binding<Account?>, ...
//    @State private var selectedAccount: Account? // optional
    
    init(sortOrder: SortOrder, filterString: String) {
        let sortDescriptors: [SortDescriptor<Account>] = switch sortOrder {

        case .title:
            [SortDescriptor(\Account.title)]
        case .accountOwner:
            [SortDescriptor(\Account.accountOwner)]
        }
        let predicate = #Predicate<Account> { account in
            account.title.localizedStandardContains(filterString)
            || account.accountOwner.localizedStandardContains(filterString)
            || filterString.isEmpty
        }
        _portfolio = Query(filter: predicate, sort: sortDescriptors)
        // underscore syntax sugar means??? assign to the wrapped property
        // array of Accounts
    }   // init
    
    var body: some View {
        Group {
            if portfolio.isEmpty {
                ContentUnavailableView {
                    Label("Enter your first account.", systemImage: "book.fill")
                } description: {
                    Text("Use the plus (+) button at the top of your screen.")
                }

            } else {
                List {
                    ForEach(portfolio) { account in
                        NavigationLink {
                            StocksList_View(account: account)
                        } label: {
                            AccountRow(account: account)
                        }   // navLink label
                        .swipeActions(edge: .trailing) {
                            // Swipe to Edit & Delete
                            Button(role: .destructive) { context.delete(account)
                            } label: { Label("Delete", systemImage: "trash") }
                            
                            Button { // action
                                isPresentingEdit = true
                                selectedAccount = account
                            } label: {
                                Label("Edit", systemImage: "slider.horizontal.3")
                            }
                            .tint(.blue)

                        }   // swipeActions

                    }   // forEach
                    

                }   // list
                .listStyle(.plain)
                .sheet(isPresented: $isPresentingEdit) {
                    EditAccount_View(account: $selectedAccount  )
                        .presentationDetents([.fraction(0.75), .large])
                        .presentationDragIndicator(.visible)
                    
                }
            }
        }   // group
        
        Text("AccountList")
            .font(.caption)
    }   // body view
    



}




#Preview {

    let preview = Preview(Account.self)
    preview.addExamples(Account.samplePortfolio)
    return NavigationStack {
        AccountsList(sortOrder: .title, filterString: "")
    }
        .modelContainer(preview.container)
}

Perhaps I'm doing this all "wrong"... but I'm attempting it anyway - and learning. Until the Matrix can give me a download of Swift Design... doing my best.

The reason I'm asking about Class Inheritance... One attempted solution I tried with SwiftData was instead of TWO Transaction tables... I was going to have one table and two subclasses of a base Transation Class. Which would have the:
class BuyTransaction: Transaction
and also
class SellTransaction: Transaction

Assuming SwiftData could deal with class inheritance... this was to give me the (my assumption) I could pass the base class Transaction to a general TransactionRowView( transaction: Transaction) {..}

Let the view figure out if it's Buy or Sell and display the transactions... do the profit/loss math... etc.

So all that... to explain why I "think" I want a persistance framework like SwiftData to work with class inheritance. I hope this explains my reasoning...

[mbrandonw]

Can you share EquitySellTransaction and Kind too? They are not included in the code snippet above, just to make sure I understand.

[davidakoontz]

Happy too...

EquitySellTransaction (Just a copy of the EquityBuyTransaction with a change of Kind) to create a 2nd Table in SwiftData.

//
//  EquitySellTransaction.swift
//  MyPortfolio
//
//  Created by David on 2/14/25.
//

import Foundation
import SwiftData
import SwiftUI

// A Child class - Inheriting everything from Parent; except Kind
@Model
class EquitySellTransaction: EquityTransactionProtocol {
    
    var kind: Kind = Kind.Sell       // Type is some reserved word
    var symbol: String = ""
    var date: Date = Date.now
    var shares: Double = 0.0
    var price: Double = 0.0
    
    var fees: Double = 0.0
    var commission: Double = 0.0
    
    var total: Double = 0.0
    
    var id: UUID = UUID()           // Identifiable conformance
    var stockRef: Stock?            // Optional backRef to associated Stock in 1-to-Many
    
    init() {
        
        self.kind = Kind.Sell
        self.symbol = "___"
        self.date = Date.now
        self.shares = 0.0
        self.price = 0.0
        self.fees = 0.0
        self.commission = 0.0
        self.total = 0.0
        self.stockRef = nil
        self.id = UUID()
    }
    
    init(kind: Kind, ticker: String) {
        
        self.kind = kind
        self.symbol = ticker
        self.date = Date.now
        self.shares = 0.0
        self.price = 0.0
        self.fees = 0.0
        self.commission = 0.0
        self.total = 0.0
        self.stockRef = nil
        self.id = UUID()
    }
    
    
    init(kind: Kind, symbol: String, date: Date, shares: Double, price: Double, fees: Double = 0.0, commission: Double = 0.0, total: Double, stockRef: Stock?) {
        
        self.kind = kind
        self.symbol = symbol
        self.date = date
        self.shares = shares
        self.price = price
        self.fees = fees
        self.commission = commission
        self.total = total
        self.stockRef = stockRef
        self.id = UUID()
        
    }
    
    static let AppleSell = EquitySellTransaction(kind: .Sell, symbol: "AAPL", date: Date.now, shares: 80.0, price: 262.50, fees: 0.00, commission: 0.0, total: 21000.00, stockRef: nil)
    
}

Kind is an Enum - and I maybe persisting this poorly - I've read there are issues with Enum & SwiftData... but a bit beyond my current knowledge... and I don't THINK I care. I found out somehow that I could not use "Type"...

//
//  Kind_Enum.swift
//  MyPortfolio
//
//  Created by David on 2/9/25.
//

import Foundation
import SwiftData

// embedded Enum  might be an issue with SwiftData - removing to it's own obj.

enum Kind: String, Identifiable, CaseIterable, Codable, CustomStringConvertible, CustomDebugStringConvertible {
    
    var id: Self { self }       // trick for Identifiable in Enum
    
    case Buy = "Buy"
    case Sell = "Sell"
    case Split = "Split"
    case Dividend = "Dividend"
    case Other = "Other"
    
    var description: String {
        // for CustomStringConvertible conformance
        switch self {
            case .Buy: return "Buy"
            case .Sell: return "Sell"
            case .Split: return "Split"
            case .Dividend: return "Dividend"
            case .Other: return "Other"
        }
    }
    
    var debugDescription: String {
        return self.description
    }
}

THANKS for caring!

[davidakoontz]

You might also care about Account class - which a collection of Accounts is a Portfolio... Used in the View attached.
An Account contains a list of Stocks in the equities property [Stock].
Stocks hold their own Transactions (not held by the Account). I don't yet know if this modeling will last... maybe I will need to move the transactions up into Account. In my model a Stock is the thing offered in the Market... when someone purchases the Stock it becomes an Equity (which is held in the Account).

//
// MyPortfolio by David Koontz 2025-01-29
import Foundation
import SwiftUI
import SwiftData

@Model
class Account {
    var title: String = ""
    var nickname: String = ""
    var accountOwner: String = ""
    var accountNumber: String = ""
    var dateOpened: Date = Date.now

    var synopsis: String = ""

    // Account Total & Balances
    var totalValue: Double = 0.0
    var cashBalance: Double = 0.0
    var previousNetLiq: Double = 0.0
    // change in value??
    
    @Relationship(deleteRule: .cascade, inverse: \Stock.accountRef)
    var equities: [Stock]?      // optional

    @Relationship(inverse: \TaxType.accountRef)
    var taxTypes: [TaxType]?      // optional
    
    @Attribute(.externalStorage)
    var bookCover: Data?      // optional
    
    init(title: String, accountOwner: String) {
        // simple quick constructor
        self.title = title
        self.accountOwner = accountOwner
        self.dateOpened = .now
        self.synopsis = ""
        // Account Total & Balances
        self.totalValue = 0.0
        self.cashBalance = 0.0
        self.previousNetLiq = 0.0
    }
    
    init(
        title: String,
        accountOwner: String,
        dateOpened: Date = Date.now,
        synopsis: String = "",
        totalValue: Double,
        cashBalance: Double,
        previousNetLiq: Double
    ) {
        self.title = title
        self.accountOwner = accountOwner
        self.dateOpened = dateOpened
        self.synopsis = synopsis
        // Account Total & Balances
        self.totalValue = 0.0
        self.cashBalance = 0.0
        self.previousNetLiq = 0.0
    }
    
    var icon: Image {
        Image(systemName: "books.vertical.fill")
    }
    
    static let Apple = Stock(name: "Apple Inc.", symbol: "AAPL")
    static let Microsoft = Stock(name: "Microsoft Corporation", symbol: "MSFT")
    static let Amazon = Stock(name: "Amazon.com Inc.", symbol: "AMZN")
    static let Alphabet = Stock(name: "Alphabet Inc.", symbol: "GOOGL")
    
//    static let holdings = [Apple, Microsoft, Amazon, Alphabet]
    
    static let EmptyAccount = Account(title: "Empty Placeholder", accountOwner: "programmer")
}

[mbrandonw]

I recommend a single Transaction type with a kind field for distinguishing buy vs sell. Further, the Stock must have only a relationship to just [Transaction]. It cannot have a separate sellList and buyList.

For the times you need those separates lists, you must query for them separately:

import SwiftData
import SwiftUI

@Model
class Stock: Identifiable {
  var symbol = ""
  @Relationship(deleteRule: .cascade)
  var transactions: [Transaction] = []
  // Other fields...
  init() {}
}

@Model
class Transaction {
  var kind: String
  // Other fields...
  init(kind: String) {
    self.kind = kind
  }
}

struct StockDetail: View {
  let stock: Stock
  @Query var buys: [Transaction]
  @Query var sells: [Transaction]

  init(stock: Stock) {
    self.stock = stock
    _buys = Query(filter: #Predicate { $0.kind == "buy" })
    _sells = Query(filter: #Predicate { $0.kind == "sell" })
  }

  var body: some View {
    List {}
  }
}

And this is basically the same way you would approach this problem using this library. So it's really up to you how you want to do this.

[davidakoontz]

Thanks you Brandon! Thanks for the code examples. So my missunderstand is about how to connect Stock to the relationship Transaction. I had assumed have a list (connection) of buy & separate list of sell transactions would be a good thing. Appeartly, this is my modeling mistake - thanks for pointing it out.

I will try out your suggestions. I'm sure it will workout.
Thanks for your time & effort!!
Much appreciated !