Rename the project to nim-ladybug, after kuzu's sudden October abandoning. Picked up by a new party under the new name, lets see where this goes!

No new functionality, just rename and docs updates.

tests/connection/t_can_create_new_connection.nim

@@ -1,10 +1,10 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 
 assert db.path == "(in-memory)"
-assert typeOf( db.connect ) is KuzuConnection
+assert typeOf( db.connect ) is LbugConnection
 

tests/connection/t_can_interrupt_running_query.nim

@@ -1,9 +1,9 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 # FIXME: This test should really perform some

tests/connection/t_can_set_connection_query_timeout.nim

@@ -1,8 +1,8 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 # There is currently no getter for this, so

tests/constants/t_has_a_default_config.nim

@@ -1,6 +1,6 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-assert typeOf( KUZU_DEFAULT_CONFIG ) is kuzu_system_config
+assert typeOf( LBUG_DEFAULT_CONFIG ) is lbug_system_config
 

tests/constants/t_has_a_version.nim

@@ -1,7 +1,7 @@
 # vim: set et sta sw=4 ts=4 :
 
 import re
-import kuzu
+import lbug
 
-assert KUZU_VERSION.contains( re"^\d+\.\d+\.\d+$" )
+assert LBUG_VERSION.contains( re"^\d+\.\d+\.\d+$" )
 

tests/constants/t_knows_its_libversion.nim

@@ -1,8 +1,8 @@
 # vim: set et sta sw=4 ts=4 :
 
 import re
-import kuzu
+import lbug
 
-let version = $kuzuGetVersion()
+let version = $lbugGetVersion()
 assert version.contains( re"^\d+\.\d+\.\d+(?:\.\d+)?$" )
 

tests/constants/t_knows_its_storage_version.nim

@@ -1,6 +1,6 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-assert kuzuGetStorageVersion() >= 36
+assert lbugGetStorageVersion() >= 36
 

tests/database/t_can_create_in_memory.nim

@@ -1,8 +1,8 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-var db = newKuzuDatabase()
+var db = newLbugDatabase()
 assert db.path == "(in-memory)"
 assert db.kind == memory
 

tests/database/t_can_create_with_custom_config.nim

@@ -4,12 +4,12 @@ import
     std/files,
     std/paths
 
-import kuzu
+import lbug
 
 const DATABASE_PATH = Path( "tmp/testdb" )
 DATABASE_PATH.removeFile()
 
-var db = newKuzuDatabase( $DATABASE_PATH, kuzuConfig( auto_checkpoint=false ) )
+var db = newLbugDatabase( $DATABASE_PATH, lbugConfig( auto_checkpoint=false ) )
 assert db.path == "tmp/testdb"
 assert db.config.auto_checkpoint == false
 

tests/database/t_checks_for_valid_kuzu_file.nim

@@ -5,7 +5,7 @@ import
   std/paths,
   std/re
 
-import kuzu
+import lbug
 
 const NOT_A_DATABASE_PATH = Path( "tmp/not-a-db" )
 
@@ -15,9 +15,9 @@ fh.write( "Hi." )
 fh.close
 
 try:
-    discard newKuzuDatabase( $NOT_A_DATABASE_PATH )
-except KuzuException as err:
-    assert err.msg.contains( re"""Unable to open database: "tmp/not-a-db" Doesn't appear to be a Kuzu file""" )
+    discard newLbugDatabase( $NOT_A_DATABASE_PATH )
+except LbugException as err:
+    assert err.msg.contains( re"""Unable to open database: "tmp/not-a-db" Doesn't appear to be a LadybugDB file""" )
 
 NOT_A_DATABASE_PATH.removeFile()
 

tests/database/t_creates_with_default_config.nim

@@ -4,16 +4,16 @@ import
     std/files,
     std/paths
 
-import kuzu
+import lbug
 
 const DATABASE_PATH = Path( "tmp/testdb" )
 
 DATABASE_PATH.removeFile()
-var db = newKuzuDatabase( $DATABASE_PATH )
+var db = newLbugDatabase( $DATABASE_PATH )
 
 assert db.path == $DATABASE_PATH
 assert db.kind == disk
-assert db.config == kuzuConfig()
+assert db.config == lbugConfig()
 assert db.config.read_only == false
 
 DATABASE_PATH.removeFile()

tests/queries/t_auto_rewinds_the_iterator.nim

