How to copy a Record object?

[kentaroi]

Record.copy() was removed in a15f731
How to copy a Record object?
I cannot mimic the removed Record.copy() since Row(self) seems to be internal.
I can use JSONEncoder and JSONDecoder or manually copy properties, but cannot reset referenceRow variable or call resetDatabaseChanges() since they are internal or private.

Thanks in advance!

[groue]

Hello @kentaroi,

It was removed when FetchableRecord.init(row:) has become a throwing initializer.

We could reintroduce copy(), but it would have to be a throwing method. And... you're the first user asking for it, so it does not look like a frequent use case.

May I ask if you have considered some alternatives?

• Use structs instead of Record subclasses? Structs don't need the copy method:

  let p1: Player = ...
  let p2 = p1 // A copy, freely given by the language

• Write your own version of copy()? It would be much more efficient than a serialisation-deserialization from Row or from JSON. Oh no you can't because referenceRow is not public.

• If you use methods that depend on referenceRow, which gives Record the unique ability to compare against itself, did you have a look at the features available for non-Record records, in Record Comparison?

On the last bullet, I'm constantly using updateChanges(_:modify:):

struct Player { ... }

// Updates the database if and only if `player` was modified:
var player: Player = ...
player.updateChanges(db) {
    $0.score = 1000
}
print(player.score) // 1000

This method alone has completely removed my own needs for self-comparing records.

[kentaroi]

Thank you very much for your quick response, @groue!!
And, thanks for the suggestions.

I’ve implemented some records both ways, with Record classes and with structs with protocols of GRDB, and I think I understand the pros of using structs.

However, as you know, when structs are complicated, they can be cumbersome.
For example:

struct A {
    var name: String = “A” {
        didSet {
            print(“A.name is updated”)
        }
    }
}

struct B {
    var a: A = A() {
        didSet {
            print(“B.a is updated”)
        }
    }
}

struct C {
    var b: B = B() {
        print(“C.b is updated”)
    }
}
var c = C()
c.b.a.name = “a”

If you execute the above code, you will see the following output:

A.name is updated
B.a is updated
C.b is updated

instead of A.name is updated.
I use associations and my structs are a bit complicated. And to make things work correctly, in the property observers(didSet), I have to check if it actually changed the value of the property or a property or a descendant property of the value is changed.

Therefore, I think Record class is helpful sometimes.

I don't think structs and protocols of GRDB have any problems, but sometimes I'd like to use classes for some purposes in Swift in general especially when handling hierarchical objects.

Is it possible to make resetDatabaseChanges() accessible or create a way to make hasDatabaseChanges be false, or reintroduce copy() as a throwing method as you wrote?

[kentaroi]

I apologize if my previous comment was misleading.

For example, the user can change the duration of the MiniTimer, which will be reflected to the duration of the timerTemplate of the MiniTimer, which will be reflected in a TimerTemplate object in the favoriteInfo of the MiniTimer (because they are the same TimerTemplate object),

This is what I want and I intentionally coded it that way.

, but actually this favoriteInfo object is the same instance as a FavoriteInfo object in the the data source of the above table view

But, this is not what I want.

When the user tapped a cell in the table view, I would like to deep copy the favoriteInfo and set it to a MiniTimer object as follows:

extension FavoritesViewController: UITableViewDelegate {
    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        guard let favoriteInfo = try? favoriteInfos[indexPath.row].copy() else { return }
        TimerService.shared.miniTimer.favoriteInfo = favoriteInfo
    }
}

I try to resist repeating that structs are the baked-in-the-language solution to this 😅

You might be right. I implemented it in both ways, but I prefer the code using the Record class. Maybe it's because my understanding of structs is shallow.
Here is my MiniTimer code using structs for models:

class MiniTimer: Codable {
    var favoriteInfo: FavoriteInfo? {
        didSet {
            guard
                (favoriteInfo != nil && oldValue == nil) ||
                (favoriteInfo == nil && oldValue != nil) ||
                (favoriteInfo != nil && oldValue != nil && favoriteInfo!.favorite.id != oldValue!.favorite.id)
            else {
                return
            }

            referenceFavoriteInfo = favoriteInfo
            guard let favoriteInfo = favoriteInfo else {
                _timerTemplate = TimerTemplate()
                return
            }
            routineIndex = 0
        }
    }

