Skip to content

Creating Your Data Model◈

This document explains how to model data using Graphite’s graph model.

Note This document does not cover all Graphite features or general database design principles.

Engine Setup◈

Note See the Quickstart guide for a complete setup walkthrough.

First, install Graphite:

pip install graphitedb

Then import it and create an engine instance:

import graphite

engine = graphite.engine()

The engine is responsible for parsing DSL definitions, storing data, and executing graph operations.

Defining Node Types◈

Before inserting data, define the structure of your domain. Start by identifying the core object types in your system.

In this example, we model employment relationships. The primary entities are Person and Company.

node_types = """
node Person
name: string

node Company
"""

engine.parse(node_types)

This defines:

  • A Person node type with a name field of type string.
  • A Company node type without fields.

Note You can define node types, relation types, nodes, and relations in a single .parse() call if needed.

Node Type Inheritance◈

Graphite supports inheritance using the from keyword. This allows you to share fields across related types.

node_types = """
node Object
price: int

node Chair from Object
height: float

node Book from Object
author: string
"""

In this example:

  • Object defines a shared price field.
  • Chair inherits price and adds height.
  • Book inherits price and adds author.

Child node types include all fields from their base types.

Defining Relation Types◈

Relations define how nodes connect and what data is associated with those connections.

For modeling jobs, a WORKS_AT relation is appropriate:

relation_types = """
relation WORKS_AT
Person -> Company
salary: int
"""

engine.parse(relation_types)

This defines:

  • A relation type named WORKS_AT
  • Source node type: Person
  • Target node type: Company
  • A salary field of type int

The engine enforces the source and target type constraints.

Creating Nodes◈

After defining types, you can create nodes using either DSL or direct engine methods.

Using DSL◈

engine.parse("graphite_games, Company")

engine.parse("""
database_home, Company

joe, Person, Joe
admin, Person, John
""")

Using Engine API◈

engine.create_node("alice", "Person", "Alice")

Each node:

  • Has a unique ID
  • Has a base type
  • Stores field values in the order defined by its type hierarchy

Creating Relations◈

Relations connect nodes according to relation type definitions.

Using DSL◈

engine.parse("""
alice -[WORKS_AT, 30000]-> graphite_games
alice -[WORKS_AT, 1000]-> database_home
""")

The DSL pattern is:

source -[RELATION_TYPE, field_values]-> target

Using Engine API◈

engine.create_relation("joe", "graphite_games", "WORKS_AT", 30000)

Note Undirected relations can be defined using:

source -[RELATION_TYPE, field_values]- target

Next Steps◈

Once your data model and data are defined, you can query the graph, traverse relationships, and perform analysis using Graphite’s APIs. These operations are covered in the next documents.