1
2
3
4
5
6
7
// Launch Gremlin Console
bin/gremlin.sh

// Create a graph instance
graph = TinkerGraph.open()
g = graph.traversal()

1
2
3
4
5
6
7
8
9
10
11
# Python (Gremlin-Python)
from gremlin_python.driver import client
gremlin_client = client.Client('ws://localhost:8182/gremlin', 'g')

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

# JavaScript (Node.js)
const gremlin = require('gremlin');
const client = new gremlin.driver.Client('ws://localhost:8182/gremlin');

1
2
3
4
5
6
7
8
9
// Create vertices
g.addV('Person').property('name', 'Alice')
g.addV('Company').property('name', 'TinkerCorp')

// Create edges
g.V().has('name', 'Alice')
  .addE('works_at')
  .to(g.V().has('name', 'TinkerCorp'))

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

// Retrieve properties
g.V().has('name', 'Alice').valueMap()

1
2
3
4
5
6
// Pipeline-based traversals
g.V()                  // Start with all vertices
  .has('type', 'User') // Filter vertices
  .out('friends')      // Traverse outgoing edges
  .values('name')      // Extract name property

1
2
3
4
5
6
g.V()                  // All vertices
g.E()                  // All edges
g.V().out()            // Outgoing neighbors
g.V().in()             // Incoming neighbors
g.V().both()           // All connected vertices

1
2
3
4
5
6
7
// Simple filtering
g.V().has('age', gt(25))
g.V().has('name', containing('John'))

// Complex predicates
g.V().where(__.out('knows').count().is(gt(2)))

1
2
3
4
5
6
7
8
// Comparison predicates
eq()    // Equal to
neq()   // Not equal
gt()    // Greater than
lt()    // Less than
inside()
outside()

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

// Select specific properties
g.V().select('name', 'age')

// Project multiple values
g.V().project('name', 'friends')
     .by('name')
     .by(out('knows').count())

1
2
3
4
5
6
7
8
// Count elements
g.V().count()
g.V().group().by('type').by(count())

// Fold and reduce
g.V().fold()
g.V().group().by('type').by(fold())

1
2
3
4
5
6
// Path tracking
g.V().out().path()

// Complex path filtering
g.V().repeat(out()).times(2).path()

1
2
3
4
5
6
7
8
9
10
11
12
// Add vertex
g.addV('Person')
  .property('name', 'Bob')

// Add edge
g.V().has('name', 'Alice')
  .addE('knows')
  .to(g.V().has('name', 'Bob'))

// Drop elements
g.V().has('name', 'Bob').drop()

1
2
3
4
5
6
7
8
9
// Branch traversal
g.V().branch(
  select('type').option('User', __.out('friends'))
              .option('Company', __.in('works_at'))
)

// Subgraph extraction
g.V().has('age', gt(25)).subgraph('adult_network')

1
2
3
4
5
6
// Use local steps
g.V().local(values('name').limit(5))

// Avoid full graph scans
g.V('user_id')  // Direct vertex lookup

1
2
3
4
5
6
// Shortest path
g.V('start').repeat(both()).until(hasId('end')).path()

// Centrality calculation
g.V().pageRank()