PyPI - real-ladybug - Versions diffs - 0.0.1.dev1__cp311-cp311-macosx_11_0_arm64.whl - Mend

real-ladybug 0.0.1.dev1__cp311-cp311-macosx_11_0_arm64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of real-ladybug might be problematic. Click here for more details.

Files changed (3088) hide show

@@ -0,0 +1,54 @@
+from __future__ import annotations
+import real_ladybug as lb
+import pytest
+from type_aliases import ConnDB
+def test_exception(conn_db_readonly: ConnDB) -> None:
+    conn, _ = conn_db_readonly
+    with pytest.raises(RuntimeError, match=r"Parameter 1 not found."):
+        conn.execute("MATCH (a:person) WHERE a.registerTime = $1 RETURN COUNT(*);", {"asd": 1})
+    with pytest.raises(RuntimeError, match=r"Binder exception: Cannot find property dummy for a."):
+        conn.execute("MATCH (a:person) RETURN a.dummy;")
+def test_db_path_exception() -> None:
+    path = ":memory:"
+    error_message = "Cannot open an in-memory database under READ ONLY mode."
+    with pytest.raises(RuntimeError, match=error_message):
+        lb.Database(path, read_only=True)
+def test_read_only_exception(conn_db_readonly: ConnDB) -> None:
+    _, db = conn_db_readonly
+    path = db.database_path
+    read_only_db = lb.Database(path, read_only=True)
+    conn = lb.Connection(read_only_db)
+    with pytest.raises(RuntimeError, match=r"Cannot execute write operations in a read-only database!"):
+        conn.execute("CREATE NODE TABLE test (id INT64, PRIMARY KEY(id));")
+def test_max_db_size_exception() -> None:
+    with pytest.raises(
+        RuntimeError, match=r"Buffer manager exception: The given max db size should be at least 8388608 bytes."
+    ):
+        lb.Database("test.db", max_db_size=1024)
+    with pytest.raises(RuntimeError, match=r"Buffer manager exception: The given max db size should be a power of 2."):
+        lb.Database("test.db", max_db_size=8388609)
+def test_buffer_pool_size_exception() -> None:
+    with pytest.raises(
+        RuntimeError, match=r"Buffer manager exception: The given buffer pool size should be at least 4096 bytes."
+    ):
+        lb.Database("test.db", buffer_pool_size=1024)
+def test_query_exception(conn_db_readonly: ConnDB) -> None:
+    conn, _ = conn_db_readonly
+    with pytest.raises(RuntimeError, match=r"Binder exception: Table nonexisting does not exist."):
+        conn.execute("MATCH (a:nonexisting) RETURN a;")

