SQL Script

BEGIN [ISOLATION <READ_COMMITTED | REPEATABLE_READ>]

BEGIN ISOLATION REPEATABLE_READ;
LET v1 = SELECT FROM Account WHERE id = 1;
-- ... other work ...
LET v2 = SELECT FROM Account WHERE id = 1;  -- guaranteed to match v1
COMMIT;

COMMIT [RETRY <n> [ELSE { <statements> } [AND] (FAIL | CONTINUE)]]

-- retry up to 100 times, fail if still conflicting
BEGIN;
LET account = CREATE VERTEX Account SET name = 'Luke';
LET city    = SELECT FROM City WHERE name = 'London';
LET e       = CREATE EDGE Lives FROM $account TO $city;
COMMIT RETRY 100;
RETURN $e;

-- retry, otherwise log to a dead-letter type and continue
BEGIN;
UPDATE Account SET balance = balance - 100 WHERE id = 1;
UPDATE Account SET balance = balance + 100 WHERE id = 2;
COMMIT RETRY 10 ELSE {
  INSERT INTO TransferDLQ SET fromId = 1, toId = 2, amount = 100, ts = sysdate();
} AND CONTINUE;

LOCK TYPE   <type-name>  [, <type-name>]*
LOCK BUCKET <bucket-name>[, <bucket-name>]*

BEGIN;
LOCK TYPE Account;                              -- nobody else can modify Account until we commit
LET total = SELECT sum(balance) FROM Account;
INSERT INTO Audit SET kind = 'snapshot', total = $total[0].sum, ts = sysdate();
COMMIT;

BEGIN;
LOCK BUCKET orders_2026_q2;                     -- serialize writes on a hot bucket
INSERT INTO Order BUCKET orders_2026_q2 SET ...;
COMMIT;

LET <var> = <expression>
LET <var> = <SQL statement>
LET <var1> = <expr1>, <var2> = <expr2>, ...

LET hubs = SELECT FROM City WHERE category = 'hub';
LET count = $hubs.size();
INSERT INTO Stat SET name = 'hub-count', value = $count;
RETURN $count;

LET mytype = 'vec';
LET r = SELECT FROM $mytype WHERE num > 0;
RETURN $r;

LET myedge = 'Lives';
LET r = CREATE EDGE $myedge FROM #1:0 TO #1:1;
RETURN $r;

SET GLOBAL <var> = <BOOLEAN | STRING | NUMBER | LIST | MAP>

SET GLOBAL tenant = 'acme';
-- later, in any query on this database:
SELECT FROM Account WHERE tenantId = $tenant;

RETURN [<expression>]

IF (<sql-predicate>) {
  <statement>;
  <statement>;
  ...
} [ELSE {
  <statement>;
  ...
}]

LET existing = SELECT FROM User WHERE email = '[email protected]';
IF ($existing.size() = 0) {
  INSERT INTO User SET email = '[email protected]', createdAt = sysdate();
} ELSE {
  UPDATE User SET lastSeen = sysdate() WHERE email = '[email protected]';
}

IF ($a.size() > 0) {
  ROLLBACK;
}

FOREACH (<variable> IN <expression>) {
  <statement>;
  <statement>;
  ...
}

FOREACH ($i IN [1, 2, 3]) {
  INSERT INTO Foo SET value = $i;
}

-- bulk-create edges from a query result
LET people = SELECT FROM Person WHERE city = 'London';
FOREACH ($p IN $people) {
  CREATE EDGE LivesIn FROM $p TO (SELECT FROM City WHERE name = 'London');
}

WHILE (<condition>) {
  <statement>;
  <statement>;
  ...
}

LET $i = 0;
WHILE ($i < 10) {
  INSERT INTO Foo SET value = $i;
  LET $i = $i + 1;
}

FOREACH ($i IN [1, 2, 3, 4, 5]) {
  IF ($i > 2) {
    BREAK;
  }
  CONSOLE.log $i;
}

-- sum positive amounts until you hit a negative one
LET total = 0;
FOREACH ($record IN (SELECT FROM CustomerAccount)) {
  IF ($record.amount < 0) {
    BREAK;
  }
  LET total = $total + $record.amount;
}
RETURN $total;

SLEEP <milliseconds>

FOREACH ($url IN $urls) {
  INSERT INTO FetchJob SET url = $url, status = 'queued';
  SLEEP 50;                                  -- be polite to a downstream system
}

CONSOLE.log    <expression>
CONSOLE.output <expression>
CONSOLE.error  <expression>
CONSOLE.warn   <expression>
CONSOLE.debug  <expression>

LET count = SELECT count(*) AS c FROM Order WHERE status = 'pending';
IF ($count[0].c > 1000) {
  CONSOLE.warn 'Pending order backlog is ' + $count[0].c;
}

CREATE VERTEX TYPE City   IF NOT EXISTS;
CREATE VERTEX TYPE Account IF NOT EXISTS;
CREATE EDGE   TYPE Lives   IF NOT EXISTS;

CREATE INDEX IF NOT EXISTS ON City    (name)  UNIQUE;
CREATE INDEX IF NOT EXISTS ON Account (email) UNIQUE;

BEGIN;

-- 1. Upsert the city. UNIQUE index on City.name makes this atomic.
--    `RETURN AFTER` returns the upserted row directly, so we capture
--    the vertex (and its RID) in $city without a second roundtrip.
LET city    = UPDATE City SET name = 'London', country = 'UK'
              UPSERT RETURN AFTER WHERE name = 'London';

-- 2. Upsert the person. UNIQUE index on Account.email makes this atomic.
LET account = UPDATE Account SET name = 'Luke', email = '[email protected]',
                                 updatedAt = sysdate()
              UPSERT RETURN AFTER WHERE email = '[email protected]';

-- 3. Idempotently connect them. CREATE EDGE has no UPSERT clause,
--    so check for an existing edge first.
LET existing = SELECT FROM Lives
                WHERE @out = $account[0] AND @in = $city[0];
IF ($existing.size() = 0) {
  CREATE EDGE Lives FROM $account TO $city SET since = sysdate();
}

COMMIT RETRY 100;

RETURN (SELECT FROM Lives
         WHERE @out = $account[0] AND @in = $city[0]);