perf: eliminate .map().join() in WindowOperator/SetOperator key construction; fix docs categorization

- WindowOperator partition key: .map().join() → direct concatenation loop
- SetOperator rowKey: Object.keys().sort().map().join() → direct concatenation loop
- dataframe-api docs: move toCode/toDescriptor from "Terminal methods" to new "Introspection" section
  (they don't execute queries)

Author: teamchong

docs/src/content/docs/dataframe-api.mdx

@@ -172,8 +172,6 @@ These execute the query and return results:
 | `stream(batchSize)` | `AsyncGenerator<Row[]>` | Async generator over result batches |
 | `cursor({ batchSize })` | `AsyncIterable<Row[]>` | Async iterable over batches |
 | `materialize()` | `DataFrame` | Execute and re-wrap as in-memory DataFrame |
-| `toCode(opts?)` | `string` | Convert query to fluent builder TypeScript code |
-| `toDescriptor()` | `QueryDescriptor` | Serializable query plan (JSON) |
 | `append(rows, opts?)` | `AppendResult` | Write rows (CAS-coordinated) |
 | `dropTable()` | `DropResult` | Delete table and all fragments |
 
@@ -204,6 +202,15 @@ const csv = await df.toCSV({ delimiter: "\t" })
 
 These are all sugar over existing methods — `shape()` calls `explain()`, `valueCounts()` uses `groupBy().aggregate()`, `fillNull()` and `cast()` use `computed()`.
 
+## Introspection
+
+These methods inspect the query without executing it:
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `toCode(opts?)` | `string` | Convert query to fluent builder TypeScript code |
+| `toDescriptor()` | `QueryDescriptor` | Serializable query plan (JSON) |
+
 ## Query decompilation (toCode)
 
 Convert any query back to readable, copy-pasteable fluent builder TypeScript. Useful for logging, debugging, and LLM context compression (~50x smaller than raw QueryDescriptor JSON).

src/operators.ts

@@ -924,9 +924,16 @@ export class WindowOperator implements Operator {
     // Group by partitionBy keys
     const partitions = new Map<string, number[]>();
     for (let i = 0; i < rows.length; i++) {
-      const key = win.partitionBy.length > 0
-        ? win.partitionBy.map(c => String(rows[i][c] ?? "")).join("\x00")
-        : "__all__";
+      let key: string;
+      if (win.partitionBy.length > 0) {
+        key = "";
+        for (let p = 0; p < win.partitionBy.length; p++) {
+          if (p > 0) key += "\x00";
+          key += String(rows[i][win.partitionBy[p]] ?? "");
+        }
+      } else {
+        key = "__all__";
+      }
       const indices = partitions.get(key);
       if (indices) indices.push(i);
       else partitions.set(key, [i]);
@@ -1199,7 +1206,13 @@ export class SetOperator implements Operator {
   }
 
   private rowKey(row: Row): string {
-    return Object.keys(row).sort().map(k => `${k}=${String(row[k] ?? "")}`).join("\x00");
+    const keys = Object.keys(row).sort();
+    let result = "";
+    for (let i = 0; i < keys.length; i++) {
+      if (i > 0) result += "\x00";
+      result += keys[i] + "=" + String(row[keys[i]] ?? "");
+    }
+    return result;
   }
 
   async next(): Promise<RowBatch | null> {