@@ -0,0 +1,227 @@
+from pathlib import Path
+import real_ladybug as lb
+import pytest
+from test_helper import LBUG_ROOT
+from conftest import get_db_file_path
+def get_used_page_ranges(conn, table, column=None):
+    used_pages = []
+    if column is None:
+        storage_info = conn.execute(f'call storage_info("{table}") return start_page_idx, num_pages')
+    else:
+        storage_info = conn.execute(
+            f'call storage_info("{table}") where prefix(column_name, "{column}") return start_page_idx, num_pages'
+        )
+    while storage_info.has_next():
+        cur_tuple = storage_info.get_next()
+        # don't add empty (e.g. constant-compressed) pages
+        if cur_tuple[1] > 0:
+            used_pages.append(cur_tuple)
+    return used_pages
+def get_total_used_pages(conn):
+    return conn.execute("call file_info() return num_pages").get_next()[0]
+def get_free_page_ranges(conn):
+    free_pages = []
+    result = conn.execute("call fsm_info() return *")
+    while result.has_next():
+        cur_tuple = result.get_next()
+        assert cur_tuple[1] > 0
+        free_pages.append(cur_tuple)
+    return free_pages
+def combine_adjacent_page_ranges(page_ranges):
+    new_page_ranges = []
+    last_range = None
+    for page_range in page_ranges:
+        if last_range is not None and last_range[0] + last_range[1] == page_range[0]:
+            new_range = [last_range[0], last_range[1] + page_range[1]]
+            last_range = new_range
+        else:
+            if last_range is not None:
+                new_page_ranges.append(last_range)
+            last_range = page_range
+    if last_range:
+        new_page_ranges.append(last_range)
+    return new_page_ranges
+def compare_page_range_lists(used_list, free_list):
+    used_list.sort()
+    free_list.sort()
+    # used pages should be subset of new free pages
+    for entry in combine_adjacent_page_ranges(used_list):
+        assert any(entry[0] >= i[0] and entry[0] + entry[1] <= i[0] + i[1] for i in free_list)
+def prevent_data_file_truncation(conn):
+    conn.execute("CREATE NODE TABLE IF NOT EXISTS TMP(ID INT64, PRIMARY KEY(ID))")
+    conn.execute("CREATE (:TMP{id: 1})")
+    conn.execute("CREATE (:TMP{id: 2})")
+@pytest.fixture
+def fsm_node_table_setup(tmp_path: Path):
+    db = lb.Database(get_db_file_path(tmp_path))
+    conn = lb.Connection(db)
+    conn.execute("call threads=1")
+    conn.execute("call auto_checkpoint=false")
+    conn.execute(
+        "create node table person (ID INt64, fName StRING, gender INT64, isStudent BoOLEAN, isWorker BOOLEAN, age INT64, eyeSight DOUBLE, birthdate DATE, registerTime TIMESTAMP, lastJobDuration interval, workedHours INT64[], usedNames STRING[], courseScoresPerTerm INT64[][], grades INT64[4], height float, u UUID, PRIMARY KEY (ID));"
+    )
+    conn.execute(
+        f"COPY person FROM ['{LBUG_ROOT}/dataset/tinysnb/vPerson.csv', '{LBUG_ROOT}/dataset/tinysnb/vPerson2.csv'](ignore_errors=true, header=false)"
+    )
+    return db, conn
+@pytest.fixture
+def fsm_rel_table_setup(fsm_node_table_setup):
+    _, conn = fsm_node_table_setup
+    conn.execute(
+        "create rel table knows (FROM person TO person, date DATE, meetTime TIMESTAMP, validInterval INTERVAL, comments STRING[], summary STRUCT(locations STRING[], transfer STRUCT(day DATE, amount INT64[])), notes UNION(firstmet DATE, type INT16, comment STRING), someMap MAP(STRING, STRING), MANY_MAnY);"
+    )
+    conn.execute(
+        f"COPY knows FROM ['{LBUG_ROOT}/dataset/tinysnb/eKnows.csv', '{LBUG_ROOT}/dataset/tinysnb/eKnows_2.csv']"
+    )
+    return fsm_node_table_setup
+@pytest.fixture
+def fsm_rel_group_setup(tmp_path: Path):
+    db = lb.Database(get_db_file_path(tmp_path))
+    conn = lb.Connection(db)
+    conn.execute("call threads=1")
+    conn.execute("call auto_checkpoint=false")
+    conn.execute("create node table personA (ID INt64, fName StRING, PRIMARY KEY (ID));")
+    conn.execute("create node table personB (ID INt64, fName StRING, PRIMARY KEY (ID));")
+    conn.execute("create rel table likes (FROM personA TO personB, FROM personB To personA, date DATE);")
+    conn.execute(f'COPY personA FROM "{LBUG_ROOT}/dataset/rel-group/node.csv";')
+    conn.execute(f'COPY personB FROM "{LBUG_ROOT}/dataset/rel-group/node.csv";')
+    conn.execute(f'COPY likes FROM "{LBUG_ROOT}/dataset/rel-group/edge.csv" (FROM="personA", TO="personB");')
+    conn.execute(f'COPY likes FROM "{LBUG_ROOT}/dataset/rel-group/edge.csv" (FROM="personB", TO="personA");')
+    return db, conn
+def test_fsm_reclaim_list_column(fsm_node_table_setup) -> None:
+    _, conn = fsm_node_table_setup
+    used_pages = get_used_page_ranges(conn, "person", "workedHours")
+    conn.execute("alter table person drop workedHours")
+    prevent_data_file_truncation(conn)
+    conn.execute("checkpoint")
+    free_pages = get_free_page_ranges(conn)
+    compare_page_range_lists(used_pages, free_pages)
+def test_fsm_reclaim_string_column(fsm_node_table_setup) -> None:
+    _, conn = fsm_node_table_setup
+    used_pages = get_used_page_ranges(conn, "person", "fName")
+    conn.execute("alter table person drop fName")
+    prevent_data_file_truncation(conn)
+    conn.execute("checkpoint")
+    free_pages = get_free_page_ranges(conn)
+    compare_page_range_lists(used_pages, free_pages)
+def test_fsm_reclaim_list_of_lists(fsm_node_table_setup) -> None:
+    _, conn = fsm_node_table_setup
+    used_pages = get_used_page_ranges(conn, "person", "courseScoresPerTerm")
+    conn.execute("alter table person drop courseScoresPerTerm")
+    prevent_data_file_truncation(conn)
+    conn.execute("checkpoint")
+    free_pages = get_free_page_ranges(conn)
+    compare_page_range_lists(used_pages, free_pages)
+def test_fsm_reclaim_node_table(fsm_node_table_setup) -> None:
+    _, conn = fsm_node_table_setup
+    used_pages = get_used_page_ranges(conn, "person")
+    conn.execute("drop table person")
+    prevent_data_file_truncation(conn)
+    conn.execute("checkpoint")
+    free_pages = get_free_page_ranges(conn)
+    compare_page_range_lists(used_pages, free_pages)
+def test_fsm_reclaim_node_table_recopy(fsm_node_table_setup) -> None:
+    _, conn = fsm_node_table_setup
+    prev_num_pages = get_total_used_pages(conn)
+    conn.execute("drop table person")
+    conn.execute("checkpoint")
+    conn.execute(
+        "create node table person (ID INt64, fName StRING, gender INT64, isStudent BoOLEAN, isWorker BOOLEAN, age INT64, eyeSight DOUBLE, birthdate DATE, registerTime TIMESTAMP, lastJobDuration interval, workedHours INT64[], usedNames STRING[], courseScoresPerTerm INT64[][], grades INT64[4], height float, u UUID, PRIMARY KEY (ID));"
+    )
+    conn.execute(
+        f"COPY person FROM ['{LBUG_ROOT}/dataset/tinysnb/vPerson.csv', '{LBUG_ROOT}/dataset/tinysnb/vPerson2.csv'](ignore_errors=true, header=false)"
+    )
+    new_num_pages = get_total_used_pages(conn)
+    assert prev_num_pages == new_num_pages
+def test_fsm_reclaim_node_table_delete(fsm_node_table_setup) -> None:
+    _, conn = fsm_node_table_setup
+    used_pages = get_used_page_ranges(conn, "person")
+    conn.execute("match (p:person) delete p")
+    prevent_data_file_truncation(conn)
+    conn.execute("checkpoint")
+    free_pages = get_free_page_ranges(conn)
+    compare_page_range_lists(used_pages, free_pages)
+def test_fsm_reclaim_rel_table(fsm_rel_table_setup) -> None:
+    _, conn = fsm_rel_table_setup
+    used_pages = get_used_page_ranges(conn, "knows")
+    conn.execute("drop table knows")
+    prevent_data_file_truncation(conn)
+    conn.execute("checkpoint")
+    free_pages = get_free_page_ranges(conn)
+    compare_page_range_lists(used_pages, free_pages)
+def test_fsm_reclaim_rel_table_delete(fsm_node_table_setup) -> None:
+    _, conn = fsm_node_table_setup
+    used_pages = get_used_page_ranges(conn, "person")
+    conn.execute("match (p:person) delete p")
+    prevent_data_file_truncation(conn)
+    conn.execute("checkpoint")
+    free_pages = get_free_page_ranges(conn)
+    compare_page_range_lists(used_pages, free_pages)
+def test_fsm_reclaim_struct(fsm_rel_table_setup) -> None:
+    _, conn = fsm_rel_table_setup
+    used_pages = get_used_page_ranges(conn, "knows", "fwd_summary") + get_used_page_ranges(
+        conn, "knows", "bwd_summary"
+    )
+    conn.execute("alter table knows drop summary")
+    prevent_data_file_truncation(conn)
+    conn.execute("checkpoint")
+    free_pages = get_free_page_ranges(conn)
+    compare_page_range_lists(used_pages, free_pages)
+def test_fsm_reclaim_rel_group(fsm_rel_group_setup) -> None:
+    _, conn = fsm_rel_group_setup
+    used_pages = get_used_page_ranges(conn, "likes")
+    conn.execute("drop table likes")
+    prevent_data_file_truncation(conn)
+    conn.execute("checkpoint")
+    free_pages = get_free_page_ranges(conn)
+    compare_page_range_lists(used_pages, free_pages)
+def test_fsm_reclaim_rel_group_column(fsm_rel_group_setup) -> None:
+    _, conn = fsm_rel_group_setup
+    used_pages = get_used_page_ranges(conn, "likes", "fwd_date") + get_used_page_ranges(conn, "likes", "bwd_date")
+    conn.execute("alter table likes drop date")
+    prevent_data_file_truncation(conn)
+    conn.execute("checkpoint")
+    free_pages = get_free_page_ranges(conn)
+    compare_page_range_lists(used_pages, free_pages)

