@@ -1760,8 +1760,8 @@ describe('Metadata Integration Tests', () => {
 
   describe('getAllKeyValues - values repeated across parts', () => {
     // mergeTreeTextIndex returns one row per part and token, so a token cap
-    // that ignores the part count stops before the later parts' values. Each
-    // part holds the same SHARED values plus OWN values no other part has.
+    // stops before the later parts' values. Each part holds the same SHARED
+    // values plus OWN values no other part has.
     const tableName = 'test_text_index_values_across_parts';
     const PARTS = 25;
     const SHARED = 1000;
@@ -1820,7 +1820,7 @@ describe('Metadata Integration Tests', () => {
       ['Map key=value', "ResourceAttributes['pod']"],
       ['plain-column', 'Tags'],
     ])(
-      'returns every distinct value from the %s text index, with and without a part limit',
+      'returns every distinct value from the %s text index for "Load more"',
       async (_, keyExpression) => {
         if (!textIndexSupported) {
           console.warn(
@@ -1829,26 +1829,20 @@ describe('Metadata Integration Tests', () => {
           return;
         }
 
-        // PARTS is above the default limit of 20, so unset reads 20 parts and
-        // null reads all of them.
-        for (const [mapKeyIndexMaxParts, partsRead] of [
-          [undefined, 20],
-          [null, PARTS],
-        ] as const) {
-          const metadata = new Metadata(hdxClient, new MetadataCache());
-          const result = await metadata.getAllKeyValues({
-            databaseName: 'default',
-            tableName,
-            keyExpressions: [keyExpression],
-            maxValuesPerKey: 10000,
-            mapKeyIndexMaxParts,
-            connectionId: 'test_connection',
-            dateRange: dateRange(),
-            timestampValueExpression: 'Timestamp',
-          });
-          expect(result).toHaveLength(1);
-          expect(result[0].value).toHaveLength(SHARED + OWN * partsRead);
-        }
+        // "Load more" passes null: every part, no token cap.
+        const metadata = new Metadata(hdxClient, new MetadataCache());
+        const result = await metadata.getAllKeyValues({
+          databaseName: 'default',
+          tableName,
+          keyExpressions: [keyExpression],
+          maxValuesPerKey: 10000,
+          mapKeyIndexMaxParts: null,
+          connectionId: 'test_connection',
+          dateRange: dateRange(),
+          timestampValueExpression: 'Timestamp',
+        });
+        expect(result).toHaveLength(1);
+        expect(result[0].value).toHaveLength(SHARED + OWN * PARTS);
       },
     );
   });
 
@@ -1382,8 +1382,7 @@ describe('Metadata', () => {
 
       expect(sql).toContain('mergeTreeTextIndex(');
       expect(sql).toContain('topKWeighted(');
-      // 20,000 tokens for each of the default 20 parts.
-      expect(sql).toContain('LIMIT 400000');
+      expect(sql).toContain('LIMIT 20000');
       expect(sql).not.toContain('startsWith(token,');
     });
 
@@ -1437,8 +1436,7 @@ describe('Metadata', () => {
       expect(branches[0]).toContain("'requestId' AS key");
       expect(branches[1]).toContain("startsWith(token, 'region=')");
       for (const branch of branches) {
-        // 20,000 tokens for each of the default 20 parts.
-        expect(branch).toContain('LIMIT 400000');
+        expect(branch).toContain('LIMIT 20000');
       }
       expect(call.clickhouse_settings.max_rows_to_read).toBe('0');
       expect(call.clickhouse_settings.read_overflow_mode).toBeUndefined();
@@ -1448,7 +1446,7 @@ describe('Metadata', () => {
       ['map KV', "LogAttributes['requestId']"],
       ['native', 'TraceId'],
     ])(
-      'scales the %s text index token cap by the parts read, and drops it when every part is read',
+      'caps the %s text index read per key, and drops the cap when every part is read',
       async (_, keyExpression) => {
         setupDefaultLogsSchema();
         withDictionaryBlockSize(8192);
@@ -1465,7 +1463,7 @@ describe('Metadata', () => {
           .map(([opts]) => opts.query as string)
           .filter(q => q.includes('mergeTreeTextIndex('))
           .map(q => q.match(/LIMIT (\d+)/)?.[1]);
-        expect(tokenLimits).toEqual(['100000', undefined]);
+        expect(tokenLimits).toEqual(['20000', undefined]);
       },
     );
 
 
@@ -79,19 +79,19 @@ export const DEFAULT_MAP_KEY_INDEX_MAX_PARTS = 20;
 // Cap keys per dispatched query: each key is another operation for the db to fetch, and simply fetching all keys at once can be too much for the db to handle.
 export const GET_ALL_KEY_VALUES_CHUNK_SIZE = 100;
 
-// Distinct values a text index values lookup reads per key. The dictionary is
+// Index rows a text index values lookup reads per key. The dictionary is
 // sorted, so a key with more than this gets the most frequent among its
-// alphabetically first ones. Keep it above "Load more"'s 10,000 values.
+// alphabetically first ones.
 const TEXT_INDEX_TOKENS_PER_KEY = 20_000;
 
-// mergeTreeTextIndex returns one row per part and token, so a value in every
-// part read takes maxParts rows; scaling the LIMIT by maxParts keeps room for
-// TEXT_INDEX_TOKENS_PER_KEY distinct values. A read of every part ("Load
-// more") isn't capped.
+// mergeTreeTextIndex returns one row per part and token, so the cap counts a
+// value once per part it's in, and values only in parts read after it are
+// missed. That sample is enough for the top values of a filter, but "Load
+// more" (no part limit) wants every value, so its read isn't capped.
 const textIndexTokenLimit = (maxParts: number | null): ChSql =>
   maxParts == null
     ? chSql``
-    : chSql`LIMIT ${{ UNSAFE_RAW_SQL: inlineNonNegativeInt(TEXT_INDEX_TOKENS_PER_KEY * maxParts, 'maxParts') }}`;
+    : chSql`LIMIT ${{ UNSAFE_RAW_SQL: String(TEXT_INDEX_TOKENS_PER_KEY) }}`;
 // Keys or columns per text index values query; see dispatchKeyValueQueries.
 const TEXT_INDEX_KEYS_PER_QUERY = 10;
 // Smallest dictionary block size that gets one read per key; see