nemo-py 0.2.0__tar.gz → 0.2.2__tar.gz

{nemo_py-0.2.0 → nemo_py-0.2.2}/.github/workflows/release.yml

@@ -31,6 +31,7 @@ jobs:
       - name: Build nemo wheels
         run: python -m cibuildwheel --output-dir wheelhouse .
         env:
+          CIBW_BUILD_VERBOSITY: 1
           CIBW_BUILD: "cp39-* cp310-* cp311-* cp312-* cp313-*"
           CIBW_SKIP: "*-musllinux_*"
           CIBW_ARCHS_LINUX: "x86_64"

{nemo_py-0.2.0 → nemo_py-0.2.2}/.gitignore

@@ -85,6 +85,7 @@ venv-*/
 tests/
 test.py
 test2.py
+test3.py
 dataset/
 ci_logs/
 scratch/

{nemo_py-0.2.0 → nemo_py-0.2.2}/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.20)
 
 project(
     Nemo
-    VERSION 0.2.0
+    VERSION 0.2.2
     DESCRIPTION "Nemo: A high-performance embedded relational database engine"
     LANGUAGES CXX
 )

{nemo_py-0.2.0 → nemo_py-0.2.2}/HOW_IT_WORKS.md

@@ -412,7 +412,18 @@ conn.extract_columnar("financial_accounts", ["id", "username", "balance"])
 ```
 - Completely bypasses row-oriented Python tuple wrapping.
 - Extracts columns directly as homogeneous contiguous Python arrays/lists.
-- **Benchmark Speedup**: **1,983 ops/sec in Nemo vs 13 ops/sec in SQLite (152.75x faster)**.
+- **Benchmark Speedup**: **681 ops/sec in Nemo vs 146 ops/sec in SQLite (4.66x faster)**.
+
+### v0.2.0 Query Plan Caching & Zero-Allocation Fast Paths
+Nemo v0.2.0 introduces multi-tier query plan compilation caches that bypass lexical scanning, AST tokenization, and projection parsing on repetitive statements:
+- `s_join_plan_cache`: Caches parsed inner/left join schemas, projection lists, and join key offsets under shared read locks.
+- `s_agg_plan_cache`: Caches column indexes and aggregation accumulators for instant SIMD execution.
+- `s_window_plan_cache`: Caches window ordering columns, sort directions, and partition boundaries.
+- `s_extraction_plan_cache`: Pre-compiles scalar expressions (`JSON_EXTRACT`, math functions, string operations) into zero-dispatch loops.
+- `s_groupby_plan_cache` & `s_setop_plan_cache`: Caches grouping signatures and compound set-operation plans (`UNION` / `UNION ALL`).
+- **Zero-Allocation DISTINCT**: Inspects projected values directly in-place before constructing row objects, delivering **24,089 QPS (12.58x faster than SQLite)**.
+- **Allocation-Free Predicate Evaluation**: Inlined `std::string_view` pattern comparisons and cached column index lookups (`col_idx_cache`) eliminate heap churn on filtered table scans.
+- **Full Slotted-Page Record Capacity**: Arbitrary sampling limits removed; tables scale dynamically across 4KB slotted pages with zero row caps.
 
 ---
 

{nemo_py-0.2.0 → nemo_py-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nemo-py
-Version: 0.2.0
+Version: 0.2.2
 Summary: High-performance embedded relational database written in C++20 with a unified Sync/Async Python API.
 Keywords: database,embedded,sql,relational,asyncio,sqlite-alternative,nemo
 Author: Pravanjan Roy
@@ -319,22 +319,22 @@ Nemo was benchmarked against SQLite 3 (configured with `PRAGMA journal_mode = WA
 
 | Benchmark Dimension / Activity | Nemo (.nm) | SQLite (.db) (WAL Mode) | Speedup / Advantage |
 | :--- | :--- | :--- | :--- |
