PyPI - real-ladybug - Versions diffs - 0.0.1.dev1__cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl - Mend

real-ladybug 0.0.1.dev1__cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.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 (3340) hide show

@@ -0,0 +1,564 @@
+from __future__ import annotations
+import datetime
+import math
+from decimal import Decimal
+from typing import Any
+from uuid import UUID
+import real_ladybug as lb
+import pytz
+from pandas import Timedelta, Timestamp
+from type_aliases import ConnDB
+from real_ladybug.constants import ID, LABEL, SRC, DST, NODES, RELS
+def test_to_df(conn_db_readonly: ConnDB) -> None:
+    conn, _ = conn_db_readonly
+    def _test_person_to_df(conn: lb.Connection) -> None:
+        query = "MATCH (p:person) return p.* ORDER BY p.ID"
+        pd = conn.execute(query).get_as_df()
+        assert pd["p.ID"].tolist() == [0, 2, 3, 5, 7, 8, 9, 10]
+        assert str(pd["p.ID"].dtype) == "int64"
+        assert pd["p.fName"].tolist() == [
+            "Alice",
+            "Bob",
+            "Carol",
+            "Dan",
+            "Elizabeth",
+            "Farooq",
+            "Greg",
+            "Hubert Blaine Wolfeschlegelsteinhausenbergerdorff",
+        ]
+        assert str(pd["p.fName"].dtype) == "object"
+        assert pd["p.gender"].tolist() == [1, 2, 1, 2, 1, 2, 2, 2]
+        assert str(pd["p.gender"].dtype) == "int64"
+        assert pd["p.isStudent"].tolist() == [
+            True,
+            True,
+            False,
+            False,
+            False,
+            True,
+            False,
+            False,
+        ]
+        assert str(pd["p.isStudent"].dtype) == "bool"
+        assert pd["p.eyeSight"].tolist() == [5.0, 5.1, 5.0, 4.8, 4.7, 4.5, 4.9, 4.9]
+        assert str(pd["p.eyeSight"].dtype) == "float64"
+        assert pd["p.birthdate"].tolist() == [
+            Timestamp("1900-01-01"),
+            Timestamp("1900-01-01"),
+            Timestamp("1940-06-22"),
+            Timestamp("1950-07-23 "),
+            Timestamp("1980-10-26"),
+            Timestamp("1980-10-26"),
+            Timestamp("1980-10-26"),
+            Timestamp("1990-11-27"),
+        ]
+        assert str(pd["p.birthdate"].dtype) == "datetime64[us]"
+        assert pd["p.registerTime"].tolist() == [
+            Timestamp("2011-08-20 11:25:30"),
+            Timestamp("2008-11-03 15:25:30.000526"),
+            Timestamp("1911-08-20 02:32:21"),
+            Timestamp("2031-11-30 12:25:30"),
+            Timestamp("1976-12-23 11:21:42"),
+            Timestamp("1972-07-31 13:22:30.678559"),
+            Timestamp("1976-12-23 04:41:42"),
+            Timestamp("2023-02-21 13:25:30"),
+        ]
+        assert str(pd["p.registerTime"].dtype) == "datetime64[us]"
+        assert pd["p.lastJobDuration"].tolist() == [
+            Timedelta("1082 days 13:02:00"),
+            Timedelta("3750 days 13:00:00.000024"),
+            Timedelta("2 days 00:24:11"),
+            Timedelta("3750 days 13:00:00.000024"),
+            Timedelta("2 days 00:24:11"),
+            Timedelta("0 days 00:18:00.024000"),
+            Timedelta("3750 days 13:00:00.000024"),
+            Timedelta("1082 days 13:02:00"),
+        ]
+        assert str(pd["p.lastJobDuration"].dtype) == "timedelta64[ns]"
+        assert pd["p.workedHours"].tolist() == [
+            [10, 5],
+            [12, 8],
+            [4, 5],
+            [1, 9],
+            [2],
+            [3, 4, 5, 6, 7],
+            [1],
+            [10, 11, 12, 3, 4, 5, 6, 7],
+        ]
+        assert str(pd["p.workedHours"].dtype) == "object"
+        assert pd["p.usedNames"].tolist() == [
+            ["Aida"],
+            ["Bobby"],
+            ["Carmen", "Fred"],
+            ["Wolfeschlegelstein", "Daniel"],
+            ["Ein"],
+            ["Fesdwe"],
+            ["Grad"],
+            ["Ad", "De", "Hi", "Kye", "Orlan"],
+        ]
+        assert str(pd["p.usedNames"].dtype) == "object"
+        assert pd["p.courseScoresPerTerm"].tolist() == [
+            [[10, 8], [6, 7, 8]],
+            [[8, 9], [9, 10]],
+            [[8, 10]],
+            [[7, 4], [8, 8], [9]],
+            [[6], [7], [8]],
+            [[8]],
+            [[10]],
+            [[7], [10], [6, 7]],
+        ]
+        assert str(pd["p.courseScoresPerTerm"].dtype) == "object"
+        assert pd["p.grades"].tolist() == [
+            [96, 54, 86, 92],
+            [98, 42, 93, 88],
+            [91, 75, 21, 95],
+            [76, 88, 99, 89],
+            [96, 59, 65, 88],
+            [80, 78, 34, 83],
+            [43, 83, 67, 43],
+            [77, 64, 100, 54],
+        ]
+        assert str(pd["p.grades"].dtype) == "object"
+        expected_values = [1.731, 0.99, 1.00, 1.30, 1.463, 1.51, 1.6, 1.323]
+        actual_values = pd["p.height"].tolist()
+        for expected, actual in zip(expected_values, actual_values):
+            assert math.isclose(actual, expected, rel_tol=1e-5)
+        assert str(pd["p.height"].dtype) == "float32"
+    def _test_study_at_to_df(conn: lb.Connection) -> None:
+        query = "MATCH (p:person)-[r:studyAt]->(o:organisation) return r.* order by r.length;"
+        pd = conn.execute(query).get_as_df()
+        assert pd["r.year"].tolist() == [2021, 2020, 2020]
+        assert str(pd["r.year"].dtype) == "int64"
+        assert pd["r.places"].tolist() == [
+            ["wwAewsdndweusd", "wek"],
+            ["awndsnjwejwen", "isuhuwennjnuhuhuwewe"],
+            ["anew", "jsdnwusklklklwewsd"],
+        ]
+        assert str(pd["r.places"].dtype) == "object"
+        assert pd["r.length"].tolist() == [5, 22, 55]
+        assert str(pd["r.length"].dtype) == "int16"
+        assert pd["r.level"].tolist() == [5, 2, 120]
+        assert str(pd["r.level"].dtype) == "int8"
+        assert pd["r.code"].tolist() == [9223372036854775808, 23, 6689]
+        assert str(pd["r.code"].dtype) == "uint64"
+        assert pd["r.temperature"].tolist() == [32800, 20, 1]
+        assert str(pd["r.temperature"].dtype) == "uint32"
+        assert pd["r.ulength"].tolist() == [33768, 180, 90]
+        assert str(pd["r.ulength"].dtype) == "uint16"
+        assert pd["r.ulevel"].tolist() == [250, 12, 220]
+        assert str(pd["r.ulevel"].dtype) == "uint8"
+        assert pd["r.hugedata"].tolist() == [
+            1.8446744073709552e27,
+            -15.0,
+            -1.8446744073709552e21,
+        ]
+        assert str(pd["r.hugedata"].dtype) == "float64"
+    def _test_timestamps_to_df(conn: lb.Connection) -> None:
+        query = (
+            'RETURN cast("2012-01-01 11:12:12.12345", "TIMESTAMP_NS") as A, cast("2012-01-01 11:12:12.12345", '
+            '"TIMESTAMP_MS") as B, cast("2012-01-01 11:12:12.12345", "TIMESTAMP_SEC") as C, '
+            'cast("2012-01-01 11:12:12.12345", "TIMESTAMP_TZ") as D'
+        )
+        pd = conn.execute(query).get_as_df()
+        assert pd["A"].tolist() == [Timestamp("2012-01-01 11:12:12.123450")]
+        assert pd["B"].tolist() == [Timestamp("2012-01-01 11:12:12.123000")]
+        assert pd["C"].tolist() == [Timestamp("2012-01-01 11:12:12")]
+        assert pd["D"].tolist() == [Timestamp("2012-01-01 11:12:12.123450")]
+    def _test_movies_to_df(conn: lb.Connection) -> None:
+        query = "MATCH (m:movies) return m.* order by m.length;"
+        pd = conn.execute(query).get_as_df()
+        assert pd["m.length"].tolist() == [126, 298, 2544]
+        assert str(pd["m.length"].dtype) == "int32"
+        assert pd["m.description"].tolist() == [
+            {
+                "rating": 5.3,
+                "stars": 2,
+                "views": 152,
+                "release": datetime.datetime(2011, 8, 20, 11, 25, 30),
+                "release_ns": datetime.datetime(2011, 8, 20, 11, 25, 30, 123456),
+                "release_ms": datetime.datetime(2011, 8, 20, 11, 25, 30, 123000),
+                "release_sec": datetime.datetime(2011, 8, 20, 11, 25, 30),
+                "release_tz": datetime.datetime(2011, 8, 20, 11, 25, 30, 123456, pytz.UTC),
+                "film": datetime.date(2012, 5, 11),
+                "u8": 220,
+                "u16": 20,
+                "u32": 1,
+                "u64": 180,
+                "hugedata": Decimal("1844674407370955161811111111"),
+            },
+            {
+                "rating": 1223.0,
+                "stars": 100,
+                "views": 10003,
+                "release": datetime.datetime(2011, 2, 11, 16, 44, 22),
+                "release_ns": datetime.datetime(2011, 2, 11, 16, 44, 22, 123456),
+                "release_ms": datetime.datetime(2011, 2, 11, 16, 44, 22, 123000),
+                "release_sec": datetime.datetime(2011, 2, 11, 16, 44, 22),
+                "release_tz": datetime.datetime(2011, 2, 11, 16, 44, 22, 123456, pytz.UTC),
+                "film": datetime.date(2013, 2, 22),
+                "u8": 1,
+                "u16": 15,
+                "u32": 200,
+                "u64": 4,
+                "hugedata": Decimal(-15),
+            },
+            {
+                "rating": 7.0,
+                "stars": 10,
+                "views": 982,
+                "release": datetime.datetime(2018, 11, 13, 13, 33, 11),
+                "release_ns": datetime.datetime(2018, 11, 13, 13, 33, 11, 123456),
+                "release_ms": datetime.datetime(2018, 11, 13, 13, 33, 11, 123000),
+                "release_sec": datetime.datetime(2018, 11, 13, 13, 33, 11),
+                "release_tz": datetime.datetime(2018, 11, 13, 13, 33, 11, 123456, pytz.UTC),
+                "film": datetime.date(2014, 9, 12),
+                "u8": 12,
+                "u16": 120,
+                "u32": 55,
+                "u64": 1,
+                "hugedata": Decimal(-1844674407370955161511),
+            },
+        ]
+        assert str(pd["m.description"].dtype) == "object"
+        assert pd["m.content"].tolist() == [
+            b"\xaa\xabinteresting\x0b",
+            b"pure ascii characters",
+            b"\xab\xcd",
+        ]
+        assert str(pd["m.content"].dtype) == "object"
+        assert pd["m.audience"].tolist() == [
+            {"audience1": 52, "audience53": 42},
+            {},
+            {"audience1": 33},
+        ]
+        assert str(pd["m.audience"].dtype) == "object"
+        assert pd["m.grade"].tolist() == [True, 254.0, 8.989]
+        assert str(pd["m.grade"].dtype) == "object"
+    def _test_serial_to_df(conn: lb.Connection) -> None:
+        df = conn.execute("MATCH (a:moviesSerial) RETURN a.ID AS id").get_as_df()
+        assert len(df) == 3
+        assert df["id"].tolist() == [0, 1, 2]
+    _test_person_to_df(conn)
+    conn.set_max_threads_for_exec(2)
+    _test_study_at_to_df(conn)
+    _test_movies_to_df(conn)
+    _test_timestamps_to_df(conn)
+    _test_serial_to_df(conn)
+def test_df_multiple_times(conn_db_readonly: ConnDB) -> None:
+    conn, _ = conn_db_readonly
+    query = "MATCH (p:person) return p.ID ORDER BY p.ID"
+    res = conn.execute(query)
+    df = res.get_as_df()
+    df_2 = res.get_as_df()
+    df_3 = res.get_as_df()
+    assert df["p.ID"].tolist() == [0, 2, 3, 5, 7, 8, 9, 10]
+    assert df_2["p.ID"].tolist() == [0, 2, 3, 5, 7, 8, 9, 10]
+    assert df_3["p.ID"].tolist() == [0, 2, 3, 5, 7, 8, 9, 10]
+def test_df_get_node(conn_db_readonly: ConnDB) -> None:
+    conn, _ = conn_db_readonly
+    query = "MATCH (p:person) return p"
+    res = conn.execute(query)
+    df = res.get_as_df()
+    p_list = df["p"].tolist()
+    assert len(p_list) == 8
+    ground_truth: dict[str, list[Any]] = {
+        "ID": [0, 2, 3, 5, 7, 8, 9, 10],
+        "fName": [
+            "Alice",
+            "Bob",
+            "Carol",
+            "Dan",
+            "Elizabeth",
+            "Farooq",
+            "Greg",
+            "Hubert Blaine Wolfeschlegelsteinhausenbergerdorff",
+        ],
+        "gender": [1, 2, 1, 2, 1, 2, 2, 2],
+        "isStudent": [True, True, False, False, False, True, False, False],
+        "eyeSight": [5.0, 5.1, 5.0, 4.8, 4.7, 4.5, 4.9, 4.9],
+        "birthdate": [
+            datetime.date(1900, 1, 1),
+            datetime.date(1900, 1, 1),
+            datetime.date(1940, 6, 22),
+            datetime.date(1950, 7, 23),
+            datetime.date(1980, 10, 26),
+            datetime.date(1980, 10, 26),
+            datetime.date(1980, 10, 26),
+            datetime.date(1990, 11, 27),
+        ],
+        "registerTime": [
+            Timestamp("2011-08-20 11:25:30"),
+            Timestamp("2008-11-03 15:25:30.000526"),
+            Timestamp("1911-08-20 02:32:21"),
+            Timestamp("2031-11-30 12:25:30"),
+            Timestamp("1976-12-23 11:21:42"),
+            Timestamp("1972-07-31 13:22:30.678559"),
+            Timestamp("1976-12-23 04:41:42"),
+            Timestamp("2023-02-21 13:25:30"),
+        ],
+        "lastJobDuration": [
+            Timedelta("1082 days 13:02:00"),
+            Timedelta("3750 days 13:00:00.000024"),
+            Timedelta("2 days 00:24:11"),
+            Timedelta("3750 days 13:00:00.000024"),
+            Timedelta("2 days 00:24:11"),
+            Timedelta("0 days 00:18:00.024000"),
+            Timedelta("3750 days 13:00:00.000024"),
+            Timedelta("1082 days 13:02:00"),
+        ],
+        "workedHours": [
+            [10, 5],
+            [12, 8],
+            [4, 5],
+            [1, 9],
+            [2],
+            [3, 4, 5, 6, 7],
+            [1],
+            [10, 11, 12, 3, 4, 5, 6, 7],
+        ],
+        "usedNames": [
+            ["Aida"],
+            ["Bobby"],
+            ["Carmen", "Fred"],
+            ["Wolfeschlegelstein", "Daniel"],
+            ["Ein"],
+            ["Fesdwe"],
+            ["Grad"],
+            ["Ad", "De", "Hi", "Kye", "Orlan"],
+        ],
+        "courseScoresPerTerm": [
+            [[10, 8], [6, 7, 8]],
+            [[8, 9], [9, 10]],
+            [[8, 10]],
+            [[7, 4], [8, 8], [9]],
+            [[6], [7], [8]],
+            [[8]],
+            [[10]],
+            [[7], [10], [6, 7]],
+        ],
+        LABEL: [
+            "person",
+            "person",
+            "person",
+            "person",
+            "person",
+            "person",
+            "person",
+            "person",
+        ],
+    }
+    for i in range(len(p_list)):
+        p = p_list[i]
+        for key in ground_truth:
+            assert p[key] == ground_truth[key][i]
+def test_df_get_node_rel(conn_db_readonly: ConnDB) -> None:
+    conn, _ = conn_db_readonly
+    res = conn.execute("MATCH (p:person)-[r:workAt]->(o:organisation) RETURN p, r, o ORDER BY p.fName")
+    df = res.get_as_df()
+    p_list = df["p"].tolist()
+    o_list = df["o"].tolist()
+    assert len(p_list) == 3
+    assert len(o_list) == 3
+    ground_truth_p: dict[str, list[Any]] = {
+        "ID": [3, 5, 7],
+        "fName": ["Carol", "Dan", "Elizabeth"],
+        "gender": [1, 2, 1],
+        "isStudent": [False, False, False],
+        "eyeSight": [5.0, 4.8, 4.7],
+        "birthdate": [
+            datetime.date(1940, 6, 22),
+            datetime.date(1950, 7, 23),
+            datetime.date(1980, 10, 26),
+        ],
+        "registerTime": [
+            Timestamp("1911-08-20 02:32:21"),
+            Timestamp("2031-11-30 12:25:30"),
+            Timestamp("1976-12-23 11:21:42"),
+        ],
+        "lastJobDuration": [
+            Timedelta("48 hours 24 minutes 11 seconds"),
+            Timedelta("3750 days 13:00:00.000024"),
+            Timedelta("2 days 00:24:11"),
+        ],
+        "workedHours": [[4, 5], [1, 9], [2]],
+        "usedNames": [["Carmen", "Fred"], ["Wolfeschlegelstein", "Daniel"], ["Ein"]],
+        "courseScoresPerTerm": [[[8, 10]], [[7, 4], [8, 8], [9]], [[6], [7], [8]]],
+        LABEL: ["person", "person", "person"],
+    }
+    for i in range(len(p_list)):
+        p = p_list[i]
+        for key in ground_truth_p:
+            assert p[key] == ground_truth_p[key][i]
+    ground_truth_o: dict[str, list[Any]] = {
+        "ID": [4, 6, 6],
+        "name": ["CsWork", "DEsWork", "DEsWork"],
+        "orgCode": [934, 824, 824],
+        "mark": [4.1, 4.1, 4.1],
+        "score": [-100, 7, 7],
+        "history": [
+            "2 years 4 days 10 hours",
+            "2 years 4 hours 22 us 34 minutes",
+            "2 years 4 hours 22 us 34 minutes",
+        ],
+        "licenseValidInterval": [
+            Timedelta(days=9414),
+            Timedelta(days=3, seconds=36000, microseconds=100000),
+            Timedelta(days=3, seconds=36000, microseconds=100000),
+        ],
+        "rating": [0.78, 0.52, 0.52],
+        LABEL: ["organisation", "organisation", "organisation"],
+    }
+    for i in range(len(o_list)):
+        o = df["o"][i]
+        for key in ground_truth_o:
+            assert o[key] == ground_truth_o[key][i]
+    assert df["r"][0]["year"] == 2015
+    assert df["r"][1]["year"] == 2010
+    assert df["r"][2]["year"] == 2015
+    for i in range(len(df["r"])):
+        assert df["r"][i][SRC] == df["p"][i][ID]
+        assert df["r"][i][DST] == df["o"][i][ID]
+def test_df_get_recursive_join(conn_db_readonly: ConnDB) -> None:
+    conn, _ = conn_db_readonly
+    res = conn.execute(
+        "MATCH (p:person)-[r:knows*1..2 (e, n | WHERE e.comments = ['rnme','m8sihsdnf2990nfiwf'])]-(m:person) WHERE "
+        "p.ID = 0 and m.ID = 0 RETURN r"
+    ).get_as_df()
+    assert res["r"][0] == {
+        NODES: [
+            {
+                "ID": 2,
+                ID: {"offset": 1, "table": 0},
+                LABEL: "person",
+                "age": 30,
+                "birthdate": datetime.date(1900, 1, 1),
+                "courseScoresPerTerm": [[8, 9], [9, 10]],
+                "eyeSight": 5.1,
+                "fName": "Bob",
+                "gender": 2,
+                "grades": [98, 42, 93, 88],
+                "height": 0.9900000095367432,
+                "u": UUID("a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a12"),
+                "isStudent": True,
+                "isWorker": False,
+                "lastJobDuration": datetime.timedelta(days=3750, seconds=46800, microseconds=24),
+                "registerTime": datetime.datetime(2008, 11, 3, 15, 25, 30, 526),
+                "usedNames": ["Bobby"],
+                "workedHours": [12, 8],
+            }
+        ],
+        RELS: [
+            {
+                ID: {
+                    "offset": 0,
+                    "table": 3,
+                },
+                DST: {"offset": 1, "table": 0},
+                LABEL: "knows",
+                SRC: {"offset": 0, "table": 0},
+                "comments": ["rnme", "m8sihsdnf2990nfiwf"],
+                "date": datetime.date(2021, 6, 30),
+                "meetTime": datetime.datetime(1986, 10, 21, 21, 8, 31, 521000),
+                "notes": 1,
+                "summary": {
+                    "locations": ["'toronto'", "'waterloo'"],
+                    "transfer": {
+                        "amount": [100, 200],
+                        "day": datetime.date(2021, 1, 2),
+                    },
+                },
+                "someMap": {"a": "b"},
+                "validInterval": datetime.timedelta(days=3750, seconds=46800, microseconds=24),
+            },
+            {
+                ID: {
+                    "offset": 0,
+                    "table": 3,
+                },
+                DST: {"offset": 1, "table": 0},
+                LABEL: "knows",
+                SRC: {"offset": 0, "table": 0},
+                "comments": ["rnme", "m8sihsdnf2990nfiwf"],
+                "date": datetime.date(2021, 6, 30),
+                "meetTime": datetime.datetime(1986, 10, 21, 21, 8, 31, 521000),
+                "notes": 1,
+                "summary": {
+                    "locations": ["'toronto'", "'waterloo'"],
+                    "transfer": {
+                        "amount": [100, 200],
+                        "day": datetime.date(2021, 1, 2),
+                    },
+                },
+                "someMap": {"a": "b"},
+                "validInterval": datetime.timedelta(days=3750, seconds=46800, microseconds=24),
+            },
+        ],
+    }
+def test_get_df_unicode(conn_db_readonly: ConnDB) -> None:
+    conn, _ = conn_db_readonly
+    res = conn.execute("MATCH (m:movies) RETURN m.name").get_as_df()
+    assert res["m.name"].tolist() == [
+        "Sóló cón tu párejâ",
+        "The 😂😃🧘🏻‍♂️🌍🌦️🍞🚗 movie",
+        "Roma",
+    ]
+def test_get_df_decimal(conn_db_readonly: ConnDB) -> None:
+    conn, _ = conn_db_readonly
+    res = conn.execute(
+        "UNWIND [1, 2, 3] AS A UNWIND [5.7, 8.3, 2.9] AS B RETURN CAST(CAST(A AS DECIMAL) * CAST(B AS DECIMAL) AS DECIMAL(18, 1)) AS PROD"
+    ).get_as_df()
+    assert sorted(res["PROD"].tolist()) == sorted([
+        Decimal("5.7"),
+        Decimal("8.3"),
+        Decimal("2.9"),
+        Decimal("11.4"),
+        Decimal("16.6"),
+        Decimal("5.8"),
+        Decimal("17.1"),
+        Decimal("24.9"),
+        Decimal("8.7"),
+    ])
+    res = conn.execute(
+        "UNWIND [1, 2, 3] AS A UNWIND [5.7, 8.3, 2.9] AS B RETURN CAST(CAST(A AS DECIMAL) * CAST(B AS DECIMAL) AS DECIMAL(4, 1)) AS PROD"
+    ).get_as_df()
+    assert sorted(res["PROD"].tolist()) == sorted([
+        Decimal("5.7"),
+        Decimal("8.3"),
+        Decimal("2.9"),
+        Decimal("11.4"),
+        Decimal("16.6"),
+        Decimal("5.8"),
+        Decimal("17.1"),
+        Decimal("24.9"),
+        Decimal("8.7"),
+    ])