    var referenceFavoriteInfo: FavoriteInfo?

    var routineIndex: Int = 0 {
        didSet {
            timeRemaining = duration
            delegate?.miniTimerUpdatedTitle(self)
            delegate?.miniTimerUpdatedDuration(self)
        }
    }

    var _timerTemplate: TimerTemplate = TimerTemplate() {
        didSet {
            guard _timerTemplate.id != oldValue.id else { return }
            timeRemaining = _timerTemplate.duration
            delegate?.miniTimerUpdatedTitle(self)
            delegate?.miniTimerUpdatedDuration(self)
        }
    }

    var timerTemplate: TimerTemplate {
        get {
            guard let favoriteInfo = favoriteInfo else { return _timerTemplate }
            if let timerTemplate = favoriteInfo.timerTemplate {
                return timerTemplate
            } else {
                return favoriteInfo.routineInfo!.timerTemplates[routineIndex]
            }
        }
        set(newTimerTemplate) {
            if favoriteInfo != nil {
                if favoriteInfo?.timerTemplate != nil {
                    favoriteInfo?.timerTemplate = newTimerTemplate
                } else {
                    favoriteInfo?.routineInfo?.timerTemplates[routineIndex] = newTimerTemplate
                }
            } else {
                _timerTemplate = newTimerTemplate
            }
        }
    }

    var title: String? {
        get {
            return timerTemplate.title
        }
        set(newTitle) {
            timerTemplate.title = newTitle
            delegate?.miniTimerUpdatedTitle(self)
        }
    }

    var duration: TimeInterval {
        get { timerTemplate.duration }
        set(newDuration) {
            timerTemplate.duration = newDuration
            delegate?.miniTimerUpdatedDuration(self)
        }
    }
}

But you also said "Is it possible to make resetDatabaseChanges() accessible or create a way to make hasDatabaseChanges be false?". It looks like you see a way to implement your desired features with resetDatabaseChanges(), instead of copy(). I'm not sure I see how you'd do that?

Here is a possible solution that I came up with:

protocol CodableRecord: Record, Codable {
    func copy() throws -> Self
}

extension CodableRecord {
    func copy() throws -> Self {
        let encoder = JSONEncoder()
        let jsonData = try encoder.encode(self)

        let decoder = JSONDecoder()
        let clone = try decoder.decode(Self.self, from: jsonData)
        try clone.resetDatabaseChanges()
        return clone
    }
}

And, in my use case:

extension Favorite: CodableRecord { }
extension TimerTemplate: CodableRecord { }

extension FavoriteInfo {
    func copy() throws -> FavoriteInfo {
        let favorite = try favorite.copy()
        if let timerTemplate = timerTemplate {
            return FavoriteInfo(favorite: favorite,
                                timerTemplate: try timerTemplate.copy(),
                                routineInfo: nil)
        } else {
            return FavoriteInfo(favorite: favorite,
                                timerTemplate: nil,
                                routineInfo: try routineInfo!.copy())
        }
    }
}

[groue]

Here is a possible solution that I came up with:

I see. Yes, the record copied this way would be "clean".

OK. One last question: are you currently blocked? Or are you still using a version of GRDB that provides copy()?

[kentaroi]

OK. One last question: are you currently blocked? Or are you still using a version of GRDB that provides copy()?

Yes, I am currently blocked.

[groue]

Ouch. I can't tell when the next version of GRDB will ship that will provide copy or any other API that fulfill your needs.

So, here are a few possible recommendations that will unblock you:

1. Reconsider structs. Maybe they'll click in your mind? Expected benefits: you'll never have such a problem in the future, and you won't have to wait for the next release. ⭐
2. Fork GRDB, make resetDatabaseChanges() public, and wait for the next release. 🤓
3. Instead of copying the records, re-fetch them from the database? This looks like a very lousy workaround so I hope you won't pick this one 😅

[kentaroi]

Thank you for the suggestions!

I'm still grappling with how structs can streamline my code. If you have a spare moment, any pointers would be greatly appreciated.

I confess, the MiniTimer class code using model structs isn't quite hitting the mark for me right now. If I don't have an "aha!" moment within a day or two, I might consider forking GRDB.

Regardless, thank you again for your valuable guidance!