1
2
3
4
5
6
7
// Launch Gremlin Console (Apache TinkerPop 3.7.x)
bin/gremlin.sh

// Create an in-memory graph instance
graph = TinkerGraph.open()
g = traversal().withEmbedded(graph)   // preferred over graph.traversal()

1
2
3
4
5
6
7
8
# Python (gremlinpython 3.7.x)
from gremlin_python.driver.driver_remote_connection import DriverRemoteConnection
from gremlin_python.process.anonymous_traversal import traversal

g = traversal().withRemote(
    DriverRemoteConnection('ws://localhost:8182/gremlin', 'g')
)

1
2
3
4
5
6
7
// Java (tinkerpop 3.7.x)
import static org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal;
import org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection;

GraphTraversalSource g = traversal()
        .withRemote(DriverRemoteConnection.using("localhost", 8182, "g"));

1
2
3
4
5
6
7
8
9
// JavaScript (gremlin 3.7.x, Node.js)
const gremlin = require('gremlin');
const { DriverRemoteConnection } = gremlin.driver;
const { traversal } = gremlin.process.AnonymousTraversalSource;

const g = traversal().withRemote(
    new DriverRemoteConnection('ws://localhost:8182/gremlin')
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Create vertices (iterate() ensures execution in remote sessions)
alice  = g.addV('Person').property('name', 'Alice').next()
corp   = g.addV('Company').property('name', 'TinkerCorp').next()

// Create edges using anonymous traversals with V() inside the step
g.V().has('Person', 'name', 'Alice')
  .addE('works_at')
  .to(__.V().has('Company', 'name', 'TinkerCorp'))
  .iterate()

// mergeV / mergeE (3.6+) for idempotent upserts
g.mergeV([(T.label): 'Person', name: 'Alice'])
g.mergeE([(T.label): 'knows', (Direction.OUT): aliceId, (Direction.IN): bobId])

1
2
3
4
5
6
7
8
9
10
// Add/Modify properties
g.V().has('Person', 'name', 'Alice')
  .property('age', 30)
  .property('city', 'San Francisco')
  .iterate()

// Retrieve properties
g.V().has('name', 'Alice').valueMap(true)   // include id/label
g.V().has('name', 'Alice').elementMap()     // 3.4+ flat map incl. id/label

1
2
3
4
5
6
7
// Pipeline-based traversals are lazy; terminal steps trigger execution
g.V()                  // Start with all vertices
  .hasLabel('User')    // Filter by label (preferred over has('type', ...))
  .out('friends')      // Traverse outgoing edges labeled 'friends'
  .values('name')      // Extract name property
  .toList()            // Terminal step

1
2
3
4
5
6
7
g.V()                  // All vertices
g.E()                  // All edges
g.V().out('knows')     // Outgoing neighbors via 'knows' edges
g.V().in('knows')      // Incoming neighbors
g.V().both('knows')    // Both directions
g.V().outE('knows').inV()   // Edge-then-vertex variant

1
2
3
4
5
6
7
8
9
10
11
import static org.apache.tinkerpop.gremlin.process.traversal.P.*
import static org.apache.tinkerpop.gremlin.process.traversal.TextP.*

g.V().has('age', gt(25))
g.V().has('name', containing('John'))      // TextP, 3.4+
g.V().has('name', startingWith('Al'))
g.V().has('name', regex('^A.*'))            // TextP, 3.6+

// where() with anonymous traversal
g.V().where(__.out('knows').count().is(gt(2)))

1
2
3
4
5
6
7
// Comparison (P)
eq, neq, gt, gte, lt, lte, inside, outside, between, within, without

// Text (TextP, 3.4+; regex/notRegex added in 3.6)
startingWith, notStartingWith, endingWith, notEndingWith,
containing, notContaining, regex, notRegex

1
2
3
4
5
6
7
8
9
10
11
12
// Map transformation (anonymous traversal)
g.V().map(__.values('name'))

// Select previously labeled steps
g.V().as('v').out('knows').as('friend').select('v', 'friend')

// Project multiple values (use anonymous traversal in by())
g.V().hasLabel('Person')
     .project('name', 'friends')
     .by('name')
     .by(__.out('knows').count())

1
2
3
4
5
6
7
8
9
10
g.V().count()
g.V().group().by(label).by(count())

// Fold/unfold
g.V().fold()
g.V().group().by(label).by(fold())

// mean / sum / min / max
g.V().hasLabel('Person').values('age').mean()

1
2
3
4
5
6
7
8
9
10
g.V().out().path()
g.V().out().path().by('name')

// Bounded repeat with path output
g.V().repeat(out()).times(2).path()

// shortestPath() step (3.5+, via withComputer())
g.withComputer().V().has('name', 'Alice')
  .shortestPath().with(ShortestPath.target, __.has('name', 'Bob'))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
g.addV('Person').property('name', 'Bob').iterate()

g.V().has('Person', 'name', 'Alice')
  .addE('knows')
  .to(__.V().has('Person', 'name', 'Bob'))
  .iterate()

// Drop elements (properties, vertices, or edges)
g.V().has('Person', 'name', 'Bob').drop().iterate()

// Idempotent upserts (3.6+)
g.mergeV([(T.label): 'Person', name: 'Carol'])
 .option(Merge.onCreate, [createdAt: System.currentTimeMillis()])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// choose() for if/then, branch() for fan-out
g.V().choose(__.hasLabel('User'),
             __.out('friends'),
             __.in('works_at'))

// branch() with options
g.V().branch(__.label())
     .option('User', __.out('friends'))
     .option('Company', __.in('works_at'))

// Subgraph extraction (collects matching edges into a side-effect graph)
g.V().has('age', gt(25)).outE().subgraph('adultNetwork')
  .cap('adultNetwork')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Direct id-based lookups beat full scans
g.V(userId)

// Use indexed has() with label + property when possible
g.V().has('Person', 'email', 'alice@example.com')

// Limit results early
g.V().hasLabel('Person').limit(100).values('name')

// local() restricts a sub-traversal to each incoming element
g.V().local(__.values('name').limit(5))

// Use barrier() to batch network/IO heavy steps
g.V().hasLabel('Person').barrier(1000).out('knows')

// Prefer elementMap()/valueMap() over multiple property() calls

1
2
3
4
5
6
7
8
9
10
11
12
// Shortest path via repeat/until (works on any TinkerPop provider)
g.V().has('name', 'Alice')
  .repeat(both().simplePath())
  .until(has('name', 'Bob').or().loops().is(6))
  .has('name', 'Bob')
  .path().limit(1)

// PageRank / Peer Pressure / Connected Components (OLAP, via withComputer())
g.withComputer().V().pageRank().by('pageRank').values('pageRank')
g.withComputer().V().peerPressure().by('cluster').values('cluster')
g.withComputer().V().connectedComponent().values('gremlin.connectedComponentVertexProgram.component')