Officially out now: The TypeDB 3.0 Roadmap

Java driver tutorial

In this tutorial, we’ll build a sample application with the Java driver capable of basic interaction with TypeDB:

  • Connect to a TypeDB server (Core or Cloud),

  • Manage databases, sessions, and transactions,

  • Send different types of queries.

Follow the steps below or see the full source code.

Environment setup

To run this sample application, you’ll need:

  1. TypeDB: either a TypeDB Cloud deployment or a TypeDB Core server. For TypeDB Core installation instructions, see the TypeDB Core installation guide page.

  2. Java and TypeDB Java driver. For the driver installation instructions, see the Java driver page.

Imported modules

To be able to use the TypeDB Java driver API in the Sample application, use the following import statements:

import com.vaticle.typedb.driver.api.*;
import com.vaticle.typedb.driver.api.answer.ConceptMap;
import com.vaticle.typedb.driver.TypeDB;
import com.vaticle.typedb.driver.api.answer.JSON;
import com.vaticle.typedb.driver.common.exception.TypeDBDriverException;

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

Default values

We store default values as constants in the source code:

private static final String DB_NAME = "sample_app_db";
private static final String SERVER_ADDR = "";

public enum Edition {

private static final Edition TYPEDB_EDITION = Edition.CORE;
private static final String CLOUD_USERNAME = "admin";
private static final String CLOUD_PASSWORD = "password";

where DB_NAME — the name of the database to use; SERVER_ADDR — address of the TypeDB server to connect to; TYPEDB_EDITION — TypeDB Core or Cloud edition selector; CLOUD_USERNAME/CLOUD_PASSWORD — credentials to connect to TypeDB Cloud.

Program structure

The main workflow of this sample application includes establishing a connection to TypeDB, database setup, and querying.

public static void main(String[] args) {
    try (TypeDBDriver driver = connectToTypeDB(TYPEDB_EDITION, SERVER_ADDR)) {
        if (dbSetup(driver, DB_NAME, false)) {
            System.out.println("Setup complete.");
            queries(driver, DB_NAME);
        } else {
            System.out.println("Setup failed.");
    } catch (TypeDBDriverException e) {

The entire main() function code is executed in the context of the network connection, represented by the driver object that is returned by the function.

TypeDB connection

The connectToTypeDB() function takes edition and addr as mandatory parameters.

private static TypeDBDriver connectToTypeDB(Edition edition, String addr) {
    if (edition == Edition.CORE) {
        return TypeDB.coreDriver(addr);
    if (edition == Edition.CLOUD) {
        return TypeDB.cloudDriver(addr, new TypeDBCredential(CLOUD_USERNAME, CLOUD_PASSWORD, true ));
    return null;

The edition is expected to be an Enum for selecting a TypeDB edition. Depending on the TypeDB edition selected, this function initializes either a TypeDB Core or TypeDB Cloud connection.

TypeDB Cloud connection requires an object of the TypeDBCredential class that is initialized with a username and password. For our sample application, we have the default credentials for the admin account set in the code of the connectToTypeDB function.

TypeDB Cloud requires the default password for the default admin account to be changed before any other request can be accepted.

Database setup

To set up a TypeDB database, we need to make sure that it exists and has the correct schema and data. First, we check whether a database with the provided name already exists on the server.

If such a database doesn’t exist, we create a new database, define its schema, and load initial data.

To prevent data loss, avoid deleting an existing database without confirmation from a user.

If a database with the specified name already exists, we check whether we need to replace it. To do so, we check the dbReset parameter, and, if it’s false, ask for an input from a user. If any of the two suggesting replacement of the database is acceptable, we replace the database by deleting the existing database and then creating a new one.

As the final step of the database setup, we test it.

private static boolean dbSetup(TypeDBDriver driver, String dbName, boolean dbReset) {
    System.out.println("Setting up the database: " + dbName);
    if (driver.databases().contains(dbName)) {
        if (dbReset) {
            if (!replaceDatabase(driver, dbName)) {
                return false;
        } else{
            System.out.println("Found a pre-existing database. Do you want to replace it? (Y/N) ");
            String answer;
            try {
                BufferedReader reader = new BufferedReader(new InputStreamReader(;
                answer = reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException("Failed to read user input.", e);
            if (answer.equalsIgnoreCase("y")) {
                if (!replaceDatabase(driver, dbName)) {
                    return false;
            } else {
                System.out.println("Reusing an existing database.");
    } else { // No such database found on the server
        if (!createDatabase(driver,dbName)) {
            System.out.println("Failed to create a new database. Terminating...");
            return false;
    if (driver.databases().contains(dbName)) {
        try (TypeDBSession session = driver.session(dbName, TypeDBSession.Type.DATA)) {
            return dbCheck(session);
    } else {
        System.out.println("Database not found. Terminating...");
        return false;

Creating a new database

We create a new database with the specified name (sample_app_db by default) and call functions to define its schema and load initial data.

private static boolean createDatabase(TypeDBDriver driver, String dbName) {
    System.out.print("Creating a new database...");
    try (TypeDBSession session = driver.session(dbName, TypeDBSession.Type.SCHEMA)) {
    try (TypeDBSession session = driver.session(dbName, TypeDBSession.Type.DATA)) {
    return true;

Replacing a database

We delete a database with the specified name (sample_app_db by default) and call a function to create a new one instead:

private static boolean replaceDatabase(TypeDBDriver driver, String dbName) {
    System.out.print("Deleting an existing database...");
    driver.databases().get(dbName).delete();  // Delete the database if it exists already
    if (createDatabase(driver,dbName)) {
        return true;
    } else {
        System.out.println("Failed to create a new database. Terminating...");
        return false;

Defining a schema

We use a Define query to define a schema for the newly created database:

private static void dbSchemaSetup(TypeDBSession session) {
    String schemaFile = "iam-schema.tql";
    try (TypeDBTransaction tx = session.transaction(TypeDBTransaction.Type.WRITE)) {
        String defineQuery = new String(Files.readAllBytes(Paths.get(schemaFile)));
        System.out.print("Defining schema...");
    } catch (IOException e) {
        throw new RuntimeException("Failed to read the schema file.", e);

The schema for the sample application is stored in the iam-schema.tql file.

See the full schema

credential sub attribute, value string;
full-name sub attribute, value string;
id sub attribute, abstract, value string;
email sub id, value string;
name sub id, value string;
number sub id, value string;
path sub id, value string;
object-type sub attribute, value string;
ownership-type sub attribute, value string;
review-date sub attribute, value datetime;
size-kb sub attribute, value long;
validity sub attribute, value boolean;

access sub relation,
    relates action,
    relates object,
    plays change-request:change,
    plays permission:access;

change-request sub relation,
    relates change,
    relates requestee,
    relates requester;

membership sub relation,
    relates member,
    relates parent;

collection-membership sub membership,
    relates collection as parent;

group-membership sub membership,
    relates group as parent;

set-membership sub membership,
    relates set as parent;

ownership sub relation,
    relates owned,
    relates owner;

group-ownership sub ownership,
    owns ownership-type,
    relates group as owned;

object-ownership sub ownership,
    owns ownership-type,
    relates object as owned;

permission sub relation,
    owns review-date,
    owns validity,
    relates access,
    relates subject;

segregation-policy sub relation,
    owns name,
    relates action,
    plays segregation-violation:policy;

violation sub relation,

segregation-violation sub violation,
    relates object,
    relates policy,
    relates subject;

action sub entity,
    owns name,
    owns object-type,
    plays access:action,
    plays membership:member,
    plays segregation-policy:action;

operation sub action;

operation-set sub action,
    plays set-membership:set;

object sub entity,
    owns object-type,
    plays access:object,
    plays membership:member,
    plays object-ownership:object,
    plays segregation-violation:object;

resource sub object,

file sub resource,
    owns path,
    owns size-kb;

record sub resource,
    owns number;

resource-collection sub object,
    plays collection-membership:collection;

database sub resource-collection,
    owns name;

directory sub resource-collection,
    owns path,
    owns size-kb;

subject sub entity,
    owns credential,
    plays change-request:requestee,
    plays change-request:requester,
    plays membership:member,
    plays ownership:owner,
    plays permission:subject,
    plays segregation-violation:subject;

user sub subject,

person sub user,
    owns email,
    owns full-name;

user-group sub subject,
    plays group-membership:group,
    plays group-ownership:group;

business-unit sub user-group,
    owns name;

user-account sub user-group,
    owns email;

user-role sub user-group,
    owns name;

rule add-view-permission: when {
    $modify isa action, has name "modify_file";
    $view isa action, has name "view_file";
    $ac_modify (object: $obj, action: $modify) isa access;
    $ac_view (object: $obj, action: $view) isa access;
    (subject: $subj, access: $ac_modify) isa permission;
} then {
    (subject: $subj, access: $ac_view) isa permission;

We use a session object passed as a parameter to open a transaction. Then we send the contents of the file as a TypeQL Define query and commit the changes made by the transaction.

Loading initial data

With the schema defined, we can load initial data into our database with the Insert query:

private static void dbDatasetSetup(TypeDBSession session) {
    String dataFile = "iam-data-single-query.tql";
    try (TypeDBTransaction tx = session.transaction(TypeDBTransaction.Type.WRITE)) {
        String insertQuery = new String(Files.readAllBytes(Paths.get(dataFile)));
        System.out.print("Loading data...");
    } catch (IOException e) {
        throw new RuntimeException("Failed to read the data file.", e);

We read the iam-data-single-query.tql file, send its contents as a single query, and then commit the changes.

See the full Insert query
$p1 isa person,
    has full-name "Masako Holley",
    has email "";
$p2 isa person,
    has full-name "Pearle Goodman",
    has email "";
$p3 isa person,
    has full-name "Kevin Morrison",
    has email "";
$f1 isa file,
    has path "",
    has size-kb 55;

$modify isa operation, has name "modify_file";
$view isa operation, has name "view_file";

$a1 (object: $f1, action: $modify) isa access;
$a11 (object: $f1, action: $view) isa access;
$permission1 (subject: $p3, access: $a1) isa permission;
$f2 isa file,
    has path "zlckt.ts",
    has size-kb 143;
$a2 (object: $f2, action: $modify) isa access;
$a22 (object: $f2, action: $view) isa access;
$permission2 (subject: $p3, access: $a2) isa permission;
$f3 isa file,
    has path "",
    has size-kb 171;
$a3 (object: $f3, action: $modify) isa access;
$a33 (object: $f3, action: $view) isa access;
$permission3 (subject: $p3, access: $a3) isa permission;
$f4 isa file,
    has path "",
    has size-kb 212;
$a4 (object: $f4, action: $modify) isa access;
$a44 (object: $f4, action: $view) isa access;
$permission4 (subject: $p3, access: $a4) isa permission;
$f5 isa file,
    has path "",
    has size-kb 70;
$a5 (object: $f5, action: $modify) isa access;
$a55 (object: $f5, action: $view) isa access;
$permission5 (subject: $p3, access: $a5) isa permission;
$f6 isa file,
    has path "budget_2022-05-01.xlsx",
    has size-kb 758;
$a6 (object: $f6, action: $modify) isa access;
$a66 (object: $f6, action: $view) isa access;
$permission6 (subject: $p3, access: $a6) isa permission;
$permission66 (subject: $p2, access: $a66) isa permission;
$f7 isa file,
    has path "";
$a7 (object: $f7, action: $modify) isa access;
$a77 (object: $f7, action: $view) isa access;
$permission7 (subject: $p3, access: $a7) isa permission;
$permission77 (subject: $p2, access: $a77) isa permission;
$f8 isa file,
    has path "budget_2021-08-01.xlsx",
    has size-kb 1705;
$a8 (object: $f8, action: $modify) isa access;
$a88 (object: $f8, action: $view) isa access;
$permission8 (subject: $p3, access: $a8) isa permission;
$permission88 (subject: $p2, access: $a88) isa permission;
$f9 isa file,
    has path "LICENSE";
$a9 (object: $f9, action: $modify) isa access;
$a99 (object: $f9, action: $view) isa access;
$permission9 (subject: $p3, access: $a9) isa permission;
$permission99 (subject: $p2, access: $a99) isa permission;
$f10 isa file,
    has path "";
$a10 (object: $f10, action: $modify) isa access;
$a100 (object: $f10, action: $view) isa access;
$permission10 (subject: $p3, access: $a10) isa permission;
$permission100 (subject: $p2, access: $a100) isa permission;

Testing a database

With the schema defined and data loaded, we test our database to make sure it’s ready. To test the database, we send a query to count the number of users in the database:

private static boolean dbCheck(TypeDBSession session) {
    try (TypeDBTransaction transaction = session.transaction(TypeDBTransaction.Type.READ)) {
        String testQuery = "match $u isa user; get $u; count;";
        System.out.print("Testing the database...");
        long result = transaction.query().getAggregate(testQuery).resolve().get().asLong();
        if (result == 3) {
            return true;
        } else {
            System.out.println("Failed the test with the result: " + result + "\n Expected result: 3.");
            return false;

Query examples

After database setup is complete, we proceed with querying our database with different types of queries in the queries() function:

private static void queries(TypeDBDriver driver, String dbName) {
    System.out.println("Request 1 of 6: Fetch all users as JSON objects with full names and emails");
    List<JSON> users = fetchAllUsers(driver, dbName);

    String name = "Jack Keeper";
    String email = "";
    String secondRequestMessage = String.format("Request 2 of 6: Request 2 of 6: Add a new user with the full-name \"%s\" and email \"%s\"", name, email);
    List<ConceptMap> newUser = insertNewUser(driver, dbName, name, email);

    String nameKevin = "Kevin Morrison";
    String thirdRequestMessage = String.format("Request 3 of 6: Find all files that the user \"%s\" has access to view (no inference)", nameKevin);
    List<ConceptMap> no_files = getFilesByUser(driver, dbName, nameKevin, false);

    String fourthRequestMessage = String.format("Request 4 of 6: Find all files that the user \"%s\" has access to view (with inference)", nameKevin);
    List<ConceptMap> files = getFilesByUser(driver, dbName, nameKevin, true);

    String old_path = "";
    String new_path = "";
    String fifthRequestMessage = String.format("Request 5 of 6: Update the path of a file from \"%s\" to \"%s\"", old_path, new_path);
    List<ConceptMap> updated_files = updateFilePath(driver, dbName, old_path, new_path);

    String sixthRequestMessage = String.format("Request 6 of 6: Delete the file with path \"%s\"", new_path);
    boolean deleted = deleteFile(driver, dbName, new_path);

The queries are as follows:

  1. Fetch query — to retrieve information in a JSON format

  2. Insert query — to insert new data into the database

  3. Get query — to retrieve data from the database as stateful objects

  4. Get query with inference — to retrieve data from the database as stateful objects using inference

  5. Update query — to replace data in the database

  6. Delete query — to delete data from the database

Every query is implemented as a function that includes some output of the query response and returns some meaningful data.

Fetch query

The main way to retrieve data from a TypeDB database is to use fetching to get values of attributes, matched by a pattern.

Let’s use a Fetch query to fetch names and emails for all users in the database:

private static List<JSON> fetchAllUsers(TypeDBDriver driver, String dbName) {
    try (TypeDBSession session = driver.session(dbName, TypeDBSession.Type.DATA)) {
        try (TypeDBTransaction tx = session.transaction(TypeDBTransaction.Type.READ)) {
            String query = "match $u isa user; fetch $u: full-name, email;";
            List<JSON> answers = tx.query().fetch(query).toList();
            answers.forEach(json -> System.out.println("JSON: " + json.toString()));
            return answers;

We get the response as a stream of results, containing JSON. We create a answers variable to store the list of JSONs and iterate through it to print the JSONs.

Insert query

Let’s insert a new user with a full-name and email attributes to the database.

public static List<ConceptMap> insertNewUser(TypeDBDriver driver, String dbName, String name, String email) {
    try (TypeDBSession session = driver.session(dbName, TypeDBSession.Type.DATA)) {
        try (TypeDBTransaction tx = session.transaction(TypeDBTransaction.Type.WRITE)) {
            String query = String.format(
                    "insert $p isa person, has full-name $fn, has email $e; $fn \"%s\"; $e \"%s\";", name, email);
            List<ConceptMap> response = tx.query().insert(query).toList();
            for (ConceptMap conceptMap : response) {
                String fullName = conceptMap.get("fn").asAttribute().getValue().asString();
                String emailAddress = conceptMap.get("e").asAttribute().getValue().asString();
                System.out.println("Added new user. Name: " + fullName + ", E-mail: " + emailAddress);
            return response;

The Insert query returns a stream of ConceptMaps: one for every insert clause execution. We collect the stream to a list to store the inserted data. Then we commit the changes, print name and email by iterating though the list of ConceptMaps, and return the stored list.

Since the Insert query has no match clause, the insert clause is executed exactly once. But the Insert query always returns a list of ConceptMap objects, where every ConceptMap represents an inserted result.

Get query

Let’s retrieve all files available for a user with a getFilesByUser() function. It can be used with or without inference enabled.

public static List<ConceptMap> getFilesByUser(TypeDBDriver driver, String dbName, String name, boolean inference) {
    List<ConceptMap> filePaths = new ArrayList<>();
    TypeDBOptions options = new TypeDBOptions().infer(inference);
    try (TypeDBSession session = driver.session(dbName, TypeDBSession.Type.DATA);
         TypeDBTransaction tx = session.transaction(TypeDBTransaction.Type.READ, options)) {

        String userQuery = String.format("match $u isa user, has full-name '%s'; get;", name);
        List<ConceptMap> users = tx.query().get(userQuery).toList();

        if (users.size() > 1) {
            System.out.println("Error: Found more than one user with that name.");
            return null;
        } else if (users.size() == 1) {
            String fileQuery = String.format("""
                                            $fn '%s';
                                            $u isa user, has full-name $fn;
                                            $p($u, $pa) isa permission;
                                            $o isa object, has path $fp;
                                            $pa($o, $va) isa access;
                                            $va isa action, has name 'view_file';
                                            get $fp;""", name);
            filePaths.forEach(path -> System.out.println("File: " + path.get("fp").asAttribute().getValue().toString()));
            if (filePaths.isEmpty()) {
                System.out.println("No files found. Try enabling inference.");
            return filePaths;
        } else {
            System.out.println("Warning: No users found with that name.");
            return null;
    } catch (TypeDBDriverException e) {
        return null;

We call the function with the inference disabled (false) and expect it to return no results, as the query pattern matches only files available for view_file action, and there are no such files initially in the database.

The getFilesByUser() function checks that there is only one user matched with the name provided by an input parameter. It then executes the query to find the files, collect the results, and iterates through them to print a value of every matched path attribute.

For bigger numbers of results, it might be faster to iterate through a stream, rather than collect and store the results first.

Get query with inference

To get query results with inferred data, let’s enable the infer parameter of the TypeDB transaction options. We use the same getFilesByUser() function, but set the inference parameter to true when we call it again. The add-view-permission rule provides us with some inferred results this time.

Update query

Let’s replace a path for one of the files with a new path. We can do that by deleting ownership of the old path attribute from the file entity and assigning it with ownership of the new path attribute with the Update query:

public static List<ConceptMap> updateFilePath(TypeDBDriver driver, String dbName, String oldPath, String newPath) {
    List<ConceptMap> response = new ArrayList<>();
    try (TypeDBSession session = driver.session(dbName, TypeDBSession.Type.DATA);
         TypeDBTransaction tx = session.transaction(TypeDBTransaction.Type.WRITE)) {
        String query = String.format("""
                                    $f isa file, has path $old_path;
                                    $old_path = '%s';
                                    $f has $old_path;
                                    $f has path '%s';""", oldPath, newPath);
        response = tx.query().update(query).toList();
        if (!response.isEmpty()) {
            System.out.println(String.format("Total number of paths updated: %s", response.size()));
            return response;
        } else {
            System.out.println("No matched paths: nothing to update");

    } catch (TypeDBDriverException e) {
    return response;

We collect the response of the Update query and check the length of it to determine the number of times the delete and insert clauses are executed. We then commit the changes only if the number meets our expectation.

Delete query

Finally, let’s delete the same file we updated the path for. First, we match the file in a Get (or Fetch) query to check how many files get matched to prevent unplanned deletes. If the number (or any other relevant parameters) of matched results is as expected, we proceed with a Delete query with the same match clause.

By using the same write transaction we employ snapshot isolation to prevent any other transactions from changing the expected results. If any other transaction makes a conflicting change before we commit this transaction, then our transaction fails upon a commit.

public static boolean deleteFile(TypeDBDriver driver, String dbName, String path) {
    try (TypeDBSession session = driver.session(dbName, TypeDBSession.Type.DATA);
         TypeDBTransaction tx = session.transaction(TypeDBTransaction.Type.WRITE)) {

        String query = String.format("match $f isa file, has path '%s'; get;", path);
        List<ConceptMap> response = tx.query().get(query).toList();

        if (response.size() == 1) {
            tx.query().delete(String.format("match $f isa file, has path '%s'; delete $f isa file;", path)).resolve();
            System.out.println("The file has been deleted.");
            return true;
        } else if (response.size() > 1) {
            System.out.println("Matched more than one file with the same path. No files were deleted.");
            return false;
        } else {
            System.out.println("No files matched in the database. No files were deleted.");
            return false;
    } catch (TypeDBDriverException e) {
        return false;

Learn more

The full source code of this sample application.

The full API reference for the TypeDB Java driver.

Provide Feedback