Drivers in clustered TypeDB

from typedb.driver import (
    TypeDB, Credentials, DriverOptions, DriverTlsConfig,
    TransactionType, ServerRouting
)

DATABASE_NAME = "clustered-test"

def test_clustered_typedb():
    driver = TypeDB.driver(
        # Try automatic replica discovery by connecting to only a single server!
        # Use a list of addresses to provide multiple addresses instead.
        ADDRESS,
        Credentials(USERNAME, PASSWORD),
        DriverOptions(DriverTlsConfig.enabled_with_native_root_ca()),
    )

    servers = driver.servers()
    addresses = [server.address for server in servers]
    print(f"Servers known to the driver: {addresses}")

    primary = driver.primary_server()
    if primary is not None:
        print(f"Primary server: {primary.address}")

    version = driver.server_version()
    print(f"Server version: {version.distribution} {version.version}")

    if not driver.databases.contains(DATABASE_NAME):
        driver.databases.create(DATABASE_NAME)

    database = driver.databases.get(DATABASE_NAME)
    print(f"Database exists: {database.name}")

    # Schema transactions are always routed to the primary
    with driver.transaction(DATABASE_NAME, TransactionType.SCHEMA) as tx:
        tx.query("define entity person;").resolve()
        tx.commit()

    with driver.transaction(DATABASE_NAME, TransactionType.WRITE) as tx:
        tx.query("insert $p1 isa person; $p2 isa person;").resolve()
        tx.commit()

    # Read transactions are routed automatically
    with driver.transaction(DATABASE_NAME, TransactionType.READ) as tx:
        answer = tx.query("match $p isa person;").resolve()
        rows = list(answer.as_concept_rows())
        print(f"Persons found: {len(rows)}")

    driver.close()
    print("Done!")


if __name__ == "__main__":
    test_clustered_typedb()

import com.typedb.driver.TypeDB;
import com.typedb.driver.api.Credentials;
import com.typedb.driver.api.Driver;
import com.typedb.driver.api.DriverOptions;
import com.typedb.driver.api.DriverTlsConfig;
import com.typedb.driver.api.Transaction;
import com.typedb.driver.api.QueryAnswer;
import com.typedb.driver.api.ServerRouting;
import com.typedb.driver.api.answer.ConceptRow;
import com.typedb.driver.api.server.Server;
import com.typedb.driver.api.server.ServerVersion;

import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

public class ClusteredTypeDBExample {
    private static final String DATABASE_NAME = "clustered-test";

    public static void main(String[] args) {
        try (Driver driver = TypeDB.driver(
                // Try automatic replica discovery by connecting to only a single server!
                // Use Set.of() with multiple addresses to provide multiple addresses instead.
                ADDRESS,
                new Credentials(USERNAME, PASSWORD),
                new DriverOptions(DriverTlsConfig.enabledWithNativeRootCA())
        )) {
            Set<? extends Server> servers = driver.servers();
            List<String> addresses = servers.stream()
                    .map(Server::getAddress)
                    .collect(Collectors.toList());
            System.out.println("Servers known to the driver: " + addresses);

            Optional<? extends Server> primary = driver.primaryServer();
            primary.ifPresent(p -> System.out.println("Primary server: " + p.getAddress()));

            ServerVersion version = driver.serverVersion();
            System.out.println("Server version: " + version.getDistribution() + " " + version.getVersion());

            if (!driver.databases().contains(DATABASE_NAME)) {
                driver.databases().create(DATABASE_NAME);
            }

            String databaseName = driver.databases().get(DATABASE_NAME).name();
            System.out.println("Database exists: " + databaseName);

            // Schema transactions are always routed to the primary
            try (Transaction tx = driver.transaction(DATABASE_NAME, Transaction.Type.SCHEMA)) {
                tx.query("define entity person;").resolve();
                tx.commit();
            }

            try (Transaction tx = driver.transaction(DATABASE_NAME, Transaction.Type.WRITE)) {
                tx.query("insert $p1 isa person; $p2 isa person;").resolve();
                tx.commit();
            }

            // Read transactions are routed automatically
            try (Transaction tx = driver.transaction(DATABASE_NAME, Transaction.Type.READ)) {
                QueryAnswer answer = tx.query("match $p isa person;").resolve();
                List<ConceptRow> rows = answer.asConceptRows().stream().collect(Collectors.toList());
                System.out.println("Persons found: " + rows.size());
            }

            System.out.println("Done!");
        }
    }
}

use typedb_driver::{
    Addresses, Credentials, DriverOptions, DriverTlsConfig,
    TransactionType, TypeDBDriver, Server, ServerRouting,
};

fn test_clustered_typedb() {
    async_std::task::block_on(async {
        let driver = TypeDBDriver::new(
            // Try automatic replica discovery by connecting to only a single server!
            // Use Addresses::try_from_addresses_str() to provide multiple addresses instead.
            Addresses::try_from_address_str(ADDRESS).unwrap(),
            Credentials::new(USERNAME, PASSWORD),
            DriverOptions::new(DriverTlsConfig::enabled_with_native_root_ca()),
        )
        .await
        .expect("Error while setting up the driver");

        let servers = driver.servers().await.expect("Expected servers retrieval");
        let addresses: Vec<_> = servers.iter()
            .filter_map(|server| server.address().map(|a| a.to_string()))
            .collect();
        println!("Servers known to the driver: {addresses:?}");

        if let Some(primary) = driver.primary_server().await.expect("Expected primary check") {
            println!("Primary server: {}", primary.address());
        }

        let version = driver.server_version().await.expect("Expected version retrieval");
        println!("Server version: {} {}", version.distribution(), version.version());

        const DATABASE_NAME: &str = "clustered-test";

        if !driver.databases().contains(DATABASE_NAME).await.expect("Expected database check") {
            driver.databases().create(DATABASE_NAME).await.expect("Expected database creation");
        }

        let database = driver.databases().get(DATABASE_NAME).await.expect("Expected database retrieval");
        println!("Database exists: {}", database.name());

        // Schema transactions are always routed to the primary
        let transaction = driver
            .transaction(DATABASE_NAME, TransactionType::Schema)
            .await
            .expect("Expected schema transaction");
        transaction.query("define entity person;").await.expect("Expected schema query");
        transaction.commit().await.expect("Expected schema tx commit");

        let transaction = driver
            .transaction(DATABASE_NAME, TransactionType::Write)
            .await
            .expect("Expected write transaction");
        transaction.query("insert $p1 isa person; $p2 isa person;").await.expect("Expected insert query");
        transaction.commit().await.expect("Expected write tx commit");

        // Read transactions are routed automatically
        let transaction = driver
            .transaction(DATABASE_NAME, TransactionType::Read)
            .await
            .expect("Expected read transaction");
        let answer = transaction.query("match $p isa person;").await.expect("Expected read query");
        let rows: Vec<_> = answer.into_rows().try_collect().await.unwrap();
        println!("Persons found: {}", rows.len());

        println!("Done!");
    });
}