@@ -1,8 +1,8 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query """

tests/queries/t_can_bind_to_a_prepared_statement.nim

@@ -4,19 +4,19 @@ discard """
 output: "d.thing\nCamel\nLampshade\nDelicious Cake\n"
 """
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )
 
 var p = conn.prepare( "CREATE (d:Doop {thing: $thing})" )
-assert typeOf( p ) is KuzuPreparedStatement
+assert typeOf( p ) is LbugPreparedStatement
 
 for thing in @[ "Camel", "Lampshade", "Delicious Cake" ]:
    q = p.execute( (thing: thing) )
-   assert typeOf( q ) is KuzuQueryResult
+   assert typeOf( q ) is LbugQueryResult
 
 # Fixed post v0.8.2:
 #     https://github.com/kuzudb/kuzu/issues/5102

tests/queries/t_can_bind_various_datatypes.nim

@@ -4,9 +4,9 @@ discard """
 output: "0|-222222|128|True|Stuff!|3.344903|239.299923|a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11|2025-03-29"
 """
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( """CREATE NODE TABLE Doop (
@@ -21,7 +21,7 @@ var q = conn.query( """CREATE NODE TABLE Doop (
     date DATE,
     PRIMARY KEY(id)
 )""" )
-assert typeOf( q ) is KuzuQueryResult
+assert typeOf( q ) is LbugQueryResult
 
 
 var stmt = conn.prepare( """CREATE (d:Doop {
@@ -34,7 +34,7 @@ var stmt = conn.prepare( """CREATE (d:Doop {
     uuid: UUID($uuid),
     date: DATE($date)
 })""" )
-assert typeOf( stmt ) is KuzuPreparedStatement
+assert typeOf( stmt ) is LbugPreparedStatement
 
 
 q = stmt.execute((
@@ -47,7 +47,7 @@ q = stmt.execute((
     uuid:   "A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11",
     date:   "2025-03-29"
 ))
-assert typeOf( q ) is KuzuQueryResult
+assert typeOf( q ) is LbugQueryResult
 
 
 q = conn.query( "MATCH (d:Doop) RETURN d.*" )

tests/queries/t_can_contain_multiple_result_sets.nim

@@ -4,14 +4,14 @@ discard """
 output: "a\nb\nc\nd\ne\nf\n"
 """
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "RETURN 'hi'" )
 
-assert typeOf( q ) is KuzuQueryResult
+assert typeOf( q ) is LbugQueryResult
 assert q.sets.len == 0
 
 q = conn.query """
@@ -23,7 +23,7 @@ q = conn.query """
     RETURN "f";
 """
 
-assert typeOf( q ) is KuzuQueryResult
+assert typeOf( q ) is LbugQueryResult
 assert q.sets.len == 5
 
 echo q.getNext

tests/queries/t_can_execute_a_simple_queries.nim

@@ -1,16 +1,16 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )
-assert typeOf( q ) is KuzuQueryResult
+assert typeOf( q ) is LbugQueryResult
 
 for thing in @[ "Camel", "Lampshade", "Delicious Cake" ]:
     q = conn.query( "CREATE (d:Doop {thing: '" & thing & "'})" )
-    assert typeOf( q ) is KuzuQueryResult
+    assert typeOf( q ) is LbugQueryResult
 
 q = conn.query( "MATCH (d:Doop) RETURN d.thing" )
 assert q.num_columns == 1

tests/queries/t_can_iterate_tuples.nim

@@ -4,9 +4,9 @@ discard """
 output: "Camel\nLampshade\nDelicious Cake\n"
 """
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )

tests/queries/t_can_rewind_iteration.nim

@@ -4,9 +4,9 @@ discard """
 output: "Camel\nLampshade\nCamel\nLampshade\n"
 """
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )

tests/queries/t_can_stringify_results.nim

@@ -4,9 +4,9 @@ discard """
 output: "d.thing\nokay!\n\n"
 """
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )

tests/queries/t_knows_if_there_are_waiting_tuples.nim

@@ -1,12 +1,12 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )
-assert typeOf( q ) is KuzuQueryResult
+assert typeOf( q ) is LbugQueryResult
 
 q = conn.query( "MATCH (d:Doop) RETURN d.thing" )
 assert q.num_tuples == 0

tests/queries/t_knows_the_column_names.nim

@@ -1,12 +1,12 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )
-assert typeOf( q ) is KuzuQueryResult
+assert typeOf( q ) is LbugQueryResult
 
 q = conn.query( "CREATE (d:Doop {thing: 'okay!'})" )
 q = conn.query( "MATCH (d:Doop) RETURN d.id AS IDENTIFIER, d.thing AS THING" )

tests/queries/t_knows_the_column_types.nim

@@ -1,17 +1,17 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )
-assert typeOf( q ) is KuzuQueryResult
+assert typeOf( q ) is LbugQueryResult
 
 q = conn.query( "CREATE (d:Doop {thing: 'okay!'})" )
 q = conn.query( "MATCH (d:Doop) RETURN d.id AS IDENTIFIER, d.thing AS THING" )
 
 assert q.column_types.len == 2
