QueryAnswer.
+/// Retrieves the executed query's type of the QueryAnswer.
#[no_mangle]
pub extern "C" fn query_answer_get_query_type(query_answer: *const QueryAnswer) -> QueryType {
borrow(query_answer).get_query_type()
@@ -122,14 +120,14 @@ pub extern "C" fn concept_row_get_column_names(concept_row: *const ConceptRow) -
release(StringIterator(CIterator(box_stream(borrow(concept_row).get_column_names().into_iter().cloned().map(Ok)))))
}
-/// Retrieve the executed query's structure from the ConceptRow's header, if set.
+/// Retrieves the executed query's structure from the ConceptRow's header, if set.
/// It must be requested via "include query structure" in QueryOptions
#[no_mangle]
pub extern "C" fn concept_row_get_query_structure(concept_row: *const ConceptRow) -> *mut Pipeline {
release_optional(borrow(concept_row).get_query_structure().cloned())
}
-/// Retrieve the executed query's type of the ConceptRow's header.
+/// Retrieves the executed query's type of the ConceptRow's header.
#[no_mangle]
pub extern "C" fn concept_row_get_query_type(concept_row: *const ConceptRow) -> QueryType {
borrow(concept_row).get_query_type()
@@ -142,14 +140,12 @@ pub extern "C" fn concept_row_get_concepts(concept_row: *const ConceptRow) -> *m
}
/// Retrieves a concept for a given column name.
-///
#[no_mangle]
pub extern "C" fn concept_row_get(concept_row: *const ConceptRow, column_name: *const c_char) -> *mut Concept {
try_release_optional(borrow(concept_row).get(string_view(column_name)).map(|concept| concept.cloned()).transpose())
}
/// Retrieves a concept for a given column index.
-///
#[no_mangle]
pub extern "C" fn concept_row_get_index(concept_row: *const ConceptRow, column_index: usize) -> *mut Concept {
try_release_optional(borrow(concept_row).get_index(column_index).map(|concept| concept.cloned()).transpose())
diff --git a/c/src/error.rs b/c/src/common/error.rs
similarity index 86%
rename from c/src/error.rs
rename to c/src/common/error.rs
index a147cc4855..524d42c325 100644
--- a/c/src/error.rs
+++ b/c/src/common/error.rs
@@ -57,35 +57,35 @@ fn ok_record_flattenDatetimeAndTimeZone used to represent time zoned datetime in FFI.
+/// DatetimeAndTimeZone is used to represent time zoned datetime in FFI.
/// Time zone can be represented either as an IANA Tz or as a FixedOffset.
/// Either the zone_name (is_fixed_offset == false) or offset (is_fixed_offset == true) is set.
#[repr(C)]
@@ -84,22 +76,6 @@ impl DatetimeAndTimeZone {
is_fixed_offset,
}
}
-
- pub fn get_datetime_in_nanos(self) -> DatetimeInNanos {
- self.datetime_in_nanos
- }
-
- pub fn get_zone_name(self) -> *mut c_char {
- self.zone_name
- }
-
- pub fn get_local_minus_utc_offset(self) -> i32 {
- self.local_minus_utc_offset
- }
-
- pub fn get_is_fixed_offset(self) -> bool {
- self.is_fixed_offset
- }
}
impl Drop for DatetimeAndTimeZone {
@@ -345,9 +321,9 @@ pub extern "C" fn concept_get_datetime(concept: *const Concept) -> DatetimeInNan
/// Returns the value of this datetime-tz value concept as seconds and nanoseconds parts since the start of the UNIX epoch and timezone information.
/// If the value has another type, the error is set.
#[no_mangle]
-pub extern "C" fn concept_get_datetime_tz(concept: *const Concept) -> DatetimeAndTimeZone {
+pub extern "C" fn concept_get_datetime_tz(concept: *const Concept) -> *mut DatetimeAndTimeZone {
match borrow(concept).try_get_datetime_tz() {
- Some(value) => DatetimeAndTimeZone::new(&value),
+ Some(value) => release(DatetimeAndTimeZone::new(&value)),
None => unreachable!("Attempting to unwrap a non-datetime-tz {:?} as datetime-tz", borrow(concept)),
}
}
diff --git a/c/src/concept/instance.rs b/c/src/concept/instance.rs
index e0b753fb15..7374d4f4aa 100644
--- a/c/src/concept/instance.rs
+++ b/c/src/concept/instance.rs
@@ -22,7 +22,7 @@ use std::ptr::null_mut;
use typedb_driver::concept::Concept;
use super::concept::{borrow_as_attribute, borrow_as_entity, borrow_as_relation};
-use crate::memory::release;
+use crate::common::memory::release;
/// Retrieves the type which this ``Entity`` belongs to.
#[no_mangle]
diff --git a/c/src/concept/mod.rs b/c/src/concept/mod.rs
index 6f6bae970e..12dcd1a9f8 100644
--- a/c/src/concept/mod.rs
+++ b/c/src/concept/mod.rs
@@ -19,11 +19,13 @@
use std::ptr::addr_of_mut;
-use itertools::Itertools;
use typedb_driver::{answer::ConceptRow, concept::Concept, BoxPromise, Promise, Result};
-use super::{iterator::iterator_try_next, memory::free};
-use crate::{error::try_release_optional, iterator::CIterator, memory::take_ownership};
+use crate::common::{
+ error::try_release_optional,
+ iterator::{iterator_try_next, CIterator},
+ memory::{free, take_ownership},
+};
mod concept;
mod instance;
diff --git a/c/src/connection.rs b/c/src/connection.rs
deleted file mode 100644
index fe569e73bb..0000000000
--- a/c/src/connection.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-use std::{ffi::c_char, path::Path};
-
-use typedb_driver::{Credentials, DriverOptions, TypeDBDriver};
-
-use super::{
- error::{try_release, unwrap_void},
- memory::{borrow, free, string_view},
-};
-use crate::memory::release;
-
-const DRIVER_LANG: &'static str = "c";
-
-/// Open a TypeDB C Driver to a TypeDB server available at the provided address.
-///
-/// @param address The address (host:port) on which the TypeDB Server is running
-/// @param credentials The Credentials to connect with
-/// @param driver_options The DriverOptions to connect with
-#[no_mangle]
-pub extern "C" fn driver_open(
- address: *const c_char,
- credentials: *const Credentials,
- driver_options: *const DriverOptions,
-) -> *mut TypeDBDriver {
- try_release(TypeDBDriver::new_with_description(
- string_view(address),
- borrow(credentials).clone(),
- borrow(driver_options).clone(),
- DRIVER_LANG,
- ))
-}
-
-/// Open a TypeDB Driver to a TypeDB server available at the provided address.
-/// This method allows driver language specification for drivers built on top of the native C layer.
-///
-/// @param address The address (host:port) on which the TypeDB Server is running
-/// @param credentials The Credentials to connect with
-/// @param driver_options The DriverOptions to connect with
-/// @param driver_lang The language of the driver connecting to the server
-#[no_mangle]
-pub extern "C" fn driver_open_with_description(
- address: *const c_char,
- credentials: *const Credentials,
- driver_options: *const DriverOptions,
- driver_lang: *const c_char,
-) -> *mut TypeDBDriver {
- try_release(TypeDBDriver::new_with_description(
- string_view(address),
- borrow(credentials).clone(),
- borrow(driver_options).clone(),
- string_view(driver_lang),
- ))
-}
-
-/// Closes the driver. Before instantiating a new driver, the driver that’s currently open should first be closed.
-/// Closing a driver frees the underlying Rust object.
-#[no_mangle]
-pub extern "C" fn driver_close(driver: *mut TypeDBDriver) {
- free(driver);
-}
-
-/// Checks whether this connection is presently open.
-#[no_mangle]
-pub extern "C" fn driver_is_open(driver: *const TypeDBDriver) -> bool {
- borrow(driver).is_open()
-}
-
-/// Forcibly closes the driver. To be used in exceptional cases.
-#[no_mangle]
-pub extern "C" fn driver_force_close(driver: *mut TypeDBDriver) {
- unwrap_void(borrow(driver).force_close());
-}
-
-// Creates a new Credentials for connecting to TypeDB Server.
-//
-// @param username The name of the user to connect as
-// @param password The password for the user
-#[no_mangle]
-pub extern "C" fn credentials_new(username: *const c_char, password: *const c_char) -> *mut Credentials {
- release(Credentials::new(string_view(username), string_view(password)))
-}
-
-// Frees the native rust Credentials object
-#[no_mangle]
-pub extern "C" fn credentials_drop(credentials: *mut Credentials) {
- free(credentials);
-}
-
-// Creates a new DriverOptions for connecting to TypeDB Server.
-//
-// @param tls_root_ca Path to the CA certificate to use for authenticating server certificates.
-// @param with_tls Specify whether the connection to TypeDB Cloud must be done over TLS
-#[no_mangle]
-pub extern "C" fn driver_options_new(is_tls_enabled: bool, tls_root_ca: *const c_char) -> *mut DriverOptions {
- let tls_root_ca_path = unsafe { tls_root_ca.as_ref().map(|str| Path::new(string_view(str))) };
- try_release(DriverOptions::new(is_tls_enabled, tls_root_ca_path))
-}
-
-// Frees the native rust DriverOptions object
-#[no_mangle]
-pub extern "C" fn driver_options_drop(driver_options: *mut DriverOptions) {
- free(driver_options);
-}
diff --git a/c/src/credentials.rs b/c/src/credentials.rs
new file mode 100644
index 0000000000..7d1a11ecee
--- /dev/null
+++ b/c/src/credentials.rs
@@ -0,0 +1,39 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use std::ffi::c_char;
+
+use typedb_driver::Credentials;
+
+use crate::common::memory::{free, release, string_view};
+
+/// Creates a new Credentials for connecting to TypeDB Server.
+///
+/// @param username The name of the user to connect as
+/// @param password The password for the user
+#[no_mangle]
+pub extern "C" fn credentials_new(username: *const c_char, password: *const c_char) -> *mut Credentials {
+ release(Credentials::new(string_view(username), string_view(password)))
+}
+
+/// Frees the native rust Credentials object
+#[no_mangle]
+pub extern "C" fn credentials_drop(credentials: *mut Credentials) {
+ free(credentials);
+}
diff --git a/c/src/database/database.rs b/c/src/database/database.rs
new file mode 100644
index 0000000000..f7e1301abd
--- /dev/null
+++ b/c/src/database/database.rs
@@ -0,0 +1,108 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use std::{ffi::c_char, path::Path};
+
+use typedb_driver::Database;
+
+use crate::{
+ common::{
+ error::{try_release_string, unwrap_void},
+ memory::{borrow, decrement_arc, release_string, string_view, take_arc},
+ },
+ server::consistency_level::{native_consistency_level, ConsistencyLevel},
+};
+
+/// Frees the native rust Database object.
+#[no_mangle]
+pub extern "C" fn database_close(database: *const Database) {
+ decrement_arc(database)
+}
+
+/// The Database name as a string.
+#[no_mangle]
+pub extern "C" fn database_get_name(database: *const Database) -> *mut c_char {
+ release_string(borrow(database).name().to_owned())
+}
+
+/// Deletes this Database.
+#[no_mangle]
+pub extern "C" fn database_delete(database: *const Database) {
+ unwrap_void(take_arc(database).delete());
+}
+
+/// A full schema text as a valid TypeQL define query string.
+///
+/// @param database The Database to get the schema from.
+/// @param consistency_level The consistency level to use for the operation. Strongest possible if null.
+#[no_mangle]
+pub extern "C" fn database_schema(
+ database: *const Database,
+ consistency_level: *const ConsistencyLevel,
+) -> *mut c_char {
+ let database = borrow(database);
+ let result = match native_consistency_level(consistency_level) {
+ Some(consistency_level) => database.schema_with_consistency(consistency_level),
+ None => database.schema(),
+ };
+ try_release_string(result)
+}
+
+/// The types in the schema as a valid TypeQL define query string.
+///
+/// @param database The Database to get the type schema from.
+/// @param consistency_level The consistency level to use for the operation. Strongest possible if null.
+#[no_mangle]
+pub extern "C" fn database_type_schema(
+ database: *const Database,
+ consistency_level: *const ConsistencyLevel,
+) -> *mut c_char {
+ let database = borrow(database);
+ let result = match native_consistency_level(consistency_level) {
+ Some(consistency_level) => database.type_schema_with_consistency(consistency_level),
+ None => database.type_schema(),
+ };
+ try_release_string(result)
+}
+
+/// Export a database into a schema definition and a data files saved to the disk.
+/// This is a blocking operation and may take a significant amount of time depending on the database size.
+///
+/// @param database The Database object to export from.
+/// @param schema_file The path to the schema definition file to be created.
+/// @param data_file The path to the data file to be created.
+/// @param consistency_level The consistency level to use for the operation. Strongest possible if null.
+#[no_mangle]
+pub extern "C" fn database_export_to_file(
+ database: *const Database,
+ schema_file: *const c_char,
+ data_file: *const c_char,
+ consistency_level: *const ConsistencyLevel,
+) {
+ let database = borrow(database);
+ let schema_file_path = Path::new(string_view(schema_file));
+ let data_file_path = Path::new(string_view(data_file));
+ let result = match native_consistency_level(consistency_level) {
+ Some(consistency_level) => {
+ database.export_to_file_with_consistency(schema_file_path, data_file_path, consistency_level)
+ }
+ None => database.export_to_file(schema_file_path, data_file_path),
+ };
+ unwrap_void(result)
+}
diff --git a/c/src/database_manager.rs b/c/src/database/database_manager.rs
similarity index 50%
rename from c/src/database_manager.rs
rename to c/src/database/database_manager.rs
index 3345bb5971..aeed17a434 100644
--- a/c/src/database_manager.rs
+++ b/c/src/database/database_manager.rs
@@ -21,12 +21,14 @@ use std::{ffi::c_char, path::Path, ptr::addr_of_mut, sync::Arc};
use typedb_driver::{box_stream, Database, TypeDBDriver};
-use super::{
- error::{try_release, unwrap_or_default, unwrap_void},
- iterator::CIterator,
- memory::{borrow_mut, free, string_view},
+use crate::{
+ common::{
+ error::{try_release, try_release_arc, unwrap_or_default, unwrap_void},
+ iterator::{iterator_arc_next, CIterator},
+ memory::{borrow_mut, free, string_view},
+ },
+ server::consistency_level::{native_consistency_level, ConsistencyLevel},
};
-use crate::{error::try_release_arc, iterator::iterator_arc_next};
/// An Iterator over databases present on the TypeDB server.
pub struct DatabaseIterator(CIteratorDatabaseIterator over all databases present on the TypeDB server.
+///
+/// @param driver The TypeDBDriver object.
+/// @param consistency_level The consistency level to use for the operation. Strongest possible if null.
+#[no_mangle]
+pub extern "C" fn databases_all(
+ driver: *mut TypeDBDriver,
+ consistency_level: *const ConsistencyLevel,
+) -> *mut DatabaseIterator {
+ let databases = borrow_mut(driver).databases();
+ let result = match native_consistency_level(consistency_level) {
+ Some(consistency_level) => databases.all_with_consistency(consistency_level),
+ None => databases.all(),
+ };
+ try_release(result.map(|dbs| DatabaseIterator(CIterator(box_stream(dbs.into_iter())))))
+}
+
+/// Checks if a database with the given name exists.
+///
+/// @param driver The TypeDBDriver object.
+/// @param name The name of the database.
+/// @param consistency_level The consistency level to use for the operation. Strongest possible if null.
+#[no_mangle]
+pub extern "C" fn databases_contains(
+ driver: *mut TypeDBDriver,
+ name: *const c_char,
+ consistency_level: *const ConsistencyLevel,
+) -> bool {
+ let databases = borrow_mut(driver).databases();
+ let name = string_view(name);
+ unwrap_or_default(match native_consistency_level(consistency_level) {
+ Some(consistency_level) => databases.contains_with_consistency(name, consistency_level),
+ None => databases.contains(name),
+ })
+}
+
+/// Retrieves the database with the given name.
+///
+/// @param driver The TypeDBDriver object.
+/// @param name The name of the database.
+/// @param consistency_level The consistency level to use for the operation. Strongest possible if null.
#[no_mangle]
-pub extern "C" fn databases_all(driver: *mut TypeDBDriver) -> *mut DatabaseIterator {
- try_release(
- borrow_mut(driver).databases().all().map(|dbs| DatabaseIterator(CIterator(box_stream(dbs.into_iter())))),
- )
+pub extern "C" fn databases_get(
+ driver: *mut TypeDBDriver,
+ name: *const c_char,
+ consistency_level: *const ConsistencyLevel,
+) -> *const Database {
+ let databases = borrow_mut(driver).databases();
+ let name = string_view(name);
+ try_release_arc(match native_consistency_level(consistency_level) {
+ Some(consistency_level) => databases.get_with_consistency(name, consistency_level),
+ None => databases.get(name),
+ })
}
-/// Create a database with the given name.
+/// Creates a database with the given name.
+///
+/// @param driver The TypeDBDriver object.
+/// @param name The name of the database to be created.
#[no_mangle]
pub extern "C" fn databases_create(driver: *mut TypeDBDriver, name: *const c_char) {
unwrap_void(borrow_mut(driver).databases().create(string_view(name)));
}
-/// Create a database with the given name based on previously exported another database's data
+/// Creates a database with the given name based on previously exported another database's data
/// loaded from a file.
/// This is a blocking operation and may take a significant amount of time depending on the database
/// size.
@@ -77,15 +129,3 @@ pub extern "C" fn databases_import_from_file(
let data_file_path = Path::new(string_view(data_file));
unwrap_void(borrow_mut(driver).databases().import_from_file(string_view(name), string_view(schema), data_file_path))
}
-
-/// Checks if a database with the given name exists.
-#[no_mangle]
-pub extern "C" fn databases_contains(driver: *mut TypeDBDriver, name: *const c_char) -> bool {
- unwrap_or_default(borrow_mut(driver).databases().contains(string_view(name)))
-}
-
-/// Retrieve the database with the given name.
-#[no_mangle]
-pub extern "C" fn databases_get(driver: *mut TypeDBDriver, name: *const c_char) -> *const Database {
- try_release_arc(borrow_mut(driver).databases().get(string_view(name)))
-}
diff --git a/c/src/database/mod.rs b/c/src/database/mod.rs
new file mode 100644
index 0000000000..4194e83962
--- /dev/null
+++ b/c/src/database/mod.rs
@@ -0,0 +1,21 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+pub(crate) mod database;
+pub(crate) mod database_manager;
diff --git a/c/src/driver.rs b/c/src/driver.rs
new file mode 100644
index 0000000000..045e387b59
--- /dev/null
+++ b/c/src/driver.rs
@@ -0,0 +1,258 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use std::ffi::c_char;
+
+use typedb_driver::{box_stream, Addresses, Credentials, DriverOptions, ServerReplica, TypeDBDriver};
+
+use crate::{
+ common::{
+ error::{try_release, unwrap_or_default, unwrap_void},
+ iterator::CIterator,
+ iterators_to_map,
+ memory::{borrow, free, release, release_optional, string_array_view, string_view},
+ },
+ server::{
+ consistency_level::{native_consistency_level, ConsistencyLevel},
+ server_replica::ServerReplicaIterator,
+ server_version::ServerVersion,
+ },
+};
+
+const DRIVER_LANG: &'static str = "c";
+
+/// Open a TypeDB C Driver to a TypeDB server available at the provided address.
+///
+/// @param address The address on which the TypeDB Server is running
+/// @param credentials The Credentials to connect with
+/// @param driver_options The DriverOptions to connect with
+#[no_mangle]
+pub extern "C" fn driver_new(
+ address: *const c_char,
+ credentials: *const Credentials,
+ driver_options: *const DriverOptions,
+) -> *mut TypeDBDriver {
+ try_release(TypeDBDriver::new_with_description(
+ unwrap_or_default(Addresses::try_from_address_str(string_view(address))),
+ borrow(credentials).clone(),
+ borrow(driver_options).clone(),
+ DRIVER_LANG,
+ ))
+}
+
+/// Open a TypeDB Driver to a TypeDB server available at the provided address.
+/// This method allows driver language specification for drivers built on top of the native C layer.
+///
+/// @param address The address on which the TypeDB Server is running
+/// @param credentials The Credentials to connect with
+/// @param driver_options The DriverOptions to connect with
+/// @param driver_lang The language of the driver connecting to the server
+#[no_mangle]
+pub extern "C" fn driver_new_with_description(
+ address: *const c_char,
+ credentials: *const Credentials,
+ driver_options: *const DriverOptions,
+ driver_lang: *const c_char,
+) -> *mut TypeDBDriver {
+ try_release(TypeDBDriver::new_with_description(
+ unwrap_or_default(Addresses::try_from_address_str(string_view(address))),
+ borrow(credentials).clone(),
+ borrow(driver_options).clone(),
+ string_view(driver_lang),
+ ))
+}
+
+/// Open a TypeDB C Driver to a TypeDB cluster available at the provided addresses.
+///
+/// @param addresses A null-terminated array holding the server addresses on for connection
+/// @param credentials The Credentials to connect with
+/// @param driver_options The DriverOptions to connect with
+#[no_mangle]
+pub extern "C" fn driver_new_with_addresses(
+ addresses: *const *const c_char,
+ credentials: *const Credentials,
+ driver_options: *const DriverOptions,
+) -> *mut TypeDBDriver {
+ try_release(TypeDBDriver::new_with_description(
+ unwrap_or_default(Addresses::try_from_addresses_str(string_array_view(addresses))),
+ borrow(credentials).clone(),
+ borrow(driver_options).clone(),
+ DRIVER_LANG,
+ ))
+}
+
+/// Open a TypeDB Driver to a TypeDB cluster available at the provided addresses.
+/// This method allows driver language specification for drivers built on top of the native C layer.
+///
+/// @param addresses A null-terminated array holding the TypeDB cluster replica addresses on for connection
+/// @param credentials The Credentials to connect with
+/// @param driver_options The DriverOptions to connect with
+/// @param driver_lang The language of the driver connecting to the server
+#[no_mangle]
+pub extern "C" fn driver_new_with_addresses_with_description(
+ addresses: *const *const c_char,
+ credentials: *const Credentials,
+ driver_options: *const DriverOptions,
+ driver_lang: *const c_char,
+) -> *mut TypeDBDriver {
+ try_release(TypeDBDriver::new_with_description(
+ unwrap_or_default(Addresses::try_from_addresses_str(string_array_view(addresses))),
+ borrow(credentials).clone(),
+ borrow(driver_options).clone(),
+ string_view(driver_lang),
+ ))
+}
+
+/// Open a TypeDB C Driver to a TypeDB cluster, using the provided address translation.
+///
+/// @param public_addresses A null-terminated array holding the replica addresses on for connection.
+/// @param private_addresses A null-terminated array holding the private replica addresses, configured on the server side.
+/// This array must have the same length as public_addresses.
+/// @param credentials The Credentials to connect with
+/// @param driver_options The DriverOptions to connect with
+#[no_mangle]
+pub extern "C" fn driver_new_with_address_translation(
+ public_addresses: *const *const c_char,
+ private_addresses: *const *const c_char,
+ credentials: *const Credentials,
+ driver_options: *const DriverOptions,
+) -> *mut TypeDBDriver {
+ let addresses = iterators_to_map(string_array_view(public_addresses), string_array_view(private_addresses));
+ try_release(TypeDBDriver::new_with_description(
+ unwrap_or_default(Addresses::try_from_translation_str(addresses)),
+ borrow(credentials).clone(),
+ borrow(driver_options).clone(),
+ DRIVER_LANG,
+ ))
+}
+
+/// Open a TypeDB Driver to a TypeDB cluster, using the provided address translation.
+/// This method allows driver language specification for drivers built on top of the native C layer.
+///
+/// @param public_addresses A null-terminated array holding the replica addresses on for connection.
+/// @param private_addresses A null-terminated array holding the private replica addresses, configured on the server side.
+/// This array must have the same length as public_addresses.
+/// @param credentials The Credentials to connect with
+/// @param driver_options The DriverOptions to connect with
+/// @param driver_lang The language of the driver connecting to the server
+#[no_mangle]
+pub extern "C" fn driver_new_with_address_translation_with_description(
+ public_addresses: *const *const c_char,
+ private_addresses: *const *const c_char,
+ credentials: *const Credentials,
+ driver_options: *const DriverOptions,
+ driver_lang: *const c_char,
+) -> *mut TypeDBDriver {
+ let addresses = iterators_to_map(string_array_view(public_addresses), string_array_view(private_addresses));
+ try_release(TypeDBDriver::new_with_description(
+ unwrap_or_default(Addresses::try_from_translation_str(addresses)),
+ borrow(credentials).clone(),
+ borrow(driver_options).clone(),
+ string_view(driver_lang),
+ ))
+}
+
+/// Closes the TypeDBDriver. Before instantiating a new driver, the driver that’s currently open should first be closed.
+/// Closing a driver frees the underlying Rust object.
+#[no_mangle]
+pub extern "C" fn driver_close(driver: *mut TypeDBDriver) {
+ free(driver);
+}
+
+/// Forcibly closes the TypeDBDriver. To be used in exceptional cases.
+#[no_mangle]
+pub extern "C" fn driver_force_close(driver: *mut TypeDBDriver) {
+ unwrap_void(borrow(driver).force_close());
+}
+
+/// Checks whether this connection is presently open.
+#[no_mangle]
+pub extern "C" fn driver_is_open(driver: *const TypeDBDriver) -> bool {
+ borrow(driver).is_open()
+}
+
+/// Retrieves the server version and distribution information.
+///
+/// @param driver The TypeDBDriver object.
+/// @param consistency_level The consistency level to use for the operation. Strongest possible if null.
+#[no_mangle]
+pub extern "C" fn driver_server_version(
+ driver: *const TypeDBDriver,
+ consistency_level: *const ConsistencyLevel,
+) -> *mut ServerVersion {
+ let driver = borrow(driver);
+ let result = match native_consistency_level(consistency_level) {
+ Some(consistency_level) => driver.server_version_with_consistency(consistency_level),
+ None => driver.server_version(),
+ };
+ release(unwrap_or_default(result.map(|server_version| {
+ ServerVersion::new(server_version.distribution().to_string(), server_version.version().to_string())
+ })))
+}
+
+/// Retrieves the server's replicas.
+#[no_mangle]
+pub extern "C" fn driver_replicas(driver: *const TypeDBDriver) -> *mut ServerReplicaIterator {
+ release(ServerReplicaIterator(CIterator(box_stream(unwrap_or_default(borrow(driver).replicas()).into_iter()))))
+}
+
+/// Retrieves the server's primary replica, if exists.
+#[no_mangle]
+pub extern "C" fn driver_primary_replica(driver: *const TypeDBDriver) -> *mut ServerReplica {
+ release_optional(borrow(driver).primary_replica())
+}
+
+/// Registers a new replica in the cluster the driver is currently connected to. The registered
+/// replica will become available eventually, depending on the behavior of the whole cluster.
+/// To register a replica, its clustering address should be passed, not the connection address.
+///
+/// @param replica_id The numeric identifier of the new replica
+/// @param address The address(es) of the TypeDB replica as a string
+#[no_mangle]
+pub extern "C" fn driver_register_replica(driver: *const TypeDBDriver, replica_id: i64, address: *const c_char) {
+ unwrap_void(borrow(driver).register_replica(replica_id as u64, string_view(address).to_string()))
+}
+
+/// Deregisters a replica from the cluster the driver is currently connected to. This replica
+/// will no longer play a raft role in this cluster.
+///
+/// @param replica_id The numeric identifier of the deregistered replica
+#[no_mangle]
+pub extern "C" fn driver_deregister_replica(driver: *const TypeDBDriver, replica_id: i64) {
+ unwrap_void(borrow(driver).deregister_replica(replica_id as u64))
+}
+
+/// Updates address translation of the driver. This lets you actualize new translation
+/// information without recreating the driver from scratch. Useful after registering new
+/// replicas requiring address translation.
+/// This operation will update existing connections using the provided addresses.
+///
+/// @param public_addresses A null-terminated array holding the replica addresses on for connection.
+/// @param private_addresses A null-terminated array holding the private replica addresses, configured on the server side.
+/// This array must have the same length as public_addresses.
+#[no_mangle]
+pub extern "C" fn driver_update_address_translation(
+ driver: *const TypeDBDriver,
+ public_addresses: *const *const c_char,
+ private_addresses: *const *const c_char,
+) {
+ let translation = iterators_to_map(string_array_view(public_addresses), string_array_view(private_addresses));
+ let addresses = unwrap_or_default(Addresses::try_from_translation_str(translation));
+ unwrap_void(borrow(driver).update_address_translation(addresses))
+}
diff --git a/c/src/driver_options.rs b/c/src/driver_options.rs
new file mode 100644
index 0000000000..6b537a373c
--- /dev/null
+++ b/c/src/driver_options.rs
@@ -0,0 +1,147 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use std::{ffi::c_char, path::Path};
+
+use typedb_driver::DriverOptions;
+
+use crate::common::{
+ error::unwrap_void,
+ memory::{borrow, borrow_mut, borrow_optional, free, release, release_string, string_view},
+};
+
+/// Creates a new DriverOptions for connecting to TypeDB Server.
+#[no_mangle]
+pub extern "C" fn driver_options_new() -> *mut DriverOptions {
+ release(DriverOptions::new())
+}
+
+/// Frees the native rust DriverOptions object.
+#[no_mangle]
+pub extern "C" fn driver_options_drop(driver_options: *mut DriverOptions) {
+ free(driver_options);
+}
+
+/// Explicitly sets whether the connection to TypeDB must be done over TLS.
+/// WARNING: Setting this to false will make the driver sending passwords as plaintext.
+/// Defaults to true.
+#[no_mangle]
+pub extern "C" fn driver_options_set_tls_enabled(options: *mut DriverOptions, tls_enabled: bool) {
+ borrow_mut(options).is_tls_enabled = tls_enabled;
+}
+
+/// Returns the value set for the TLS flag in this DriverOptions object.
+/// Specifies whether the connection to TypeDB must be done over TLS.
+#[no_mangle]
+pub extern "C" fn driver_options_get_tls_enabled(options: *const DriverOptions) -> bool {
+ borrow(options).is_tls_enabled
+}
+
+/// Specifies the root CA used in the TLS config for server certificates authentication.
+/// Uses system roots if None is set.
+#[no_mangle]
+pub extern "C" fn driver_options_set_tls_root_ca_path(options: *mut DriverOptions, tls_root_ca: *const c_char) {
+ let tls_root_ca_path = borrow_optional(tls_root_ca).map(|str| Path::new(string_view(str)));
+ unwrap_void(borrow_mut(options).set_tls_root_ca(tls_root_ca_path))
+}
+
+/// Returns the TLS root CA set in this DriverOptions object.
+/// Specifies the root CA used in the TLS config for server certificates authentication.
+/// Uses system roots if None is set.
+#[no_mangle]
+pub extern "C" fn driver_options_get_tls_root_ca_path(options: *const DriverOptions) -> *mut c_char {
+ release_string(borrow(options).get_tls_root_ca().unwrap().to_string_lossy().to_string())
+}
+
+/// Checks whether TLS root CA was explicitly set for this DriverOptions object.
+#[no_mangle]
+pub extern "C" fn driver_options_has_tls_root_ca_path(options: *const DriverOptions) -> bool {
+ borrow(options).get_tls_root_ca().is_some()
+}
+
+/// Specifies whether the connection to TypeDB can use cluster replicas provided by the server
+/// or it should be limited to a single configured address.
+/// Defaults to true.
+#[no_mangle]
+pub extern "C" fn driver_options_set_use_replication(options: *mut DriverOptions, use_replication: bool) {
+ borrow_mut(options).use_replication = use_replication;
+}
+
+/// Returns the value set for the replication usage flag in this DriverOptions object.
+/// Specifies whether the connection to TypeDB can use cluster replicas provided by the server
+/// or it should be limited to a single configured address.
+#[no_mangle]
+pub extern "C" fn driver_options_get_use_replication(options: *const DriverOptions) -> bool {
+ borrow(options).use_replication
+}
+
+/// Limits the number of attempts to redirect a strongly consistent request to another
+/// primary replica in case of a failure due to the change of replica roles.
+/// Defaults to 1.
+#[no_mangle]
+pub extern "C" fn driver_options_set_primary_failover_retries(
+ options: *mut DriverOptions,
+ primary_failover_retries: i64,
+) {
+ borrow_mut(options).primary_failover_retries = primary_failover_retries as usize;
+}
+
+/// Returns the value set for the primary failover retries limit in this DriverOptions object.
+/// Limits the number of attempts to redirect a strongly consistent request to another
+/// primary replica in case of a failure due to the change of replica roles.
+#[no_mangle]
+pub extern "C" fn driver_options_get_primary_failover_retries(options: *const DriverOptions) -> i64 {
+ borrow(options).primary_failover_retries as i64
+}
+
+/// Limits the number of driver attempts to discover a single working replica to perform an
+/// operation in case of a replica unavailability. Every replica is tested once, which means
+/// that at most:
+/// - {limit} operations are performed if the limit <= the number of replicas.
+/// - {number of replicas} operations are performed if the limit > the number of replicas.
+/// - {number of replicas} operations are performed if the limit is None.
+/// Affects every eventually consistent operation, including redirect failover, when the new
+/// primary replica is unknown. If not set, the maximum (practically unlimited) value is used.
+#[no_mangle]
+pub extern "C" fn driver_options_set_replica_discovery_attempts(
+ options: *mut DriverOptions,
+ replica_discovery_attempts: i64,
+) {
+ borrow_mut(options).replica_discovery_attempts = Some(replica_discovery_attempts as usize);
+}
+
+/// Returns the value set for the replica discovery attempts limit in this DriverOptions object.
+/// Limits the number of driver attempts to discover a single working replica to perform an
+/// operation in case of a replica unavailability. Every replica is tested once, which means
+/// that at most:
+/// - {limit} operations are performed if the limit <= the number of replicas.
+/// - {number of replicas} operations are performed if the limit > the number of replicas.
+/// - {number of replicas} operations are performed if the limit is None.
+/// Affects every eventually consistent operation, including redirect failover, when the new
+/// primary replica is unknown.
+#[no_mangle]
+pub extern "C" fn driver_options_get_replica_discovery_attempts(options: *const DriverOptions) -> i64 {
+ borrow(options).replica_discovery_attempts.unwrap() as i64
+}
+
+/// Checks whether the replica discovery attempts limit was explicitly set for this DriverOptions object.
+#[no_mangle]
+pub extern "C" fn driver_options_has_replica_discovery_attempts(options: *const DriverOptions) -> bool {
+ borrow(options).replica_discovery_attempts.is_some()
+}
diff --git a/c/src/lib.rs b/c/src/lib.rs
index 0978637873..58f8934108 100644
--- a/c/src/lib.rs
+++ b/c/src/lib.rs
@@ -21,15 +21,12 @@ mod analyze;
mod answer;
mod common;
mod concept;
-mod connection;
+mod credentials;
mod database;
-mod database_manager;
-mod error;
-mod iterator;
-mod memory;
-mod promise;
+mod driver;
+mod driver_options;
mod query_options;
+mod server;
mod transaction;
mod transaction_options;
mod user;
-mod user_manager;
diff --git a/c/src/query_options.rs b/c/src/query_options.rs
index 73be282a57..7c5862646c 100644
--- a/c/src/query_options.rs
+++ b/c/src/query_options.rs
@@ -19,7 +19,7 @@
use typedb_driver::QueryOptions;
-use super::memory::{borrow, borrow_mut, free, release};
+use crate::common::memory::{borrow, borrow_mut, free, release};
/// Produces a new QueryOptions object.
#[no_mangle]
@@ -33,7 +33,7 @@ pub extern "C" fn query_options_drop(options: *mut QueryOptions) {
free(options);
}
-/// Explicitly set the "include instance types" flag.
+/// Explicitly setsthe "include instance types" flag.
/// If set, specifies if types should be included in instance structs returned in ConceptRow answers.
/// This option allows reducing the amount of unnecessary data transmitted.
#[no_mangle]
@@ -55,7 +55,7 @@ pub extern "C" fn query_options_has_include_instance_types(options: *const Query
borrow(options).include_instance_types.is_some()
}
-/// Explicitly set the prefetch size.
+/// Explicitly setsthe prefetch size.
/// If set, specifies the number of extra query responses sent before the client side has to re-request more responses.
/// Increasing this may increase performance for queries with a huge number of answers, as it can
/// reduce the number of network round-trips at the cost of more resources on the server side.
diff --git a/c/src/server/consistency_level.rs b/c/src/server/consistency_level.rs
new file mode 100644
index 0000000000..bd4f0ff200
--- /dev/null
+++ b/c/src/server/consistency_level.rs
@@ -0,0 +1,124 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+use std::ffi::c_char;
+
+use typedb_driver::consistency_level::ConsistencyLevel as NativeConsistencyLevel;
+
+use crate::common::{
+ error::unwrap_or_default,
+ memory::{borrow_optional, free, release, release_string, string_free, string_view},
+};
+
+/// ConsistencyLevelTag is used to represent consistency levels in FFI.
+/// It is the tag part, which is combined with optional fields to form an instance of the original
+/// enum.
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub enum ConsistencyLevelTag {
+ Strong,
+ Eventual,
+ ReplicaDependent,
+}
+
+/// ConsistencyLevel is used to represent consistency levels in FFI.
+/// It combines ConsistencyLevelTag and optional fields to form an instance of the
+/// original enum.
+/// address is not null only when tag is ReplicaDependent.
+#[repr(C)]
+#[derive(Debug, Clone)]
+pub struct ConsistencyLevel {
+ pub(crate) tag: ConsistencyLevelTag,
+ pub(crate) address: *mut c_char,
+}
+
+impl ConsistencyLevel {
+ fn new_strong() -> Self {
+ ConsistencyLevel { tag: ConsistencyLevelTag::Strong, address: std::ptr::null_mut() }
+ }
+
+ fn new_eventual() -> Self {
+ ConsistencyLevel { tag: ConsistencyLevelTag::Eventual, address: std::ptr::null_mut() }
+ }
+
+ fn new_replica_dependent(address: *mut c_char) -> Self {
+ ConsistencyLevel { tag: ConsistencyLevelTag::ReplicaDependent, address }
+ }
+}
+
+impl Drop for ConsistencyLevel {
+ fn drop(&mut self) {
+ string_free(self.address);
+ }
+}
+
+/// Creates a strong ConsistencyLevel object.
+#[no_mangle]
+pub extern "C" fn consistency_level_strong() -> *mut ConsistencyLevel {
+ release(ConsistencyLevel::new_strong())
+}
+
+/// Creates an eventual ConsistencyLevel object.
+#[no_mangle]
+pub extern "C" fn consistency_level_eventual() -> *mut ConsistencyLevel {
+ release(ConsistencyLevel::new_eventual())
+}
+
+/// Creates a replica dependent ConsistencyLevel object.
+///
+/// @param address The address of the replica to depend on.
+#[no_mangle]
+pub extern "C" fn consistency_level_replica_dependent(address: *const c_char) -> *mut ConsistencyLevel {
+ release(ConsistencyLevel::new_replica_dependent(release_string(string_view(address.clone()).to_string())))
+}
+
+/// Drops the ConsistencyLevel object.
+#[no_mangle]
+pub extern "C" fn consistency_level_drop(consistency_level: *mut ConsistencyLevel) {
+ free(consistency_level)
+}
+
+pub(crate) fn native_consistency_level(consistency_level: *const ConsistencyLevel) -> OptionServerReplica corresponding to each replica of a TypeDB cluster.
+pub struct ServerReplicaIterator(pub(crate) CIteratorServerReplicaIterator and returns the next ServerReplica if it exists,
+/// or null if there are no more elements.
+#[no_mangle]
+pub extern "C" fn server_replica_iterator_next(it: *mut ServerReplicaIterator) -> *mut ServerReplica {
+ unsafe { iterator_next(addr_of_mut!((*it).0)) }
+}
+
+/// Frees the native rust ServerReplicaIterator object.
+#[no_mangle]
+pub extern "C" fn server_replica_iterator_drop(it: *mut ServerReplicaIterator) {
+ free(it);
+}
+
+/// Frees the native rust ServerReplica object.
+#[no_mangle]
+pub extern "C" fn server_replica_drop(replica_info: *mut ServerReplica) {
+ free(replica_info);
+}
+
+/// Returns the id of this replica.
+#[no_mangle]
+pub extern "C" fn server_replica_get_id(replica_info: *const ServerReplica) -> i64 {
+ borrow(replica_info).id() as i64
+}
+
+/// Returns the address this replica is hosted at.
+#[no_mangle]
+pub extern "C" fn server_replica_get_address(replica_info: *const ServerReplica) -> *mut c_char {
+ release_string(borrow(replica_info).address().to_string())
+}
+
+/// Returns whether this is the primary replica of the raft cluster or any of the supporting types.
+#[no_mangle]
+pub extern "C" fn server_replica_get_type(replica_info: *const ServerReplica) -> ReplicaRole {
+ borrow(replica_info).role().unwrap() // TODO: Return optional!
+}
+
+/// Checks whether this is the primary replica of the raft cluster.
+#[no_mangle]
+pub extern "C" fn server_replica_is_primary(replica_info: *const ServerReplica) -> bool {
+ borrow(replica_info).is_primary()
+}
+
+/// Returns the raft protocol ‘term’ of this replica.
+#[no_mangle]
+pub extern "C" fn server_replica_get_term(replica_info: *const ServerReplica) -> i64 {
+ borrow(replica_info).term().unwrap() as i64 // TODO: Return optional!
+}
diff --git a/c/src/server/server_version.rs b/c/src/server/server_version.rs
new file mode 100644
index 0000000000..4509be51a2
--- /dev/null
+++ b/c/src/server/server_version.rs
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use std::{ffi::c_char, ptr::null_mut};
+
+use crate::common::memory::{free, release_string, string_free};
+
+/// ServerVersion is an FFI representation of a full server's version specification.
+#[repr(C)]
+#[derive(Debug)]
+pub struct ServerVersion {
+ distribution: *mut c_char,
+ version: *mut c_char,
+}
+
+impl ServerVersion {
+ pub fn new(distribution: String, version: String) -> Self {
+ Self { distribution: release_string(distribution), version: release_string(version) }
+ }
+}
+
+impl Default for ServerVersion {
+ fn default() -> Self {
+ Self { distribution: null_mut(), version: null_mut() }
+ }
+}
+
+impl Drop for ServerVersion {
+ fn drop(&mut self) {
+ string_free(self.distribution);
+ string_free(self.version);
+ }
+}
+
+/// Frees the native rust ServerVersion object
+#[no_mangle]
+pub extern "C" fn server_version_drop(server_version: *mut ServerVersion) {
+ free(server_version);
+}
diff --git a/c/src/transaction.rs b/c/src/transaction.rs
index 17601a1332..986acf7f6d 100644
--- a/c/src/transaction.rs
+++ b/c/src/transaction.rs
@@ -21,10 +21,14 @@ use std::{ffi::c_char, ptr::null_mut};
use typedb_driver::{Error, QueryOptions, Transaction, TransactionOptions, TransactionType, TypeDBDriver};
-use super::memory::{borrow, borrow_mut, free, release, take_ownership};
use crate::{
- analyze::AnalyzedQueryPromise, answer::QueryAnswerPromise, error::try_release, memory::string_view,
- promise::VoidPromise,
+ analyze::AnalyzedQueryPromise,
+ answer::QueryAnswerPromise,
+ common::{
+ error::try_release,
+ memory::{borrow, borrow_mut, free, release, string_view, take_ownership},
+ promise::VoidPromise,
+ },
};
/// Opens a transaction to perform read or write queries on the database connected to the session.
@@ -40,7 +44,7 @@ pub extern "C" fn transaction_new(
type_: TransactionType,
options: *const TransactionOptions,
) -> *mut Transaction {
- try_release(borrow(driver).transaction_with_options(string_view(database_name), type_, *borrow(options)))
+ try_release(borrow(driver).transaction_with_options(string_view(database_name), type_, borrow(options).clone()))
}
/// Performs a TypeQL query in the transaction.
diff --git a/c/src/transaction_options.rs b/c/src/transaction_options.rs
index af2c3797ee..48aa761e34 100644
--- a/c/src/transaction_options.rs
+++ b/c/src/transaction_options.rs
@@ -21,7 +21,10 @@ use std::time::Duration;
use typedb_driver::TransactionOptions;
-use super::memory::{borrow, borrow_mut, free, release};
+use crate::{
+ common::memory::{borrow, borrow_mut, free, release},
+ server::consistency_level::{native_consistency_level, ConsistencyLevel},
+};
/// Produces a new TransactionOptions object.
#[no_mangle]
@@ -35,7 +38,7 @@ pub extern "C" fn transaction_options_drop(options: *mut TransactionOptions) {
free(options);
}
-/// Explicitly set a transaction timeout.
+/// Explicitly sets a transaction timeout.
/// If set, specifies a timeout for killing transactions automatically, preventing memory leaks in unclosed transactions.
#[no_mangle]
pub extern "C" fn transaction_options_set_transaction_timeout_millis(
@@ -84,3 +87,34 @@ pub extern "C" fn transaction_options_has_schema_lock_acquire_timeout_millis(
) -> bool {
borrow(options).schema_lock_acquire_timeout.is_some()
}
+
+/// Explicitly sets read consistency level.
+/// If set, specifies the requested consistency level of the transaction opening operation.
+/// Affects only read transactions, as write and schema transactions require primary replicas.
+#[no_mangle]
+pub extern "C" fn transaction_options_set_read_consistency_level(
+ options: *mut TransactionOptions,
+ read_consistency_level: *const ConsistencyLevel,
+) {
+ // TODO: This is a hacky feature - you can unset the read consistency level if you pass a nullptr.
+ // We should decide what is the general approach if we want to unset an option: whether we also
+ // introduce "unset" (a little irritating to maintain) or we consider that the user just creates
+ // another object of options. We hardly want to crash here if it's a nullptr.
+ borrow_mut(options).read_consistency_level = native_consistency_level(read_consistency_level);
+}
+
+/// Returns the value set for the read consistency level in this TransactionOptions object.
+/// If set, specifies the requested consistency level of the transaction opening operation.
+/// Affects only read transactions, as write and schema transactions require primary replicas.
+#[no_mangle]
+pub extern "C" fn transaction_options_get_read_consistency_level(
+ options: *const TransactionOptions,
+) -> *mut ConsistencyLevel {
+ release(ConsistencyLevel::from(borrow(options).read_consistency_level.clone().unwrap()))
+}
+
+/// Checks whether the option for read consistency level was explicitly set for this TransactionOptions object.
+#[no_mangle]
+pub extern "C" fn transaction_options_has_read_consistency_level(options: *const TransactionOptions) -> bool {
+ borrow(options).read_consistency_level.is_some()
+}
diff --git a/c/src/user/mod.rs b/c/src/user/mod.rs
new file mode 100644
index 0000000000..3d2fb9f230
--- /dev/null
+++ b/c/src/user/mod.rs
@@ -0,0 +1,21 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+pub(crate) mod user;
+pub(crate) mod user_manager;
diff --git a/c/src/user.rs b/c/src/user/user.rs
similarity index 80%
rename from c/src/user.rs
rename to c/src/user/user.rs
index 15a3e5c2d4..684bcda406 100644
--- a/c/src/user.rs
+++ b/c/src/user/user.rs
@@ -21,11 +21,13 @@ use std::ffi::c_char;
use typedb_driver::User;
-use super::{
- error::unwrap_void,
- memory::{borrow, free, release_string, string_view},
+use crate::{
+ common::{
+ error::unwrap_void,
+ memory::{borrow, free, release_string, string_view, take_ownership},
+ },
+ memory::take_ownership,
};
-use crate::memory::take_ownership;
/// Frees the native rust User object.
#[no_mangle]
@@ -36,15 +38,9 @@ pub extern "C" fn user_drop(user: *mut User) {
/// Returns the name of this user.
#[no_mangle]
pub extern "C" fn user_get_name(user: *mut User) -> *mut c_char {
- release_string(borrow(user).name.clone())
+ release_string(borrow(user).name().to_string())
}
-// /// Returns the number of seconds remaining till this user’s current password expires.
-// #[no_mangle]
-// pub extern "C" fn user_get_password_expiry_seconds(user: *mut User) -> i64 {
-// borrow(user).password_expiry_seconds.unwrap_or(-1)
-// }
-
/// Updates the password for the current authenticated user.
///
/// @param user The user to update the password of - must be the current user.
diff --git a/c/src/user/user_manager.rs b/c/src/user/user_manager.rs
new file mode 100644
index 0000000000..987213ba85
--- /dev/null
+++ b/c/src/user/user_manager.rs
@@ -0,0 +1,129 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+use std::{ffi::c_char, ptr::addr_of_mut};
+
+use typedb_driver::{box_stream, TypeDBDriver, User};
+
+use crate::{
+ common::{
+ error::{try_release, try_release_optional, unwrap_or_default, unwrap_void},
+ iterator::{iterator_next, CIterator},
+ memory::{borrow, free, string_view},
+ },
+ server::consistency_level::{native_consistency_level, ConsistencyLevel},
+};
+
+/// Iterator over a set of Users.
+pub struct UserIterator(CIteratorUserIterator and returns the next User if it exists,
+/// or null if there are no more elements.
+#[no_mangle]
+pub extern "C" fn user_iterator_next(it: *mut UserIterator) -> *mut User {
+ unsafe { iterator_next(addr_of_mut!((*it).0)) }
+}
+
+/// Frees the native rust UserIterator object.
+#[no_mangle]
+pub extern "C" fn user_iterator_drop(it: *mut UserIterator) {
+ free(it);
+}
+
+/// Retrieves all users which exist on the TypeDB server.
+///
+/// @param driver The TypeDBDriver object.
+/// @param consistency_level The consistency level to use for the operation. Strongest possible if null.
+#[no_mangle]
+pub extern "C" fn users_all(
+ driver: *const TypeDBDriver,
+ consistency_level: *const ConsistencyLevel,
+) -> *mut UserIterator {
+ let users = borrow(driver).users();
+ let result = match native_consistency_level(consistency_level) {
+ Some(consistency_level) => users.all_with_consistency(consistency_level),
+ None => users.all(),
+ };
+ try_release(result.map(|users| UserIterator(CIterator(box_stream(users.into_iter())))))
+}
+
+/// Checks if a user with the given name exists.
+///
+/// @param driver The TypeDBDriver object.
+/// @param username The username of the user.
+/// @param consistency_level The consistency level to use for the operation. Strongest possible if null.
+#[no_mangle]
+pub extern "C" fn users_contains(
+ driver: *const TypeDBDriver,
+ username: *const c_char,
+ consistency_level: *const ConsistencyLevel,
+) -> bool {
+ let users = borrow(driver).users();
+ let username = string_view(username);
+ unwrap_or_default(match native_consistency_level(consistency_level) {
+ Some(consistency_level) => users.contains_with_consistency(username, consistency_level),
+ None => users.contains(username),
+ })
+}
+
+/// Retrieves a user with the given name.
+///
+/// @param driver The TypeDBDriver object.
+/// @param username The username of the user.
+/// @param consistency_level The consistency level to use for the operation. Strongest possible if null.
+#[no_mangle]
+pub extern "C" fn users_get(
+ driver: *const TypeDBDriver,
+ username: *const c_char,
+ consistency_level: *const ConsistencyLevel,
+) -> *mut User {
+ let users = borrow(driver).users();
+ let username = string_view(username);
+ let result = match native_consistency_level(consistency_level) {
+ Some(consistency_level) => users.get_with_consistency(username, consistency_level),
+ None => users.get(username),
+ };
+ try_release_optional(result.transpose())
+}
+
+/// Retrieves the username of the user who opened this connection.
+///
+/// @param driver The TypeDBDriver object.
+/// @param consistency_level The consistency level to use for the operation. Strongest possible if null.
+#[no_mangle]
+pub extern "C" fn users_get_current(
+ driver: *const TypeDBDriver,
+ consistency_level: *const ConsistencyLevel,
+) -> *mut User {
+ let users = borrow(driver).users();
+ let result = match native_consistency_level(consistency_level) {
+ Some(consistency_level) => users.get_current_with_consistency(consistency_level),
+ None => users.get_current(),
+ };
+ try_release_optional(result.transpose())
+}
+
+/// Creates a user with the given name & password.
+///
+/// @param username The username of the user to be created.
+/// @param consistency_level The consistency level to use for the operation. Strongest possible if null.
+#[no_mangle]
+pub extern "C" fn users_create(driver: *const TypeDBDriver, username: *const c_char, password: *const c_char) {
+ unwrap_void(borrow(driver).users().create(string_view(username), string_view(password)));
+}
diff --git a/c/swig/typedb_driver_java.swg b/c/swig/typedb_driver_java.swg
index b4c0a73fc6..e08e2845fd 100644
--- a/c/swig/typedb_driver_java.swg
+++ b/c/swig/typedb_driver_java.swg
@@ -88,9 +88,9 @@
%nojavaexception transaction_options_get_schema_lock_acquire_timeout_millis;
%nojavaexception transaction_options_set_schema_lock_acquire_timeout_millis;
%nojavaexception transaction_options_has_schema_lock_acquire_timeout_millis;
-%nojavaexception transaction_options_get_parallel;
-%nojavaexception transaction_options_set_parallel;
-%nojavaexception transaction_options_has_parallel;
+%nojavaexception transaction_options_get_read_consistency_level;
+%nojavaexception transaction_options_set_read_consistency_level;
+%nojavaexception transaction_options_has_read_consistency_level;
%nojavaexception query_options_new;
%nojavaexception query_options_get_include_instance_types;
@@ -107,21 +107,39 @@
%nojavaexception error_message;
%nojavaexception driver_is_open;
+// TODO: Remove from this list if we start making network calls to retrieve this
+%nojavaexception driver_primary_replica;
+
+%nojavaexception driver_options_new;
+%nojavaexception driver_options_set_tls_enabled;
+%nojavaexception driver_options_get_tls_enabled;
+%nojavaexception driver_options_set_tls_root_ca_path;
+%nojavaexception driver_options_get_tls_root_ca_path;
+%nojavaexception driver_options_has_tls_root_ca_path;
+%nojavaexception driver_options_set_use_replication;
+%nojavaexception driver_options_get_use_replication;
+%nojavaexception driver_options_set_primary_failover_retries;
+%nojavaexception driver_options_get_primary_failover_retries;
+%nojavaexception driver_options_set_replica_discovery_attempts;
+%nojavaexception driver_options_get_replica_discovery_attempts;
+%nojavaexception driver_options_has_replica_discovery_attempts;
%nojavaexception transaction_is_open;
%nojavaexception user_get_name;
%nojavaexception user_get_password_expiry_seconds;
-//%nojavaexception replica_info_get_server;
-//%nojavaexception replica_info_is_primary;
-//%nojavaexception replica_info_is_preferred;
-//%nojavaexception replica_info_get_term;
+%nojavaexception server_replica_get_address;
+%nojavaexception server_replica_is_primary;
+%nojavaexception server_replica_get_id;
+%nojavaexception server_replica_get_type;
+%nojavaexception server_replica_get_term;
%nojavaexception database_get_name;
-//%nojavaexception database_get_replicas_info;
-//%nojavaexception database_get_primary_replica_info;
-//%nojavaexception database_get_preferred_replica_info;
+
+%nojavaexception consistency_level_strong;
+%nojavaexception consistency_level_eventual;
+%nojavaexception consistency_level_replica_dependent;
%nojavaexception concept_is_entity;
%nojavaexception concept_is_relation;
@@ -191,6 +209,9 @@
%nojavaexception query_answer_is_concept_row_stream;
%nojavaexception query_answer_is_concept_document_stream;
+%nojavaexception ServerVersion::distribution;
+%nojavaexception ServerVersion::version;
+
%nojavaexception StringPair::_0;
%nojavaexception StringPair::_1;
@@ -212,6 +233,9 @@
%nojavaexception Duration::days;
%nojavaexception Duration::nanos;
+%nojavaexception ConsistencyLevel::tag;
+%nojavaexception ConsistencyLevel::address;
+
/* director constructors do not throw */
%nojavaexception TransactionCallbackDirector;
@@ -330,6 +354,7 @@
%nojavaexception ~ConceptIterator;
%nojavaexception ~ConceptRow;
%nojavaexception ~ConceptRowIterator;
+%nojavaexception ~ConsistencyLevel;
%nojavaexception ~DriverOptions;
%nojavaexception ~Credentials;
%nojavaexception ~Database;
@@ -339,7 +364,9 @@
%nojavaexception ~Decimal;
%nojavaexception ~Duration;
%nojavaexception ~Error;
-//%nojavaexception ~ReplicaInfo;
+%nojavaexception ~ServerReplica;
+%nojavaexception ~ServerReplicaIterator;
+%nojavaexception ~ServerVersion;
%nojavaexception ~StringIterator;
%nojavaexception ~StringAndOptValue;
%nojavaexception ~StringAndOptValueIterator;
@@ -527,7 +554,7 @@
%iterator(StringAndOptValue, string_and_opt_value)
%iterator(User, user)
%iterator(Database, database)
-//%iterator(ReplicaInfo, replica_info)
+%iterator(ServerReplica, server_replica)
%iterator(ConjunctionID, conjunction_id)
%iterator(ConstraintWithSpan, constraint_with_span)
diff --git a/c/tests/integration/driver_test.c b/c/tests/integration/driver_test.c
new file mode 100644
index 0000000000..f12e963d78
--- /dev/null
+++ b/c/tests/integration/driver_test.c
@@ -0,0 +1,439 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include + * TypeDB.driver(address); + *+ * + * @param addresses The addresses of TypeDB cluster replicas for connection + * @param credentials The credentials to connect with + * @param driverOptions The driver connection options to connect with + */ + public static Driver driver(Set
+ * TypeDB.driver(addresses); + *+ * + * @param addressTranslation The translation of public TypeDB cluster replica addresses (keys) to server-side private addresses (values) + * @param credentials The credentials to connect with + * @param driverOptions The driver connection options to connect with + */ + public static Driver driver(Map
+ * driver.serverVersion(); + *+ */ + @CheckReturnValue + default ServerVersion serverVersion() { + return serverVersion(null); + } + + /** + * Retrieves the server's version. + * + *
+ * driver.serverVersion(); + *+ * + * @param consistencyLevel The consistency level to use for the operation + */ + @CheckReturnValue + ServerVersion serverVersion(ConsistencyLevel consistencyLevel); + /** * The
DatabaseManager for this connection, providing access to database management methods.
+ *
+ * + * driver.databases(); + **/ @CheckReturnValue DatabaseManager databases(); + /** + * The
UserManager for this connection, providing access to user management methods.
+ *
+ * + * driver.users(); + *+ */ + @CheckReturnValue + UserManager users(); + /** * Opens a communication tunnel (transaction) to the given database on the running TypeDB server. * @@ -75,23 +123,77 @@ public interface Driver extends AutoCloseable { Transaction transaction(String database, Transaction.Type type, TransactionOptions options); /** - * Closes the driver. Before instantiating a new driver, the driver that’s currently open should first be closed. + * Set of
Replica instances for this driver connection.
*
*
- * driver.close()
+ * driver.replicas();
*
*/
- void close();
+ @CheckReturnValue
+ Set replicas();
/**
- * The UserManager instance for this connection, providing access to user management methods.
+ * Returns the primary replica for this driver connection.
*
*
- * driver.users();
+ * driver.primaryReplica();
*
*/
@CheckReturnValue
- UserManager users();
+ Optional primaryReplica();
+
+ /**
+ * Registers a new replica in the cluster the driver is currently connected to. The registered
+ * replica will become available eventually, depending on the behavior of the whole cluster.
+ * To register a replica, its clustering address should be passed, not the connection address.
+ *
+ * + * driver.registerReplica(2, "127.0.0.1:11729"); + *+ * + * @param replicaID The numeric identifier of the new replica + * @param address The address(es) of the TypeDB replica as a string + */ + void registerReplica(long replicaID, String address); + + /** + * Deregisters a replica from the cluster the driver is currently connected to. This replica + * will no longer play a raft role in this cluster. + * + *
+ * driver.deregisterReplica(2); + *+ * + * @param replicaID The numeric identifier of the deregistered replica + */ + void deregisterReplica(long replicaID); + + /** + * Updates address translation of the driver. This lets you actualize new translation + * information without recreating the driver from scratch. Useful after registering new + * replicas requiring address translation. + * This operation will update existing connections using the provided addresses. + * + *
+ * driver.updateAddressTranslation(2); + *+ * + * @param addressTranslation The translation of public TypeDB cluster replica addresses (keys) to server-side private addresses (values) + */ + void updateAddressTranslation(Map
+ * driver.close(); + *+ */ + void close(); } diff --git a/java/api/DriverOptions.java b/java/api/DriverOptions.java index f14e42ff9c..dbd2acb2e4 100644 --- a/java/api/DriverOptions.java +++ b/java/api/DriverOptions.java @@ -20,34 +20,211 @@ package com.typedb.driver.api; import com.typedb.driver.common.NativeObject; -import com.typedb.driver.common.exception.TypeDBDriverException; +import com.typedb.driver.common.Validator; -import javax.annotation.Nullable; +import javax.annotation.CheckReturnValue; +import java.util.Optional; +import static com.typedb.driver.jni.typedb_driver.driver_options_get_tls_enabled; +import static com.typedb.driver.jni.typedb_driver.driver_options_get_primary_failover_retries; +import static com.typedb.driver.jni.typedb_driver.driver_options_get_replica_discovery_attempts; +import static com.typedb.driver.jni.typedb_driver.driver_options_get_tls_root_ca_path; +import static com.typedb.driver.jni.typedb_driver.driver_options_get_use_replication; +import static com.typedb.driver.jni.typedb_driver.driver_options_has_replica_discovery_attempts; +import static com.typedb.driver.jni.typedb_driver.driver_options_has_tls_root_ca_path; import static com.typedb.driver.jni.typedb_driver.driver_options_new; +import static com.typedb.driver.jni.typedb_driver.driver_options_set_tls_enabled; +import static com.typedb.driver.jni.typedb_driver.driver_options_set_primary_failover_retries; +import static com.typedb.driver.jni.typedb_driver.driver_options_set_replica_discovery_attempts; +import static com.typedb.driver.jni.typedb_driver.driver_options_set_tls_root_ca_path; +import static com.typedb.driver.jni.typedb_driver.driver_options_set_use_replication; /** - * User connection settings (TLS encryption, etc.) for connecting to TypeDB Server. - * - *
- * DriverOptions driverOptions = new DriverOptions(true, Path.of("path/to/ca-certificate.pem"));
- *
+ * TypeDB driver options. DriverOptions are used to specify the driver's connection behavior.
*/
public class DriverOptions extends NativeObjectDriverOptions object.
+ *
+ * + * DriverOptions options = DriverOptions(); + *+ */ + public DriverOptions() { + super(driver_options_new()); + } + + /** + * Returns the value set for the TLS flag in this
DriverOptions object.
+ * Specifies whether the connection to TypeDB must be done over TLS.
+ *
+ * + * options.tlsEnabled(); + *+ */ + @CheckReturnValue + public Boolean tlsEnabled() { + return driver_options_get_tls_enabled(nativeObject); + } + + /** + * Explicitly sets whether the connection to TypeDB must be done over TLS. + * WARNING: Setting this to false will make the driver sending passwords as plaintext. Defaults to true. + * + *
+ * options.tlsEnabled(true); + *+ * + * @param tlsEnabled Whether the connection to TypeDB must be done over TLS. + */ + public DriverOptions tlsEnabled(boolean tlsEnabled) { + driver_options_set_tls_enabled(nativeObject, tlsEnabled); + return this; + } + + /** + * Returns the TLS root CA set in this
DriverOptions object.
+ * Specifies the root CA used in the TLS config for server certificates authentication.
+ * Uses system roots if None is set.
+ *
+ * + * options.tlsRootCAPath(); + *+ */ + @CheckReturnValue + public Optional
DriverOptions object.
+ * Specifies the root CA used in the TLS config for server certificates authentication.
+ * Uses system roots if None is set.
+ *
+ *
+ * options.tlsRootCAPath(Optional.of("/path/to/ca-certificate.pem"));
+ *
+ *
+ * @param tlsRootCAPath The path to the TLS root CA. If None, system roots are used.
*/
- public DriverOptions(boolean isTlsEnabled, String tlsRootCAPath) { // TODO: Maybe OptionalDriverOptions object.
+ * Specifies whether the connection to TypeDB can use cluster replicas provided by the server
+ * or it should be limited to a single configured address.
+ *
+ * + * options.useReplication(); + *+ */ + @CheckReturnValue + public Boolean useReplication() { + return driver_options_get_use_replication(nativeObject); + } + + /** + * Explicitly sets whether the connection to TypeDB can use cluster replicas provided by the server + * or it should be limited to a single configured address. Defaults to true. + * + *
+ * options.useReplication(true); + *+ * + * @param useReplication Whether the connection to TypeDB can use replication. + */ + public DriverOptions useReplication(boolean useReplication) { + driver_options_set_use_replication(nativeObject, useReplication); + return this; + } + + /** + * Returns the value set for the primary failover retries limit in this
DriverOptions object.
+ * Limits the number of attempts to redirect a strongly consistent request to another
+ * primary replica in case of a failure due to the change of replica roles.
+ *
+ * + * options.primaryFailoverRetries(); + *+ */ + @CheckReturnValue + public Integer primaryFailoverRetries() { + return (int) driver_options_get_primary_failover_retries(nativeObject); + } + + /** + * Explicitly sets the limit on the number of attempts to redirect a strongly consistent request to another + * primary replica in case of a failure due to the change of replica roles. Defaults to 1. + * + *
+ * options.primaryFailoverRetries(1); + *+ * + * @param primaryFailoverRetries The limit of primary failover retries. + */ + public DriverOptions primaryFailoverRetries(int primaryFailoverRetries) { + Validator.requireNonNegative(primaryFailoverRetries, "primaryFailoverRetries"); + driver_options_set_primary_failover_retries(nativeObject, primaryFailoverRetries); + return this; + } + + /** + * Returns the value set for the replica discovery attempts limit in this
DriverOptions object.
+ * Limits the number of driver attempts to discover a single working replica to perform an
+ * operation in case of a replica unavailability. Every replica is tested once, which means
+ * that at most:
+ * - {limit} operations are performed if the limit <= the number of replicas.
+ * - {number of replicas} operations are performed if the limit > the number of replicas.
+ * - {number of replicas} operations are performed if the limit is None.
+ * Affects every eventually consistent operation, including redirect failover, when the new
+ * primary replica is unknown.
+ *
+ * + * options.replicaDiscoveryAttempts(); + *+ */ + @CheckReturnValue + public Optional
+ * options.primaryFailoverRetries(1); + *+ * + * @param replicaDiscoveryAttempts The limit of replica discovery attempts. + */ + public DriverOptions replicaDiscoveryAttempts(int replicaDiscoveryAttempts) { + Validator.requireNonNegative(replicaDiscoveryAttempts, "replicaDiscoveryAttempts"); + driver_options_set_replica_discovery_attempts(nativeObject, replicaDiscoveryAttempts); + return this; } } diff --git a/java/api/QueryOptions.java b/java/api/QueryOptions.java index 65e7b63967..c9c4138320 100644 --- a/java/api/QueryOptions.java +++ b/java/api/QueryOptions.java @@ -72,7 +72,7 @@ public Optional
TransactionOptions object can be used to override
* the default server behaviour for opened transactions.
@@ -68,7 +70,7 @@ public OptionalTransactionOptions object.
+ * If set, specifies the requested consistency level of the transaction opening operation.
+ * Affects only read transactions, as write and schema transactions require primary replicas.
+ *
+ * + * options.readConsistencyLevel(); + *+ */ + public Optional
+ * options.schemaLockAcquireTimeoutMillis(schemaLockAcquireTimeoutMillis); + *+ * + * @param readConsistencyLevel The requested consistency level + */ + public TransactionOptions readConsistencyLevel(ConsistencyLevel readConsistencyLevel) { + transaction_options_set_read_consistency_level(nativeObject, readConsistencyLevel.nativeValue()); + return this; + } } diff --git a/java/api/answer/ConceptRow.java b/java/api/answer/ConceptRow.java index a137937a40..e2f84fcf01 100644 --- a/java/api/answer/ConceptRow.java +++ b/java/api/answer/ConceptRow.java @@ -78,7 +78,7 @@ public interface ConceptRow { * conceptRow.get(columnName); * * - * @param columnName the variable (column name from ``column_names``) + * @param columnName the variable (column name from
column_names)
*/
@CheckReturnValue
Optional