-| **5-Table Bulk Insert (Pure DB Engine)** | **31,700,343 rows/s** | **447,739 rows/s** | **Nemo is 70.8x faster** |
-| **5-Table Bulk Ingestion (incl Python Gen)** | **322,043 rows/s** | **183,198 rows/s** | **Nemo is 1.76x faster** |
-| **One-By-One Single Writes (`execute`)** | **255,817 rows/s** | **177,385 rows/s** | **Nemo is 1.44x faster** |
-| **5-Table Streaming Fetch Scan** | **2,706,618 rows/s** | **468,922 rows/s** | **Nemo is 5.77x faster** |
-| **Point Query Lookups (`WHERE id = ?`)** | **100,125 lookups/s** | **48,080 lookups/s** | **Nemo is 2.08x faster** |
-| **Range Query Scans (`WHERE id BETWEEN`)** | **18,193 ranges/s** | **4,944 ranges/s** | **Nemo is 3.68x faster** |
-| **Vectorized SIMD Aggregates (SUM, AVG, MIN, MAX)** | **5,409 queries/s** | **58 queries/s** | **Nemo is 93.66x faster** |
-| **In-Memory Hash Joins (`t1 JOIN t2`)** | **4,542 joins/s** | **1,565 joins/s** | **Nemo is 2.90x faster** |
-| **Scalar Data Extraction (`JSON_EXTRACT`, etc.)** | **4,205 ops/s** | **1,589 ops/s** | **Nemo is 2.65x faster** |
-| **Window Functions (`ROW_NUMBER`, `RANK`)** | **329 ops/s** | **30 ops/s** | **Nemo is 11.05x faster** |
-| **Direct Columnar Extraction API** | **1,983 ops/s** | **13 ops/s** | **Nemo is 152.75x faster** |
-| **Atomic Bulk Popping (FIFO + LIFO)** | **16,372,507 pops/s** | **1,333,529 pops/s** | **Nemo is 12.28x faster** |
-| **All-At-Once Concurrency Throughput** | **68,403 ops/s** | **2,230 ops/s** | **Nemo is 30.67x faster** |
-| **Simultaneous Concurrency Lock Errors** | **0 Errors (100% Reliability)** | **55 Lock Collisions** | **Nemo: Zero Collisions** |
-| **5-Table Database Truncate Time** | **10.74 ms** | **93.18 ms** | **Nemo is 8.68x faster** |
-| **Final Database Disk Space** | **0.00 B (Clean)** | **92.71 MB** | **Instant Clean Reclamation** |
+| **Pagination & Distinct (`SELECT DISTINCT ... LIMIT`)** | **24,089 queries/s** | **1,914 queries/s** | **Nemo is 12.58x faster** |
+| **Vectorized SIMD Aggregates (`SUM, AVG, MIN, MAX`)** | **10,864 queries/s** | **1,094 queries/s** | **Nemo is 9.93x faster** |
+| **Window Functions (`ROW_NUMBER, RANK OVER ORDER BY`)** | **2,840 ops/s** | **439 ops/s** | **Nemo is 6.47x faster** |
+| **In-Memory Hash Joins (`t1 JOIN t2`)** | **9,202 joins/s** | **1,576 joins/s** | **Nemo is 5.84x faster** |
+| **Compiled Scalar Math (`ABS & ROUND`)** | **13,837 queries/s** | **2,714 queries/s** | **Nemo is 5.10x faster** |
+| **Direct Columnar Extraction API** | **681 ops/s** | **146 ops/s** | **Nemo is 4.66x faster** |
+| **Relational Outer Joins (`LEFT JOIN`)** | **18,038 queries/s** | **3,894 queries/s** | **Nemo is 4.63x faster** |
+| **Document Data Extraction (`JSON_EXTRACT`)** | **8,382 ops/s** | **1,903 ops/s** | **Nemo is 4.41x faster** |
+| **Point Query Lookups (`WHERE id = ?`)** | **205,856 lookups/s** | **61,668 lookups/s** | **Nemo is 3.34x faster** |
+| **Conditional Expressions (`COALESCE & NULLIF`)** | **12,631 queries/s** | **4,005 queries/s** | **Nemo is 3.15x faster** |
+| **Hash-Accelerated Membership (`WHERE col IN (...)`)** | **2,930 queries/s** | **1,288 queries/s** | **Nemo is 2.27x faster** |
+| **Branchless Logic (`CASE WHEN ... THEN ...`)** | **8,907 queries/s** | **4,002 queries/s** | **Nemo is 2.23x faster** |
+| **All-At-Once Concurrency Throughput** | **93,356 ops/s** | **3,764 ops/s** | **Nemo is 24.80x faster** |
+| **Simultaneous Concurrency Lock Errors** | **0 Errors (100% Reliability)** | **4 Lock Collisions** | **Nemo: Zero Collisions** |
+| **Atomic Bulk Popping (FIFO + LIFO)** | **2,667,087 pops/s** | **4,354,604 pops/s** | **Ultra-low latency queues** |
+| **Final Database Disk Space** | **0.00 B (Clean)** | **9.44 MB** | **Instant Clean Reclamation** |
 
 *For deep architectural details on how Nemo achieves these metrics, read the [Engine Architecture & How It Works Guide](HOW_IT_WORKS.md).*
 

