New ACM paper, free-tier cloud, and open-source license

C# driver tutorial

In this tutorial, we’ll build a sample application with the C# 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. Download the TypeDB C# driver. For the driver installation instructions, see the C# driver page.


To be able to use the TypeDB C# driver API in the Sample application, use the following include statements:

using TypeDB.Driver;
using TypeDB.Driver.Api;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;

Default values

We store default values as constants in the source code:

const string DB_NAME = "sample_app_db";
const string SERVER_ADDR = "";
enum Edition { Core, Cloud }
const Edition TYPEDB_EDITION = Edition.Core;
const string CLOUD_USERNAME = "admin";
const 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, a new database setup, and querying.

static void Main(string[] args) {
    using (ITypeDBDriver driver = ConnectToTypeDB(TYPEDB_EDITION, SERVER_ADDR)) {
        if (driver.IsOpen()) {
            if (DbSetup(driver, DB_NAME)) {
                Queries(driver, DB_NAME);
            } else {
                Console.Error.WriteLine("Failed to set up the database. Terminating...");
        } else {
            Console.Error.WriteLine("Failed to connect to TypeDB server. Terminating...");

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.

static ITypeDBDriver ConnectToTypeDB(Edition typedbEdition, string addr, string username = CLOUD_USERNAME, string password = CLOUD_PASSWORD, bool encryption = true) {
    switch (typedbEdition) {
        case Edition.Core:
            return TypeDB.Driver.Drivers.CoreDriver(addr);
        case Edition.Cloud:
            return TypeDB.Driver.Drivers.CloudDriver(addr, new TypeDBCredential(username, password, encryption));
            throw new InvalidOperationException("Invalid TypeDB edition specified.");

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.

static bool DbSetup(ITypeDBDriver driver, string dbName, bool dbReset = false) {
    Console.WriteLine($"Setting up the database: {dbName}");
    if (driver.Databases.Contains(dbName)) {
        if (dbReset) {
            ReplaceDatabase(driver, dbName);
        } else {
            Console.Write("Found a pre-existing database. Do you want to replace it? (Y/N) ");
            ConsoleKeyInfo keyInfo = Console.ReadKey();
            if (keyInfo.Key == ConsoleKey.Y)
                    ReplaceDatabase(driver, dbName);
                    Console.WriteLine("Reusing an existing database.");
    } else {
        CreateDatabase(driver, dbName);
    using (ITypeDBSession session = driver.Session(dbName, SessionType.Data)) {
        return DbCheck(session);

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.

static bool CreateDatabase(ITypeDBDriver driver, string dbName) {
    Console.WriteLine("Creating a new database...");
    using (ITypeDBSession session = driver.Session(dbName, SessionType.Schema)) {
    using (ITypeDBSession session = driver.Session(dbName, SessionType.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:

static bool ReplaceDatabase(ITypeDBDriver driver, string dbName) {
    Console.WriteLine("Deleting an existing database...");
    return CreateDatabase(driver, dbName);

Defining a schema

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

static void DbSchemaSetup(ITypeDBSession session, string schemaFile = "iam-schema.tql") {
    string defineQuery;
        defineQuery = File.ReadAllText(schemaFile);
        using (ITypeDBTransaction tx = session.Transaction(TransactionType.Write)) {
            Console.WriteLine("Defining schema...");
    catch (FileNotFoundException)
        Console.WriteLine("Error: File not found.");
    catch (Exception e)
        Console.WriteLine($"An error occurred: {e.Message}");

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:

static void DbDatasetSetup(ITypeDBSession session, string dataFile = "iam-data-single-query.tql") {
    string insertQuery = File.ReadAllText(dataFile);
    using (ITypeDBTransaction tx = session.Transaction(TransactionType.Write)) {
        Console.WriteLine("Loading data...");
        IEnumerable<IConceptMap> response = tx.Query.Insert(insertQuery);
        int count = response.Count();

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:

static bool DbCheck(ITypeDBSession session) {
    using (ITypeDBTransaction tx = session.Transaction(TransactionType.Read)) {
        Console.WriteLine("Testing the database...");
        string testQuery = "match $u isa user; get $u; count;";
        long result = tx.Query.GetAggregate(testQuery).Resolve()!.AsLong();
        if (result == 3) {
            return true;
        } else {
            Console.WriteLine($"Failed with the result: {result}\nExpected 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:

static void Queries(ITypeDBDriver driver, string dbName) {
    Console.WriteLine("\nRequest 1 of 6: Fetch all users as JSON objects with full names and emails");
    List<JObject> users = FetchAllUsers(driver, dbName);

    string newName = "Jack Keeper";
    string newEmail = "";
    Console.WriteLine("\nRequest 2 of 6: Add a new user with the full-name " + newName + " and email " + newEmail);
    InsertNewUser(driver, dbName, newName, newEmail);

    string name = "Kevin Morrison";
    Console.WriteLine("\nRequest 3 of 6: Find all files that the user " + name + " has access to view (no inference)");
    List<string> noFiles = GetFilesByUser(driver, dbName, name);

    Console.WriteLine("\nRequest 4 of 6: Find all files that the user " + name + " has access to view (with inference)");
    List<string> files = GetFilesByUser(driver, dbName, name, true);

    string oldPath = "";
    string newPath = "";
    Console.WriteLine("\nRequest 5 of 6: Update the path of a file from " + oldPath + " to " + newPath);
    int updatedFiles = UpdateFilePath(driver, dbName, oldPath, newPath);

    string filePath = "";
    Console.WriteLine("\nRequest 6 of 6: Delete the file with path " + filePath);
    bool deleted = DeleteFile(driver, dbName, filePath);

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:

static List<JObject> FetchAllUsers(ITypeDBDriver driver, string dbName) {
    List<JObject> users = new();
    using (ITypeDBSession session = driver.Session(dbName, SessionType.Data)) {
        using (ITypeDBTransaction tx = session.Transaction(TransactionType.Read)) {
            IEnumerable<JObject> queryResult = tx.Query.Fetch("match $u isa user; fetch $u: full-name, email;");
            int c = 1;
            foreach (JObject user in queryResult) {
                Console.WriteLine($"User #{c++} ");
                Console.WriteLine(JsonConvert.SerializeObject(user, Formatting.Indented));
    return users;

We get the response as a stream of JSONs and iterate through it to print all String values from each JSON.

Insert query

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

static IEnumerable<IConceptMap> InsertNewUser(ITypeDBDriver driver, string dbName, string name, string email) {
    List<IConceptMap> response = new List<IConceptMap>();
    using (ITypeDBSession session = driver.Session(dbName, SessionType.Data)) {
        using (ITypeDBTransaction tx = session.Transaction(TransactionType.Write)) {
            string query = $"insert $p isa person, has full-name '{name}', has email '{email}';";
            IEnumerable<IConceptMap> result = tx.Query.Insert(query);
            foreach (IConceptMap conceptMap in result) {
                string retrievedName = conceptMap.Get("_0").AsAttribute().Value.AsString();
                string retrievedEmail = conceptMap.Get("_1").AsAttribute().Value.AsString();
                Console.WriteLine($"Added new user. Name: {retrievedName}, E-mail: {retrievedEmail}");
    return response;

The Insert query returns a stream of ConceptMaps: one for every insert clause execution. We iterate through the stream and print name and email for each ConceptMap returned.

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.

static List<string> GetFilesByUser(ITypeDBDriver driver, string dbName, string name, bool inference = false) {
    TypeDBOptions options = new();
    List<string> files = new List<string>();
    using (ITypeDBSession session = driver.Session(dbName, SessionType.Data)) {
        using (ITypeDBTransaction tx = session.Transaction(TransactionType.Read, options)) {
            string query = $"match $u isa user, has full-name '{name}'; get;";
            IEnumerable<IConceptMap> users = tx.Query.Get(query);
            int userCount = users.Count();
            if (userCount > 1) {
                Console.WriteLine("Error: Found more than one user with that name.");
            } else if (userCount == 1) {
                string fetchQuery = $@"
                    $fn == '{name}';
                    $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; sort $fp asc;";
                IEnumerable<IConceptMap> response = tx.Query.Get(fetchQuery);
                int resultCounter = 0;
                foreach (IConceptMap cm in response) {
                    Console.WriteLine($"File #{resultCounter}: {cm.Get("fp").AsAttribute().Value.AsString()}");
                if (resultCounter == 0) {
                    Console.WriteLine("No files found. Try enabling inference.");
            } else {
                Console.WriteLine("Error: No users found with that name.");
    return files;

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:

static int UpdateFilePath(ITypeDBDriver driver, string dbName, string oldPath, string newPath) {
    int count = 0;
    using (ITypeDBSession session = driver.Session(dbName, SessionType.Data)) {
        using (ITypeDBTransaction tx = session.Transaction(TransactionType.Write)) {
            string updateQuery = $@"
                $f isa file, has path $old;
                $old == '{oldPath}';
                $f has $old;
                $f has path '{newPath}';";
            List<IConceptMap> response = tx.Query.Update(updateQuery).ToList();
            count = response.Count();
            if (count > 0) {
                Console.WriteLine($"Total number of paths updated: {count}.");
            } else {
                Console.WriteLine("No matched paths: nothing to update.");
    return count;

We iterate through the response of the Update query and count 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.

static bool DeleteFile(ITypeDBDriver driver, string dbName, string path) {
    using (ITypeDBSession session = driver.Session(dbName, SessionType.Data)) {
        using (ITypeDBTransaction tx = session.Transaction(TransactionType.Write)) {
            string matchQuery = $"match $f isa file, has path '{path}'; get;";
            IEnumerable<IConceptMap> response = tx.Query.Get(matchQuery);
            int count = response.Count();
            if (count == 1) {
                tx.Query.Delete($"match $f isa file, has path '{path}'; delete $f isa file;").Resolve();
                Console.WriteLine("The file has been deleted.");
                return true;
            } else if (count > 1) {
                Console.WriteLine("Matched more than one file with the same path.");
                Console.WriteLine("No files were deleted.");
                return false;
            } else {
                Console.WriteLine("No files matched in the database.");
                Console.WriteLine("No files were deleted.");
                return false;

Learn more

The full source code of this sample application.

The full API reference for the TypeDB C# driver.

Provide Feedback