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

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

@@ -0,0 +1,159 @@
+import asyncio
+import time
+
+import real_ladybug as lb
+import pyarrow as pa
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_async_prepare_and_execute(async_connection_readonly):
+    query = "MATCH (a:person) WHERE a.ID = $1 RETURN a.age;"
+    result = await async_connection_readonly.execute(query, {"1": 0})
+    assert result.has_next()
+    assert result.get_next() == [35]
+    assert not result.has_next()
+    result.close()
+    for i in async_connection_readonly.connections_counter:
+        assert i == 0
+
+
+@pytest.mark.asyncio
+async def test_async_prepare_and_execute_concurrent(async_connection_readonly):
+    num_queries = 100
+    query = "RETURN $1;"
+    results = await asyncio.gather(*[async_connection_readonly.execute(query, {"1": i}) for i in range(num_queries)])
+    for i, result in enumerate(results):
+        assert result.has_next()
+        assert result.get_next() == [i]
+        assert not result.has_next()
+        result.close()
+    for i in async_connection_readonly.connections_counter:
+        assert i == 0
+
+
+@pytest.mark.asyncio
+async def test_async_query(async_connection_readonly):
+    query = "MATCH (a:person) WHERE a.ID = 0 RETURN a.age;"
+    result = await async_connection_readonly.execute(query)
+    assert result.has_next()
+    assert result.get_next() == [35]
+    assert not result.has_next()
+    result.close()
+
+    query = "MATCH (a:person) WHERE a.ID = 2 RETURN a.age;"
+    result = await async_connection_readonly.execute(query)
+    assert result.has_next()
+    assert result.get_next() == [30]
+    assert not result.has_next()
+    result.close()
+    for i in async_connection_readonly.connections_counter:
+        assert i == 0
+
+
+@pytest.mark.asyncio
+async def test_async_scan_df(async_connection_readwrite):
+    nodes = pa.Table.from_arrays(
+        [
+            pa.array([1, 2, 3], type=pa.int32()),
+            pa.array(["a", "b", "c"], type=pa.string()),
+            pa.array([True, False, None], type=pa.bool_()),
+        ],
+        names=["id", "A", "B"],
+    )
+    await async_connection_readwrite.execute(
+        "CREATE NODE TABLE pyarrowtab(id INT32, A STRING, B BOOL, PRIMARY KEY(id))"
+    )
+    await async_connection_readwrite.execute("COPY pyarrowtab FROM $tab", {"tab": nodes})
+
+    result = await async_connection_readwrite.execute(
+        "MATCH (t:pyarrowtab) RETURN t.id AS id, t.A AS A, t.B AS B ORDER BY t.id"
+    )
+    assert result.get_next() == [1, "a", True]
+    assert result.get_next() == [2, "b", False]
+    assert result.get_next() == [3, "c", None]
+    result.close()
+
+    for i in async_connection_readwrite.connections_counter:
+        assert i == 0
+
+
+@pytest.mark.asyncio
+async def test_async_query_concurrent(async_connection_readonly):
+    num_queries = 100
+    queries = [f"RETURN {i};" for i in range(num_queries)]
+    results = await asyncio.gather(*[async_connection_readonly.execute(query) for query in queries])
+    for i, result in enumerate(results):
+        assert result.has_next()
+        assert result.get_next() == [i]
+        assert not result.has_next()
+        result.close()
+    for i in async_connection_readonly.connections_counter:
+        assert i == 0
+
+
+@pytest.mark.asyncio
+async def test_async_query_multiple_results(async_connection_readonly):
+    query = "MATCH (a:person) WHERE a.ID = 0 RETURN a.age; MATCH (a:person) WHERE a.ID = 2 RETURN a.age;"
+    results = await async_connection_readonly.execute(query)
+    assert len(results) == 2
+    result = results[0]
+    assert result.has_next()
+    assert result.get_next() == [35]
+    assert not result.has_next()
+
+    result = results[1]
+    assert result.has_next()
+    assert result.get_next() == [30]
+    assert not result.has_next()
+    for result in results:
+        result.close()
+    for i in async_connection_readonly.connections_counter:
+        assert i == 0
+
+
+@pytest.mark.asyncio
+async def test_async_connection_create_and_close():
+    db = lb.Database(":memory:", buffer_pool_size=2**28)
+    async_connection = lb.AsyncConnection(db)
+    for _ in range(10):
+        res = await async_connection.execute("RETURN 1;")
+        assert res.has_next()
+        assert res.get_next() == [1]
+        assert not res.has_next()
+        res.close()
+    num_queries = 100
+    queries = [f"RETURN {i};" for i in range(num_queries)]
+    results = await asyncio.gather(*[async_connection.execute(query) for query in queries])
+    for i, result in enumerate(results):
+        assert result.has_next()
+        assert result.get_next() == [i]
+        assert not result.has_next()
+        result.close()
+    async_connection.close()
+    db.close()
+
+
+def test_acquire_connection(async_connection_readonly):
+    conn = async_connection_readonly.acquire_connection()
+    assert conn is not None
+    assert async_connection_readonly.connections_counter[0] == 1
+    result = conn.execute("RETURN 1;")
+    assert result.has_next()
+    assert result.get_next() == [1]
+    assert not result.has_next()
+    result.close()
+    async_connection_readonly.release_connection(conn)
+    for i in async_connection_readonly.connections_counter:
+        assert i == 0
+
+
+@pytest.mark.asyncio
+async def test_async_connection_interrupt(async_connection_readonly) -> None:
+    query = "UNWIND RANGE(1,1000000) AS x UNWIND RANGE(1, 1000000) AS y RETURN COUNT(x + y);"
+    async_connection_readonly.set_query_timeout(100 * 1000)
+    task = asyncio.create_task(async_connection_readonly.execute(query))
+    time.sleep(5)
+    task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await task

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

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import re
+
+import pytest
+from type_aliases import ConnDB
+
+
+def test_bytes_param(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    conn.execute("CREATE NODE TABLE tab(id SERIAL PRIMARY KEY, data BLOB)")
+
+    data_0 = b"\x00\x01\x02\x03\xff"
+    data_1 = b"testing"
+    data_2 = b"A" * 4096  # max size: 4KB, see https://docs.ladybugdb.com/cypher/data-types/#blob
+    data_3 = b""  # empty
+    data_4 = None  # null
+    data_5 = "Hello 🌍"  # str
+
+    cases = [
+        data_0,
+        data_1,
+        data_2,
+        data_3,
+        data_4,
+        data_5.encode("utf-8"),  # to bytes
+    ]
+    for data in cases:
+        conn.execute("CREATE (t:tab {data: $data})", {"data": data})
+
+    result = conn.execute("MATCH (t:tab) RETURN t.data ORDER BY t.id")
+    assert result.get_next() == [data_0]
+    assert result.get_next() == [data_1]
+    assert result.get_next() == [data_2]
+    assert result.get_next() == [data_3]
+    assert result.get_next() == [data_4]
+    assert result.get_next()[0].decode("utf-8") == data_5
+    result.close()
+
+
+def test_bytes_param_backwards_compatibility(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    conn.execute("CREATE NODE TABLE tab(id SERIAL PRIMARY KEY, data BLOB)")
+
+    binary = b"backwards_compatibility"
+    string = "".join(f"\\x{b:02x}" for b in binary)  # to \xHH format
+
+    assert isinstance(string, str)
+    assert re.match(r"^(\\x[0-9a-f]{2})+$", string)
+
+    conn.execute("CREATE (t:tab {data: BLOB($string)})", {"string": string})
+
+    result = conn.execute("MATCH (t:tab) RETURN t.data")
+    assert result.get_next() == [binary]
+    result.close()
+
+
+def test_bytes_param_where_clause(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    conn.execute("CREATE NODE TABLE tab(id INT64 PRIMARY KEY, data BLOB)")
+
+    data = b"where_clause"
+
+    conn.execute("CREATE (t:tab {id: 0, data: $data})", {"data": b"some data"})
+    conn.execute("CREATE (t:tab {id: 1, data: $data})", {"data": data})
+    conn.execute("CREATE (t:tab {id: 2, data: $data})", {"data": b"some other data"})
+
+    result = conn.execute("MATCH (t:tab) WHERE t.data = $search RETURN t.id", {"search": data})
+    assert result.get_next() == [1]
+    assert not result.has_next()
+    result.close()
+
+
+def test_bytes_param_update(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    conn.execute("CREATE NODE TABLE tab(id SERIAL PRIMARY KEY, data BLOB)")
+
+    initial = b"initial"
+    updated = b"updated"
+
+    conn.execute("CREATE (t:tab {data: $data})", {"data": initial})
+    conn.execute("MATCH (t:tab) SET t.data = $new_data", {"new_data": updated})
+
+    result = conn.execute("MATCH (t:tab) RETURN t.data")
+    assert result.get_next() == [updated]
+    result.close()
+
+
+def test_bytes_param_mixed_types(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    conn.execute("CREATE NODE TABLE tab(id SERIAL PRIMARY KEY, data BLOB, name STRING, value DOUBLE)")
+
+    data = b"data"
+    name = "name"
+    value = 3.14
+
+    params = {"data": data, "name": name, "value": value}
+    conn.execute("CREATE (t:tab {data: $data, name: $name, value: $value})", params)
+
+    result = conn.execute("MATCH (t:tab) RETURN t.data, t.name, t.value")
+    assert result.get_next() == [data, name, value]
+    result.close()
+
+
+def test_bytes_param_relationship(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+    conn.execute("CREATE NODE TABLE person(name STRING PRIMARY KEY)")
+    conn.execute("CREATE REL TABLE rel(FROM person TO person, data BLOB)")
+
+    conn.execute("CREATE (p:person {name: 'Alice'})")
+    conn.execute("CREATE (p:person {name: 'Bob'})")
+
+    data = b"relationship"
+
+    conn.execute(
+        """
+            MATCH (p1:person {name: 'Alice'}), (p2:person {name: 'Bob'})
+            CREATE (p1)-[r:rel {data: $data}]->(p2)
+        """,
+        {"data": data},
+    )
+
+    result = conn.execute("MATCH ()-[r:rel]->() RETURN r.data")
+    assert result.get_next() == [data]
+    result.close()
+
+
+def test_bytes_param_udf(conn_db_empty: ConnDB) -> None:
+    conn, _ = conn_db_empty
+
+    def reverse_bytes(data: bytes) -> bytes:
+        return data[::-1]
+
+    conn.create_function("reverse_bytes", reverse_bytes, ["BLOB"], "BLOB")
+
+    data = b"hello"
+    expected = b"olleh"
+
+    result = conn.execute("RETURN reverse_bytes($data)", {"data": data})
+    assert result.get_next() == [expected]
+
+    result = conn.execute("RETURN reverse_bytes(NULL)")
+    assert result.get_next() == [None]
+
+    result.close()

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

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import threading
+import time
+from typing import TYPE_CHECKING
+
+import real_ladybug as lb
+import pytest
+from type_aliases import ConnDB
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_connection_close(tmp_path: Path) -> None:
+    db_path = tmp_path / "test_connection_close.lbug"
+    db = lb.Database(database_path=db_path, read_only=False)
+    conn = lb.Connection(db)
+    conn.close()
+    assert conn.is_closed
+    pytest.raises(RuntimeError, conn.execute, "RETURN 1")
+    db.close()
+
+
+def test_connection_close_context_manager(tmp_path: Path) -> None:
+    db_path = tmp_path / "test_connection_close_context_manager.lbug"
+    with lb.Database(database_path=db_path, read_only=False) as db:
+        with lb.Connection(db) as conn:
+            pass
+        assert conn.is_closed
+        pytest.raises(RuntimeError, conn.execute, "RETURN 1")
+    assert db.is_closed
+
+
+def run_long_query(conn):
+    query = "UNWIND RANGE(1,1000000) AS x UNWIND RANGE(1, 1000000) AS y RETURN COUNT(x + y);"
+    with pytest.raises(RuntimeError) as excinfo:
+        conn.execute(query)
+    assert "Interrupted" in str(excinfo.value)
+
+
+def test_connection_interrupt(conn_db_readwrite: ConnDB) -> None:
+    conn, _ = conn_db_readwrite
+    execute_thread = threading.Thread(target=run_long_query, args=(conn,))
+    execute_thread.start()
+    time.sleep(5)
+    conn.interrupt()
+    execute_thread.join(timeout=100)
+    assert not execute_thread.is_alive()

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

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+from textwrap import dedent
+from typing import TYPE_CHECKING
+
+import real_ladybug as lb
+import pytest
+from conftest import get_db_file_path
+
+
+def open_database_on_subprocess(tmp_path: Path, build_dir: Path) -> None:
+    code = dedent(
+        f"""
+        import sys
+        sys.path.append(r"{build_dir!s}")
+
+        import real_ladybug as lb
+        db = lb.Database(r"{tmp_path!s}")
+        print(r"{tmp_path!s}")
+    """
+    )
+    result = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr)
+
+
+def test_database_close(tmp_path: Path, build_dir: Path) -> None:
+    db_path = tmp_path / "test_database_close.lbug"
+    db = lb.Database(database_path=db_path, read_only=False)
+    assert not db.is_closed
+    assert db._database is not None
+
+    # Open the database on a subprocess. It should raise an exception.
+    with pytest.raises(
+        Exception,
+        match=r"RuntimeError: IO exception: Could not set lock on file",
+    ):
+        open_database_on_subprocess(db_path, build_dir)
+
+    db.close()
+    assert db.is_closed
+    assert db._database is None
+
+    # Try to close the database again. It should not raise any exceptions.
+    db.close()
+    assert db.is_closed
+    assert db._database is None
+
+    # Open the database on a subprocess. It should not raise any exceptions.
+    # TODO: Enable this test on Windows when the read-only mode is implemented.
+    if sys.platform != "win32":
+        open_database_on_subprocess(db_path, build_dir)
+
+
+def test_database_context_manager(tmp_path: Path, build_dir: Path) -> None:
+    db_path = tmp_path / "test_database_context_manager.lbug"
+    with lb.Database(database_path=db_path, read_only=False) as db:
+        assert not db.is_closed
+        assert db._database is not None
+
+        # Open the database on a subprocess. It should raise an exception.
+        # TODO: Enable this test on Windows when the read-only mode is implemented.
+        if sys.platform != "win32":
+            with pytest.raises(
+                RuntimeError,
+                match=r"RuntimeError: IO exception: Could not set lock on file",
+            ):
+                open_database_on_subprocess(db_path, build_dir)
+
+    # Open the database on a subprocess. It should not raise any exceptions.
+    # TODO: Enable this test on Windows when the read-only mode is implemented.
+    if sys.platform != "win32":
+        open_database_on_subprocess(db_path, build_dir)
+
+
+def test_in_mem_database_memory_db_path() -> None:
+    db = lb.Database(database_path=":memory:")
+    assert not db.is_closed
+    assert db._database is not None
+
+    # Open the database on a subprocess. It should raise an exception.
+    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
+
+
+def test_in_mem_database_empty_db_path() -> None:
+    db = lb.Database()
+    assert not db.is_closed
+    assert db._database is not None
+
+    # Open the database on a subprocess. It should raise an exception.
+    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
+
+
+def test_in_mem_database_no_db_path() -> None:
+    with lb.Database(database_path="") as db:
+        assert not db.is_closed
+        assert db._database is not None
+
+        # Open the database on a subprocess. It should raise an exception.
+        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});")
+        with conn.execute("MATCH (p:person) RETURN p.*") as result:
+            assert result.get_num_tuples() == 2
+
+
+def test_database_auto_checkpoint_config(tmp_path: Path) -> None:
+    with lb.Database(database_path=get_db_file_path(tmp_path), auto_checkpoint=False) as db:
+        assert not db.is_closed
+        assert db._database is not None
+
+        conn = lb.Connection(db)
+        with conn.execute("CALL current_setting('auto_checkpoint') RETURN *") as result:
+            assert result.get_num_tuples() == 1
+            assert result.get_next()[0] == "False"
+
+
+def test_database_checkpoint_threshold_config(tmp_path: Path) -> None:
+    with lb.Database(database_path=get_db_file_path(tmp_path), checkpoint_threshold=1234) as db:
+        assert not db.is_closed
+        assert db._database is not None
+
+        conn = lb.Connection(db)
+        with conn.execute("CALL current_setting('checkpoint_threshold') RETURN *") as result:
+            assert result.get_num_tuples() == 1
+            assert result.get_next()[0] == "1234"
+
+
+def test_database_throw_on_wal_replay_failure_config(tmp_path: Path) -> None:
+    database_path = get_db_file_path(tmp_path)
+    wal_file_path = str(database_path) + ".wal"
+    with Path.open(wal_file_path, "w") as wal_file:
+        wal_file.write("a" * 28)
+    with lb.Database(database_path=database_path, throw_on_wal_replay_failure=False) as db:
+        assert not db.is_closed
+        assert db._database is not None
+
+        conn = lb.Connection(db)
+        with conn.execute("RETURN 1") as result:
+            assert result.get_num_tuples() == 1
+            assert result.get_next()[0] == 1
+
+
+def test_database_enable_checksums_config(tmp_path: Path) -> None:
+    database_path = get_db_file_path(tmp_path)
+    # first construct database file with enable_checksums=True
+    with lb.Database(database_path=database_path) as db:
+        assert not db.is_closed
+        assert db._database is not None
+        conn = lb.Connection(db)
+
+        # do some updates to leave a WAL
+        conn.execute("call auto_checkpoint=false")
+        conn.execute("call force_checkpoint_on_close=false")
+        conn.execute("create node table test(id int64 primary key)")
+
+    # running again with enable_checksums=False should give an error
+    with pytest.raises(RuntimeError) as check:
+        db = lb.Database(database_path=database_path, enable_checksums=False)
+
+
+def test_database_close_order() -> None:
+    in_mem_db = lb.Database(database_path=":memory:", buffer_pool_size=1024 * 1024 * 10)
+    assert not in_mem_db.is_closed
+    assert in_mem_db._database is not None
+
+    in_mem_conn = lb.Connection(in_mem_db)
+    assert not in_mem_conn.is_closed
+    assert in_mem_conn._connection is not None
+
+    query_result = in_mem_conn.execute("RETURN 1+1")
+    assert not query_result.is_closed
+    assert query_result._query_result is not None
+
+    assert query_result.get_next()[0] == 2
+    # Close the database first, it should not cause crashes or exceptions
+    in_mem_db.close()
+
+    # The query result and connection will be unusable after the database is closed.
+    # But calling methods on them should raise exceptions instead of crashing.
+    with pytest.raises(Exception, match="Database is closed"):
+        in_mem_conn.execute("RETURN 1+1")
+
+    with pytest.raises(Exception, match="the parent database is closed"):
+        query_result.get_next()
+
+    # Close the connection and query result, they should not raise any exceptions.
+    in_mem_conn.close()
+    query_result.close()
+
+
+def test_database_close_order_with_multiple_statements() -> None:
+    in_mem_db = lb.Database(database_path=":memory:", buffer_pool_size=1024 * 1024 * 10)
+    assert not in_mem_db.is_closed
+    assert in_mem_db._database is not None
+
+    in_mem_conn = lb.Connection(in_mem_db)
+    assert not in_mem_conn.is_closed
+    assert in_mem_conn._connection is not None
+
+    query_results = in_mem_conn.execute("RETURN 1+1; RETURN 2+2; RETURN 3+3;")
+    for i, qr in enumerate(query_results):
+        assert not qr.is_closed
+        assert qr._query_result is not None
+        assert qr.get_next()[0] == (i + 1) * 2
+    # Close the database first, it should not cause crashes or exceptions
+    in_mem_db.close()
+
+    # The query result and connection will be unusable after the database is closed.
+    # But calling methods on them should raise exceptions instead of crashing.
+    with pytest.raises(Exception, match="Database is closed"):
+        in_mem_conn.execute("RETURN 1+1")
+
+    with pytest.raises(Exception, match="the parent database is closed"):
+        query_results[0].get_next()
+
+    # Close the connection and query result, they should not raise any exceptions.
+    in_mem_conn.close()
+    for qr in query_results:
+        qr.close()