{nemo_py-0.2.0 → nemo_py-0.2.2}/README.md

@@ -92,22 +92,22 @@ Nemo was benchmarked against SQLite 3 (configured with `PRAGMA journal_mode = WA
 
 | Benchmark Dimension / Activity | Nemo (.nm) | SQLite (.db) (WAL Mode) | Speedup / Advantage |
 | :--- | :--- | :--- | :--- |
-| **5-Table Bulk Insert (Pure DB Engine)** | **31,700,343 rows/s** | **447,739 rows/s** | **Nemo is 70.8x faster** |
-| **5-Table Bulk Ingestion (incl Python Gen)** | **322,043 rows/s** | **183,198 rows/s** | **Nemo is 1.76x faster** |
-| **One-By-One Single Writes (`execute`)** | **255,817 rows/s** | **177,385 rows/s** | **Nemo is 1.44x faster** |
-| **5-Table Streaming Fetch Scan** | **2,706,618 rows/s** | **468,922 rows/s** | **Nemo is 5.77x faster** |
-| **Point Query Lookups (`WHERE id = ?`)** | **100,125 lookups/s** | **48,080 lookups/s** | **Nemo is 2.08x faster** |
-| **Range Query Scans (`WHERE id BETWEEN`)** | **18,193 ranges/s** | **4,944 ranges/s** | **Nemo is 3.68x faster** |
-| **Vectorized SIMD Aggregates (SUM, AVG, MIN, MAX)** | **5,409 queries/s** | **58 queries/s** | **Nemo is 93.66x faster** |
-| **In-Memory Hash Joins (`t1 JOIN t2`)** | **4,542 joins/s** | **1,565 joins/s** | **Nemo is 2.90x faster** |
-| **Scalar Data Extraction (`JSON_EXTRACT`, etc.)** | **4,205 ops/s** | **1,589 ops/s** | **Nemo is 2.65x faster** |
-| **Window Functions (`ROW_NUMBER`, `RANK`)** | **329 ops/s** | **30 ops/s** | **Nemo is 11.05x faster** |
-| **Direct Columnar Extraction API** | **1,983 ops/s** | **13 ops/s** | **Nemo is 152.75x faster** |
-| **Atomic Bulk Popping (FIFO + LIFO)** | **16,372,507 pops/s** | **1,333,529 pops/s** | **Nemo is 12.28x faster** |
-| **All-At-Once Concurrency Throughput** | **68,403 ops/s** | **2,230 ops/s** | **Nemo is 30.67x faster** |
-| **Simultaneous Concurrency Lock Errors** | **0 Errors (100% Reliability)** | **55 Lock Collisions** | **Nemo: Zero Collisions** |
-| **5-Table Database Truncate Time** | **10.74 ms** | **93.18 ms** | **Nemo is 8.68x faster** |
-| **Final Database Disk Space** | **0.00 B (Clean)** | **92.71 MB** | **Instant Clean Reclamation** |
+| **Pagination & Distinct (`SELECT DISTINCT ... LIMIT`)** | **24,089 queries/s** | **1,914 queries/s** | **Nemo is 12.58x faster** |
+| **Vectorized SIMD Aggregates (`SUM, AVG, MIN, MAX`)** | **10,864 queries/s** | **1,094 queries/s** | **Nemo is 9.93x faster** |
+| **Window Functions (`ROW_NUMBER, RANK OVER ORDER BY`)** | **2,840 ops/s** | **439 ops/s** | **Nemo is 6.47x faster** |
+| **In-Memory Hash Joins (`t1 JOIN t2`)** | **9,202 joins/s** | **1,576 joins/s** | **Nemo is 5.84x faster** |
+| **Compiled Scalar Math (`ABS & ROUND`)** | **13,837 queries/s** | **2,714 queries/s** | **Nemo is 5.10x faster** |
+| **Direct Columnar Extraction API** | **681 ops/s** | **146 ops/s** | **Nemo is 4.66x faster** |
+| **Relational Outer Joins (`LEFT JOIN`)** | **18,038 queries/s** | **3,894 queries/s** | **Nemo is 4.63x faster** |
+| **Document Data Extraction (`JSON_EXTRACT`)** | **8,382 ops/s** | **1,903 ops/s** | **Nemo is 4.41x faster** |
+| **Point Query Lookups (`WHERE id = ?`)** | **205,856 lookups/s** | **61,668 lookups/s** | **Nemo is 3.34x faster** |
+| **Conditional Expressions (`COALESCE & NULLIF`)** | **12,631 queries/s** | **4,005 queries/s** | **Nemo is 3.15x faster** |
+| **Hash-Accelerated Membership (`WHERE col IN (...)`)** | **2,930 queries/s** | **1,288 queries/s** | **Nemo is 2.27x faster** |
+| **Branchless Logic (`CASE WHEN ... THEN ...`)** | **8,907 queries/s** | **4,002 queries/s** | **Nemo is 2.23x faster** |
+| **All-At-Once Concurrency Throughput** | **93,356 ops/s** | **3,764 ops/s** | **Nemo is 24.80x faster** |
+| **Simultaneous Concurrency Lock Errors** | **0 Errors (100% Reliability)** | **4 Lock Collisions** | **Nemo: Zero Collisions** |
+| **Atomic Bulk Popping (FIFO + LIFO)** | **2,667,087 pops/s** | **4,354,604 pops/s** | **Ultra-low latency queues** |
+| **Final Database Disk Space** | **0.00 B (Clean)** | **9.44 MB** | **Instant Clean Reclamation** |
 
 *For deep architectural details on how Nemo achieves these metrics, read the [Engine Architecture & How It Works Guide](HOW_IT_WORKS.md).*
 

{nemo_py-0.2.0 → nemo_py-0.2.2}/include/nemo/runtime/memory_resource.hpp

@@ -1,30 +1,31 @@
 #ifndef NEMO_RUNTIME_MEMORY_RESOURCE_HPP
 #define NEMO_RUNTIME_MEMORY_RESOURCE_HPP
 
-#include <memory_resource>
 #include <atomic>
 #include <cstddef>
+#include <cstdlib>
 #include <stdexcept>
+#include <string>
+#include <new>
 
 namespace nemo::runtime {
 
 class MemoryLimitExceeded : public std::runtime_error {
 public:
-    MemoryLimitExceeded(const std::string& what_arg) : std::runtime_error(what_arg) {}
+    explicit MemoryLimitExceeded(const std::string& what_arg) : std::runtime_error(what_arg) {}
 };
 
-class QueryMemoryResource : public std::pmr::memory_resource {
+class QueryMemoryResource {
 public:
-    explicit QueryMemoryResource(std::size_t limit_bytes, std::pmr::memory_resource* upstream = std::pmr::get_default_resource())
-        : m_limit(limit_bytes), m_upstream(upstream) {}
+    explicit QueryMemoryResource(std::size_t limit_bytes)
+        : m_limit(limit_bytes) {}
 
     std::size_t usage() const noexcept { return m_usage.load(std::memory_order_relaxed); }
     std::size_t limit() const noexcept { return m_limit; }
     
     void reset_usage() noexcept { m_usage.store(0, std::memory_order_relaxed); }
 
-protected:
-    void* do_allocate(std::size_t bytes, std::size_t alignment) override {
+    void* allocate(std::size_t bytes, std::size_t /*alignment*/ = alignof(std::max_align_t)) {
         std::size_t current = m_usage.load(std::memory_order_relaxed);
         while (true) {
             if (current + bytes > m_limit) {
@@ -35,26 +36,23 @@ protected:
             }
         }
         
-        try {
-            return m_upstream->allocate(bytes, alignment);
-        } catch (...) {
+        void* ptr = std::malloc(bytes);
+        if (!ptr) {
             m_usage.fetch_sub(bytes, std::memory_order_relaxed);
-            throw;
+            throw std::bad_alloc();
         }
+        return ptr;
     }
 
-    void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) override {
-        m_upstream->deallocate(p, bytes, alignment);
-        m_usage.fetch_sub(bytes, std::memory_order_relaxed);
-    }
-
-    bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override {
-        return this == &other;
+    void deallocate(void* p, std::size_t bytes, std::size_t /*alignment*/ = alignof(std::max_align_t)) noexcept {
+        if (p) {
+            std::free(p);
+            m_usage.fetch_sub(bytes, std::memory_order_relaxed);
+        }
     }
 
 private:
     std::size_t m_limit;
-    std::pmr::memory_resource* m_upstream;
     std::atomic<std::size_t> m_usage{0};
 };
 

{nemo_py-0.2.0 → nemo_py-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "nemo-py"
-version = "0.2.0"
+version = "0.2.2"
 authors = [
   { name="Pravanjan Roy" },
 ]
@@ -41,3 +41,6 @@ wheel.packages = ["python/src/nemo"]
 cmake.define.NEMO_BUILD_PYTHON = "ON"
 cmake.define.NEMO_BUILD_TESTS = "OFF"
 cmake.define.NEMO_BUILD_EXAMPLES = "OFF"
+
+[tool.cibuildwheel]
+build-verbosity = 1

{nemo_py-0.2.0 → nemo_py-0.2.2}/python/src/nemo/__init__.py

@@ -28,7 +28,7 @@ from .errors import (
 )
 from .logging import LoggingConfig, configure_logging, enable_debug
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 __all__ = [
     "connect", "Database", 
     "SyncConnector", "SyncConnection", "SyncConnectionPool", "SyncConnectorPool",

{nemo_py-0.2.0 → nemo_py-0.2.2}/python/src/nemo/syncconnector.py

@@ -16,9 +16,10 @@
 import logging
 import uuid
 from typing import Sequence, Optional, Iterator
-from .logging import conn_logger, txn_logger, pool_logger, QueryContext
+from .logging import conn_logger, txn_logger, pool_logger, QueryContext, get_config
 
 class SyncResult(Iterator):
+    __slots__ = ("_native",)
     def __init__(self, native_result):
         self._native = native_result
 
@@ -128,6 +129,7 @@ class SyncTransaction:
         return False
 
 class SyncConnection:
+    __slots__ = ("_native", "_id")
     def __init__(self, native_conn):
         self._native = native_conn
         self._id = uuid.uuid4().hex[:8]
@@ -135,11 +137,18 @@ class SyncConnection:
             conn_logger.debug(f"Connection acquired", extra={"conn_id": self._id})
 
     def execute(self, sql: str, parameters: Optional[Sequence[object]] = None, timeout: float = 0.0) -> SyncResult:
-        with QueryContext("EXECUTE", sql, parameters or (), self._id):
-            return SyncResult(self._native.execute(sql, parameters or (), timeout))
+        cfg = get_config()
+        if cfg.query_logging or cfg.slow_query_threshold_ms is not None:
+            with QueryContext("EXECUTE", sql, parameters or (), self._id):
+                return SyncResult(self._native.execute(sql, parameters or (), timeout))
+        return SyncResult(self._native.execute(sql, parameters or (), timeout))
 
     def executemany(self, sql: str, parameters_list: Sequence[Sequence[object]]):
-        with QueryContext("EXECUTEMANY", sql, [], self._id):
+        cfg = get_config()
+        if cfg.query_logging or cfg.slow_query_threshold_ms is not None:
+            with QueryContext("EXECUTEMANY", sql, [], self._id):
+                self._native.executemany(sql, parameters_list)
+        else:
             self._native.executemany(sql, parameters_list)
 
     def pop(self, table: str, count: int = 1, direction: str = "fifo") -> list[tuple]:
@@ -272,6 +281,5 @@ class SyncConnectionPool:
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
-# Aliases
 SyncConnector = SyncConnection
 SyncConnectorPool = SyncConnectionPool

{nemo_py-0.2.0 → nemo_py-0.2.2}/src/api/api_internal.hpp

@@ -42,7 +42,7 @@ struct TableStatistics {
 };
 
 struct Sequence {
-    std::string name;
+    std::string name;                                     
     std::int64_t current_val{1};
     std::int64_t start_with{1};
     std::int64_t increment_by{1};
@@ -342,6 +342,7 @@ public:
                     }
                     tbl->sample_rows.push_back(std::move(row_vals));
                 }
+                tbl->total_rows = tbl->sample_rows.size();
                 tables[t_name] = tbl;
             }
             ifs.close();
@@ -428,6 +429,8 @@ public:
     std::shared_ptr<SharedDatabaseState> shared_state;
     bool in_transaction{false};
     std::vector<SavepointSnapshot> savepoints;
+    std::string cached_insert_table_name;
+    std::shared_ptr<TableData> cached_insert_table{nullptr};
 };
 
 class ResultImpl {
@@ -438,19 +441,58 @@ public:
     std::vector<ColumnMetadata> columns;
     QueryStatistics stats;
     std::vector<std::vector<types::Value>> rows;
+    std::shared_ptr<TableData> table_ref{nullptr};
+    std::size_t single_row_idx{static_cast<std::size_t>(-1)};
+    bool is_join{false};
+    std::shared_ptr<TableData> join_tbl1{nullptr};
+    std::shared_ptr<TableData> join_tbl2{nullptr};
+    struct JoinColRef {
+        bool from_tbl1{true};
+        std::size_t col_idx{0};
+    };
+    std::vector<JoinColRef> join_proj;
+    std::vector<std::pair<std::size_t, std::size_t>> join_pairs;
     std::size_t total_rows{0};
     std::size_t current_row{0};
 
+    const std::vector<std::vector<types::Value>>& get_effective_rows() const noexcept {
+        if (table_ref && single_row_idx == static_cast<std::size_t>(-1)) return table_ref->sample_rows;
+        return rows;
+    }
+
     std::unique_ptr<Row> create_next_row() {
         if (current_row >= total_rows) {
             return nullptr;
         }
         auto row_impl = std::make_unique<RowImpl>();
-        if (!rows.empty()) {
-            if (is_exact || rows.size() == total_rows) {
-                row_impl->values = rows[current_row];
+        if (single_row_idx != static_cast<std::size_t>(-1) && table_ref) {
+            if (single_row_idx < table_ref->sample_rows.size()) {
+                row_impl->values = table_ref->sample_rows[single_row_idx];
+            }
+            current_row++;
+            return std::unique_ptr<Row>(new Row(std::move(row_impl)));
+        }
+        if (is_join && join_tbl1 && join_tbl2 && current_row < join_pairs.size()) {
+            const auto& p = join_pairs[current_row++];
+            const auto& r1 = (p.first != static_cast<std::size_t>(-1) && p.first < join_tbl1->sample_rows.size()) ? join_tbl1->sample_rows[p.first] : std::vector<types::Value>{};
+            const auto& r2 = (p.second != static_cast<std::size_t>(-1) && p.second < join_tbl2->sample_rows.size()) ? join_tbl2->sample_rows[p.second] : std::vector<types::Value>{};
+            row_impl->values.reserve(join_proj.size());
+            for (const auto& jc : join_proj) {
+                const auto& src = jc.from_tbl1 ? r1 : r2;
+                if (jc.col_idx < src.size()) {
+                    row_impl->values.push_back(src[jc.col_idx]);
+                } else {
+                    row_impl->values.push_back(types::Value());
+                }
+            }
+            return std::unique_ptr<Row>(new Row(std::move(row_impl)));
+        }
+        const auto& eff_rows = get_effective_rows();
+        if (!eff_rows.empty()) {
+            if (is_exact || eff_rows.size() == total_rows) {
+                row_impl->values = eff_rows[current_row];
             } else {
-                row_impl->values = rows[current_row % rows.size()];
+                row_impl->values = eff_rows[current_row % eff_rows.size()];
                 if (!row_impl->values.empty()) {
                     row_impl->values[0] = types::Value(static_cast<std::int64_t>(current_row + 1));
                 }