Meet TypeDB and TypeQL

let connection = Connection::new_core("localhost:1729")?;
let databases = DatabaseManager::new(connection);

databases.create("access-management-db").await?;

let session = Session::new(databases.get("access-management-db").await?, SessionType::Schema).await?;
let tx = session.transaction(TransactionType::Write).await?;
tx.query().define(access_management_schema).await?;
tx.commit().await?;
drop(session);

let session = Arc::new(Session::new(databases.get("access-management-db").await?, SessionType::Data).await?);
futures::future::try_join_all(access_management_data_batches.into_iter().map(|batch| {
    let session = session.clone();
    async move {
        let tx = session.transaction(TransactionType::Write).await?;
        batch.iter().try_for_each(|query| tx.query().insert(query).map(|_| ()))?;
        tx.commit().await
    }
})).await?;

let tx = session.transaction(TransactionType::Read).await?;
let mut stream = tx.query().get("match $u isa user; get;")?;

with TypeDB.core_driver("localhost:1729") as driver:
    driver.databases.create("access-management-db")
    with driver.session("access-management-db", SessionType.SCHEMA) as session:
        with session.transaction(TransactionType.WRITE) as tx:
            tx.query.define(access_management_schema)
            tx.commit()

    with driver.session("access-management-db", SessionType.DATA) as session:
        for batch in access_management_data_batches:
            with session.transaction(TransactionType.WRITE) as tx:
                for query in batch:
                    tx.query.insert(query)
                tx.commit()
            with session.transaction(TransactionType.READ) as tx:
                results = tx.query.get("match $u isa user; get;")

let driver, session, tx;
try {
    driver = await TypeDB.coreDriver("localhost:1729");
    await driver.databases.create("access-management-db");

    session = await driver.session("access-management-db", SessionType.SCHEMA);
    tx = await session.transaction(TransactionType.WRITE);
    tx.query.define(accessManagementSchema);
    await tx.commit();
    await session.close();

    session = await driver.session("access-management-db", SessionType.DATA);
    for (const batch of accessManagementDataBatches) {
        tx = await session.transaction(TransactionType.WRITE);
        for (const query of batch) {
            tx.query.insert(query);
        }
        await tx.commit();
    }
    tx = await session.transaction(TransactionType.READ);
    const results = tx.query.get("match $u isa user; get;");
} finally {
    if (tx) await tx.close();
    if (session) await session.close();
    if (driver) await driver.close();
}

try (TypeDBDriver driver = TypeDB.coreDriver("localhost:1729")) {
    driver.databases().create("access-management-db");

    try (TypeDBSession session = driver.session("access-management-db", TypeDBSession.Type.SCHEMA)) {
        try (TypeDBTransaction tx = session.transaction(TypeDBTransaction.Type.WRITE)) {
            tx.query().define(accessManagementSchema);
            tx.commit();
        }
    }
    try (TypeDBSession session = driver.session("access-management-db", TypeDBSession.Type.DATA)) {
        for (List<TypeQLInsert> batch: accessManagementDataBatches) {
            try (TypeDBTransaction tx = session.transaction(TypeDBTransaction.Type.WRITE)) {
                for (TypeQLInsert query: batch) {
                    tx.query().insert(query);
                }
                tx.commit();
            }
        }
        try (TypeDBTransaction tx = session.transaction(TypeDBTransaction.Type.READ)) {
            Stream<ConceptMap> results = tx.query().get(TypeQL.match(TypeQL.cVar("u").isa("user")).get());
        }
    }
}

Connection* connection = connection_open_core("localhost:1729");
DatabaseManager* databaseManager = database_manager_new(connection);

{
    Options* options = options_new();
    Session* session = session_new(databaseManager, "access-management-db", Schema, options);
    Transaction* tx = transaction_new(session, Write, options);
    void_promise_resolve(query_define(tx, accessManagementSchema, options));
    void_promise_resolve(transaction_commit(tx));
    session_close(session);
    options_drop(options);
}
{
    Options* options = options_new();
    Session* session = session_new(databaseManager, "access-management-db", Data, options);
    {
        Transaction* tx = transaction_new(session, Write, options);
        for (int i = 0; i < accessManagementDataBatchCount; i++) {
            for (int j = 0; j < accessManagementDataBatchSize; j++) {
                ConceptMapIterator* inserted = query_insert(tx, accessManagementDataBatches[i][j], options);
                concept_map_iterator_drop(inserted);
            }
        }
        void_promise_resolve(transaction_commit(tx));
    }
    {
        Transaction* tx = transaction_new(session, Read, options);
        ConceptMapIterator* results = query_get(tx, "match $u isa user; get;", options);
        concept_map_iterator_drop(results);
        transaction_close(tx);
    }
    session_close(session);
    options_drop(options);
}

