DataStore - Query/Mutate Performance Issue

[tyllark]

Describe the bug

Queries/mutate calls against specific models (or join tables) are taking excessive amounts of time. A single mutate is averaging 5.4 seconds and a simple query for all ~200 items will take ~1 minute. The schema consists of heavily inter connected models. This is from a Flutter app that does not experience the issue on Android.

Steps To Reproduce

Steps to reproduce the behavior:
1. Create a schema with several interconnected models (hasMany, hasOne, belongsTo)
2. Populate each model with 200 entries
3. Query each model for all entries

Expected behavior

All models are created in ~1.5 minutes (Amplify Android timings)
Each query executes in < .1 seconds

Amplify Framework Version

2.48.2

Amplify Categories

DataStore

Dependency manager

Swift PM

Swift version

6.1

CLI version

13.0.0

Xcode version

Xcode 16.3 (16E140)

Relevant log output

No Logs

Is this a regression?

No

Regression additional context

No response

Platforms

iOS

OS Version

OS 17.5

Device

iPhone 15 Pro MAxi

Specific to simulators

No response

Additional context

No response

[github-actions]

This issue was opened by a maintainer of this repository; updates will be posted here. If you are also experiencing this issue, please comment here with any relevant information so that we're aware and can prioritize accordingly.

[harsh62]

DataStore Performance Issue: JSON Decoding Bottleneck

Core Performance Problem

The Amplify Swift DataStore is experiencing severe performance degradation with single mutations taking ~5.4 seconds and simple queries for ~200 items taking ~1 minute.

Root Cause: JSON Decoding Bottleneck

The Problem

Every DataStore query result must go through an expensive JSON serialization/deserialization process:

// In Statement+Model.swift - convertResultToModel()
let jsonString = try modelDictionary.toJSONString()
let model = try ModelRegistry.decode(modelName: modelSchema.name, from: jsonString)

Performance Impact

• Result conversion takes 78-81ms per model
• For 200 items: 200 × 78ms = 15.6 seconds just for decoding
• This explains the 60-second query times

Framework Design Limitation

Why This Happens

Amplify's model system is built around JSON as the universal data format:

1. SQLite stores data as primitive types (strings, integers, etc.)
2. Models require complex object structures with relationships, custom types, etc.
3. JSON acts as the bridge between SQLite primitives and Swift models
4. Every query result must be converted: SQLite → Dictionary → JSON String → Model

The Inherent Constraint

// This is the required flow for every model:
SQLite Row → Dictionary → JSON String → Model Instance

There's no direct path from SQLite data to model instances without going through JSON serialization.

Why It's Slow

• JSON serialization is computationally expensive
• String manipulation for large model dictionaries
• Type conversion overhead for complex nested structures
• Memory allocation for intermediate JSON strings

Performance Comparison

Platform	Query 200 Items	Single Mutation	Root Cause
Android	<0.1s	<1s	Optimized native decoding
iOS	~60s	~5.4s	JSON serialization bottleneck

The Design Challenge

This isn't a simple optimization problem - it's a fundamental architectural constraint:

• Amplify requires JSON for model decoding
• JSON serialization is inherently slow for complex objects
• The framework design makes this bottleneck unavoidable
• Any attempt to bypass JSON breaks the model system

Impact on Real Applications

• Heavily interconnected models suffer the most (more complex JSON)
• Large datasets compound the problem (more items to decode)
• Frequent queries become prohibitively expensive
• User experience is severely degraded

Technical Details

Where the Bottleneck Occurs

// Statement+Model.swift - Line ~150
internal func convertResultToModel(modelSchema: ModelSchema, statement: Statement) throws -> Model {
    let columnMap = statement.columnMap
    let modelDictionary = try convertResultToModelDictionary(modelSchema: modelSchema, columnMap: columnMap)
    
    // THIS IS THE BOTTLENECK
    let jsonString = try modelDictionary.toJSONString()
    let model = try ModelRegistry.decode(modelName: modelSchema.name, from: jsonString)
    
    return model
}

Why It Can't Be Easily Fixed

Framework Dependencies

• ModelRegistry.decode() requires JSON strings
• Model relationships are resolved through JSON parsing
• Custom type handling depends on JSON serialization

Changes Required

To truly fix this, Amplify would need:

• Complete model system redesign
• Platform-specific optimizations

Performance Metrics

Current Performance (iOS)

• Single model decode: 78-81ms
• 200 models decode: 15.6 seconds
• Query overhead: 60+ seconds for simple queries
• Mutation overhead: 5+ seconds for single operations

Expected Performance

• Single model decode: <1ms
• 200 models decode: <200ms
• Query overhead: <1 second
• Mutation overhead: <1 second

Conclusion

This bottleneck represents a fundamental limitation of Amplify's current architecture that cannot be easily resolved without breaking changes to the framework's core design. The JSON serialization requirement creates an inherent performance ceiling that severely impacts iOS applications with complex data models.

---

Amplify Version: 2.48.2
Platform: iOS (iPhone 15 Pro Max, iOS 17.5)
Swift Version: 6.1