adapters

Author: singaraiona

.claude/settings.local.json

@@ -0,0 +1,26 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(git push:*)",
+      "Bash(ls:*)",
+      "Bash(gh api:*)",
+      "Bash(gh run list:*)",
+      "Bash(gh run view:*)",
+      "Bash(curl:*)",
+      "Bash(gh workflow run:*)",
+      "Bash(python scripts/generate_window_join.py:*)",
+      "Bash(source .venv/bin/activate)",
+      "Bash(python scripts/generate_h2oai_join.py:*)",
+      "Bash(python run_bench.py:*)",
+      "Bash(../rayforce/rayforce:*)",
+      "Bash(python -m py_compile:*)",
+      "Bash(python3 -m py_compile:*)"
+    ]
+  },
+  "enableAllProjectMcpServers": true,
+  "enabledMcpjsonServers": [
+    "connect-apps"
+  ]
+}

FAIRNESS.md

@@ -162,18 +162,18 @@ For subprocess-based adapters:
 
 ## Threading Configuration
 
-| Adapter   | Default Threading     | Override Option           |
-|-----------|----------------------|---------------------------|
-| DuckDB    | Multi-threaded (auto)| `--duckdb-threads N`      |
-| Polars    | Multi-threaded (auto)| `--polars-threads N`      |
-| Rayforce  | Configurable         | Via rayforce `-c` flag    |
-| KDB+      | Single-threaded      | N/A (q is single-threaded)|
-
-For fair comparison, consider matching thread counts:
-```bash
-# Single-threaded comparison
-python run_bench.py --duckdb-threads 1 --polars-threads 1 ...
-```
+Each adapter uses its default threading model:
+
+| Adapter   | Threading                                  |
+|-----------|--------------------------------------------|
+| DuckDB    | Multi-threaded (auto, uses all CPU cores)  |
+| Polars    | Multi-threaded (auto, uses all CPU cores)  |
+| Pandas    | Single-threaded (GIL-bound)                |
+| Rayforce  | Multi-threaded (auto)                      |
+| KDB+      | Single-threaded (q is single-threaded)     |
+| QuestDB   | Server-managed threading                   |
+
+Threading is managed internally by each database engine for optimal performance.
 
 ## Validation
 

adapters/duckdb_adapter.py

@@ -35,26 +35,24 @@
 
 class DuckDBAdapter(Adapter):
     """DuckDB in-process adapter.
-    
+
     Uses DuckDB's embedded Python API for minimal overhead.
     All operations run in-process without IPC or network.
     """
-    
+
     name = "duckdb"
     version = duckdb.__version__
     embedded = True
-    
-    def __init__(self, threads: int | None = None, memory_limit: str | None = None):
+
+    def __init__(self, memory_limit: str | None = None):
         """Initialize DuckDB adapter.
-        
+
         Args:
-            threads: Number of threads (None = auto, or from config).
             memory_limit: Memory limit (e.g., "4GB", or from config).
         """
         config = get_config()
         ddb_config = config.duckdb
-        
-        self.threads = threads if threads is not None else ddb_config.get("threads")
+
         self.memory_limit = memory_limit if memory_limit is not None else ddb_config.get("memory_limit")
         self._conn: duckdb.DuckDBPyConnection | None = None
         self._table_name: str = ""
@@ -90,10 +88,8 @@ def setup(self, schema: dict[str, Any]) -> None:
         """Initialize DuckDB with in-memory database."""
         # Create in-memory connection
         self._conn = duckdb.connect(":memory:")
-        
+
         # Configure settings
-        if self.threads is not None:
-            self._conn.execute(f"SET threads = {self.threads}")
         if self.memory_limit is not None:
             self._conn.execute(f"SET memory_limit = '{self.memory_limit}'")
 
@@ -162,25 +158,23 @@ def get_info(self) -> dict[str, Any]:
         info = super().get_info()
         info.update({
             "duckdb_version": duckdb.__version__,
-            "threads": self.threads,
             "memory_limit": self.memory_limit,
         })
         return info
 
     def _execute_query(self, query: str) -> AdapterResult:
         """Execute a query and return result metadata.
-        
-        FAIRNESS: DuckDB execute() runs the full query (not lazy).
-        We time only execute(), then fetch results afterward for validation.
+
+        FAIRNESS: DuckDB execute() can be lazy, so we include fetchall()
+        in timing to ensure full query materialization is measured.
         """
         try:
-            # Time only query execution
+            # Time query execution AND result materialization
             start_ns = time.perf_counter_ns()
             result = self._conn.execute(query)
-            end_ns = time.perf_counter_ns()
-            
-            # Fetch results AFTER timing (for row count and checksum validation)
             rows = result.fetchall()
+            end_ns = time.perf_counter_ns()
+
             row_count = len(rows)
 
             # Checksum from sample

adapters/kdb_adapter.py

@@ -20,32 +20,28 @@
 
 class KDBAdapter(Adapter):
     """KDB+/q adapter using subprocess execution.
-    
+
     Uses q's \t command for timing, which measures only query execution
     (similar to Rayforce's timeit function).
     """
-    
+
     name = "kdb"
     version = "4.0"
     embedded = False
-    
+
     def __init__(
         self,
         binary_path: str | Path | None = None,
-        threads: int | None = None,
     ):
         """Initialize KDB adapter.
 
         Args:
             binary_path: Path to q binary (default: from config or 'q')
-            threads: Number of secondary threads (-s flag). Default 3 for 4-core license.
         """
         config = get_config()
         kdb_config = config.kdb
 
         self.binary_path = Path(binary_path or kdb_config.get("binary", "q"))
-        # KDB+ -s flag sets secondary threads. 3 secondary + 1 main = 4 total cores
-        self.threads = threads if threads is not None else kdb_config.get("threads", 3)
 
         self._schema: dict[str, Any] = {}
         self._table_name: str = ""
@@ -97,7 +93,7 @@ def setup(self, schema: dict[str, Any]) -> None:
         # Try to get version
         try:
             result = subprocess.run(
-                [str(self.binary_path), "-s", str(self.threads), "-q"],
+                [str(self.binary_path), "-q"],
                 input="\\\\",  # Exit immediately
                 capture_output=True,
                 text=True,
@@ -134,8 +130,6 @@ def get_info(self) -> dict[str, Any]:
             "kdb_version": self.version,
             "mode": "subprocess",
             "binary_path": str(self.binary_path),
-            "threads": self.threads,  # Secondary threads (-s flag)
-            "total_cores": self.threads + 1,  # Secondary + main thread
         })
         return info
 
@@ -191,7 +185,7 @@ def _execute_q(self, expr: str) -> AdapterResult:
 """
 
             result = subprocess.run(
-                [str(self.binary_path), "-s", str(self.threads), "-q"],
+                [str(self.binary_path), "-q"],
                 input=q_script,
                 capture_output=True,
                 text=True,