ArcFlow
Company
Managed Services
Markets
  • News
  • LOG IN
  • GET STARTED

OZ brings Visual Intelligence to physical venues, a managed edge layer that lets real-world environments see, understand, and act in real time.

Talk to us

ArcFlow

  • World Models
  • Sensors

Managed Services

  • OZ VI Venue 1
  • Case Studies

Markets

  • Sports
  • Broadcasting
  • Robotics

Company

  • About
  • Technology
  • Careers
  • Contact

Ready to see it live?

Talk to the OZ team about deploying at your venues, from a single pilot match to a full regional rollout.

Schedule a deployment review

© 2026 OZ. All rights reserved.

LinkedIn
ArcFlow Docs
Start
  • Quickstart
  • Installation
  • Bindings
  • Platforms
  • Get Started
  • Cookbook
Concepts
  • World Model
  • Graph Model
  • Evidence Model
  • Observations
  • Confidence & Provenance
  • Proof Artifacts & Gates
  • SQL vs GQL
  • Graph Patterns
  • Parameters
  • Query Results
  • Persistence & WAL
  • Snapshot-Pinned Reads
  • Error Handling
  • Execution Models
  • Causal Edges
  • Adapter Discipline
  • Time Decay
  • Layers
  • 1. World Store
  • 1a. World Store · Smart Reader
  • 2. Perception Lake
  • 3. World Graph
  • 4. Query Engine
  • 5. Live Surface
  • 6. Event Bus
  • 7. Behavior Engine
  • 8. Algorithm Library
  • Virtual Computed Columns
  • Threading Model
  • Typed ID Contract
WorldCypher
  • Overview
  • Execution Options
  • Statements
  • MATCH
  • WHERE
  • RETURN
  • OPTIONAL MATCH
  • CREATE
  • SET
  • MERGE
  • DELETE
  • REMOVE
  • Composition
  • WITH
  • UNION
  • UNWIND
  • CASE
  • Schema
  • Schema Overview
  • Indexes
  • Constraints
  • Functions
  • Built-in Functions
  • Aggregations
  • Procedures
  • Shortest Path
  • EXPLAIN
  • PROFILE
  • Temporal Queriesfacet
  • Spatial Queriesfacet
  • Algorithmsfacet
  • Triggers
Capabilities
  • Live Queries
  • Vector Search
  • Trusted RAG
  • Spatial Knowledge
  • Temporal
  • Behavior Graphs
  • Graph Algorithms
  • Skills
  • CREATE SKILL
  • PROCESS NODE
  • REPROCESS EDGES
  • Sync
  • Programs
  • GPU Acceleration
  • Agent-Native
  • MCP Server
  • Event Sourcing
  • Intent Relay
  • Event Bus
Use Cases
  • Agent Tooling
  • Trusted RAG
  • Knowledge Management
  • Behavior Graphs
  • Autonomous Systems
  • Physical AI
  • Digital Twins
  • Robotics & Perception
  • Sports Analytics
  • Grounded Neural Objects
  • Fraud Detection
Walkthroughs
    Guides
  • Agent Integration
  • Building a World Model
  • Modeling a Social Graph
  • Build a RAG Pipeline
  • Using Skills
  • Behavior Graphs
  • Swarm & Multi-Agent
  • Fleet Coordination
  • Migrate from Cypher / Neo4j
  • From SQL to GQL
  • Filesystem Workspace
  • Data Quality
  • Code Intelligence
  • Scale Patterns
  • v0.7 → v0.8 Lakehouse Fast-Path
  • Tutorials
  • Knowledge Graph
  • Entity Linking
  • Vector Search
  • Graph Algorithms
  • Recipes
  • CRUD
  • Multi-MATCH
  • MERGE (Upsert)
  • Full-Text Search
  • Batch Projection
  • Multi-Source Observation
  • Sports Analytics