database_manager_drop(databaseManager);
connection_close(connection);

TypeDB::Driver driver = TypeDB::Driver::coreDriver("localhost:1729");
TypeDB::Options options;
{
    TypeDB::Session session = driver.session("access-management-db", TypeDB::SessionType::SCHEMA, options);
    TypeDB::Transaction tx = session.transaction(TypeDB::TransactionType::WRITE, options);
    tx.query.define(accessManagementSchema, options).wait();
    tx.commit();
}
{
    TypeDB::Session session = driver.session("access-management-db", TypeDB::SessionType::DATA, options);

    for (auto& batch: accessManagementDataBatches) {
        TypeDB::Transaction tx = session.transaction(TypeDB::TransactionType::WRITE, options);
        for (auto& query: batch) {
            tx.query.insert(query, options);
        }
        tx.commit();
    }
    {
        TypeDB::Transaction tx = session.transaction(TypeDB::TransactionType::READ, options);
        ConceptMapIterable results = tx.query.get("match $u isa user; get;", options);
    }
}

using (ITypeDBDriver driver = Drivers.CoreDriver("localhost:1729"))
{
    driver.Databases.Create("access-management-db");
    using (ITypeDBSession session = driver.Session("access-management-db", SessionType.Schema))
    {
        using (ITypeDBTransaction tx = session.Transaction(TransactionType.Write))
        {
            tx.Query.Define(accessManagementSchema).Resolve();
            tx.Commit();
        }
    }
 
    using (ITypeDBSession session = driver.Session("access-management-db", SessionType.Data))
    {
        foreach (var batch in accessManagementDataBatches)
        {
            using (ITypeDBTransaction tx = session.Transaction(TransactionType.Write))
            {
                foreach (var query in batch)
                {
                    tx.Query.Insert(query);
                }
                tx.Commit();
            }
        }
 
        using (ITypeDBTransaction tx = session.Transaction(TransactionType.Read))
        {
            IEnumerable<IConceptMap> results = tx.Query.Get("match $u isa user; get;");
        }
    }
}

let connection = Connection::new_core("localhost:1729")?;
let databases = DatabaseManager::new(connection);
let session = Session::new(databases.get("access-management-db").await?, SessionType::Schema).await?;
let tx = session.transaction(TransactionType::Write).await?;

// create a new abstract type "user"
let mut user = tx.concept().put_entity_type("user".to_owned()).await?;
user.set_abstract(&tx).await?;

// change the supertype of "employee" to "user"
let mut employee = tx.concept().get_entity_type("employee".to_owned()).await?.unwrap();
employee.set_supertype(&tx, user.clone()).await?;

// change the supertype of "contractor" to "user"
let mut contractor = tx.concept().get_entity_type("contractor".to_owned()).await?.unwrap();
contractor.set_supertype(&tx, user.clone()).await?;

// move "email" and "name" attribute types to be owned by "user" instead of "employee"
let email = tx.concept().get_attribute_type("email".to_owned()).await?.unwrap();
let mut name = tx.concept().get_attribute_type("name".to_owned()).await?.unwrap();
employee.unset_owns(&tx, email.clone()).await?;
employee.unset_owns(&tx, name.clone()).await?;
user.set_owns(&tx, email, None, Vec::new()).await?;
user.set_owns(&tx, name.clone(), None, Vec::new()).await?;

// rename "name" attribute type to "full-name"
name.set_label(&tx, "full-name".to_owned()).await?;

// commit all schema changes in one transaction, which will fail if we violate any data validation
tx.commit().await?;

