sqlite: add setReturnArrays method to StatementSync

Author: gurgunday

src/node_sqlite.cc

@@ -1582,27 +1582,38 @@ void StatementSync::All(const FunctionCallbackInfo<Value>& args) {
   int num_cols = sqlite3_column_count(stmt->statement_);
   LocalVector<Value> rows(isolate);
   LocalVector<Name> row_keys(isolate);
+
   while ((r = sqlite3_step(stmt->statement_)) == SQLITE_ROW) {
-    if (row_keys.size() == 0) {
-      row_keys.reserve(num_cols);
+    if (stmt->return_arrays_) {
+      Local<Array> row = Array::New(isolate, num_cols);
       for (int i = 0; i < num_cols; ++i) {
-        Local<Name> key;
-        if (!stmt->ColumnNameToName(i).ToLocal(&key)) return;
-        row_keys.emplace_back(key);
+        Local<Value> val;
+        if (!stmt->ColumnToValue(i).ToLocal(&val)) return;
+        if (row->Set(env->context(), i, val).IsNothing()) return;
+      }
+      rows.emplace_back(row);
+    } else {
+      if (row_keys.size() == 0) {
+        row_keys.reserve(num_cols);
+        for (int i = 0; i < num_cols; ++i) {
+          Local<Name> key;
+          if (!stmt->ColumnNameToName(i).ToLocal(&key)) return;
+          row_keys.emplace_back(key);
+        }
       }
-    }
 
-    LocalVector<Value> row_values(isolate);
-    row_values.reserve(num_cols);
-    for (int i = 0; i < num_cols; ++i) {
-      Local<Value> val;
-      if (!stmt->ColumnToValue(i).ToLocal(&val)) return;
-      row_values.emplace_back(val);
-    }
+      LocalVector<Value> row_values(isolate);
+      row_values.reserve(num_cols);
+      for (int i = 0; i < num_cols; ++i) {
+        Local<Value> val;
+        if (!stmt->ColumnToValue(i).ToLocal(&val)) return;
+        row_values.emplace_back(val);
+      }
 
-    Local<Object> row = Object::New(
-        isolate, Null(isolate), row_keys.data(), row_values.data(), num_cols);
-    rows.emplace_back(row);
+      Local<Object> row = Object::New(
+          isolate, Null(isolate), row_keys.data(), row_values.data(), num_cols);
+      rows.emplace_back(row);
+    }
   }
 
   CHECK_ERROR_OR_THROW(isolate, stmt->db_.get(), r, SQLITE_DONE, void());
@@ -1645,7 +1656,7 @@ void StatementSync::IterateReturnCallback(
 }
 
 void StatementSync::IterateNextCallback(
-    const FunctionCallbackInfo<Value>& args) {
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   auto isolate = env->isolate();
   auto context = isolate->GetCurrentContext();
@@ -1688,6 +1699,15 @@ void StatementSync::IterateNextCallback(
   THROW_AND_RETURN_ON_BAD_STATE(
       env, stmt->IsFinalized(), "statement has been finalized");
 
+  // Get the return_arrays flag from the iterator object
+  Local<Value> return_arrays_val;
+  bool return_arrays = false;
+  if (self->Get(context, FIXED_ONE_BYTE_STRING(isolate, "return_arrays"))
+           .ToLocal(&return_arrays_val) &&
+      return_arrays_val->IsBoolean()) {
+    return_arrays = return_arrays_val.As<Boolean>()->Value();
+  }
+
   int r = sqlite3_step(stmt->statement_);
   if (r != SQLITE_ROW) {
     CHECK_ERROR_OR_THROW(
@@ -1702,39 +1722,47 @@ void StatementSync::IterateNextCallback(
       return;
     }
 
-    LocalVector<Name> keys(isolate, {env->done_string(), env->value_string()});
-    LocalVector<Value> values(isolate,
-                              {Boolean::New(isolate, true), Null(isolate)});
-
-    DCHECK_EQ(keys.size(), values.size());
+    Local<Name> keys[] = {env->done_string(), env->value_string()};
+    Local<Value> values[] = {Boolean::New(isolate, true), Null(isolate)};
+    static_assert(arraysize(keys) == arraysize(values));
     Local<Object> result = Object::New(
-        isolate, Null(isolate), keys.data(), values.data(), keys.size());
+        isolate, Null(isolate), &keys[0], &values[0], arraysize(keys));
     args.GetReturnValue().Set(result);
     return;
   }
 
-  LocalVector<Name> row_keys(isolate);
-  row_keys.reserve(num_cols);
-  LocalVector<Value> row_values(isolate);
-  row_values.reserve(num_cols);
-  for (int i = 0; i < num_cols; ++i) {
-    Local<Name> key;
-    if (!stmt->ColumnNameToName(i).ToLocal(&key)) return;
-    Local<Value> val;
-    if (!stmt->ColumnToValue(i).ToLocal(&val)) return;
-    row_keys.emplace_back(key);
-    row_values.emplace_back(val);
-  }
-
-  Local<Object> row = Object::New(
-      isolate, Null(isolate), row_keys.data(), row_values.data(), num_cols);
+  Local<Value> row;
+  if (return_arrays) {
+    Local<Array> array_row = Array::New(isolate, num_cols);
+    for (int i = 0; i < num_cols; ++i) {
+      Local<Value> val;
+      if (!stmt->ColumnToValue(i).ToLocal(&val)) return;
+      if (array_row->Set(env->context(), i, val).IsNothing()) return;
+    }
+    row = array_row;
+  } else {
+    LocalVector<Name> row_keys(isolate);
+    row_keys.reserve(num_cols);
+    LocalVector<Value> row_values(isolate);
+    row_values.reserve(num_cols);
+    for (int i = 0; i < num_cols; ++i) {
+      Local<Name> key;
+      if (!stmt->ColumnNameToName(i).ToLocal(&key)) return;
+      Local<Value> val;
+      if (!stmt->ColumnToValue(i).ToLocal(&val)) return;
+      row_keys.emplace_back(key);
+      row_values.emplace_back(val);
+    }
 
-  LocalVector<Name> keys(isolate, {env->done_string(), env->value_string()});
-  LocalVector<Value> values(isolate, {Boolean::New(isolate, false), row});
+    row = Object::New(
+        isolate, Null(isolate), row_keys.data(), row_values.data(), num_cols);
+  }
 
-  DCHECK_EQ(keys.size(), values.size());
+  Local<Name> keys[] = {env->done_string(), env->value_string()};
+  Local<Value> values[] = {Boolean::New(isolate, false), row};
+  static_assert(arraysize(keys) == arraysize(values));
   Local<Object> result = Object::New(
-      isolate, Null(isolate), keys.data(), values.data(), keys.size());
+      isolate, Null(isolate), &keys[0], &values[0], arraysize(keys));
   args.GetReturnValue().Set(result);
 }
 
@@ -1804,15 +1832,30 @@ void StatementSync::Iterate(const FunctionCallbackInfo<Value>& args) {
 
   auto is_finished_pd =
       v8::PropertyDescriptor(v8::Boolean::New(isolate, false), true);
-  stmt_pd.set_enumerable(false);
-  stmt_pd.set_configurable(false);
+  is_finished_pd.set_enumerable(false);
+  is_finished_pd.set_configurable(false);
   if (iterable_iterator
           ->DefineProperty(context, env->isfinished_string(), is_finished_pd)
           .IsNothing()) {
     // An error will have been scheduled.
     return;
   }
 
+  // Add the return_arrays flag to the iterator
+  auto return_arrays_pd =
+      v8::PropertyDescriptor(v8::Boolean::New(
+        isolate, stmt->return_arrays_), false);
+  return_arrays_pd.set_enumerable(false);
+  return_arrays_pd.set_configurable(false);
+  if (iterable_iterator
+          ->DefineProperty(
+            context, FIXED_ONE_BYTE_STRING(
+              isolate, "return_arrays"), return_arrays_pd)
+          .IsNothing()) {
+    // An error will have been scheduled.
+    return;
+  }
+
   args.GetReturnValue().Set(iterable_iterator);
 }
 
@@ -1843,24 +1886,35 @@ void StatementSync::Get(const FunctionCallbackInfo<Value>& args) {
     return;
   }
 
-  LocalVector<Name> keys(isolate);
-  keys.reserve(num_cols);
-  LocalVector<Value> values(isolate);
-  values.reserve(num_cols);
+  if (stmt->return_arrays_) {
+    Local<Array> result = Array::New(isolate, num_cols);
+    for (int i = 0; i < num_cols; ++i) {
+      Local<Value> val;
+      if (!stmt->ColumnToValue(i).ToLocal(&val)) return;
+      if (result->Set(env->context(), i, val).IsNothing()) return;
+    }
+    args.GetReturnValue().Set(result);
+  } else {
+    LocalVector<Name> keys(isolate);
+    keys.reserve(num_cols);
+    LocalVector<Value> values(isolate);
+    values.reserve(num_cols);
 
-  for (int i = 0; i < num_cols; ++i) {
-    Local<Name> key;
-    if (!stmt->ColumnNameToName(i).ToLocal(&key)) return;
-    Local<Value> val;
-    if (!stmt->ColumnToValue(i).ToLocal(&val)) return;
-    keys.emplace_back(key);
-    values.emplace_back(val);
-  }
+    for (int i = 0; i < num_cols; ++i) {
+      Local<Name> key;
+      if (!stmt->ColumnNameToName(i).ToLocal(&key)) return;
+      Local<Value> val;
+      if (!stmt->ColumnToValue(i).ToLocal(&val)) return;
+      keys.emplace_back(key);
+      values.emplace_back(val);
+    }
 
-  Local<Object> result =
-      Object::New(isolate, Null(isolate), keys.data(), values.data(), num_cols);
+    Local<Object> result =
+        Object::New(
+          isolate, Null(isolate), keys.data(), values.data(), num_cols);
 
-  args.GetReturnValue().Set(result);
+    args.GetReturnValue().Set(result);
+  }
 }
 
 void StatementSync::Run(const FunctionCallbackInfo<Value>& args) {
@@ -2043,6 +2097,22 @@ void StatementSync::SetReadBigInts(const FunctionCallbackInfo<Value>& args) {
   stmt->use_big_ints_ = args[0]->IsTrue();
 }
 
+void StatementSync::SetReturnArrays(const FunctionCallbackInfo<Value>& args) {
+  StatementSync* stmt;
+  ASSIGN_OR_RETURN_UNWRAP(&stmt, args.This());
+  Environment* env = Environment::GetCurrent(args);
+  THROW_AND_RETURN_ON_BAD_STATE(
+      env, stmt->IsFinalized(), "statement has been finalized");
+
+  if (!args[0]->IsBoolean()) {
+    THROW_ERR_INVALID_ARG_TYPE(
+        env->isolate(), "The \"returnArrays\" argument must be a boolean.");
+    return;
+  }
+
+  stmt->return_arrays_ = args[0]->IsTrue();
+}
+
 void IllegalConstructor(const FunctionCallbackInfo<Value>& args) {
   THROW_ERR_ILLEGAL_CONSTRUCTOR(Environment::GetCurrent(args));
 }
@@ -2094,6 +2164,8 @@ Local<FunctionTemplate> StatementSync::GetConstructorTemplate(
                    StatementSync::SetAllowBareNamedParameters);
     SetProtoMethod(
         isolate, tmpl, "setReadBigInts", StatementSync::SetReadBigInts);
+    SetProtoMethod(
+      isolate, tmpl, "setReturnArrays", StatementSync::SetReturnArrays);
     env->set_sqlite_statement_sync_constructor_template(tmpl);
   }
   return tmpl;

src/node_sqlite.h

@@ -123,6 +123,7 @@ class StatementSync : public BaseObject {
   static void SetAllowBareNamedParameters(
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetReadBigInts(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void SetReturnArrays(const v8::FunctionCallbackInfo<v8::Value>& args);
   void Finalize();
   bool IsFinalized();
 
@@ -133,6 +134,7 @@ class StatementSync : public BaseObject {
   ~StatementSync() override;
   BaseObjectPtr<DatabaseSync> db_;
   sqlite3_stmt* statement_;
+  bool return_arrays_ = false;
   bool use_big_ints_;
   bool allow_bare_named_params_;
   std::optional<std::map<std::string, std::string>> bare_named_params_;