real-ladybug 0.0.1.dev1__cp312-cp312-win_amd64.whl

real_ladybug-source/tools/python_api/test/test_exception.py

@@ -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;")

real_ladybug-source/tools/python_api/test/test_fsm.py

@@ -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)

real_ladybug-source/tools/python_api/test/test_get_header.py

@@ -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[][]",
+        }

real_ladybug-source/tools/python_api/test/test_helper.py

@@ -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("\\", "/")

real_ladybug-source/tools/python_api/test/test_issue.py

@@ -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()

real_ladybug-source/tools/python_api/test/test_iteration.py

@@ -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]