@@ -0,0 +1,112 @@
+from __future__ import annotations
+import real_ladybug as lb
+from type_aliases import ConnDB
+def test_get_next(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
+    result.rows_as_dict()
+    row = result.get_next()
+    assert row == {"p.name": "Alice", "p.age": 30}
+    row = result.get_next()
+    assert row == {"p.name": "Bob", "p.age": 40}
+def test_get_all(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
+    result.rows_as_dict()
+    rows = result.get_all()
+    assert rows[0] == {"p.name": "Alice", "p.age": 30}
+    assert rows[1] == {"p.name": "Bob", "p.age": 40}
+def test_get_n(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});")
+    conn.execute("CREATE (:person {name: 'Cole', age: 20});")
+    result = conn.execute("MATCH (p:person) RETURN p.*")
+    assert result.get_num_tuples() == 3
+    result.rows_as_dict()
+    rows = result.get_n(2)
+    assert len(rows) == 2
+    assert rows[0] == {"p.name": "Alice", "p.age": 30}
+    assert rows[1] == {"p.name": "Bob", "p.age": 40}
+    rows = result.get_n(1)
+    assert len(rows) == 1
+    assert rows[0] == {"p.name": "Cole", "p.age": 20}
+    rows = result.get_n(1)
+    assert len(rows) == 0
+def test_dict_iteration(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
+    result.rows_as_dict()
+    rows = list(result)
+    assert rows[0] == {"p.name": "Alice", "p.age": 30}
+    assert rows[1] == {"p.name": "Bob", "p.age": 40}
+def test_dict_iteration_inline(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.rows_as_dict())
+    assert rows[0] == {"p.name": "Alice", "p.age": 30}
+    assert rows[1] == {"p.name": "Bob", "p.age": 40}
+def test_on_off(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});")
+    conn.execute("CREATE (:person {name: 'Cole', age: 20});")
+    result = conn.execute("MATCH (p:person) RETURN p.*")
+    assert result.get_num_tuples() == 3
+    row = result.get_next()
+    assert row == ["Alice", 30]
+    result.rows_as_dict()
+    row = result.get_next()
+    assert row == {"p.name": "Bob", "p.age": 40}
+    result.rows_as_dict(False)
+    row = result.get_next()
+    assert row == ["Cole", 20]