Reduce Realm File Size - Swift SDK

Avoid Pinning Transactions

Realm vincula la duración de las transacciones de lectura con la duración de la memoria de las instancias de Realm. Evite fijar transacciones antiguas de Realm. Utilice reinos con actualización automática y encierre el uso de las API de Realm desde subprocesos en segundo plano en grupos de liberación automática explícitos.

Enhebrado

Realm actualiza la versión de tus datos a la que accede al inicio de una iteración del ciclo de ejecución. Si bien esto te brinda una vista coherente de tus datos, tiene implicaciones en el tamaño del archivo.

Imagínese este escenario:

• Thread A: Read some data from a realm, and then block the thread on a long-running operation.

• Hilo B: Guarda datos en otro hilo.

• Hilo A: La versión en el hilo de lectura no se actualiza. Realm debe mantener versiones intermedias de los datos, aumentando el tamaño del archivo con cada escritura.

To avoid this issue, call invalidate() on the realm. This tells the realm that you no longer need the objects you've read so far. This frees realm from tracking intermediate versions of those objects. The next time you access it, realm will have the latest version of the objects.

You can also use these two methods to compact your Realm:

• Establezca shouldCompactOnLaunch en la configuración

• Use writeCopy(toFile:encryptionKey:)

Dispatch Queues

Al acceder a Realm mediante Grand Central DispatchEs posible que observe un crecimiento de archivos similar. Es posible que el grupo de liberación automática de una cola de despacho no se vacíe inmediatamente tras ejecutar el código. Realm no puede reutilizar versiones intermedias de los datos hasta que el grupo de despacho desasigne el objeto realm. Utilice un grupo de liberación automática explícito al acceder a realm desde una cola de despacho.

Compactar un reino de forma asincrónica

When you use the Swift async/await syntax to open a realm asynchronously, you can compact a realm in the background.

func testAsyncCompact() async {
    let config = Realm.Configuration(shouldCompactOnLaunch: { totalBytes, usedBytes in
        // totalBytes refers to the size of the file on disk in bytes (data + free space)
        // usedBytes refers to the number of bytes used by data in the file
        // Compact if the file is over 100MB in size and less than 50% 'used'
        let oneHundredMB = 100 * 1024 * 1024
        return (totalBytes > oneHundredMB) && (Double(usedBytes) / Double(totalBytes)) < 0.5
    })
    do {
        // Realm is compacted asynchronously on the first open if the
        // configuration block conditions were met.
        let realm = try await Realm(configuration: config)
    } catch {
        // handle error compacting or opening Realm
    }
}

Starting with Realm Swift SDK Versions 10.15.0 and 10.16.0, many of the Realm APIs support the Swift async/await syntax. Projects must meet these requirements:

Si su aplicación accede a Realm en un async/await contexto, marque el código con @MainActor para evitar fallas relacionadas con subprocesos.

Make a Compacted Copy

You can save a compacted (and optionally encrypted) copy of a realm to another file location with the Realm.writeCopy(toFile:encryptionKey:) method. The destination file cannot already exist.

Tips for Using Manual Compaction

Compacting a realm can be an expensive operation that can block the UI thread. Your application should not compact every time you open a realm. Instead, try to optimize compacting so your application does it just often enough to prevent the file size from growing too large. If your application runs in a resource-constrained environment, you may want to compact when you reach a certain file size or when the file size negatively impacts performance.

These recommendations can help you optimize manual compaction for your application:

• Establezca el tamaño máximo de archivo en un múltiplo del tamaño promedio de su estado de dominio. Si el tamaño promedio de su estado de dominio es de 10 MB, puede establecer el tamaño máximo de archivo en 20 MB o 40 MB, según el uso previsto y las limitaciones del dispositivo.

• As a starting point, compact realms when more than 50% of the realm file size is no longer in use. Divide the currently used bytes by the total file size to determine the percentage of space that is currently used. Then, check for that to be less than 50%. This means that greater than 50% of your realm file size is unused space, and it is a good time to compact. After experimentation, you may find a different percentage works best for your application.

Estos cálculos pueden tener el siguiente aspecto en su función de retorno shouldCompactOnLaunch:

// Set a maxFileSize equal to 20MB in bytes
let maxFileSize = 20 * 1024 * 1024
// Check for the realm file size to be greater than the max file size,
// and the amount of bytes currently used to be less than 50% of the
// total realm file size
return (realmFileSizeInBytes > maxFileSize) && (Double(usedBytes) / Double(realmFileSizeInBytes)) < 0.5

Experiment with conditions to find the right balance of how often to compact realm files in your application.