@@ -0,0 +1,49 @@
+from __future__ import annotations
+from type_aliases import ConnDB
+def test_get_column_names(conn_db_readonly: ConnDB) -> None:
+    conn, _ = conn_db_readonly
+    with conn.execute("MATCH (a:person)-[e:knows]->(b:person) RETURN a.fName, e.date, b.ID;") as result:
+        column_names = result.get_column_names()
+        assert column_names[0] == "a.fName"
+        assert column_names[1] == "e.date"
+        assert column_names[2] == "b.ID"
+def test_get_column_data_types(conn_db_readonly: ConnDB) -> None:
+    conn, _ = conn_db_readonly
+    with conn.execute(
+        "MATCH (p:person) RETURN p.ID, p.fName, p.isStudent, p.eyeSight, p.birthdate, p.registerTime, "
+        "p.lastJobDuration, p.workedHours, p.courseScoresPerTerm;"
+    ) as result:
+        column_data_types = result.get_column_data_types()
+        assert column_data_types[0] == "INT64"
+        assert column_data_types[1] == "STRING"
+        assert column_data_types[2] == "BOOL"
+        assert column_data_types[3] == "DOUBLE"
+        assert column_data_types[4] == "DATE"
+        assert column_data_types[5] == "TIMESTAMP"
+        assert column_data_types[6] == "INTERVAL"
+        assert column_data_types[7] == "INT64[]"
+        assert column_data_types[8] == "INT64[][]"
+def test_get_schema(conn_db_readonly: ConnDB) -> None:
+    conn, _ = conn_db_readonly
+    with conn.execute(
+        "MATCH (p:person) RETURN p.ID, p.fName, p.isStudent, p.eyeSight, p.birthdate, p.registerTime, "
+        "p.lastJobDuration, p.workedHours, p.courseScoresPerTerm;"
+    ) as result:
+        assert result.get_schema() == {
+            "p.ID": "INT64",
+            "p.fName": "STRING",
+            "p.isStudent": "BOOL",
+            "p.eyeSight": "DOUBLE",
+            "p.birthdate": "DATE",
+            "p.registerTime": "TIMESTAMP",
+            "p.lastJobDuration": "INTERVAL",
+            "p.workedHours": "INT64[]",
+            "p.courseScoresPerTerm": "INT64[][]",
+        }

