react-native-nitro-sqlite 9.1.5 → 9.1.6

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,6 +203,10 @@ 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);
+
+            if (!metadata) {
+              metadata = std::make_optional<SQLiteQueryTableMetadata>();
+            }
             metadata->insert({column_name, columnMeta});
             i++;
           }
@@ -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): HybridObject(TAG), _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 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/cpp/sqliteExecuteBatch.cpp

@@ -19,13 +19,13 @@ std::vector<BatchQuery> batchParamsToCommands(const std::vector<BatchQueryComman
       if (std::holds_alternative<NestedParamsVec>(*command.params)) {
         // This arguments is an array of arrays, like a batch update of a single sql command.
         for (const auto& params : std::get<NestedParamsVec>(*command.params)) {
-          commands.push_back(BatchQuery{command.query, std::make_shared<ParamsVec>(params)});
+          commands.push_back(BatchQuery{command.query, ParamsVec(params)});
         }
       } else {
-        commands.push_back(BatchQuery{command.query, std::make_shared<ParamsVec>(std::move(std::get<ParamsVec>(*command.params)))});
+        commands.push_back(BatchQuery{command.query, std::move(std::get<ParamsVec>(*command.params))});
       }
     } else {
-      commands.push_back(BatchQuery{command.query, NULL});
+      commands.push_back(BatchQuery{command.query, std::nullopt});
     }
   }
 
@@ -48,7 +48,7 @@ SQLiteOperationResult sqliteExecuteBatch(const std::string& dbName, const std::v
       auto results = SQLiteQueryResults();
       auto metadata = std::optional<SQLiteQueryTableMetadata>(std::nullopt);
       try {
-        auto result = sqliteExecute(dbName, command.sql, *command.params.get());
+        auto result = sqliteExecute(dbName, command.sql, command.params);
         rowsAffected += result.rowsAffected;
       } catch (NitroSQLiteException& e) {
         sqliteExecuteLiteral(dbName, "ROLLBACK");

package/cpp/sqliteExecuteBatch.hpp

@@ -13,7 +13,7 @@ namespace margelo::rnnitrosqlite {
 
 struct BatchQuery {
   std::string sql;
-  std::shared_ptr<SQLiteQueryParams> params;
+  std::optional<SQLiteQueryParams> params;
 };
 
 /**

package/cpp/types.hpp

@@ -27,8 +27,8 @@ struct SQLiteExecuteQueryResult {
   int rowsAffected;
   double insertId;
 
-  std::unique_ptr<SQLiteQueryResults> results;
-  std::unique_ptr<std::optional<SQLiteQueryTableMetadata>> metadata;
+  SQLiteQueryResults results;
+  std::optional<SQLiteQueryTableMetadata> metadata;
 };
 
 // constexpr function that maps SQLiteColumnType to string literals

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-sqlite",
-  "version": "9.1.5",
+  "version": "9.1.6",
   "description": "Fast SQLite library for React Native built using Nitro Modules",
   "source": "./src/index.ts",
   "main": "./lib/commonjs/index",