CONCEPT Cited by 1 source

Property graph¶

The property graph is a graph data model where:

Nodes have a type and zero or more typed properties.
Edges connect nodes, have a type, zero or more typed properties, and a direction (unidirectional or bidirectional).
Properties are typed (e.g. STRING, TIMESTAMP, INT) — the type system is not just a comment but enforced at write time.

The model contrasts with RDF / triple-store graphs (every fact is a (subject, predicate, object) triple) and with knowledge-graph ontologies that overlay subclass / equivalence reasoning. Property graphs are the canonical model for OLTP graph workloads — the model that traversal-style languages like Gremlin (Apache TinkerPop) and openCypher target.

The shape¶

                  ┌─────────────────┐
                  │ Node            │
                  │  type: account  │
                  │  props:         │
                  │    created_at:  │
                  │    TIMESTAMP    │
                  └────────┬────────┘
                           │ edge
                           │  type: owns
                           │  direction: UNIDIRECTIONAL
                           │  props: (none in this example)
                           ▼
                  ┌─────────────────┐
                  │ Node            │
                  │  type: profile  │
                  │  props:         │
                  │    last_active: │
                  │    TIMESTAMP    │
                  └────────┬────────┘
                           │ edge
                           │  type: linked_to
                           │  direction: BIDIRECTIONAL
                           │  props:
                           │    registration_time: TIMESTAMP
                           │    status: STRING
                           ▼
                  ┌─────────────────┐
                  │ Node            │
                  │  type: device   │
                  └─────────────────┘

Why "strongly typed" matters¶

A property-graph schema declares which edge types are legal between which node types and which property types are legal on which edges:

{
  "edgeMappingKey": {
    "fromNodeType": "profile",
    "edgeType": "linked_to",
    "toNodeType": "device"
  },
  "directionType": "BIDIRECTIONAL",
  "propertySchema": {
    "propertyMappings": [
      { "propertyKey": "registration_time", "propertyValueType": "TIMESTAMP" },
      { "propertyKey": "status",            "propertyValueType": "STRING" }
    ]
  }
}

A schema-aware property-graph runtime gets four query-time optimisations for free:

Data quality — reject non-conforming nodes / edges / properties at write time.
Query planning — enumerate only the traversal paths the schema permits.
Bidirectional dedup — for traversals on edges between the same node type, walk only one side.
Path elimination — drop traversals whose relationships are structurally impossible or whose property filters are type- incompatible.

(Source: sources/2026-05-29-netflix-high-throughput-graph-abstraction-at-netflix-part-i)

OLTP vs OLAP property graphs¶

The same data model serves two very different workload classes (concepts/oltp-vs-olap):

	OLAP graph	OLTP graph
Query shape	open-ended exploration	start-from-known-node + bounded depth
Languages	RDF / SPARQL · Gremlin · openCypher · SQL	custom traversal API + property-key pushdown
Throughput	analytical	up to millions of ops/sec
Latency	seconds to minutes	single-digit-ms to low-100s
Consistency	typically read-snapshot of analytical store	eventual consistency tolerated
Wiki canonical instance	not yet covered	systems/netflix-graph-abstraction

Netflix Graph Abstraction is the wiki's first canonical property-graph-OLTP system.

Edge direction is a first-class property¶

In property-graph models, edges are not symmetric pointers — the direction is part of the schema:

UNIDIRECTIONAL — (account)-[owns]→(profile). Walking profile → account requires a separate edge or a reverse index.
BIDIRECTIONAL — (profile)-[linked_to]-(device). Traversable from either end.

Storage systems that materialise property graphs frequently maintain forward and reverse adjacency indexes (concepts/forward-reverse-edge-index) so traversals don't need full scans for either direction. Edge properties, by contrast, are direction-symmetric and can be stored once under a direction-agnostic edge identifier.

Comparison with adjacent models¶

Model	Relationship to property graph
RDF / triple store	facts are atomic triples; properties are not first-class on edges (use reified statements)
Knowledge graph (concepts/knowledge-graph)	property graph + ontology / inference layer; can be implemented on either property-graph or RDF substrates
Document store with references	objects with foreign-key-like links; lacks first-class edge typing and traversal primitives
Adjacency-matrix / GraphBLAS	algorithmic / linear-algebra graph view; complements rather than replaces property graph for OLAP

Seen in¶

sources/2026-05-29-netflix-high-throughput-graph-abstraction-at-netflix-part-i — canonical wiki disclosure; Netflix Graph Abstraction uses the property-graph model as its data shape, with strongly- typed schemas in the Data Gateway Control Plane and an in-memory metadata graph driving four query-time optimisations.