Store: add experimental maxDataSizeInKByte (#149)

Author: greenrobot-team

objectbox-java/src/main/java/io/objectbox/BoxStoreBuilder.java

@@ -77,6 +77,8 @@ public class BoxStoreBuilder {
     /** Defaults to {@link #DEFAULT_MAX_DB_SIZE_KBYTE}. */
     long maxSizeInKByte = DEFAULT_MAX_DB_SIZE_KBYTE;
 
+    long maxDataSizeInKByte;
+
     /** On Android used for native library loading. */
     @Nullable Object context;
     @Nullable Object relinker;
@@ -339,10 +341,34 @@ BoxStoreBuilder modelUpdate(ModelUpdate modelUpdate) {
      * (for example you insert data in an infinite loop).
      */
     public BoxStoreBuilder maxSizeInKByte(long maxSizeInKByte) {
+        if (maxSizeInKByte <= maxDataSizeInKByte) {
+            throw new IllegalArgumentException("maxSizeInKByte must be larger than maxDataSizeInKByte.");
+        }
         this.maxSizeInKByte = maxSizeInKByte;
         return this;
     }
 
+    /**
+     * This API is experimental and may change or be removed in future releases.
+     * <p>
+     * Sets the maximum size the data stored in the database can grow to. Must be below {@link #maxSizeInKByte(long)}.
+     * <p>
+     * Different from {@link #maxSizeInKByte(long)} this only counts bytes stored in objects, excluding system and
+     * metadata. However, it is more involved than database size tracking, e.g. it stores an internal counter.
+     * Only use this if a stricter, more accurate limit is required.
+     * <p>
+     * When the data limit is reached data can be removed to get below the limit again (assuming the database size limit
+     * is not also reached).
+     */
+    @Experimental
+    public BoxStoreBuilder maxDataSizeInKByte(long maxDataSizeInKByte) {
+        if (maxDataSizeInKByte >= maxSizeInKByte) {
+            throw new IllegalArgumentException("maxDataSizeInKByte must be smaller than maxSizeInKByte.");
+        }
+        this.maxDataSizeInKByte = maxDataSizeInKByte;
+        return this;
+    }
+
     /**
      * Open the store in read-only mode: no schema update, no write transactions are allowed (would throw).
      */
@@ -491,13 +517,12 @@ byte[] buildFlatStoreOptions(String canonicalPath) {
                 FlatStoreOptions.addValidateOnOpenPageLimit(fbb, validateOnOpenPageLimit);
             }
         }
-        if(skipReadSchema) FlatStoreOptions.addSkipReadSchema(fbb, skipReadSchema);
-        if(usePreviousCommit) FlatStoreOptions.addUsePreviousCommit(fbb, usePreviousCommit);
-        if(readOnly) FlatStoreOptions.addReadOnly(fbb, readOnly);
-        if(noReaderThreadLocals) FlatStoreOptions.addNoReaderThreadLocals(fbb, noReaderThreadLocals);
-        if (debugFlags != 0) {
-            FlatStoreOptions.addDebugFlags(fbb, debugFlags);
-        }
+        if (skipReadSchema) FlatStoreOptions.addSkipReadSchema(fbb, true);
+        if (usePreviousCommit) FlatStoreOptions.addUsePreviousCommit(fbb, true);
+        if (readOnly) FlatStoreOptions.addReadOnly(fbb, true);
+        if (noReaderThreadLocals) FlatStoreOptions.addNoReaderThreadLocals(fbb, true);
+        if (debugFlags != 0) FlatStoreOptions.addDebugFlags(fbb, debugFlags);
+        if (maxDataSizeInKByte > 0) FlatStoreOptions.addMaxDataSizeInKbyte(fbb, maxDataSizeInKByte);
 
         int offset = FlatStoreOptions.endFlatStoreOptions(fbb);
         fbb.finish(offset);

objectbox-java/src/main/java/io/objectbox/exception/DbMaxDataSizeExceededException.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2022 ObjectBox Ltd. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.exception;
+
+/**
+ * Thrown when applying a transaction would exceed the {@link io.objectbox.BoxStoreBuilder#maxDataSizeInKByte(long) maxDataSizeInKByte}
+ * configured for the store.
+ */
+public class DbMaxDataSizeExceededException extends DbException {
+    public DbMaxDataSizeExceededException(String message) {
+        super(message);
+    }
+}

tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreBuilderTest.java

@@ -16,6 +16,8 @@
 
 package io.objectbox;
 
+import io.objectbox.exception.DbFullException;
+import io.objectbox.exception.DbMaxDataSizeExceededException;
 import io.objectbox.exception.PagesCorruptException;
 import io.objectbox.model.ValidateOnOpenMode;
 import org.greenrobot.essentials.io.IoUtils;
@@ -28,7 +30,6 @@
 import java.io.InputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -38,13 +39,16 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 public class BoxStoreBuilderTest extends AbstractObjectBoxTest {
 
     private BoxStoreBuilder builder;
 
+    private static final String LONG_STRING = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+
     @Override
     protected BoxStore createBoxStore() {
         // Standard setup of store not required
@@ -167,6 +171,73 @@ public void readOnly() {
         assertTrue(store.isReadOnly());
     }
 
+    @Test
+    public void maxSize_invalidValues_throw() {
+        // Max data larger than max database size throws.
+        builder.maxSizeInKByte(10);
+        IllegalArgumentException exSmaller = assertThrows(
+                IllegalArgumentException.class,
+                () -> builder.maxDataSizeInKByte(11)
+        );
+        assertEquals("maxDataSizeInKByte must be smaller than maxSizeInKByte.", exSmaller.getMessage());
+
+        // Max database size smaller than max data size throws.
+        builder.maxDataSizeInKByte(9);
+        IllegalArgumentException exLarger = assertThrows(
+                IllegalArgumentException.class,
+                () -> builder.maxSizeInKByte(8)
+        );
+        assertEquals("maxSizeInKByte must be larger than maxDataSizeInKByte.", exLarger.getMessage());
+    }
+
+    @Test
+    public void maxFileSize() {
+        builder = createBoxStoreBuilder(null);
+        builder.maxSizeInKByte(30); // Empty file is around 12 KB, object below adds about 8 KB each.
+        store = builder.build();
+        putTestEntity(LONG_STRING, 1);
+        TestEntity testEntity2 = createTestEntity(LONG_STRING, 2);
+        DbFullException dbFullException = assertThrows(
+                DbFullException.class,
+                () -> getTestEntityBox().put(testEntity2)
+        );
+        assertEquals("Could not commit tx", dbFullException.getMessage());
+
+        // Re-open with larger size.
+        store.close();
+        builder.maxSizeInKByte(40);
+        store = builder.build();
+        testEntity2.setId(0); // Clear ID of object that failed to put.
+        getTestEntityBox().put(testEntity2);
+    }
+
+    @Test
+    public void maxDataSize() {
+        // Put until max data size is reached, but still below max database size.
+        builder = createBoxStoreBuilder(null);
+        builder.maxSizeInKByte(50); // Empty file is around 12 KB, each put adds about 8 KB.
+        builder.maxDataSizeInKByte(1);
+        store = builder.build();
+
+        TestEntity testEntity1 = putTestEntity(LONG_STRING, 1);
+        TestEntity testEntity2 = createTestEntity(LONG_STRING, 2);
+        DbMaxDataSizeExceededException maxDataExc = assertThrows(
+                DbMaxDataSizeExceededException.class,
+                () -> getTestEntityBox().put(testEntity2)
+        );
+        assertEquals("Exceeded user-set maximum by [bytes]: 64", maxDataExc.getMessage());
+
+        // Remove to get below max data size, then put again.
+        getTestEntityBox().remove(testEntity1);
+        getTestEntityBox().put(testEntity2);
+
+        // Alternatively, re-open with larger max data size.
+        store.close();
+        builder.maxDataSizeInKByte(2);
+        store = builder.build();
+        putTestEntity(LONG_STRING, 3);
+    }
+
     @Test
     public void validateOnOpen() {
         // Create a database first; we must create the model only once (ID/UID sequences would be different 2nd time)