Operations
  • CLI
  • REPL Commands
  • Snapshot & Restore
  • Filesystem Projection
  • Plugin Management
  • Agent Governance
  • Server Modes & PG Wire
  • Persistence (ops)
  • Import & Export
  • Deployment
  • Deployment Modes
  • Daemon (UDS)
  • Why not Docker
  • Architecture
  • Engine Architecture
  • Cloud Architecture
  • Sync Protocol (Deep Dive)
  • World Graph Substrate (Preview)
Reference
  • TypeScript API
  • Glossary
  • Naming & Domain Map
  • Data Types
  • Operators
  • Error Codes
  • GQL Reference
  • Known Issues
  • Versioning
  • Licensing
  • Conformance
  • GQL Conformance
  • openCypher TCK
  • Extension Regressions
GQL Reference
    Conformance
  • Conformance Dashboard
  • openCypher TCK Results
  • Extension Regressions
  • Features
  • MATCH Basic
  • CREATE Nodes Edges
  • SET REMOVE Properties
  • DELETE Detach DELETE
  • RETURN WITH WHERE
  • Order BY Limit Skip
  • Order BY Nulls First Last
  • UNWIND
  • Aggregate Functions
  • OPTIONAL MATCH
  • Variable Length Paths
  • Label OR AND NOT Expressions
  • Label Wildcard
  • Quantified Path Sugar
  • Path Modes Walk Trail Simple Acyclic
  • Shortest Path Variants
  • IS Labeled Predicate
  • Element ID Function
  • IS Type Predicate
  • Binary Literals
  • Line Comments Solidus
  • Line Comments Minus
  • GQLSTATUS Result Codes
  • GQL Error Code Mapping
  • Transaction Control Syntax
  • SET Session
  • Conditional Execution WHEN THEN ELSE
  • RETURN NEXT Pipeline
  • Primary Key Constraint
  • Unique Constraint
  • Deterministic MERGE Via PK
  • Undirected Edge MATCH
  • Cast Type Conversion
  • GQL Directories
  • Multiple Labels Per Node
  • GQL Flagger
  • NEXT Linear Composition
  • Cardinality Function
  • INT64 BIGINT Type Names
  • FLOAT64 Double Type Names
  • Log10 Log2 Functions
  • Trim Leading Trailing Both
  • FILTER Clause
  • LET Statement
  • Group BY Explicit
  • EXCEPT SET Operations
  • INTERSECT SET Operations
  • ALL Different Predicate
  • Same Predicate
  • Property Exists Function
  • Path Variable Binding
  • USE Graph Clause
  • FOR IN List
  • Typed Temporal Literals
  • Session SET Value Params
  • Typed List Annotations
  • arcflow.cosine() function
  • arcflow.embed() function
  • arcflow.similar() procedure
  • arcflow.graphrag() procedure
  • ArcFlow Extensions
  • LIVE Queries
  • Triggered Write-Back Views
  • Evidence Algebra
  • Relationship Skills
  • AI Function Namespace
  • Graph Embedding Algorithms
  • ASOF JOIN
  • Durable Workflows
  • Incremental Z-Set Engine
  • GPU GraphBLAS
  • Triggers
  • HNSW Vector Index
  • Extensions Moat

Built-in Functions

This reference is designed for both human developers and AI coding agents. Every entry includes complete syntax that can be used directly in queries.

93 built-in functions across 10 categories: Aggregation (14), String (24), Math (17), Type Conversion (5), Graph Introspection (6), Node Metadata (5), Map and List (5), Date/Time (7), Temporal (1), Utility (5), and Predicates (4).

Aggregation (14)#

Aggregation functions operate across rows in a result set. Use with or without GROUP BY (via WITH).

