Add test showing that computed SQL queries aren't cached properly.

src/workerd/api/sql-test.js

@@ -1012,6 +1012,27 @@ async function test(state) {
   await state.blockConcurrencyWhile(async () => {
     sql.exec(`PRAGMA foreign_keys = ON;`);
   });
+
+  // Verify caching.
+  {
+    let isCached = (q) => {
+      let cursor = sql.exec(q);
+      cursor.toArray();
+      return cursor.reusedCachedQueryForTest;
+    };
+
+    // Query based on literal string is cached.
+    assert.equal(false, isCached('SELECT 179321'));
+    assert.equal(true, isCached('SELECT 179321'));
+    assert.equal(true, isCached('SELECT 179321'));
+
+    // Qeury based on computed string is cached.
+    assert.equal(false, isCached('SELECT "' + 'x'.repeat(4) + '"'));
+
+    // TODO(now): These should be true.
+    assert.equal(false, isCached('SELECT "' + 'x'.repeat(4) + '"'));
+    assert.equal(false, isCached('SELECT "' + 'x'.repeat(4) + '"'));
+  }
 }
 
 async function testIoStats(storage) {

src/workerd/api/sql.c++

@@ -159,6 +159,8 @@ void SqlStorage::Cursor::initColumnNames(jsg::Lock& js, State& stateRef) {
   // TODO(cleanup): Make `js.withinHandleScope` understand `jsg::JsValue` types in addition to
   //   `v8::Local`.
   KJ_IF_SOME(cached, stateRef.cachedStatement) {
+    reusedCachedQuery = cached->useCount++ > 0;
+
     KJ_IF_SOME(names, cached->cachedColumnNames) {
       // Use cached copy.
       columnNames = names.addRef(js);

src/workerd/api/sql.h

@@ -87,6 +87,7 @@ class SqlStorage final: public jsg::Object, private SqliteDatabase::Regulator {
     SqliteDatabase::Statement statement;
     kj::Maybe<jsg::JsRef<jsg::JsArray>> cachedColumnNames;  // initialized on first exec
     kj::ListLink<CachedStatement> lruLink;
+    uint useCount = 0;
 
     CachedStatement(jsg::Lock& js,
         SqlStorage& sqlStorage,
@@ -190,7 +191,7 @@ class SqlStorage::Cursor final: public jsg::Object {
   double getRowsWritten();
 
   jsg::JsArray getColumnNames(jsg::Lock& js);
-  JSG_RESOURCE_TYPE(Cursor) {
+  JSG_RESOURCE_TYPE(Cursor, CompatibilityFlags::Reader flags) {
     JSG_METHOD(next);
     JSG_METHOD(toArray);
     JSG_METHOD(one);
@@ -210,6 +211,10 @@ class SqlStorage::Cursor final: public jsg::Object {
       one(): T;
       columnNames: string[];
     });
+
+    if (flags.getWorkerdExperimental()) {
+      JSG_READONLY_PROTOTYPE_PROPERTY(reusedCachedQueryForTest, getReusedCachedQueryForTest);
+    }
   }
 
   JSG_ITERATOR(RowIterator, rows, jsg::JsObject, jsg::Ref<Cursor>, rowIteratorNext);
@@ -226,6 +231,10 @@ class SqlStorage::Cursor final: public jsg::Object {
     tracker.trackField("columnNames", columnNames);
   }
 
+  bool getReusedCachedQueryForTest() {
+    return reusedCachedQuery;
+  }
+
 private:
   struct State {
     kj::Maybe<kj::Rc<CachedStatement>> cachedStatement;
@@ -251,6 +260,9 @@ class SqlStorage::Cursor final: public jsg::Object {
   // flag an error if the application tries to reuse the cursor.
   bool canceled = false;
 
+  // Did we reuse a query from the query cache? Tracked for testing purposes.
+  bool reusedCachedQuery = false;
+
   // Reference to a weak reference that might point back to this object. If so, null it out at
   // destruction. Used by Statement to invalidate past cursors when the statement is
   // executed again.