Tuple preformance and functionality improvements

Removed limit of max 16 elements in tuple.
Tuple is now storing all values in JavaScript.
During serialization from Rust to JavaScript, the
tuple is converted to a JavaScript tuple.

Author: PiotrJunior

lib/types/tuple.js

@@ -18,44 +18,23 @@ const resultWrapper = require("./results-wrapper");
  * - If the tuple comes from a ScyllaDB query result, its values remain in Rust memory, and access requires a native call.
  */
 class Tuple {
-    /**
-     * Rust tuple object if stored in Rust part of the driver.
-     * @type {rust.TupleWrapper?}
-     * @private
-     */
-    #internal;
-
     /**
      * Elements of the tuple if stored in JS.
      * @type {Array?}
      * @private
      */
-    #jsElements;
-
-    /**
-     * True if the tuple is stored in JS, false if it's stored in Rust part of the driver.
-     * @type {Boolean}
-     * @private
-     */
-    #isJsStored;
+    #elements;
 
     /**
      * Creates a new instance of Tuple.
      * @param  {...any} args
      */
     constructor(...args) {
-        this.#isJsStored = true;
-        this.#internal = null;
-        this.#jsElements = args;
+        this.#elements = args;
 
         if (this.elements.length === 0) {
             throw new TypeError("Tuple must contain at least one value");
         }
-
-        // This is Rust driver limitation.
-        if (this.elements.length > 16) {
-            throw new TypeError("Tuple must contain at most 16 values");
-        }
     }
 
     /**
@@ -64,8 +43,7 @@ class Tuple {
      * @type Array
      */
     get elements() {
-        if (this.#isJsStored) return this.#jsElements;
-        return this.#internal.getAll();
+        return this.#elements;
     }
 
     set elements(_) {
@@ -78,8 +56,7 @@ class Tuple {
      * @type Number
      */
     get length() {
-        if (this.#isJsStored) return this.#jsElements.length;
-        return this.#internal.getLength();
+        return this.#elements.length;
     }
 
     set length(_) {
@@ -101,8 +78,7 @@ class Tuple {
      * @param {Number} index Element index
      */
     get(index) {
-        if (this.#isJsStored) return this.#jsElements[index || 0];
-        return resultWrapper.getCqlObject(this.#internal.get(index || 0));
+        return this.#elements[index || 0];
     }
 
     /**
@@ -143,9 +119,10 @@ class Tuple {
      */
     static fromRust(rustTuple) {
         let jsTuple = new Tuple(null);
-        jsTuple.#internal = rustTuple;
-        jsTuple.#isJsStored = false;
-        jsTuple.#jsElements = null;
+        jsTuple.#elements = rustTuple
+            .getAll()
+            .map((e) => resultWrapper.getCqlObject(e))
+            .map((e) => e == null ? undefined : e);
         return jsTuple;
     }
 }

src/types/tuple.rs

@@ -15,24 +15,6 @@ impl TupleWrapper {
         Ok(TupleWrapper { values: None })
     }
 
-    #[napi]
-    pub fn get_length(&self) -> u32 {
-        self.values.as_ref().map_or(0, |v| v.len() as u32)
-    }
-
-    #[napi]
-    pub fn get(&self, index: u32) -> napi::Result<Option<CqlValueWrapper>> {
-        self.values
-            .as_ref()
-            .ok_or_else(|| js_error("Values are stored in JS"))
-            .and_then(|values| {
-                values
-                    .get(index as usize)
-                    .map(|v| v.as_ref().map(|v| CqlValueWrapper { inner: v.clone() }))
-                    .ok_or_else(|| js_error("Index out of bounds"))
-            })
-    }
-
     #[napi]
     pub fn get_all(&self) -> napi::Result<Vec<Option<CqlValueWrapper>>> {
         self.values

test/unit/cql-value-wrapper-tests.js

@@ -248,7 +248,7 @@ describe("Cql value wrapper", function () {
         console.log(value.get(0));
         assert.strictEqual(value.get(0), "some text");
         assert.strictEqual(value.get(1), 1);
-        assert.strictEqual(value.get(2), null);
+        assert.strictEqual(value.get(2), undefined);
     });
 
     it("should get time uuid type correctly from napi", function () {

test/unit/tuple-tests.js

@@ -8,9 +8,6 @@ describe("Tuple", function () {
         it("should throw an error when no arguments are provided", function () {
             assert.throws(() => new Tuple(), TypeError);
         });
-        it("should throw an error when more than 16 arguments are provided", function () {
-            assert.throws(() => new Tuple(...Array(17).fill(0)), TypeError);
-        });
     });
     describe("#get()", function () {
         it("should return the element at position", function () {