src/query-builder/SelectQueryBuilder.ts (1)

1942-1944: Only trigger COUNT when pagination actually shifts the window; return 0 otherwise (and drop the stray semicolon).

Unconditionally forcing a COUNT on zero rows regresses the lazy-count optimization when there’s no skip/offset. If there’s no pagination offset, zero entities implies total=0 and we can skip the extra COUNT. Also, the semicolon is inconsistent with surrounding style.

Apply:

-        if (entitiesAndRaw.entities.length === 0) {
-            return undefined;
-        }
+        if (entitiesAndRaw.entities.length === 0) {
+            const hasSkip =
+                this.expressionMap.skip !== undefined &&
+                this.expressionMap.skip !== null &&
+                this.expressionMap.skip > 0
+            const hasOffset =
+                this.expressionMap.offset !== undefined &&
+                this.expressionMap.offset !== null &&
+                this.expressionMap.offset > 0
+            // If pagination shifted the window, we can't deduce total => force COUNT.
+            // Otherwise, we know total is 0 without an extra query.
+            return hasSkip || hasOffset ? undefined : 0
+        }

test/other-issues/lazy-count/lazy-count.ts (1)

269-295: Good coverage for offset > total; tighten COUNT detection regex and consider a skip/take variant.

• Minor: use word boundaries to avoid false positives in query text matching.
• Optional: add a companion test for take/skip where skip > total to cover both pagination APIs.

Regex tweak in this block:

-                expect(
-                    afterQuery
-                        .getCalledQueries()
-                        .filter((query) => query.match(/(count|cnt)/i)),
-                ).not.to.be.empty
+                expect(
+                    afterQuery
+                        .getCalledQueries()
+                        .filter((query) => /\b(count|cnt)\b/i.test(query)),
+                ).not.to.be.empty

Optional additional test (outside this hunk) mirroring the scenario with take/skip:

it("run count query when skip is greater than total entities", () =>
  Promise.all(
    connections.map(async (connection) => {
      await savePostEntities(connection, 5)

      const afterQuery = connection.subscribers[0] as AfterQuerySubscriber
      afterQuery.clear()

      const [entities, count] = await connection.manager
        .createQueryBuilder(Post, "post")
        .take(10)
        .skip(20)
        .orderBy("post.id")
        .getManyAndCount()

      expect(count).to.be.equal(5)
      expect(entities.length).to.be.equal(0)
      expect(
        afterQuery.getCalledQueries().filter((q) => /\b(count|cnt)\b/i.test(q)),
      ).not.to.be.empty
    }),
  ))

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled
• Linear integration is disabled

You can enable these sources in your CodeRabbit configuration.