FunctionSyntaxDescriptionReturn Type
countcount(expr)Number of non-null valuesInteger
count(DISTINCT)count(DISTINCT expr)Number of distinct non-null valuesInteger
sumsum(expr)Sum of numeric valuesFloat
avgavg(expr)Arithmetic meanFloat
minmin(expr)Minimum valueSame as input
maxmax(expr)Maximum valueSame as input
collectcollect(expr)Collect values into a listList
percentilepercentile(expr, p)Percentile value (p between 0.0 and 1.0)Float
stdevstdev(expr)Sample standard deviationFloat
variancevariance(expr)Sample varianceFloat
medianmedian(expr)Median (50th percentile)Float
covar_popcovar_pop(a.x, b.y)Population covariance between two property columnsFloat
covar_sampcovar_samp(a.x, b.y)Sample covariance between two property columnsFloat
corrcorr(a.x, b.y)Pearson correlation coefficient between two property columnsFloat
MATCH (n:Person)
RETURN count(n) AS total, avg(n.age) AS avgAge, percentile(n.score, 0.95) AS p95
MATCH (n:Person)
WITH n.department AS dept, collect(n.name) AS members, stdev(n.salary) AS salaryStdev
RETURN dept, members, salaryStdev

String (24)#

FunctionSyntaxDescriptionReturn Type
toLowertoLower(s)Convert to lowercaseString
toUppertoUpper(s)Convert to uppercaseString
trimtrim(s)Strip leading and trailing whitespaceString
ltrimltrim(s)Strip leading whitespaceString
rtrimrtrim(s)Strip trailing whitespaceString
substringsubstring(s, start, len)Extract substring from start positionString
leftleft(s, n)First n charactersString
rightright(s, n)Last n charactersString
headhead(expr)First element of a list or comma-separated stringSame as element
tailtail(expr)All elements except the first, from a list or comma-separated stringSame as input
lastlast(expr)Last element of a list or comma-separated stringSame as element
replacereplace(s, find, rep)Replace all occurrences of find with repString
splitsplit(s, delim)Split string by delimiter into listList
reversereverse(s)Reverse a string or comma-separated listString
sortsort(expr)Alphabetically sort comma-separated string valuesString
repeatrepeat(s, n)Repeat string n timesString
lpadlpad(s, width, char)Left-pad string to width with charString
rpadrpad(s, width, char)Right-pad string to width with charString
containscontains(s, sub)True if string contains substringBoolean
startsWithstartsWith(s, prefix)True if string starts with prefixBoolean
endsWithendsWith(s, suffix)True if string ends with suffixBoolean
indexOfindexOf(s, sub)Position of substring, -1 if not foundInteger
sizesize(s)Length of string or listInteger
toStringtoString(expr)Convert any value to string representationString
MATCH (n:Person)
RETURN toLower(n.name) AS lower, left(n.name, 3) AS initials, size(n.name) AS len
MATCH (n:Person)
WHERE startsWith(n.email, 'admin')
RETURN n.name, replace(n.email, '@old.com', '@new.com') AS newEmail
MATCH (n:Person)
RETURN lpad(toString(n.id), 6, '0') AS paddedId, repeat('*', n.rating) AS stars

Math (17)#

FunctionSyntaxDescriptionReturn Type
absabs(expr)Absolute valueFloat
roundround(expr)Round to nearest integerFloat
ceilceil(expr)Ceiling (round up)Float
floorfloor(expr)Floor (round down)Float
sqrtsqrt(expr)Square rootFloat
signsign(expr)Signum: -1, 0, or 1Float
expexp(expr)e raised to the power of the valueFloat
loglog(expr)Natural logarithm (ln)Float
log10log10(expr)Base-10 logarithmFloat
log2log2(expr)Base-2 logarithmFloat
powerpower(base, exp)Raise base to exponentFloat
sinsin(expr)Sine (radians)Float
coscos(expr)Cosine (radians)Float
tantan(expr)Tangent (radians)Float
atan2atan2(y, x)Arctangent of y/x (radians)Float
pipi()Pi constant (3.14159...)Float
ee()Euler's number (2.71828...)Float
MATCH (n:Sensor)
RETURN n.name, abs(n.reading) AS magnitude, round(n.value * 100) / 100 AS rounded
MATCH (n:Point)
RETURN atan2(n.y, n.x) AS angle, sqrt(power(n.x, 2) + power(n.y, 2)) AS distance

