Fix incorrect resource ownership transmission in schema retrieval C functions (#756)

## Usage and product changes
Fix a crash caused by an incorrect database's ownership acquisition in
the C layer of the `schema` and `type_schema` functions, affecting
Python and Java drivers.

Add respective BDD steps implementations for these functions in Rust,
Python, and Java.

## Implementation
Borrow instead of taking ownership of the referenced database resource.

Author: farost

c/src/database.rs

@@ -49,13 +49,13 @@ pub extern "C" fn database_delete(database: *const Database) {
 /// A full schema text as a valid TypeQL define query string.
 #[no_mangle]
 pub extern "C" fn database_schema(database: *const Database) -> *mut c_char {
-    try_release_string(take_arc(database).schema())
+    try_release_string(borrow(database).schema())
 }
 
 /// The types in the schema as a valid TypeQL define query string.
 #[no_mangle]
 pub extern "C" fn database_type_schema(database: *const Database) -> *mut c_char {
-    try_release_string(take_arc(database).type_schema())
+    try_release_string(borrow(database).type_schema())
 }
 
 // /// Iterator over the <code>ReplicaInfo</code> corresponding to each replica of a TypeDB cloud database.

dependencies/typedb/artifacts.bzl

@@ -25,7 +25,7 @@ def typedb_artifact():
         artifact_name = "typedb-all-{platform}-{version}.{ext}",
         tag_source = deployment["artifact"]["release"]["download"],
         commit_source = deployment["artifact"]["snapshot"]["download"],
-        commit = "fed272ee65df1e854c72c4066fdb2c4241565bb0"
+        commit = "16eca5f4238a772532a6824966e2fc78437467dc"
     )
 
 #def typedb_cloud_artifact():

dependencies/typedb/repositories.bzl

@@ -35,5 +35,5 @@ def typedb_behaviour():
     git_repository(
         name = "typedb_behaviour",
         remote = "https://github.com/typedb/typedb-behaviour",
-        commit = "569b59cad1355bfaaf1ca18a8f4adf40e5d1da4f",  # sync-marker: do not remove this comment, this is used for sync-dependencies by @typedb_behaviour
+        commit = "8f9345de853ad7d0ae66e7afefd16be2cfa3dced",  # sync-marker: do not remove this comment, this is used for sync-dependencies by @typedb_behaviour
     )

java/test/behaviour/connection/database/DatabaseSteps.java

@@ -20,6 +20,7 @@
 package com.typedb.driver.test.behaviour.connection.database;
 
 import com.typedb.driver.api.Driver;
+import com.typedb.driver.api.Transaction;
 import com.typedb.driver.api.database.Database;
 import com.typedb.driver.test.behaviour.config.Parameters;
 import io.cucumber.java.en.Then;
@@ -53,6 +54,15 @@ public void deleteDatabases(Driver driver, List<String> names) {
         }
     }
 
+    public String createTemporaryDatabaseWithSchema(Driver driver, String schemaQuery) {
+        String name = "temp-" + (int) (Math.random() * 10000);
+        createDatabases(driver, list(name));
+        Transaction transaction = driver.transaction(name, Transaction.Type.SCHEMA);
+        transaction.query(schemaQuery).resolve();
+        transaction.commit();
+        return name;
+    }
+
     @When("connection create database: {non_semicolon}{may_error}")
     public void connection_create_database(String name, Parameters.MayError mayError) {
         mayError.check(() -> createDatabases(driver, list(name)));
@@ -133,4 +143,34 @@ public void connection_does_not_have_databases(List<String> names) {
             assertFalse(databases.contains(databaseName));
         }
     }
+
+    @Then("connection get database\\({word}) has schema:")
+    public void connection_get_database_has_schema(String name, String schema) {
+        String expectedSchema = schema.strip();
+        String expectedSchemaRetrieved;
+        if (expectedSchema.isEmpty()) {
+            expectedSchemaRetrieved = "";
+        } else {
+            String tempDatabaseName = createTemporaryDatabaseWithSchema(driver, expectedSchema);
+            expectedSchemaRetrieved = driver.databases().get(tempDatabaseName).schema();
+        }
+
+        String realSchema = driver.databases().get(name).schema();
+        assertEquals(expectedSchemaRetrieved, realSchema);
+    }
+
+    @Then("connection get database\\({word}) has type schema:")
+    public void connection_get_database_has_type_schema(String name, String schema) {
+        String expectedSchema = schema.strip();
+        String expectedSchemaRetrieved;
+        if (expectedSchema.isEmpty()) {
+            expectedSchemaRetrieved = "";
+        } else {
+            String tempDatabaseName = createTemporaryDatabaseWithSchema(driver, expectedSchema);
+            expectedSchemaRetrieved = driver.databases().get(tempDatabaseName).typeSchema();
+        }
+
+        String realSchema = driver.databases().get(name).typeSchema();
+        assertEquals(expectedSchemaRetrieved, realSchema);
+    }
 }