-assert $q.column_types[0] == "KUZU_SERIAL"
-assert $q.column_types[1] == "KUZU_STRING"
+assert $q.column_types[0] == "LBUG_SERIAL"
+assert $q.column_types[1] == "LBUG_STRING"
 

tests/queries/t_raises_on_bad_syntax.nim

@@ -2,13 +2,13 @@
 
 import
     std/re
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 try:
     discard conn.query( "NOPE NOPE NOPE" )
-except KuzuQueryError as err:
+except LbugQueryError as err:
     assert err.msg.contains( re"""Parser exception: extraneous input 'NOPE'""" )
 

tests/queries/t_raises_on_invalid_varbind.nim

@@ -2,30 +2,30 @@
 
 import
     std/re
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, created DATE, PRIMARY KEY(id) )" )
-assert typeOf( q ) is KuzuQueryResult
+assert typeOf( q ) is LbugQueryResult
 
 var p = conn.prepare( "CREATE (d:Doop {created: $created})" )
-assert typeOf( p ) is KuzuPreparedStatement
+assert typeOf( p ) is LbugPreparedStatement
 
 # Typecast binding failure
 #
 try:
     discard p.execute( (created: "1111-1111") )
-except KuzuQueryError as err:
-    assert err.msg.contains( re"""Expression \$created has data type STRING but expected DATE.""" )
+except LbugQueryError as err:
+    assert err.msg.contains( re"""Conversion exception: Error occurred during parsing date.""" )
 
 # Invalid value for typecast
 #
 p = conn.prepare( "CREATE (d:Doop {created: DATE($created)})" )
 try:
     discard p.execute( (created: "1111-1111") )
-except KuzuQueryError as err:
+except LbugQueryError as err:
     assert err.msg.contains( re"""Given: "1111-1111". Expected format: \(YYYY-MM-DD\)""" )
 
 

tests/queries/t_raises_on_unknown_varbind.nim

@@ -2,19 +2,19 @@
 
 import
     std/re
-import kuzu
+import ladybug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )
 
 var p = conn.prepare( "CREATE (d:Doop {thing: $thing})" )
-assert typeOf( p ) is KuzuPreparedStatement
+assert typeOf( p ) is LbugPreparedStatement
 
 try:
-    discard p.execute( (nope: "undefined var in statement!") )
-except KuzuQueryError as err:
+    discard p.execute( (nope: "undefined var in statement!", thing: "yep") )
+except LbugQueryError as err:
     assert err.msg.contains( re"""Parameter nope not found.""" )
 
 

tests/queries/t_raises_with_invalid_prepared_statement.nim

@@ -2,19 +2,19 @@
 
 import
     std/re
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )
 
 var p = conn.prepare( "CREAET (d:Doop {thing: $thing})" )
-assert typeOf( p ) is KuzuPreparedStatement
+assert typeOf( p ) is LbugPreparedStatement
 
 try:
     discard p.execute
-except KuzuQueryError as err:
+except LbugQueryError as err:
     assert err.msg.contains( re"""Parser exception: extraneous input 'CREAET'""" )
 
 

tests/tuples/t_can_be_stringified.nim

@@ -4,9 +4,9 @@ discard """
 output: "okay!"
 """
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )

tests/tuples/t_throws_exception_fetching_at_end.nim

@@ -2,9 +2,9 @@
 
 import
     std/re
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )
@@ -12,6 +12,6 @@ q = conn.query( "MATCH (d:Doop) RETURN d.thing" )
 
 try:
    discard q.getNext
-except KuzuIterationError as err:
+except LbugIterationError as err:
     assert err.msg.contains( re"""Query iteration past end.""" )
 

tests/tuples/t_throws_exception_invalid_index.nim

@@ -2,9 +2,9 @@
 
 import
     std/re
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )
@@ -15,6 +15,6 @@ let tup = q.getNext
 
 try:
     echo tup[22]
-except KuzuIndexError as err:
+except LbugIndexError as err:
     assert err.msg.contains( re"""Unable to fetch tuple value at idx 22.""" )
 

tests/values/t_can_be_stringified.nim

@@ -4,9 +4,9 @@ discard """
 output: "okay!"
 """
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )

tests/values/t_can_convert_to_native_types.nim

