I ran your code with 10,000 objects and it took about a second. I am running it on iMac 2017.

Perhaps I am not fully understanding. Let me share my testing code:

For simplicity I have Thing object that just has default values based on your JSON

class Thing: Object {
    @Persisted var drugId = 1713
    @Persisted var ifile = "LLY07151"
    @Persisted var color = "white"
    @Persisted var shape = ""
    @Persisted var score = ""
    @Persisted var clarity = "cloudy"
    @Persisted var coating = ""
    @Persisted var subshape = ""
    @Persisted var subcolor = "milky white"
    @Persisted var flavor = ""
    @Persisted var imprint1 = ""
    @Persisted var imprint2 = ""
    @Persisted var formulation = "human recombinant 70 units-30 units/mL"
    @Persisted var drugForm = "suspension"
    @Persisted var genericName = "insulin isophane-insulin regular"
}

I then have a class var that stores the start time so we can determine the write time

var startTime = Date()

and then a function that creates 10,000 Thing objects and stores them in an array, once completed the startTime is populated and then that array is written to Realm. When the write completes, the endTime is calculated and printed to console.

func writeABunchOfThings() {
    let realm = //your realm

    var myThingArray = [Thing]()

    for _ in 0...9999 { // <-10,000 objects
        let myThing = Thing()
        myThingArray.append(myThing)
    }

    self.startTime = Date()
    realm.writeAsync {
        realm.add(myThingArray)
    } onComplete: { error in
        let elapsed = Date().timeIntervalSince(self.startTime)
        print("done inserting. Elapsed time: \(elapsed)")
    }
}

If I run that code three times, deleting the Realm file in between runs, I get this output in console

done inserting. Elapsed time: 0.5658090114593506
done inserting. Elapsed time: 0.5397540330886841
done inserting. Elapsed time: 0.5507090091705322

I believe the issue with your code is writing each object separately within a tight loop on the main thread- if you need that functionality (which may be more memory safe) this would work noting it’s an asynchronous write.

self.startTime = Date()

realm.writeAsync {
    for _ in 0...9999 {
        realm.create(Thing.self)
    }
} onComplete: { error in
    let elapsed = Date().timeIntervalSince(self.startTime)
    print("done inserting. Elapsed time: \(elapsed)")
}

and the output

done inserting. Elapsed time: 0.9166730642318726
done inserting. Elapsed time: 0.9176139831542969
done inserting. Elapsed time: 0.911078929901123

So not quite as fast but still within reason.

Let me know if that helps.

Jay

@Basavaraj_KM1

Confirmed! There are a bunch of ways to code that - I was just using the latest syntax from the SDK but the functionality is consistent.

Add Swift API for asynchronous transactions

    try? realm.writeAsync {
        realm.create(SwiftStringObject.self, value: ["string"])
    } onComplete: { error in
        // optional handling on write complete
    }

    try? realm.beginAsyncWrite {
        realm.create(SwiftStringObject.self, value: ["string"])
        realm.commitAsyncWrite()
    }

    let asyncTransactionId = try? realm.beginAsyncWrite {
        // ...
    }
    try! realm.cancelAsyncWrite(asyncTransactionId)

@Basavaraj_KM1

Well not really. If you’re using less than 10.26 it would probably be a good idea to update to 10.26

pod update

but if want to use and older SDK you just have to code it without the spiffy new syntax.

Oh, and the new syntax in 10.26 is actually covered in the current documentation (GO REALM TEAM!)

Sure!

If we knew what version of CocoaPods you were using (pod --version) and could see your entire podfile we may be able to spot the issue.

Here’s mine (for macOS)

project 'My Great Realm App'
target 'My Great Realm App' do
  use_frameworks!
  platform :osx, '10.15'
   pod 'RealmSwift', '~>10'
end

There’s an installation guide right on the Realm site as well for reference

@Basavaraj_KM1

Well, it’s working great for me. I would propose it’s time for a split-half search to eliminate some variables. Please create a brand new macOS XCode project using my podfile from above (changing the project name)

Then copy and paste my Thing object from above and then the code (func writeABunchOfThings) in the new project. I would add a button to run the code itself.

Run the project.

If it works and behaves correctly, something in your original project is causing the issue

If it does not work, then you’ve got an environment issue; maybe a config issue or some other issue - possibly event corrupted files or a hardware problem.

I have followed those steps on three different Macs; a 2019 iMac, 2017 iMac and a 2013 Macbook Pro 15". The results are roughly the same.

My apologies but I am struggling trying to understand what you’re attempting to do with that code.

The .create function creates a single realm object so this

.create([RLMIngredient].self

won’t work as [].self is an array and not a Realm object. It’s unclear what the purpose of that would be even if it did work.

Why? Why do you need an array of dictionaries for? Where does data come from? Is it encoded? Why not just pass data to a Realm object when it’s instantiated, let the object decode it and assign properties and then write it out to Realm?

Your new question is

And the answer is you cannot insert and array of json objects to Realm. You can only insert Realm objects into Realm.

I feel the thread is getting off topic.

The initial issue was Realm write performance. Using my examples above, we’re not able to replicate that issue which would indicate the problem lies elsewhere in your code that was not included.

Working with JSONSerialization, arrays etc are off topic for this discussion and to prevent the thread from being a mile-long, it should probably be posed as another question (it’s really a separate topic)

Happy to help but it’s important to keep threads on a single topic so it may help future readers that are looking for help about this particular subject matter.

So, post a separate question with the code you’re stuck on an we’ll take a look!