Replace bytearray creation to more optimal and more readable method.

marykdb · Sep 28, 2024 · cf64630 · cf64630
1 parent 370395d
commit cf64630
Show file tree

Hide file tree

Showing 25 changed files with 119 additions and 38 deletions.
diff --git a/lib/src/commonMain/kotlin/maryk/lib/bytes/combineToByteArray.kt b/lib/src/commonMain/kotlin/maryk/lib/bytes/combineToByteArray.kt
@@ -0,0 +1,29 @@
+package maryk.lib.bytes
+
+fun combineToByteArray(vararg elements: Any): ByteArray {
+    val totalSize = elements.sumOf { element ->
+        when (element) {
+            is ByteArray -> element.size
+            is Byte -> 1
+            else -> throw IllegalArgumentException("Unsupported type: ${element::class.simpleName}")
+        }
+    }
+
+    val result = ByteArray(totalSize)
+    var offset = 0
+
+    elements.forEach { element ->
+        when (element) {
+            is ByteArray -> {
+                element.copyInto(result, offset)
+                offset += element.size
+            }
+            is Byte -> {
+                result[offset] = element
+                offset++
+            }
+        }
+    }
+
+    return result
+}
diff --git a/lib/src/commonTest/kotlin/maryk/lib/bytes/CombineToByteArrayTest.kt b/lib/src/commonTest/kotlin/maryk/lib/bytes/CombineToByteArrayTest.kt
@@ -0,0 +1,48 @@
+package maryk.lib.bytes
+
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.expect
+
+class CombineToByteArrayTest {
+    @Test
+    fun testCombineByteArrays() {
+        val result = combineToByteArray(
+            byteArrayOf(1, 2, 3),
+            byteArrayOf(4, 5),
+            byteArrayOf(6)
+        )
+        assertContentEquals(byteArrayOf(1, 2, 3, 4, 5, 6), result)
+    }
+
+    @Test
+    fun testCombineBytes() {
+        val result = combineToByteArray(1.toByte(), 2.toByte(), 3.toByte())
+        assertContentEquals(byteArrayOf(1, 2, 3), result)
+    }
+
+    @Test
+    fun testCombineMixed() {
+        val result = combineToByteArray(
+            byteArrayOf(1, 2),
+            3.toByte(),
+            byteArrayOf(4, 5),
+            6.toByte()
+        )
+        assertContentEquals(byteArrayOf(1, 2, 3, 4, 5, 6), result)
+    }
+
+    @Test
+    fun testEmptyInput() {
+        val result = combineToByteArray()
+        expect(0) { result.size }
+    }
+
+    @Test
+    fun testUnsupportedType() {
+        assertFailsWith<IllegalArgumentException> {
+            combineToByteArray(byteArrayOf(1, 2), "unsupported")
+        }
+    }
+}
diff --git a/store/hbase/src/commonMain/kotlin/maryk/datastore/hbase/processors/processChange.kt b/store/hbase/src/commonMain/kotlin/maryk/datastore/hbase/processors/processChange.kt
@@ -236,7 +236,7 @@ private suspend fun <DM : IsRootDataModel> applyChanges(
             if (validationExceptions == null) {
                 validationExceptions = mutableListOf()
             }
-            validationExceptions!!.add(ve)
+            validationExceptions.add(ve)
         }
 
         var isChanged = false
@@ -734,14 +734,14 @@ private suspend fun <DM : IsRootDataModel> applyChanges(
                 if (newValue == null) {
                     if (oldValue != null) {
                         dependentPuts += Put(oldValue).setTimestamp(version.timestamp.toLong()).addColumn(family, key.bytes, softDeleteIndicator)
-                        indexUpdates.add(IndexDelete(index.referenceStorageByteArray, Bytes(byteArrayOf(*oldValue, *key.bytes))))
+                        indexUpdates.add(IndexDelete(index.referenceStorageByteArray, Bytes(oldValue + key.bytes)))
                     } // else ignore since did not exist
                 } else if (oldValue == null || !newValue.contentEquals(oldValue)) {
                     if (oldValue != null) {
                         dependentPuts += Put(oldValue).setTimestamp(version.timestamp.toLong()).addColumn(family, key.bytes, softDeleteIndicator)
                     }
                     dependentPuts += Put(newValue).setTimestamp(version.timestamp.toLong()).addColumn(family, key.bytes, trueIndicator)
-                    indexUpdates.add(IndexUpdate(index.referenceStorageByteArray, Bytes(byteArrayOf(*newValue, *key.bytes)), oldValue?.let { Bytes(byteArrayOf(*oldValue, *key.bytes)) }))
+                    indexUpdates.add(IndexUpdate(index.referenceStorageByteArray, Bytes(newValue + key.bytes), oldValue?.let { Bytes(oldValue + key.bytes) }))
                 }
             }
 