@@ -0,0 +1,8 @@
+import sys
+from pathlib import Path
+LBUG_ROOT = Path(__file__).parent.parent.parent.parent
+if sys.platform == "win32":
+    # \ in paths is not supported by lbug's parser
+    LBUG_ROOT = str(LBUG_ROOT).replace("\\", "/")

@@ -0,0 +1,147 @@
+from __future__ import annotations
+try:
+    from tools.python_api.test.type_aliases import ConnDB
+except ImportError:
+    from type_aliases import ConnDB
+# required by python-lint
+def test_param_empty(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+    lst = [[]]
+    conn.execute("CREATE NODE TABLE tab(id SERIAL, lst INT64[][], PRIMARY KEY(id))")
+    result = conn.execute("CREATE (t:tab {lst: $1}) RETURN t.*", {"1": lst})
+    assert result.has_next()
+    assert result.get_next() == [0, lst]
+    assert not result.has_next()
+    result.close()
+def test_issue_2874(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+    result = conn.execute("UNWIND $idList as tid MATCH (t:person {ID: tid}) RETURN t.fName;", {"idList": [1, 2, 3]})
+    assert result.has_next()
+    assert result.get_next() == ["Bob"]
+    assert result.has_next()
+    assert result.get_next() == ["Carol"]
+    assert not result.has_next()
+    result.close()
+def test_issue_2906(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+    result = conn.execute("MATCH (a:person) WHERE $1 > a.ID AND $1 < a.age / 5 RETURN a.fName;", {"1": 6})
+    assert result.has_next()
+    assert result.get_next() == ["Alice"]
+    assert result.has_next()
+    assert result.get_next() == ["Carol"]
+    assert not result.has_next()
+    result.close()
+def test_issue_3135(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+    conn.execute("CREATE NODE TABLE t1(id SERIAL, number INT32, PRIMARY KEY(id));")
+    conn.execute("CREATE (:t1 {number: $1})", {"1": 2})
+    result = conn.execute("MATCH (n:t1) RETURN n.number;")
+    assert result.has_next()
+    assert result.get_next() == [2]
+    assert not result.has_next()
+    result.close()
+def test_empty_list2(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+    conn.execute(
+        """
+        CREATE NODE TABLE SnapArtifactScan (
+            artifact_name STRING,
+            scan_columns STRING[],
+            scan_filter STRING,
+            scan_limit INT64,
+            scan_id STRING,
+            PRIMARY KEY(scan_id)
+        )
+        """
+    )
+    result = conn.execute(
+        """
+        MERGE (n:SnapArtifactScan { scan_id: $scan_id })
+        SET n.artifact_name = $artifact_name, n.scan_columns = $scan_columns
+        RETURN n.scan_id
+    """,
+        {
+            "artifact_name": "taxi_zones",
+            "scan_columns": [],
+            "scan_id": "896de6b9c7b69fa2598def49e8c61de07949be374d229a82899c9c75994fad20",
+        },
+    )
+    assert result.has_next()
+    assert result.get_next() == ["896de6b9c7b69fa2598def49e8c61de07949be374d229a82899c9c75994fad20"]
+    assert not result.has_next()
+    result.close()
+def test_empty_map(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+    conn.execute(
+        """
+        CREATE NODE TABLE Test (
+            id SERIAL,
+            prop1 MAP(STRING, STRING),
+            prop2 MAP(STRING, STRING[]),
+            PRIMARY KEY(id)
+        )
+        """
+    )
+    result = conn.execute(
+        """
+            CREATE (n:Test {prop1: $prop1, prop2: $prop2})
+            RETURN n.id, n.prop1, n.prop2
+        """,
+        {
+            "prop1": {"key": [], "value": []},
+            "prop2": {"key": ["a"], "value": [[]]},
+        },
+    )
+    assert result.has_next()
+    assert result.get_next() == [0, {}, {"a": []}]
+    assert not result.has_next()
+    result.close()
+def test_int8_type_sniffing(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+    conn.execute("CREATE NODE TABLE Chunk(id INT64, PRIMARY KEY(id))")
+    conn.execute("CREATE (c:Chunk {id:259})")
+    result = conn.execute(
+        "MATCH (node:Chunk) WHERE node.id IN $chunk_ids RETURN node.id",
+        {"chunk_ids": [1]},
+    )
+    assert result.get_num_tuples() == 0
+    result.close()
+# TODO(Maxwell): check if we should change getCastCost() for the following test
+# def test_issue_3248(conn_db_readwrite: ConnDB) -> None:
+#     conn, _ = conn_db_readwrite
+#     # Define schema
+#     conn.execute("CREATE NODE TABLE Item(id UINT64, item STRING, price DOUBLE, vector DOUBLE[2], PRIMARY KEY (id))")
+#
+#     # Add data
+#     conn.execute("MERGE (a:Item {id: 1, item: 'apple', price: 2.0, vector: cast([3.1, 4.1], 'DOUBLE[2]')})")
+#     conn.execute("MERGE (b:Item {id: 2, item: 'banana', price: 1.0, vector: cast([5.9, 26.5], 'DOUBLE[2]')})")
+#
+#     # Run similarity search
+#     result = conn.execute("MATCH (a:Item) RETURN a.item, a.price,
+#               array_cosine_similarity(a.vector, [6.0, 25.0]) AS sim ORDER BY sim DESC")
+#     assert result.has_next()
+#     assert result.get_next() == [2]
+#     assert result.has_next()
+#     assert result.get_next() == [2]
+#     assert not result.has_next()
+#     result.close()

@@ -0,0 +1,96 @@
+from __future__ import annotations
+import real_ladybug as lb
+from type_aliases import ConnDB
+def test_iteration_list(conn_db_in_mem: ConnDB) -> None:
+    conn, _ = conn_db_in_mem
+    conn.execute("CREATE NODE TABLE person(name STRING, age INT64, PRIMARY KEY(name));")
+    conn.execute("CREATE (:person {name: 'Alice', age: 30});")
+    conn.execute("CREATE (:person {name: 'Bob', age: 40});")
+    result = conn.execute("MATCH (p:person) RETURN p.*")
+    assert result.get_num_tuples() == 2
+    rows = list(result)
+    assert rows[0] == ["Alice", 30]
+    assert rows[1] == ["Bob", 40]
+def test_iteration_loop(conn_db_in_mem: ConnDB) -> None:
+    conn, _ = conn_db_in_mem
+    conn.execute("CREATE NODE TABLE person(name STRING, age INT64, PRIMARY KEY(name));")
+    conn.execute("CREATE (:person {name: 'Alice', age: 30});")
+    conn.execute("CREATE (:person {name: 'Bob', age: 40});")
+    result = conn.execute("MATCH (p:person) RETURN p.*")
+    assert result.get_num_tuples() == 2
+    rows = []
+    for row in result:
+        rows.append(row)
+    assert rows[0] == ["Alice", 30]
+    assert rows[1] == ["Bob", 40]
+def test_get_all(conn_db_in_mem: ConnDB) -> None:
+    conn, _ = conn_db_in_mem
+    db = lb.Database(database_path=":memory:")
+    assert not db.is_closed
+    assert db._database is not None
+    conn = lb.Connection(db)
+    conn.execute("CREATE NODE TABLE person(name STRING, age INT64, PRIMARY KEY(name));")
+    conn.execute("CREATE (:person {name: 'Alice', age: 30});")
+    conn.execute("CREATE (:person {name: 'Bob', age: 40});")
+    result = conn.execute("MATCH (p:person) RETURN p.*")
+    assert result.get_num_tuples() == 2
+    rows = result.get_all()
+    assert rows[0] == ["Alice", 30]
+    assert rows[1] == ["Bob", 40]
+def test_get_n(conn_db_in_mem: ConnDB) -> None:
+    conn, _ = conn_db_in_mem
+    db = lb.Database(database_path=":memory:")
+    assert not db.is_closed
+    assert db._database is not None
+    conn = lb.Connection(db)
+    conn.execute("CREATE NODE TABLE person(name STRING, age INT64, PRIMARY KEY(name));")
+    conn.execute("CREATE (:person {name: 'Alice', age: 30});")
+    conn.execute("CREATE (:person {name: 'Bob', age: 40});")
+    conn.execute("CREATE (:person {name: 'Cole', age: 20});")
+    # Basic
+    result = conn.execute("MATCH (p:person) RETURN p.*")
+    assert result.get_num_tuples() == 3
+    rows = result.get_n(2)
+    assert len(rows) == 2
+    assert rows[0] == ["Alice", 30]
+    assert rows[1] == ["Bob", 40]
+    rows = result.get_n(1)
+    assert len(rows) == 1
+    assert rows[0] == ["Cole", 20]
+    rows = result.get_n(3)
+    assert len(rows) == 0
+    # Empty rows on excess count
+    result = conn.execute("MATCH (p:person) RETURN p.*")
+    assert result.get_num_tuples() == 3
+    rows = result.get_n(10)
+    assert len(rows) == 3
+    assert rows[0] == ["Alice", 30]
+    assert rows[1] == ["Bob", 40]
+    assert rows[2] == ["Cole", 20]