sqlite: optimize column name creation and text value encoding

Use simdutf to detect ASCII text values and create them via NewFromOneByte for compact one byte representation. Internalize column name strings with kInternalized
Cache column names on StatementSync for the iterate(), invalidated via SQLITE_STMTSTATUS_REPREPARE.

Refs: nodejs/performance#181

Author: thisalihassan

src/node_sqlite.cc

@@ -8,6 +8,7 @@
 #include "node_errors.h"
 #include "node_mem-inl.h"
 #include "node_url.h"
+#include "simdutf.h"
 #include "sqlite3.h"
 #include "threadpoolwork-inl.h"
 #include "util-inl.h"
@@ -55,6 +56,18 @@ using v8::TryCatch;
 using v8::Uint8Array;
 using v8::Value;
 
+inline MaybeLocal<String> Utf8StringMaybeOneByte(Isolate* isolate,
+                                                 const char* data,
+                                                 size_t length) {
+  int len = static_cast<int>(length);
+  if (simdutf::validate_ascii(data, length)) {
+    return String::NewFromOneByte(
+        isolate, reinterpret_cast<const uint8_t*>(data), NewStringType::kNormal,
+        len);
+  }
+  return String::NewFromUtf8(isolate, data, NewStringType::kNormal, len);
+}
+
 #define CHECK_ERROR_OR_THROW(isolate, db, expr, expected, ret)                 \
   do {                                                                         \
     int r_ = (expr);                                                           \
@@ -97,7 +110,8 @@ using v8::Value;
       case SQLITE_TEXT: {                                                      \
         const char* v =                                                        \
             reinterpret_cast<const char*>(sqlite3_##from##_text(__VA_ARGS__)); \
-        (result) = String::NewFromUtf8((isolate), v).As<Value>();              \
+        int v_len = sqlite3_##from##_bytes(__VA_ARGS__);                       \
+        (result) = Utf8StringMaybeOneByte((isolate), v, v_len).As<Value>();    \
         break;                                                                 \
       }                                                                        \
       case SQLITE_NULL: {                                                      \
@@ -2147,6 +2161,7 @@ StatementSync::~StatementSync() {
 void StatementSync::Finalize() {
   sqlite3_finalize(statement_);
   statement_ = nullptr;
+  cached_column_names_.clear();
 }
 
 inline bool StatementSync::IsFinalized() {
@@ -2325,7 +2340,40 @@ MaybeLocal<Name> StatementSync::ColumnNameToName(const int column) {
     return MaybeLocal<Name>();
   }
 
-  return String::NewFromUtf8(env()->isolate(), col_name).As<Name>();
+  return String::NewFromUtf8(
+             env()->isolate(), col_name, NewStringType::kInternalized)
+      .As<Name>();
+}
+
+bool StatementSync::GetCachedColumnNames(LocalVector<Name>* keys) {
+  Isolate* isolate = env()->isolate();
+
+  int reprepare_count = sqlite3_stmt_status(
+      statement_, SQLITE_STMTSTATUS_REPREPARE, 0);
+  if (reprepare_count != cached_column_names_reprepare_count_) {
+    cached_column_names_.clear();
+    int num_cols = sqlite3_column_count(statement_);
+    if (num_cols == 0) {
+      cached_column_names_reprepare_count_ = reprepare_count;
+      return true;
+    }
+    cached_column_names_.reserve(num_cols);
+    for (int i = 0; i < num_cols; ++i) {
+      Local<Name> key;
+      if (!ColumnNameToName(i).ToLocal(&key)) {
+        cached_column_names_.clear();
+        return false;
+      }
+      cached_column_names_.emplace_back(Global<Name>(isolate, key));
+    }
+    cached_column_names_reprepare_count_ = reprepare_count;
+  }
+
+  keys->reserve(cached_column_names_.size());
+  for (const auto& name : cached_column_names_) {
+    keys->emplace_back(name.Get(isolate));
+  }
+  return true;
 }
 
 MaybeLocal<Value> StatementExecutionHelper::ColumnToValue(Environment* env,
@@ -2347,7 +2395,9 @@ MaybeLocal<Name> StatementExecutionHelper::ColumnNameToName(Environment* env,
     return MaybeLocal<Name>();
   }
 
-  return String::NewFromUtf8(env->isolate(), col_name).As<Name>();
+  return String::NewFromUtf8(
+             env->isolate(), col_name, NewStringType::kInternalized)
+      .As<Name>();
 }
 
 void StatementSync::MemoryInfo(MemoryTracker* tracker) const {}
@@ -3251,12 +3301,7 @@ void StatementSyncIterator::Next(const FunctionCallbackInfo<Value>& args) {
   if (iter->stmt_->return_arrays_) {
     row_value = Array::New(isolate, row_values.data(), row_values.size());
   } else {
-    row_keys.reserve(num_cols);
-    for (int i = 0; i < num_cols; ++i) {
-      Local<Name> key;
-      if (!iter->stmt_->ColumnNameToName(i).ToLocal(&key)) return;
-      row_keys.emplace_back(key);
-    }
+    if (!iter->stmt_->GetCachedColumnNames(&row_keys)) return;
 
     DCHECK_EQ(row_keys.size(), row_values.size());
     row_value = Object::New(

src/node_sqlite.h

@@ -12,6 +12,7 @@
 #include <list>
 #include <map>
 #include <unordered_set>
+#include <vector>
 
 namespace node {
 namespace sqlite {
@@ -228,6 +229,7 @@ class StatementSync : public BaseObject {
   static void SetReturnArrays(const v8::FunctionCallbackInfo<v8::Value>& args);
   v8::MaybeLocal<v8::Value> ColumnToValue(const int column);
   v8::MaybeLocal<v8::Name> ColumnNameToName(const int column);
+  bool GetCachedColumnNames(v8::LocalVector<v8::Name>* keys);
   void Finalize();
   bool IsFinalized();
 
@@ -243,6 +245,8 @@ class StatementSync : public BaseObject {
   bool allow_bare_named_params_;
   bool allow_unknown_named_params_;
   std::optional<std::map<std::string, std::string>> bare_named_params_;
+  std::vector<v8::Global<v8::Name>> cached_column_names_;
+  int cached_column_names_reprepare_count_ = -1;
   bool BindParams(const v8::FunctionCallbackInfo<v8::Value>& args);
   bool BindValue(const v8::Local<v8::Value>& value, const int index);