diff --git a/store/hbase/src/commonMain/kotlin/maryk/datastore/hbase/processors/scanIndex.kt b/store/hbase/src/commonMain/kotlin/maryk/datastore/hbase/processors/scanIndex.kt
@@ -143,7 +143,7 @@ internal suspend fun <DM : IsRootDataModel> scanIndex(
 
                         add(
                             Get(cell.qualifierArray, cell.qualifierOffset, cell.qualifierLength).apply {
-                                sortingKeys.add(byteArrayOf(*result.row, *this.row))
+                                sortingKeys.add(result.row + this.row)
 
                                 addFamily(dataColumnFamily)
                                 readVersions(if (scanRequest is IsChangesRequest<*, *>) scanRequest.maxVersions.toInt() else 1)

diff --git a/...b/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/DBAccessorStoreValuesGetter.kt b/...b/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/DBAccessorStoreValuesGetter.kt
@@ -40,7 +40,7 @@ internal class DBAccessorStoreValuesGetter(
     override fun <T : Any, D : IsPropertyDefinition<T>, C : Any> get(propertyReference: IsPropertyReference<T, D, C>): T? {
         @Suppress("UNCHECKED_CAST")
         return cache.getOrPut(propertyReference) {
-            dbAccessor.getValue(columnFamilies, readOptions, this.toVersion, byteArrayOf(*key, *propertyReference.toStorageByteArray())) { valueAsBytes, offset, length ->
+            dbAccessor.getValue(columnFamilies, readOptions, this.toVersion, key + propertyReference.toStorageByteArray()) { valueAsBytes, offset, length ->
                 (valueAsBytes.convertToValue(propertyReference, offset, length) as T?)?.also {
                     if (captureVersion) {
                         val version = valueAsBytes.readVersionBytes()

diff --git a/...rc/commonMain/kotlin/maryk/datastore/rocksdb/processors/HistoricStoreIndexValuesGetter.kt b/...rc/commonMain/kotlin/maryk/datastore/rocksdb/processors/HistoricStoreIndexValuesGetter.kt
@@ -59,7 +59,7 @@ internal class HistoricStoreIndexValuesWalker(
                     bytes.invert(versionIndex)
                 }
                 handleIndexReference(historicIndexReference)
-            } catch (e: Throwable) {
+            } catch (_: Throwable) {
                 // skip failing index reference generation
             }
         } while (getter.gotoNextVersion())
@@ -134,7 +134,7 @@ private class HistoricStoreIndexValuesGetter(
         }
         val iterator = iterableReference.iterator
         val reference = iterableReference.referenceAsBytes
-        val keyAndReference = byteArrayOf(*key, *iterableReference.referenceAsBytes)
+        val keyAndReference = key + iterableReference.referenceAsBytes
 
         // Only seek the first time
         if (iterableReference.lastVersion == null) {

diff --git a/store/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/StoreValuesGetter.kt b/store/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/StoreValuesGetter.kt
@@ -33,7 +33,7 @@ internal class StoreValuesGetter(
     override fun <T : Any, D : IsPropertyDefinition<T>, C : Any> get(propertyReference: IsPropertyReference<T, D, C>): T? {
         key?.let { currentKey ->
             val valueAsBytes = cache.getOrPut(propertyReference) {
-                val reference = byteArrayOf(*currentKey, *propertyReference.toStorageByteArray())
+                val reference = currentKey + propertyReference.toStorageByteArray()
 
                 db.get(columnFamilies.table, readOptions, reference)
             }

diff --git a/...db/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/createCountUpdater.kt b/...db/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/createCountUpdater.kt
@@ -9,7 +9,7 @@ import maryk.datastore.rocksdb.Transaction
 import org.rocksdb.ReadOptions
 
 /**
- * Set count for [reference] at [version] by applying [countChange] to current count read with [readOptions]
+ * Set count for [reference] at [versionBytes] by applying [countChange] to current count read with [readOptions]
  */
 internal fun <T : Any> createCountUpdater(
     transaction: Transaction,
@@ -23,7 +23,7 @@ internal fun <T : Any> createCountUpdater(
 ) {
     val referenceToCompareTo = reference.toStorageByteArray()
 
-    val previousCount = transaction.getValue(columnFamilies, readOptions, null, byteArrayOf(*key.bytes, *referenceToCompareTo)) { b, o, _ ->
+    val previousCount = transaction.getValue(columnFamilies, readOptions, null, key.bytes + referenceToCompareTo) { b, o, _ ->
         var readIndex = o
         initIntByVar { b[readIndex++] }
     } ?: 0

diff --git a/...sdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/deleteByReference.kt b/...sdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/deleteByReference.kt
@@ -47,7 +47,7 @@ internal fun <T : Any> deleteByReference(
     version: ByteArray,
     handlePreviousValue: ((ByteArray, T?) -> Unit)?
 ): Boolean {
-    val referenceToCompareTo = byteArrayOf(*key.bytes, *referenceAsBytes)
+    val referenceToCompareTo = key.bytes + referenceAsBytes
     var referenceOfParent: ByteArray? = null
     var toShiftListCount = 0u
 

diff --git a/...ksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/deleteIndexValue.kt b/...ksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/deleteIndexValue.kt
@@ -5,6 +5,7 @@ import maryk.datastore.rocksdb.HistoricTableColumnFamilies
 import maryk.datastore.rocksdb.TableColumnFamilies
 import maryk.datastore.rocksdb.Transaction
 import maryk.datastore.rocksdb.processors.FALSE_ARRAY
+import maryk.lib.bytes.combineToByteArray
 
 /** Delete the [indexReference] and [valueAndKey] for [version] */
 internal fun deleteIndexValue(
@@ -15,11 +16,11 @@ internal fun deleteIndexValue(
     version: ByteArray,
     hardDelete: Boolean = false
 ) {
-    transaction.delete(columnFamilies.index, byteArrayOf(*indexReference, *valueAndKey))
+    transaction.delete(columnFamilies.index, indexReference + valueAndKey)
 
     // Only delete with non hard deletes since with hard deletes all values are deleted
     if (!hardDelete && columnFamilies is HistoricTableColumnFamilies) {
-        val historicReference = byteArrayOf(*indexReference, *valueAndKey, *version)
+        val historicReference = combineToByteArray(indexReference, valueAndKey, version)
         // Invert so the time is sorted in reverse order with newest on top
         historicReference.invert(historicReference.size - version.size)
 

diff --git a/...rc/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/deleteUniqueIndexValue.kt b/...rc/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/deleteUniqueIndexValue.kt
@@ -24,7 +24,7 @@ internal fun deleteUniqueIndexValue(
 
     // Only add a delete marker when not a hard delete. With hard delete all historic values are deleted
     if (!hardDelete && columnFamilies is HistoricTableColumnFamilies) {
-        val historicReference = byteArrayOf(*reference, *version)
+        val historicReference = reference + version
         // Invert so the time is sorted in reverse order with newest on top
         historicReference.invert(reference.size)
 

diff --git a/...e/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/deleteValue.kt b/...e/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/deleteValue.kt
@@ -19,7 +19,7 @@ internal fun deleteValue(
     )
 
     if (columnFamilies is HistoricTableColumnFamilies) {
-        val historicReference = byteArrayOf(*keyAndReference, *version)
+        val historicReference = keyAndReference + version
         // Invert so the time is sorted in reverse order with newest on top
         historicReference.invert(historicReference.size - version.size)
 

diff --git a/...b/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/getKeyByUniqueValue.kt b/...b/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/getKeyByUniqueValue.kt
@@ -36,7 +36,7 @@ internal fun getKeyByUniqueValue(
         val versionBytes = toVersion.toReversedVersionBytes()
 
         dbAccessor.getIterator(readOptions, columnFamilies.historic.unique).use { iterator ->
-            val toSeek = byteArrayOf(*reference, *versionBytes)
+            val toSeek = reference + versionBytes
             iterator.seek(toSeek)
             while (iterator.isValid()) {
                 val key = iterator.key()

diff --git a/store/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/getValue.kt b/store/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/getValue.kt
@@ -43,7 +43,7 @@ internal fun <T: Any> DBAccessor.getValue(
         }
 
         this.getIterator(readOptions, columnFamilies.historic.table).use { iterator ->
-            val toSeek = byteArrayOf(*keyAndReference, *versionBytes)
+            val toSeek = keyAndReference + versionBytes
             iterator.seek(toSeek)
             while (iterator.isValid()) {
                 val key = iterator.key()

diff --git a/...rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/iterateValues.kt b/...rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/iterateValues.kt
@@ -41,7 +41,7 @@ internal fun <R: Any> DBAccessor.iterateValues(
         }
         this.getIterator(readOptions, columnFamilies.historic.table).use { iterator ->
             val toVersionBytes = toVersion.toReversedVersionBytes()
-            val toSeek = byteArrayOf(*reference, *toVersionBytes)
+            val toSeek = reference + toVersionBytes
             iterator.seek(toSeek)
             while (iterator.isValid()) {
                 val referenceBytes = iterator.key()

diff --git a/...rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/setIndexValue.kt b/...rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/setIndexValue.kt
@@ -5,6 +5,7 @@ import maryk.datastore.rocksdb.HistoricTableColumnFamilies
 import maryk.datastore.rocksdb.TableColumnFamilies
 import maryk.datastore.rocksdb.Transaction
 import maryk.datastore.rocksdb.processors.EMPTY_ARRAY
+import maryk.lib.bytes.combineToByteArray
 
 /** Set the [indexReference] and [valueAndKey] for [version] */
 internal fun setIndexValue(
@@ -14,9 +15,9 @@ internal fun setIndexValue(
     valueAndKey: ByteArray,
     version: ByteArray
 ) {
-    transaction.put(columnFamilies.index, byteArrayOf(*indexReference, *valueAndKey), version)
+    transaction.put(columnFamilies.index, indexReference + valueAndKey, version)
     if (columnFamilies is HistoricTableColumnFamilies) {
-        val historicReference = byteArrayOf(*indexReference, *valueAndKey, *version)
+        val historicReference = combineToByteArray(indexReference, valueAndKey, version)
         // Invert so the time is sorted in reverse order with newest on top
         historicReference.invert(historicReference.size - version.size)
 

diff --git a/...ksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/setLatestVersion.kt b/...ksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/setLatestVersion.kt
@@ -2,8 +2,8 @@ package maryk.datastore.rocksdb.processors.helpers
 
 import maryk.core.properties.types.Key
 import maryk.datastore.rocksdb.TableColumnFamilies
-import maryk.datastore.rocksdb.processors.LAST_VERSION_INDICATOR
 import maryk.datastore.rocksdb.Transaction
+import maryk.datastore.rocksdb.processors.LAST_VERSION_INDICATOR
 
 /** Set the latest [version] for [key] */
 internal fun setLatestVersion(
@@ -12,6 +12,6 @@ internal fun setLatestVersion(
     key: Key<*>,
     version: ByteArray
 ) {
-    val lastVersionRef = byteArrayOf(*key.bytes, LAST_VERSION_INDICATOR)
+    val lastVersionRef = key.bytes + LAST_VERSION_INDICATOR
     transaction.put(columnFamilies.table, lastVersionRef, version)
 }
diff --git a/...b/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/setUniqueIndexValue.kt b/...b/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/setUniqueIndexValue.kt
@@ -14,10 +14,10 @@ internal fun setUniqueIndexValue(
     version: ByteArray,
     key: Key<*>
 ) {
-    transaction.put(columnFamilies.unique, uniqueReferenceWithValue, byteArrayOf(*version, *key.bytes))
+    transaction.put(columnFamilies.unique, uniqueReferenceWithValue, version + key.bytes)
 
     if (columnFamilies is HistoricTableColumnFamilies) {
-        val historicReference = byteArrayOf(*uniqueReferenceWithValue, *version)
+        val historicReference = uniqueReferenceWithValue + version
         // Invert so the time is sorted in reverse order with newest on top
         historicReference.invert(historicReference.size - version.size)
 

diff --git a/store/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/setValue.kt b/store/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/setValue.kt
@@ -5,6 +5,7 @@ import maryk.core.properties.types.Key
 import maryk.datastore.rocksdb.HistoricTableColumnFamilies
 import maryk.datastore.rocksdb.TableColumnFamilies
 import maryk.datastore.rocksdb.Transaction
+import maryk.lib.bytes.combineToByteArray
 
 /** Set [reference] = [value] (ByteArray) at [version] for object at [key] */
 internal fun setValue(
@@ -17,12 +18,12 @@ internal fun setValue(
 ) {
     transaction.put(
         columnFamilies.table,
-        byteArrayOf(*key.bytes, *reference),
-        byteArrayOf(*version, *value)
+        key.bytes + reference,
+        version + value
     )
 
     if (columnFamilies is HistoricTableColumnFamilies) {
-        val historicReference = byteArrayOf(*key.bytes, *reference, *version)
+        val historicReference = combineToByteArray(key.bytes, reference, version)
         // Invert so the time is sorted in reverse order with newest on top
         historicReference.invert(historicReference.size - version.size)
 

diff --git a/.../commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/setValueWithKeyReference.kt b/.../commonMain/kotlin/maryk/datastore/rocksdb/processors/helpers/setValueWithKeyReference.kt
@@ -5,7 +5,7 @@ import maryk.datastore.rocksdb.HistoricTableColumnFamilies
 import maryk.datastore.rocksdb.TableColumnFamilies
 import maryk.datastore.rocksdb.Transaction
 
-/** Set [keyAndReference] = [value] (ByteArray) at [version] for object at [key] */
+/** Set [keyAndReference] = [value] (ByteArray) at [version] for object at [keyAndReference] */
 internal fun setValue(
     transaction: Transaction,
     columnFamilies: TableColumnFamilies,
@@ -26,7 +26,7 @@ internal fun setValue(
     )
 
     if (columnFamilies is HistoricTableColumnFamilies) {
-        val historicReference = byteArrayOf(*keyAndReference, *version)
+        val historicReference = keyAndReference + version
         // Invert so the time is sorted in reverse order with newest on top
         historicReference.invert(historicReference.size - version.size)
 

diff --git a/store/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/processAdd.kt b/store/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/processAdd.kt
@@ -89,7 +89,7 @@ internal suspend fun <DM : IsRootDataModel> processAdd(
 
                         // If a unique index, check if exists, and then write
                         if ((definition is IsComparableDefinition<*, *>) && definition.unique) {
-                            val uniqueReference = byteArrayOf(*reference, *valueBytes)
+                            val uniqueReference = reference + valueBytes
 
                             checksBeforeWrite.add {
                                 val uniqueCount =

diff --git a/store/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/processChange.kt b/store/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/processChange.kt
@@ -797,7 +797,7 @@ private fun createValueWriter(
                             columnFamilies,
                             dataStore.defaultReadOptions,
                             null,
-                            byteArrayOf(*key.bytes, *reference)
+                            key.bytes + reference
                         ) { b, o, l ->
                             deleteUniqueIndexValue(transaction, columnFamilies, reference, b, o, l, versionBytes, false)
                         }

diff --git a/store/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/processDelete.kt b/store/rocksdb/src/commonMain/kotlin/maryk/datastore/rocksdb/processors/processDelete.kt
@@ -20,6 +20,7 @@ import maryk.datastore.rocksdb.processors.helpers.setLatestVersion
 import maryk.datastore.shared.Cache
 import maryk.datastore.shared.updates.IsUpdateAction
 import maryk.datastore.shared.updates.Update.Deletion
+import maryk.lib.bytes.combineToByteArray
 import maryk.lib.extensions.compare.matchPart
 import maryk.lib.extensions.compare.nextByteInSameLength
 import maryk.lib.recyclableByteArray
@@ -54,7 +55,7 @@ internal suspend fun <DM : IsRootDataModel> processDelete(
                 for (reference in dataStore.getUniqueIndices(
                     dbIndex, columnFamilies.unique
                 )) {
-                    val referenceAndKey = byteArrayOf(*key.bytes, *reference)
+                    val referenceAndKey = key.bytes + reference
                     val valueLength = transaction.get(
                         columnFamilies.table,
                         dataStore.defaultReadOptions,
@@ -147,13 +148,13 @@ internal suspend fun <DM : IsRootDataModel> processDelete(
 
                     transaction.put(
                         columnFamilies.table,
-                        byteArrayOf(*key.bytes, SOFT_DELETE_INDICATOR),
-                        byteArrayOf(*versionBytes, TRUE)
+                        key.bytes + SOFT_DELETE_INDICATOR,
+                        versionBytes + TRUE
                     )
 
                     if (columnFamilies is HistoricTableColumnFamilies) {
                         val historicReference =
-                            byteArrayOf(*key.bytes, SOFT_DELETE_INDICATOR, *versionBytes)
+                            combineToByteArray(key.bytes, SOFT_DELETE_INDICATOR, versionBytes)
                         // Invert so the time is sorted in reverse order with newest on top
                         historicReference.invert(historicReference.size - versionBytes.size)