review fixed

Author: mertcanaltin

doc/api/sqlite.md

@@ -158,30 +158,20 @@ changes:
   * `limits` {Object} Configuration for various SQLite limits. These limits
     can be used to prevent excessive resource consumption when handling
     potentially malicious input. See [Run-Time Limits][] and [Limit Constants][]
-    in the SQLite documentation for details. The following properties are
-    supported:
+    in the SQLite documentation for details. Default values are determined by
+    SQLite's compile-time defaults and may vary depending on how SQLite was
+    built. The following properties are supported:
     * `length` {number} Maximum length of a string or BLOB.
-      **Default:** `1000000000`.
     * `sqlLength` {number} Maximum length of an SQL statement.
-      **Default:** `1000000000`.
     * `column` {number} Maximum number of columns.
-      **Default:** `2000`.
     * `exprDepth` {number} Maximum depth of expression tree.
-      **Default:** `1000`.
     * `compoundSelect` {number} Maximum number of terms in compound SELECT.
-      **Default:** `500`.
     * `vdbeOp` {number} Maximum number of VDBE instructions.
-      **Default:** `250000000`.
     * `functionArg` {number} Maximum number of function arguments.
-      **Default:** `1000`.
     * `attach` {number} Maximum number of attached databases.
-      **Default:** `10`.
     * `likePatternLength` {number} Maximum length of LIKE pattern.
-      **Default:** `50000`.
     * `variableNumber` {number} Maximum number of SQL variables.
-      **Default:** `32766`.
     * `triggerDepth` {number} Maximum trigger recursion depth.
-      **Default:** `1000`.
 
 Constructs a new `DatabaseSync` instance.
 

src/node_sqlite.cc

@@ -140,65 +140,23 @@ Local<DictionaryTemplate> getLazyIterTemplate(Environment* env) {
 }  // namespace
 
 // Mapping from JavaScript property names to SQLite limit constants
-// Default compile-time maximums from SQLite (these match SQLite's defaults)
-#ifndef SQLITE_MAX_LENGTH
-#define SQLITE_MAX_LENGTH 1000000000
-#endif
-#ifndef SQLITE_MAX_SQL_LENGTH
-#define SQLITE_MAX_SQL_LENGTH 1000000000
-#endif
-#ifndef SQLITE_MAX_COLUMN
-#define SQLITE_MAX_COLUMN 2000
-#endif
-#ifndef SQLITE_MAX_EXPR_DEPTH
-#define SQLITE_MAX_EXPR_DEPTH 1000
-#endif
-#ifndef SQLITE_MAX_COMPOUND_SELECT
-#define SQLITE_MAX_COMPOUND_SELECT 500
-#endif
-#ifndef SQLITE_MAX_VDBE_OP
-#define SQLITE_MAX_VDBE_OP 250000000
-#endif
-#ifndef SQLITE_MAX_FUNCTION_ARG
-#define SQLITE_MAX_FUNCTION_ARG 1000
-#endif
-#ifndef SQLITE_MAX_ATTACHED
-#define SQLITE_MAX_ATTACHED 10
-#endif
-#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH
-#define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000
-#endif
-#ifndef SQLITE_MAX_VARIABLE_NUMBER
-#define SQLITE_MAX_VARIABLE_NUMBER 32766
-#endif
-#ifndef SQLITE_MAX_TRIGGER_DEPTH
-#define SQLITE_MAX_TRIGGER_DEPTH 1000
-#endif
-
 struct LimitInfo {
   std::string_view js_name;
   int sqlite_limit_id;
-  int max_value;
 };
 
 static constexpr std::array<LimitInfo, 11> kLimitMapping = {{
-    {"length", SQLITE_LIMIT_LENGTH, SQLITE_MAX_LENGTH},
-    {"sqlLength", SQLITE_LIMIT_SQL_LENGTH, SQLITE_MAX_SQL_LENGTH},
-    {"column", SQLITE_LIMIT_COLUMN, SQLITE_MAX_COLUMN},
-    {"exprDepth", SQLITE_LIMIT_EXPR_DEPTH, SQLITE_MAX_EXPR_DEPTH},
-    {"compoundSelect",
-     SQLITE_LIMIT_COMPOUND_SELECT,
-     SQLITE_MAX_COMPOUND_SELECT},
-    {"vdbeOp", SQLITE_LIMIT_VDBE_OP, SQLITE_MAX_VDBE_OP},
-    {"functionArg", SQLITE_LIMIT_FUNCTION_ARG, SQLITE_MAX_FUNCTION_ARG},
-    {"attach", SQLITE_LIMIT_ATTACHED, SQLITE_MAX_ATTACHED},
-    {"likePatternLength",
-     SQLITE_LIMIT_LIKE_PATTERN_LENGTH,
-     SQLITE_MAX_LIKE_PATTERN_LENGTH},
-    {"variableNumber",
-     SQLITE_LIMIT_VARIABLE_NUMBER,
-     SQLITE_MAX_VARIABLE_NUMBER},
-    {"triggerDepth", SQLITE_LIMIT_TRIGGER_DEPTH, SQLITE_MAX_TRIGGER_DEPTH},
+    {"length", SQLITE_LIMIT_LENGTH},
+    {"sqlLength", SQLITE_LIMIT_SQL_LENGTH},
+    {"column", SQLITE_LIMIT_COLUMN},
+    {"exprDepth", SQLITE_LIMIT_EXPR_DEPTH},
+    {"compoundSelect", SQLITE_LIMIT_COMPOUND_SELECT},
+    {"vdbeOp", SQLITE_LIMIT_VDBE_OP},
+    {"functionArg", SQLITE_LIMIT_FUNCTION_ARG},
+    {"attach", SQLITE_LIMIT_ATTACHED},
+    {"likePatternLength", SQLITE_LIMIT_LIKE_PATTERN_LENGTH},
+    {"variableNumber", SQLITE_LIMIT_VARIABLE_NUMBER},
+    {"triggerDepth", SQLITE_LIMIT_TRIGGER_DEPTH},
 }};
 
 // Helper function to find limit info from JS property name