with TypeDB.core_driver("localhost:1729") as driver:
    with driver.session("access-management-db", SessionType.SCHEMA) as session:
        with session.transaction(TransactionType.WRITE) as tx:

            # create a new abstract type "user"
            user = tx.concepts.put_entity_type("user").resolve()
            user.set_abstract(tx).resolve()

            # change the supertype of "employee" to "user"
            employee = tx.concepts.get_entity_type("employee").resolve()
            employee.set_supertype(tx, user).resolve()

            # change the supertype of "contractor" to "user"
            contractor = tx.concepts.get_entity_type("contractor").resolve()
            contractor.set_supertype(tx, user).resolve()

            # move "email" and "name" attribute types to be owned by "user" instead of "employee"
            email = tx.concepts.get_attribute_type("email").resolve()
            name = tx.concepts.get_attribute_type("name").resolve()
            employee.unset_owns(tx, email).resolve()
            employee.unset_owns(tx, name).resolve()
            user.set_owns(tx, email).resolve()
            user.set_owns(tx, name).resolve()

            # rename "name" attribute type to "full-name"
            name.set_label(tx, "full-name").resolve()

            # commit all schema changes in one transaction, which will fail if we violate any data validation
            tx.commit()

try {
    driver = await TypeDB.coreDriver("localhost:1729");
    session = await driver.session("access-management-db", SessionType.SCHEMA);
    tx = await session.transaction(TransactionType.WRITE);

    // create a new abstract type "user"
    let user = await tx.concepts.putEntityType("user");
    await user.setAbstract(tx);

    // change the supertype of "employee" to "user"
    let employee = await tx.concepts.getEntityType("employee");
    await employee.setSupertype(tx, user);

    // change the supertype of "contractor" to "user"
    let contractor = await tx.concepts.getEntityType("contractor");
    await contractor.setSupertype(tx, user);

    // move "email" and "name" attribute types to be owned by "user" instead of "employee"
    let email = await tx.concepts.getAttributeType("email");
    let name = await tx.concepts.getAttributeType("name");
    await employee.unsetOwns(tx, email);
    await employee.unsetOwns(tx, name);
    await user.setOwns(tx, email);
    await user.setOwns(tx, name);

    // rename "name" attribute type to "full-name"
    await name.setLabel(tx, "full-name");

    // commit all schema changes in one transaction, which will fail if we violate any data validation
    await tx.commit()
}  finally {
    if (tx) await tx.close();
    if (session) await session.close();
    if (driver) await driver.close();
}

try (TypeDBDriver driver = TypeDB.coreDriver("localhost:1729")) {
    try (TypeDBSession session = driver.session("access-management-db", TypeDBSession.Type.SCHEMA)) {
        try (TypeDBTransaction tx = session.transaction(TypeDBTransaction.Type.WRITE)) {
            // create a new abstract type "user"
            EntityType user = tx.concepts().putEntityType("user").resolve();
            user.setAbstract(tx).resolve();

            // change the supertype of "employee" to "user"
            EntityType employee = tx.concepts().getEntityType("employee").resolve();
            employee.setSupertype(tx, user).resolve();

            // change the supertype of "contractor" to "user"
            EntityType contractor = tx.concepts().getEntityType("contractor").resolve();
            contractor.setSupertype(tx, user).resolve();

            // move "email" and "name" attribute types to be owned by "user" instead of "employee"
            AttributeType email = tx.concepts().getAttributeType("email").resolve();
            AttributeType name = tx.concepts().getAttributeType("name").resolve();
            employee.unsetOwns(tx, email).resolve();
            employee.unsetOwns(tx, name).resolve();
            user.setOwns(tx, email).resolve();
            user.setOwns(tx, name).resolve();

            // rename "name" attribute type to "full-name"
            name.setLabel(tx, "full-name").resolve();

            // commit all schema changes in one transaction, which will fail if we violate any data validation
            tx.commit();
        }
    }
}

Connection* connection = connection_open_core("localhost:1729");
DatabaseManager* databaseManager = database_manager_new(connection);
Options* options = options_new();
Session* session = session_new(databaseManager, "access-management-db", Schema, options);

Transaction* tx = transaction_new(session, Write, options);

// create a new abstract type "user"
Concept* user = concept_promise_resolve(concepts_put_entity_type(tx, "user"));
void_promise_resolve(thing_type_set_abstract(tx, user));

// change the supertype of "employee" to "user"
Concept* employee = concept_promise_resolve(concepts_get_entity_type(tx, "employee"));
void_promise_resolve(entity_type_set_supertype(tx, employee, user));

