Databases

This section covers the management of databases and the definition of the schema, which provides the structural foundation for your data.

Managing databases

In TypeDB, databases are high-level containers for your data and its corresponding schema. A single TypeDB server can contain multiple databases, each of which are fully separated. No operations or data can cross between them.

Database creation and deletion are administrative operations performed through tools like the TypeDB Console or programmatically via the drivers, rather than through TypeQL queries.

Database creation

To create a new database, you can use the database create command in the Console (e.g., database create my-database) or call the appropriate method in a client driver, such as driver.databases.create("my-database") in Python.

Database deletion

Deleting a database, which permanently removes all of its contents, is handled similarly. The Console command is database delete my-database, and the equivalent in the Python driver is client.databases.delete("my-database"). This is an irreversible action and should be used with care.

Database administration

You can also perform administrative checks, such as verifying if a database exists or viewing all databases on the server. To see a complete list, you can use database list in the Console or client.databases.all() in the Python driver.

Defining a schema

The schema is a high-level specification of your application’s data model. The schema must be defined before any data is inserted into the database.

The schema is composed of three main kinds of types:

  • Entity types represent the primary objects or concepts in your domain (e.g., person, company, movie).

  • Relation types represent the relationships that can exist between types (e.g., friendship, employment, casting).

  • Attribute types represent the properties or data values that other types can have (e.g., name, mission-statement, release-date).

You build your schema by defining these types and their interactions using several key statements within a define query:

  • entity/relation/attribute creates a root type of specified kind (e.g., entity person;).

  • sub creates a type that inherits from a supertype (e.g., entity employee sub person;).

  • owns specifies that an entity or relation can have a certain attribute (e.g., person owns name;).

  • relates defines a role that is part of a relation (e.g., employment relates employee;).

  • plays specifies that an entity can play a role in a relation (e.g., person plays employment:employee;).

Here is an example of a simple schema definition:

#!test[schema]
define
  entity person,
    owns name,
    owns email,
    plays employment:employee;

  attribute name, value string;

  attribute email, value string;

  entity employee sub person,
    owns employee-id;

  attribute employee-id, value string;

  relation employment,
    relates employee;

For more information on defining a schema and the TypeDB data model, refer to the Entities, Relations, Attributes documentation.