@@ -1,8 +1,8 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( """CREATE NODE TABLE Doop (

tests/values/t_can_return_a_blob_object.nim

@@ -1,8 +1,8 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-var db   = newKuzuDatabase()
+var db   = newLbugDatabase()
 var conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doot ( id SERIAL, data BLOB, PRIMARY KEY(id) )" )
@@ -16,12 +16,12 @@ q = conn.query( "MATCH (d:Doot) RETURN d.data" )
 
 var expected: seq[byte] = @[188, 189, 186, 170]
 var val = q.getNext[0]
-assert val.kind == KUZU_BLOB
+assert val.kind == LBUG_BLOB
 assert val.toBlob == expected
 
 expected = @[72, 101, 108, 108, 111, 33]
 val = q.getNext[0]
-assert val.kind == KUZU_BLOB
+assert val.kind == LBUG_BLOB
 assert val.toBlob == expected
 
 var str: string

tests/values/t_can_return_a_list_object.nim

@@ -1,39 +1,39 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "RETURN [1,2,3,4,5] AS list" )
 var list = q.getNext[0]
-assert list.kind == KUZU_LIST
+assert list.kind == LBUG_LIST
 
 var items = list.toSeq
 assert items.len == 5
-assert typeOf( items ) is seq[KuzuValue]
+assert typeOf( items ) is seq[LbugValue]
 
 for i in items:
-    assert( i.kind == KUZU_INT64 )
+    assert( i.kind == LBUG_INT64 )
 
 
 q = conn.query( """RETURN ["woo", "hoo"] AS list""" )
 list = q.getNext[0]
-assert list.kind == KUZU_LIST
+assert list.kind == LBUG_LIST
 
 items = list.toSeq
 assert items.len == 2
-assert typeOf( items ) is seq[KuzuValue]
+assert typeOf( items ) is seq[LbugValue]
 
 for i in items:
-    assert( i.kind == KUZU_STRING )
+    assert( i.kind == LBUG_STRING )
 
 
 q = conn.query( """RETURN [] AS list""" )
 list = q.getNext[0]
-assert list.kind == KUZU_LIST
+assert list.kind == LBUG_LIST
 
 items = list.toList
 assert items.len == 0
-assert typeOf( items ) is seq[KuzuValue]
+assert typeOf( items ) is seq[LbugValue]
 

tests/values/t_can_return_a_struct_object.nim

@@ -1,14 +1,14 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( """RETURN 12""" )
 try:
     discard q.getNext[0].toStruct
-except KuzuTypeError:
+except LbugTypeError:
     discard
 
 

tests/values/t_can_return_a_type.nim

@@ -1,8 +1,8 @@
 # vim: set et sta sw=4 ts=4 :
 
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )
@@ -15,7 +15,7 @@ var id    = row[0]
 var thing = row[1]
 var node = row[2]
 
-assert id.kind    == KUZU_INT64
-assert thing.kind == KUZU_STRING
-assert node.kind  == KUZU_NODE
+assert id.kind    == LBUG_INT64
+assert thing.kind == LBUG_STRING
+assert node.kind  == LBUG_NODE
 

tests/values/t_raise_error_on_invalid_conversion.nim

@@ -2,9 +2,9 @@
 
 import
   std/re
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( "CREATE NODE TABLE Doop ( id SERIAL, thing STRING, PRIMARY KEY(id) )" )
@@ -14,12 +14,12 @@ q = conn.query( "MATCH (d:Doop) RETURN d" )
 
 var tup = q.getNext
 var val = tup[0]
-assert val.kind == KUZU_NODE
+assert val.kind == LBUG_NODE
 
 try:
     discard val.toInt32
-except KuzuTypeError as err:
-    assert err.msg.contains( re"""Mismatched types: KUZU_NODE != {KUZU_INT32}""" )
+except LbugTypeError as err:
+    assert err.msg.contains( re"""Mismatched types: LBUG_NODE != {LBUG_INT32}""" )
 
 
 q = conn.query( "RETURN 1" )
@@ -27,7 +27,7 @@ val = q.getNext[0]
 
 try:
     discard val.toStruct
-except KuzuTypeError as err:
-    assert err.msg.contains( re"""Mismatched types: KUZU_INT.* != {KUZU_NODE, KUZU_REL,.*}""" )
+except LbugTypeError as err:
+    assert err.msg.contains( re"""Mismatched types: LBUG_INT.* != {LBUG_NODE, LBUG_REL,.*}""" )
 
 

tests/values/t_raises_error_on_struct_missing_key.nim

@@ -2,9 +2,9 @@
 
 import
     std/re
-import kuzu
+import lbug
 
-let db = newKuzuDatabase()
+let db = newLbugDatabase()
 let conn = db.connect
 
 var q = conn.query( """RETURN {test1: 1, test2: "bewts"} AS struct""" )
@@ -15,7 +15,7 @@ assert struct.keys == @["test1", "test2"]
 
 try:
     discard struct["nope"]
-except KuzuIndexError as err:
+except LbugIndexError as err:
     assert err.msg.contains( re"""No such struct key "nope"""" )