Type Conversion (5)#

FunctionSyntaxDescriptionReturn Type
toStringtoString(expr)Convert to stringString
toIntegertoInteger(expr)Convert to integerInteger
toFloattoFloat(expr)Convert to floatFloat
toBooleantoBoolean(expr)Convert to booleanBoolean
coalescecoalesce(a, b, ...)First non-null valueSame as first non-null
MATCH (n:Person)
RETURN toInteger(n.ageStr) AS age, coalesce(n.nickname, n.name) AS displayName

Graph Introspection (6)#

FunctionSyntaxDescriptionReturn Type
idid(n)Internal node or relationship IDInteger
labelslabels(n)List of labels on a nodeList<String>
typetype(r)Relationship type stringString
degreedegree(n)Total degree (in + out)Integer
inDegreeinDegree(n)Incoming relationship countInteger
outDegreeoutDegree(n)Outgoing relationship countInteger
MATCH (n:Person)
RETURN n.name, degree(n) AS connections, inDegree(n) AS followers, outDegree(n) AS following
ORDER BY degree(n) DESC

Node Metadata (5)#

ArcFlow world-model metadata functions for provenance and trust scoring.

FunctionSyntaxDescriptionReturn Type
confidenceconfidence(n)World-model confidence score (0.0-1.0)Float
observationClassobservationClass(n)Observation class: observed, inferred, or predictedString
authorityPlaneauthorityPlane(n)Authority plane: semantic or sceneString
clockDomainclockDomain(n)Temporal clock domain nameString
observationSourceobservationSource(n)Source identity (sensor, model, user)String
MATCH (n:Observation)
WHERE confidence(n) > 0.8 AND observationClass(n) = 'observed'
RETURN n.name, confidence(n) AS conf, authorityPlane(n) AS plane

Map and List (5)#

FunctionSyntaxDescriptionReturn Type
propertiesproperties(n)Full property map as stringString
keyskeys(n)List of property key namesList<String>
rangerange(start, end)Generate integer sequence [start..=end]List<Integer>
mapProjectionn {.name, .age}Return only named properties as a mapMap
cardinalitycardinality(expr)Length of a list or string. Synonym of size — interchangeable in queries.Integer
MATCH (n:Person)
RETURN keys(n) AS propKeys, properties(n) AS allProps
MATCH (n:Person)
RETURN n {.name, .age} AS profile
UNWIND range(1, 10) AS i
RETURN i

Date/Time (7)#

The zero-argument forms are non-deterministic (they return the current time). The string-argument forms parse an ISO 8601 input.

FunctionSyntaxDescriptionReturn Type
timestamptimestamp()Current Unix timestamp in millisecondsInteger
datedate() / date("YYYY-MM-DD")Current date, or parse ISO date stringString
timetime() / time("HH:MM:SS")Current zoned time, or parse ISO time stringString
datetimedatetime() / datetime("YYYY-MM-DDTHH:MM:SSZ")Current zoned datetime, or parse ISO datetime stringString
localTimelocalTime() / localTime("HH:MM:SS")Current local time (no timezone), or parse ISO local time stringString
localDateTimelocalDateTime() / localDateTime("YYYY-MM-DDTHH:MM:SS")Current local datetime (no timezone), or parse ISO local datetime stringString
durationduration("PT1H30M")Parse an ISO 8601 duration stringDuration
CREATE (e:Event {name: 'deploy', createdAt: timestamp(), date: date()})
RETURN e

Temporal (1)#

Read the engine's logical clock from inside a query.

