fix: Avoid a bunch of heap allocations (shared_ptr/unique_ptr)

Author: mrousavy

package/cpp/operations.cpp

@@ -5,6 +5,7 @@
 #include <cmath>
 #include <ctime>
 #include <iostream>
+#include <optional>
 #include <map>
 #include <sqlite3.h>
 #include <sstream>
@@ -143,8 +144,8 @@ SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::str
   std::string column_name;
   ColumnType column_declared_type;
   SQLiteQueryResultRow row;
-  auto results = std::make_unique<SQLiteQueryResults>();
-  auto metadata = new SQLiteQueryTableMetadata();
+  SQLiteQueryResults results;
+  std::optional<SQLiteQueryTableMetadata> metadata = std::nullopt();
 
   while (isConsuming) {
     result = sqlite3_step(statement);
@@ -192,7 +193,7 @@ SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::str
           }
           i++;
         }
-        results->push_back(std::move(row));
+        results.push_back(std::move(row));
         break;
       case SQLITE_DONE:
           i = 0;
@@ -202,7 +203,11 @@ SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::str
             const char* tp = sqlite3_column_decltype(statement, i);
             column_declared_type = mapSQLiteTypeToColumnType(tp);
             auto columnMeta = SQLiteQueryColumnMetadata(std::move(column_name), std::move(column_declared_type), i);
-            metadata->insert({column_name, columnMeta});
+
+            if (!metadata) {
+              metadata = std::make_optional<SQLiteQueryTableMetadata>();
+            }
+            metadata.insert({column_name, columnMeta});
             i++;
           }
           isConsuming = false;
@@ -221,16 +226,11 @@ SQLiteExecuteQueryResult sqliteExecute(const std::string& dbName, const std::str
 
   int rowsAffected = sqlite3_changes(db);
   long long latestInsertRowId = sqlite3_last_insert_rowid(db);
-  auto meta = std::make_unique<std::optional<SQLiteQueryTableMetadata>>(
-    metadata && metadata->size() > 0
-    ? std::make_optional(std::move(*metadata))
-    : std::nullopt
-  );
   return {
     .rowsAffected = rowsAffected,
     .insertId = static_cast<double>(latestInsertRowId),
     .results = std::move(results),
-    .metadata = std::move(meta)
+    .metadata = std::move(metadata)
   };
 }
 

package/cpp/specs/HybridNativeQueryResult.cpp

@@ -3,19 +3,19 @@
 namespace margelo::nitro::rnnitrosqlite {
 
 std::optional<double> HybridNativeQueryResult::getInsertId() {
-  return this->_insertId;
+  return _result.insertId;
 }
 
 double HybridNativeQueryResult::getRowsAffected() {
-  return this->_rowsAffected;
+  return _result.rowsAffected;
 }
 
 SQLiteQueryResults HybridNativeQueryResult::getResults() {
-  return this->_results;
+  return _result.results;
 };
 
 std::optional<SQLiteQueryTableMetadata> HybridNativeQueryResult::getMetadata() {
-  return this->_metadata;
+  return _result.metadata;
 }
 
 } // namespace margelo::nitro::rnnitrosqlite

package/cpp/specs/HybridNativeQueryResult.hpp

@@ -11,27 +11,16 @@ namespace margelo::nitro::rnnitrosqlite {
 class HybridNativeQueryResult : public HybridNativeQueryResultSpec {
 public:
   HybridNativeQueryResult() : HybridObject(TAG) {}
-  HybridNativeQueryResult(std::optional<double> insertId, int rowsAffected, SQLiteQueryResults& results, std::optional<SQLiteQueryTableMetadata>& metadata)
-      : HybridObject(TAG),
-        _insertId(insertId),
-        _rowsAffected(rowsAffected),
-        _results(std::move(results)),
-        _metadata(std::move(metadata)) {}
+  HybridNativeQueryResult(SQLiteExecuteQueryResult&& result): _result(std::move(result)) {}
 
 private:
-  std::optional<double> _insertId;
-  int _rowsAffected;
-  SQLiteQueryResults _results;
-  std::optional<SQLiteQueryTableMetadata> _metadata;
+  SQLiteExecuteQueryResult _result;
 
 public:
   // Properties
-  std::optional<double> getInsertId() override;
-  
+  double getInsertId() override;
   double getRowsAffected() override;
-  
   SQLiteQueryResults getResults() override;
-  
   std::optional<SQLiteQueryTableMetadata> getMetadata() override;
 };
 

package/cpp/specs/HybridNitroSQLite.cpp

@@ -54,8 +54,8 @@ using ExecuteQueryResult = std::shared_ptr<HybridNativeQueryResultSpec>;
 
 ExecuteQueryResult HybridNitroSQLite::execute(const std::string& dbName, const std::string& query,
                                              const std::optional<SQLiteQueryParams>& params) {
-  auto result = sqliteExecute(dbName, query, params);
-  return std::make_shared<HybridNativeQueryResult>(result.insertId, result.rowsAffected, *result.results, *result.metadata);
+  SQLiteExecuteQueryResult result = sqliteExecute(dbName, query, params);
+  return std::make_shared<HybridNativeQueryResult>(std::move(result));
 };
 
 std::shared_ptr<Promise<std::shared_ptr<HybridNativeQueryResultSpec>>> HybridNitroSQLite::executeAsync(const std::string& dbName, const std::string& query,

package/src/specs/NativeQueryResult.nitro.ts

@@ -14,7 +14,7 @@ import type { ColumnType, SQLiteValue } from '../types'
 export interface NativeQueryResult
   extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   readonly rowsAffected: number
-  readonly insertId?: number
+  readonly insertId: number
 
   /** Query results */
   readonly results: NativeSQLiteQueryResults