본문으로 건너뛰기
D.HubLearning Center
KOEN
Ontology Modeler
55분

Ontology Modeler Path

Six lessons modeling data as a graph of entities and relations — entity design, backing-dataset mapping, relations, inspecting instances in the Graph explorer, and handoff to analysts and engineers.

0/6 complete

About this Path

This Path takes you through D.Hub portal from the ontology modeler point of view. If the Analyst Path is the flow of a person building result screens on top of data that already exists, and the Engineer Path is the flow of ingesting that data from external systems and automating it, this Path covers the third leg — modeling data as a graph of entities and relations — end to end across six lessons. About 55 minutes in total.

The persona is intentionally not narrowed. A data architect, a domain modeler, or a bridge between engineer and analyst can all enter, so the body is written in a task tone rather than a role tone — how to draw an entity, how to connect a relation, and how to inspect the instances that land on top.

Each lesson is 5–10 minutes. You can run through them in one sitting or spread one or two per day.

Prerequisites

  • Portal access (Editor or above). You need to be able to create entities and relations inside a collection.
  • Familiarity with collection and dataset basics. The depth from Analyst Path lessons 02–03 is enough.
  • At least one dataset already landed in your own collection. The fastest paths are the outputs of Engineer Path lessons 02–03, or a dhub2-examples scenario imported.

Prior knowledge of entity-relation modeling (ER) or knowledge graph tools like Neo4j, RDF, or OWL maps quickly, but is not required. Lesson 01 lays out the mapping between portal's vocabulary and the familiar one in a single table.

What you can do by the end

  • Explain where ontology sits in portal as a first-class surface (the Modeling and Graph Explorer menus inside the ONTOLOGY section).
  • Define one entity — name, alias, identity keys, display column, and the six attribute types.
  • Map dataset columns onto entity attributes 1:1 and understand how the backend sink automatically lands the result into the graph database after mapping.
  • Connect two entities with a relation by drag on the canvas and decide its cardinality (1:1, 1:N, N:N) and naming convention (verb_phrase).
  • In the Graph explorer, click a label, double-click a node to expand, and query instances directly with the three-line Cypher pattern (MATCH · RETURN · LIMIT).
  • Know how far a model change propagates (a pipeline's Entity I/O, graph instances, the inspector labels) and close the cycle of adding a new mapping when a new dataset arrives.
  • Hand the graph you built off to analysts as an entry link to the Graph explorer and to engineers as the procedure to add a new dataset mapping, one paragraph each.

What comes after this Path

Natural directions to go deeper from the ontology flow:

  • Analyst Path lesson 04 — First dashboard and widgets — Put one of your entities onto a widget as input and watch the data architect's model = the analyst's input close inside one portal.
  • Engineer Path lesson 03 — First pipeline — The flow of regularly populating your backing dataset from external systems. Natural when you also own the responsibility of who feeds the data.
  • Workshop: Retail Inventory Intelligence — Every surface in this Path (four entities + three relations) appears tied together on a single domain scenario. The three viewpoints — analyst, engineer, modeler — meet on top of the same collection. About 90 minutes.

Filling the checkbox next to each lesson auto-records your progress. Go ahead and start.

Lessons

  1. 01Ontology Modeler workflow overviewWhere ontology sits in portal as a first-class surface, which two menus the modeler lives in (Modeling and Graph Explorer), and how it connects to the analyst and engineer surfaces — all in a single table.
    7분
  2. 02Entity design — name · Identity · Display · attribute typesDefine a single entity in the Modeling builder. Walk through name and alias, Identity Keys and Display Column, and the six attribute types together using the IoT scenario's `IOT_Machine`.
    10분
  3. 03Backing-dataset mapping — wiring columns to attributesConnect a real dataset to the entity defined in the previous lesson. 1:1 column-to-attribute mapping, Identity Keys mapping, automatic backend sink sync, and the question of whether one dataset can back multiple entities.
    10분
  4. 04Relationships — connect two entities and set the cardinalityFrom the builder canvas, drag from a source entity to a target entity to create a relation, then close the loop on naming convention (verb_phrase), cardinality (1:1, 1:N, N:N), and backing-dataset mapping. The example walks through the three relations of the retail supply-chain scenario.
    10분
  5. 05Graph explorer — click a label, expand neighbors, three lines of CypherWalk through the Graph explorer's three faces — metadata panel, visualization area, query editor — in order. Start from a single label click and end at the three-line Cypher pattern (MATCH · RETURN · LIMIT), all in one lesson.
    8분
  6. 06Iteration · handoff to analysts and engineersHow model changes propagate (pipeline Entity I/O, graph instances, inspector labels), the flow of adding a mapping when a new dataset arrives, and a paragraph each handing off to analysts (Graph explorer entry) and engineers (new dataset mapping pattern).
    10분