// change the supertype of "contractor" to "user"
Concept* contractor = concept_promise_resolve(concepts_get_entity_type(tx, "contractor"));
void_promise_resolve(entity_type_set_supertype(tx, contractor, user));

// move "email" and "name" attribute types to be owned by "user" instead of "employee"
Concept* email = concept_promise_resolve(concepts_get_attribute_type(tx, "email"));
Concept* name = concept_promise_resolve(concepts_get_attribute_type(tx, "name"));
void_promise_resolve(entity_type_set_supertype(tx, contractor, user));
void_promise_resolve(thing_type_unset_owns(tx, employee, email));
void_promise_resolve(thing_type_unset_owns(tx, employee, name));
const Annotation* noAnnotations[1] = {NULL};
void_promise_resolve(thing_type_set_owns(tx, user, email, NULL, noAnnotations));
void_promise_resolve(thing_type_set_owns(tx, user, name, NULL, noAnnotations));

// rename "name" attribute type to "full-name"
void_promise_resolve(thing_type_set_label(tx, name, "full-name"));

// commit all schema changes in one transaction, which will fail if we violate any data validation
void_promise_resolve(transaction_commit(tx));

session_close(session);
options_drop(options);
database_manager_drop(databaseManager);
connection_close(connection);

TypeDB::Driver driver = TypeDB::Driver::coreDriver("localhost:1729");
TypeDB::Options options;
TypeDB::Session session = driver.session("access-management-db", TypeDB::SessionType::SCHEMA, options);
TypeDB::Transaction tx = session.transaction(TypeDB::TransactionType::WRITE, options);

// create a new abstract type "user"
std::unique_ptr<EntityType> user = tx.concepts.putEntityType("user").get();
user->setAbstract(tx).get();

// change the supertype of "employee" to "user"
auto employee = tx.concepts.getEntityType("employee").get();
employee->setSupertype(tx, user.get()).get();

// change the supertype of "contractor" to "user"
auto contractor = tx.concepts.getEntityType("contractor").get();
contractor->setSupertype(tx, user.get()).get();

// move "email" and "name" attribute types to be owned by "user" instead of "employee"
std::unique_ptr<AttributeType> email = tx.concepts.getAttributeType("email").get();
std::unique_ptr<AttributeType> name = tx.concepts.getAttributeType("name").get();
employee->unsetOwns(tx, email.get()).get();
employee->unsetOwns(tx, name.get()).get();
user->setOwns(tx, email.get()).get();
user->setOwns(tx, name.get()).get();

// rename "name" attribute type to "full-name"
name->setLabel(tx, "full-name").get();

// commit all schema changes in one transaction, which will fail if we violate any data validation
tx.commit();

using (ITypeDBDriver driver = Drivers.CoreDriver("localhost:1729")) 
{
    using (ITypeDBSession session = driver.Session("access-management-db", SessionType.Schema)) 
    {
        using (ITypeDBTransaction tx = session.Transaction(TransactionType.Write)) 
        {
            // create a new abstract type "user"
            IEntityType user = tx.Concepts.PutEntityType("user").Resolve();
            user.SetAbstract(tx).Resolve();
 
            // change the supertype of "employee" to "user"
            IEntityType employee = tx.Concepts.GetEntityType("employee").Resolve();
            employee.SetSupertype(tx, user).Resolve();
 
            // change the supertype of "contractor" to "user"
            IEntityType contractor = tx.Concepts.GetEntityType("contractor").Resolve();
            contractor.SetSupertype(tx, user).Resolve();
 
            // move "email" and "name" attribute types to be owned by "user" instead of "employee"
            IAttributeType email = tx.Concepts.GetAttributeType("email").Resolve();
            IAttributeType name = tx.Concepts.GetAttributeType("name").Resolve();
            employee.UnsetOwns(tx, email).Resolve();
            employee.UnsetOwns(tx, name).Resolve();
            user.SetOwns(tx, email).Resolve();
            user.SetOwns(tx, name).Resolve();
 
            // rename "name" attribute type to "full-name"
            name.SetLabel(tx, "full-name").Resolve();
 
            // commit all schema changes in one transaction, which will fail if we violate any data validation
            tx.Commit();
        }
    }
}