FunctionSyntaxDescriptionReturn Type
walSeqwalSeq()Current mutation sequence (advances on every CREATE/SET/MERGE/DELETE)Integer
-- Snapshot the current seq alongside the data being read
MATCH (e:Event)
RETURN e.id, e.kind, walSeq() AS observed_at_seq
-- Pair walSeq() with AS OF seq to anchor a follow-up query at the same logical point
WITH walSeq() AS now_seq
MATCH (a:Account {id: $id}) AS OF seq now_seq
RETURN a.balance

The integer returned is the same sequence space used by AS OF seq N — pass it back through a parameter to query historical state, write it onto an audit record, or compare against g.seq to compute relative offsets.

The function name is case-insensitive: walSeq(), wal_seq(), WAL_SEQ(), and walseq() are all accepted by the parser. Pick whichever fits your team's naming convention — the canonical form in this reference is walSeq() to match the rest of the function table.

Utility (5)#

FunctionSyntaxDescriptionReturn Type
randomUUIDrandomUUID()Generate a UUID v4 stringString
hashhash(expr)Deterministic FNV-1a 64-bit hash as hex stringString
toJsontoJson(n)Serialize all node properties to JSON stringString
sizesize(expr)Length of string or listInteger
sessionUsersessionUser()Identifier of the current session actor (GQL GS09)String
CREATE (n:Record {id: randomUUID(), fingerprint: hash(n.data)})
RETURN n
MATCH (n:Person)
RETURN toJson(n) AS json

Predicates (4)#

Predicate expressions used in WHERE clauses and RETURN.

PredicateSyntaxDescriptionReturn Type
existsexists(n.prop)True if property existsBoolean
IS NULLn.prop IS NULLTrue if property is null or missingBoolean
IS NOT NULLn.prop IS NOT NULLTrue if property exists and is not nullBoolean
INexpr IN [list]True if value is in the listBoolean
MATCH (n:Person)
WHERE exists(n.email) AND n.role IN ['admin', 'editor']
RETURN n.name
MATCH (n:Person)
WHERE n.deletedAt IS NULL
RETURN n.name

Path Functions (3)#

Functions for operating on path values bound with MATCH p = ....

FunctionSyntaxDescriptionReturn Type
nodesnodes(path)Ordered list of nodes along the pathList<Node>
relationshipsrelationships(path)Ordered list of relationships along the pathList<Rel>
lengthlength(path)Number of relationships in the pathInteger
MATCH p = (a:Person {name: 'Alice'})-[*..5]->(b:Person {name: 'Dave'})
RETURN length(p) AS hops, [n IN nodes(p) | n.name] AS names

List Operations#

List subscript and slice#

-- Access by index (0-based)
RETURN n.tags[0]          -- first element
RETURN n.tags[$idx]       -- dynamic index via parameter
 
-- Slice
RETURN n.tags[1..3]       -- elements at index 1 and 2
RETURN n.tags[..3]        -- first 3 elements
RETURN n.tags[-2..]       -- last 2 elements

List comprehension#

-- [variable IN list WHERE filter | transform]
MATCH (n:Person)
RETURN [x IN n.scores WHERE x > 80 | x * 1.1] AS bonus_scores
 
-- filter only
RETURN [x IN n.tags WHERE x <> 'archived'] AS active_tags
 
-- transform only
RETURN [x IN range(1, 10) | x * x] AS squares

List quantifiers#

WHERE ALL(x IN n.scores WHERE x > 60)     -- all elements match
WHERE ANY(x IN n.tags WHERE x = 'urgent') -- at least one matches
WHERE NONE(x IN n.tags WHERE x = 'spam')  -- none match

See Also#

  • Aggregations & Window Functions -- GROUP BY, LAG, LEAD, PERCENT_RANK
  • Procedures -- CALL db.* and algo.* procedures
  • Operators -- comparison and logical operators
Try it
Open ↗⌘↵ to run
Loading engine…
← PreviousConstraintsNext →Aggregations