@@ -387,7 +345,7 @@ class CustomAggregate {
   static inline void xStepBase(sqlite3_context* ctx,
                                int argc,
                                sqlite3_value** argv,
-                               Global<Function> CustomAggregate::*mptr) {
+                               Global<Function> CustomAggregate::* mptr) {
     CustomAggregate* self =
         static_cast<CustomAggregate*>(sqlite3_user_data(ctx));
     Environment* env = self->env_;
@@ -848,13 +806,6 @@ Intercepted DatabaseSyncLimits::LimitsSetter(
     return Intercepted::kYes;
   }
 
-  // Validate against compile-time maximum
-  if (new_value > limit_info->max_value) {
-    THROW_ERR_OUT_OF_RANGE(isolate,
-                           "Limit value exceeds compile-time maximum.");
-    return Intercepted::kYes;
-  }
-
   sqlite3_limit(
       limits->database_->Connection(), limit_info->sqlite_limit_id, new_value);
   return Intercepted::kYes;
@@ -1390,14 +1341,6 @@ void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
             return;
           }
 
-          if (limit_val > kLimitMapping[i].max_value) {
-            std::string msg = "The \"options.limits." +
-                              std::string(kLimitMapping[i].js_name) +
-                              "\" argument exceeds compile-time maximum.";
-            THROW_ERR_OUT_OF_RANGE(env->isolate(), msg);
-            return;
-          }
-
           open_config.set_initial_limit(kLimitMapping[i].sqlite_limit_id,
                                         limit_val);
         }

test/parallel/test-sqlite-limits.js

@@ -5,21 +5,28 @@ const { DatabaseSync } = require('node:sqlite');
 const { suite, test } = require('node:test');
 
 suite('DatabaseSync limits', () => {
-  test('default limits match expected SQLite defaults', (t) => {
+  test('limits object has expected properties with positive values', (t) => {
     const db = new DatabaseSync(':memory:');
-    t.assert.deepStrictEqual({ ...db.limits }, {
-      length: 1000000000,
-      sqlLength: 1000000000,
-      column: 2000,
-      exprDepth: 1000,
-      compoundSelect: 500,
-      vdbeOp: 250000000,
-      functionArg: 1000,
-      attach: 10,
-      likePatternLength: 50000,
-      variableNumber: 32766,
-      triggerDepth: 1000,
-    });
+    const expectedProperties = [
+      'length',
+      'sqlLength',
+      'column',
+      'exprDepth',
+      'compoundSelect',
+      'vdbeOp',
+      'functionArg',
+      'attach',
+      'likePatternLength',
+      'variableNumber',
+      'triggerDepth',
+    ];
+
+    for (const prop of expectedProperties) {
+      t.assert.strictEqual(typeof db.limits[prop], 'number',
+        `${prop} should be a number`);
+      t.assert.ok(db.limits[prop] > 0,
+        `${prop} should be positive`);
+    }
   });
 
   test('constructor accepts limits option', (t) => {
@@ -158,25 +165,6 @@ suite('DatabaseSync limits', () => {
     });
   });
 
-  test('throws on value exceeding compile-time maximum via setter', (t) => {
-    const db = new DatabaseSync(':memory:');
-    t.assert.throws(() => {
-      db.limits.attach = 100;
-    }, {
-      name: 'RangeError',
-      message: /Limit value exceeds compile-time maximum/,
-    });
-  });
-
-  test('throws on value exceeding compile-time maximum in constructor', (t) => {
-    t.assert.throws(() => {
-      new DatabaseSync(':memory:', { limits: { attach: 100 } });
-    }, {
-      name: 'RangeError',
-      message: /options\.limits\.attach.*exceeds compile-time maximum/,
-    });
-  });
-
   test('partial limits in constructor', (t) => {
     const db = new DatabaseSync(':memory:', {
       limits: {