java/test/behaviour/debug/BUILD

@@ -28,6 +28,8 @@ typedb_java_test(
     deps = [
         # Internal package dependencies
         "//java/test/behaviour:behaviour",
+        "//java/test/behaviour/query:steps",
+        "//java/test/behaviour/util:steps",
 
         # TODO: Add your addition debugging dependencies here
         # e.g. "//java/test/behaviour/connection/steps:connection-database",

java/test/integration/ExampleTest.java

@@ -17,6 +17,7 @@
  * under the License.
  */
 
+// EXAMPLE START MARKER
 // EXAMPLE START MARKER
 // EXAMPLE START MARKER
 package com.typedb.driver.test.integration;
@@ -48,6 +49,8 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 
+
+// EXAMPLE END MARKER
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
@@ -56,6 +59,7 @@
 import static org.junit.Assert.fail;
 
 @SuppressWarnings("Duplicates")
+// EXAMPLE START MARKER
 public class ExampleTest {
     // EXAMPLE END MARKER
     @BeforeClass

python/tests/behaviour/connection/database/database_steps.py

@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
+import random
 from concurrent.futures.thread import ThreadPoolExecutor
 from functools import partial
 
@@ -23,6 +24,7 @@
 from tests.behaviour.config.parameters import MayError, parse_list
 from tests.behaviour.context import Context
 from tests.behaviour.util.util import assert_collections_equal
+from typedb.api.connection.transaction import TransactionType
 from typedb.driver import *
 
 
@@ -125,15 +127,34 @@ def step_impl(context: Context):
     does_not_have_databases(context, names=parse_list(context))
 
 
+def create_temporary_database_with_schema(context: Context, schema_query: str) -> str:
+    name = "temp-" + str(random.randint(0, 100000))
+    create_databases(context.driver, [name])
+    transaction = context.driver.transaction(name, TransactionType.SCHEMA)
+    transaction.query(schema_query).resolve()
+    transaction.commit()
+    return name
+
+
 @step("connection get database({name}) has schema")
 def step_impl(context: Context, name: str):
-    expected_schema = context.text
+    expected_schema = context.text.strip()
+    if expected_schema:
+        temp_database_name = create_temporary_database_with_schema(context, expected_schema)
+        expected_schema_retrieved = context.driver.databases.get(temp_database_name).schema()
+    else:
+        expected_schema_retrieved = ""
     real_schema = context.driver.databases.get(name).schema()
-    assert_that(real_schema, is_(expected_schema))
+    assert_that(real_schema, is_(expected_schema_retrieved))
 
 
 @step("connection get database({name}) has type schema")
 def step_impl(context: Context, name: str):
-    expected_schema = context.text
-    real_schema = context.driver.databases.get(name).type_schema()
-    assert_that(real_schema, is_(expected_schema))
+    expected_type_schema = context.text.strip()
+    if expected_type_schema:
+        temp_database_name = create_temporary_database_with_schema(context, expected_type_schema)
+        expected_type_schema_retrieved = context.driver.databases.get(temp_database_name).type_schema()
+    else:
+        expected_type_schema_retrieved = ""
+    real_type_schema = context.driver.databases.get(name).type_schema()
+    assert_that(real_type_schema, is_(expected_type_schema_retrieved))

rust/README.md

@@ -72,7 +72,7 @@ use typedb_driver::{
         ConceptRow, QueryAnswer,
     },
     concept::{Concept, ValueType},
-    Credentials, DriverOptions, Error, TransactionOptions, TransactionType, TypeDBDriver, QueryOptions,
+    Credentials, DriverOptions, Error, QueryOptions, TransactionOptions, TransactionType, TypeDBDriver,
 };
 
 fn typedb_example() {

rust/example.rs

@@ -9,7 +9,7 @@ use typedb_driver::{
         ConceptRow, QueryAnswer,
     },
     concept::{Concept, ValueType},
-    Credentials, DriverOptions, Error, TransactionOptions, TransactionType, TypeDBDriver, QueryOptions,
+    Credentials, DriverOptions, Error, QueryOptions, TransactionOptions, TransactionType, TypeDBDriver,
 };
 
 fn typedb_example() {

rust/tests/behaviour/steps/connection/database.rs

@@ -26,9 +26,13 @@ use futures::{
 };
 use macro_rules_attribute::apply;
 use tokio::time::sleep;
-use typedb_driver::{Database, DatabaseManager, Result as TypeDBResult, TypeDBDriver};
+use typedb_driver::{Database, DatabaseManager, Result as TypeDBResult, TransactionType, TypeDBDriver};
+use uuid::Uuid;
 
-use crate::{assert_with_timeout, generic_step, in_oneshot_background, params, util::iter_table, Context};
+use crate::{
+    assert_with_timeout, connection::transaction::open_transaction_for_database, generic_step, in_oneshot_background,
+    params, query::run_query, util::iter_table, Context,
+};
 
 async fn create_database(driver: &TypeDBDriver, name: String, may_error: params::MayError) {
     may_error.check(driver.databases().create(name).await);
@@ -38,6 +42,14 @@ async fn delete_database(driver: &TypeDBDriver, name: &str, may_error: params::M
     may_error.check(driver.databases().get(name).and_then(Database::delete).await);
 }
 
+async fn database_schema(driver: &TypeDBDriver, name: &str) -> String {
+    driver.databases().get(name).await.expect("Expected database").schema().await.expect("Expected schema")
+}
+
+async fn database_type_schema(driver: &TypeDBDriver, name: &str) -> String {
+    driver.databases().get(name).await.expect("Expected database").type_schema().await.expect("Expected type schema")
+}
+
 async fn has_database(driver: &TypeDBDriver, name: &str) -> bool {
     driver.databases().contains(name.clone()).await.unwrap()
 }
@@ -155,3 +167,44 @@ async fn connection_does_not_have_databases(context: &mut Context, step: &Step)
         );
     }
 }
+
+async fn create_temporary_database_with_schema(driver: &TypeDBDriver, schema_query: String) -> String {
+    let name = format!("temp-{}", Uuid::new_v4());
+    create_database(driver, name.clone(), params::MayError::False).await;
+    let transaction = open_transaction_for_database(driver, &name, TransactionType::Schema, None)
+        .await
+        .expect("Expected transaction");
+    run_query(&transaction, &schema_query, None).await.expect("Expected successful query");
+    transaction.commit().await.expect("Expected successful commit");
+    name
+}
+
+#[apply(generic_step)]
+#[step(expr = r"connection get database\({word}\) has schema:")]
+async fn connection_get_database_has_schema(context: &mut Context, name: String, step: &Step) {
+    let expected_schema = step.docstring.as_ref().unwrap().trim().to_string();
+    let driver = context.driver.as_ref().unwrap();
+    let expected_schema_retrieved = if expected_schema.is_empty() {
+        String::new()
+    } else {
+        let temp_database_name = create_temporary_database_with_schema(driver, expected_schema).await;
+        database_schema(driver, &temp_database_name).await
+    };
+    let schema = database_schema(driver, &name).await;
+    assert_eq!(expected_schema_retrieved, schema);
+}
+
+#[apply(generic_step)]
+#[step(expr = r"connection get database\({word}\) has type schema:")]
+async fn connection_get_database_has_type_schema(context: &mut Context, name: String, step: &Step) {
+    let expected_type_schema = step.docstring.as_ref().unwrap().trim().to_string();
+    let driver = context.driver.as_ref().unwrap();
+    let expected_type_schema_retrieved = if expected_type_schema.is_empty() {
+        String::new()
+    } else {
+        let temp_database_name = create_temporary_database_with_schema(driver, expected_type_schema).await;
+        database_type_schema(driver, &temp_database_name).await
+    };
+    let type_schema = database_type_schema(driver, &name).await;
+    assert_eq!(expected_type_schema_retrieved, type_schema);
+}

rust/tests/behaviour/steps/connection/transaction.rs

@@ -28,7 +28,7 @@ use crate::{
     generic_step, in_background, in_oneshot_background, params, params::check_boolean, util::iter_table, Context,
 };
 
-async fn open_transaction_for_database(
+pub(crate) async fn open_transaction_for_database(
     driver: &TypeDBDriver,
     database_name: impl AsRef<str>,
     transaction_type: TransactionType,

rust/tests/behaviour/steps/query.rs

@@ -38,7 +38,7 @@ use crate::{
     BehaviourTestOptionalError, Context,
 };
 
-async fn run_query(
+pub(crate) async fn run_query(
     transaction: &Transaction,
     query: impl AsRef<str>,
     query_options: Option<QueryOptions>,