Built-in Functions Reference

COUNT(*) -> INTEGER
COUNT(expression) -> INTEGER
COUNT(DISTINCT expression) -> INTEGER

-- Count all rows
MATCH (n:Person)
RETURN COUNT(*) AS total;

-- Count non-null values
MATCH (n:Person)
RETURN COUNT(n.email) AS with_email;

-- Count distinct values
MATCH (n:Person)
RETURN COUNT(DISTINCT n.city) AS unique_cities;

SUM(numeric_expression) -> FLOAT | INTEGER

MATCH (o:Order)
RETURN SUM(o.total) AS revenue;

-- With grouping
MATCH (o:Order)
RETURN o.category, SUM(o.quantity) AS total_quantity
GROUP BY o.category;

AVG(numeric_expression) -> FLOAT

MATCH (p:Person)
RETURN AVG(p.age) AS average_age;

-- Rounded average
MATCH (p:Product)
RETURN round(AVG(p.price), 2) AS avg_price;

MIN(expression) -> same type as input
MAX(expression) -> same type as input

MATCH (p:Person)
RETURN MIN(p.age) AS youngest,
       MAX(p.age) AS oldest;

-- Works with strings (lexicographic)
MATCH (p:Person)
RETURN MIN(p.name) AS first_alphabetically;

-- Works with dates
MATCH (o:Order)
RETURN MAX(o.order_date) AS most_recent;

COLLECT(expression) -> LIST
COLLECT(DISTINCT expression) -> LIST

-- Collect all values
MATCH (p:Person)-[:LIVES_IN]->(c:City)
RETURN c.name, COLLECT(p.name) AS residents;

-- Collect distinct values
MATCH (p:Person)
RETURN COLLECT(DISTINCT p.city) AS unique_cities;

-- Collect objects
MATCH (p:Person)
RETURN COLLECT({name: p.name, age: p.age}) AS people;

STDEV(numeric_expression) -> FLOAT   -- Sample standard deviation
STDEVP(numeric_expression) -> FLOAT  -- Population standard deviation

MATCH (s:Score)
RETURN STDEV(s.value) AS sample_stdev,
       STDEVP(s.value) AS population_stdev;

PERCENTILE_CONT(numeric_expression, percentile) -> FLOAT  -- Continuous (interpolated)
PERCENTILE_DISC(numeric_expression, percentile) -> FLOAT  -- Discrete (actual value)

MATCH (p:Person)
RETURN PERCENTILE_CONT(p.salary, 0.5) AS median_salary,
       PERCENTILE_CONT(p.salary, 0.95) AS p95_salary;

lower(string) -> STRING
upper(string) -> STRING

RETURN lower('Hello World') AS lowercase;  -- 'hello world'
RETURN upper('Hello World') AS uppercase;  -- 'HELLO WORLD'

-- Case-insensitive comparison
MATCH (p:Person)
WHERE lower(p.email) = lower($input_email)
RETURN p;

trim(string) -> STRING
ltrim(string) -> STRING
rtrim(string) -> STRING
trim(string, characters) -> STRING  -- Remove specific characters

RETURN trim('  hello  ') AS trimmed;       -- 'hello'
RETURN ltrim('  hello  ') AS left_trim;    -- 'hello  '
RETURN rtrim('  hello  ') AS right_trim;   -- '  hello'
RETURN trim('xxhelloxx', 'x') AS custom;   -- 'hello'

substring(string, start) -> STRING
substring(string, start, length) -> STRING

RETURN substring('Hello World', 0, 5) AS sub;   -- 'Hello'
RETURN substring('Hello World', 6) AS rest;     -- 'World'

-- Negative start (from end)
RETURN substring('Hello', -2) AS last_two;      -- 'lo'

replace(string, search, replacement) -> STRING

RETURN replace('hello world', 'world', 'there') AS replaced;
-- 'hello there'

-- Remove characters
RETURN replace('hello-world', '-', '') AS no_dashes;
-- 'helloworld'

split(string, delimiter) -> LIST<STRING>

RETURN split('a,b,c', ',') AS parts;           -- ['a', 'b', 'c']
RETURN split('hello world', ' ') AS words;     -- ['hello', 'world']

length(string) -> INTEGER

RETURN length('hello') AS len;  -- 5

-- Unicode-aware
RETURN length('') AS emoji_len;  -- 1 (grapheme count)

reverse(string) -> STRING

RETURN reverse('hello') AS reversed;  -- 'olleh'

left(string, count) -> STRING
right(string, count) -> STRING

RETURN left('hello', 3) AS first_three;   -- 'hel'
RETURN right('hello', 3) AS last_three;   -- 'llo'

lpad(string, length, pad_string) -> STRING
rpad(string, length, pad_string) -> STRING

RETURN lpad('42', 5, '0') AS padded;    -- '00042'
RETURN rpad('hi', 5, '-') AS padded;    -- 'hi---'

toString(value) -> STRING

RETURN toString(42) AS str;              -- '42'
RETURN toString(3.14) AS str;            -- '3.14'
RETURN toString(true) AS str;            -- 'true'
RETURN toString(date('2026-01-28')) AS str;  -- '2026-01-28'

abs(number) -> same type

RETURN abs(-42) AS absolute;     -- 42
RETURN abs(-3.14) AS absolute;   -- 3.14

ceil(number) -> INTEGER
floor(number) -> INTEGER

RETURN ceil(3.2) AS ceiling;     -- 4
RETURN floor(3.8) AS floor_val;  -- 3
RETURN ceil(-3.2) AS neg_ceil;   -- -3
RETURN floor(-3.8) AS neg_floor; -- -4

round(number) -> INTEGER
round(number, precision) -> FLOAT

RETURN round(3.5) AS rounded;           -- 4
RETURN round(3.14159, 2) AS precise;    -- 3.14
RETURN round(123.456, -1) AS tens;      -- 120

sign(number) -> INTEGER  -- Returns -1, 0, or 1

RETURN sign(42) AS positive;    -- 1
RETURN sign(-42) AS negative;   -- -1
RETURN sign(0) AS zero;         -- 0

sqrt(number) -> FLOAT
cbrt(number) -> FLOAT

RETURN sqrt(16) AS square_root;  -- 4.0
RETURN cbrt(27) AS cube_root;    -- 3.0

power(base, exponent) -> FLOAT
exp(number) -> FLOAT              -- e^x
log(number) -> FLOAT              -- Natural logarithm
log10(number) -> FLOAT            -- Base-10 logarithm

RETURN power(2, 10) AS two_to_ten;  -- 1024.0
RETURN exp(1) AS e_value;           -- 2.718281828...
RETURN log(exp(1)) AS ln_e;         -- 1.0
RETURN log10(100) AS log_100;       -- 2.0

sin(radians) -> FLOAT
cos(radians) -> FLOAT
tan(radians) -> FLOAT
asin(value) -> FLOAT
acos(value) -> FLOAT
atan(value) -> FLOAT
atan2(y, x) -> FLOAT

RETURN sin(0) AS sine_zero;        -- 0.0
RETURN cos(0) AS cosine_zero;      -- 1.0
RETURN atan2(1, 1) AS angle;       -- 0.785398... (PI/4)

rand() -> FLOAT  -- Returns 0.0 <= x < 1.0

RETURN rand() AS random_value;

-- Random integer in range [1, 100]
RETURN floor(rand() * 100) + 1 AS random_int;

-- Random sample
MATCH (p:Person)
RETURN p.name
ORDER BY rand()
LIMIT 10;

size(list) -> INTEGER
length(list) -> INTEGER  -- Alias

RETURN size([1, 2, 3, 4, 5]) AS count;  -- 5
RETURN size([]) AS empty;               -- 0

head(list) -> element type
last(list) -> element type
tail(list) -> LIST  -- All except first

RETURN head([1, 2, 3]) AS first;   -- 1
RETURN last([1, 2, 3]) AS final;   -- 3
RETURN tail([1, 2, 3]) AS rest;    -- [2, 3]

range(start, end) -> LIST<INTEGER>
range(start, end, step) -> LIST<INTEGER>

RETURN range(1, 5) AS nums;          -- [1, 2, 3, 4, 5]
RETURN range(0, 10, 2) AS evens;     -- [0, 2, 4, 6, 8, 10]
RETURN range(10, 1, -1) AS countdown; -- [10, 9, 8, ..., 1]

reverse(list) -> LIST

RETURN reverse([1, 2, 3]) AS reversed;  -- [3, 2, 1]

reduce(accumulator = initial_value, element IN list | expression) -> result

-- Sum of list
RETURN reduce(total = 0, x IN [1, 2, 3, 4] | total + x) AS sum;  -- 10

-- Product
RETURN reduce(prod = 1, x IN [1, 2, 3, 4] | prod * x) AS product;  -- 24

-- String concatenation
RETURN reduce(s = '', x IN ['a', 'b', 'c'] | s + x) AS concat;  -- 'abc'

-- Path total cost
MATCH p = (a)-[rels*]->(b)
RETURN reduce(cost = 0, r IN relationships(p) | cost + r.weight) AS total_cost;

[element IN list WHERE condition]
[element IN list WHERE condition | expression]

-- Filter to even numbers
RETURN [x IN [1, 2, 3, 4, 5, 6] WHERE x % 2 = 0] AS evens;  -- [2, 4, 6]

-- Filter and transform
RETURN [x IN [1, 2, 3, 4] WHERE x > 2 | x * 2] AS doubled;  -- [6, 8]

list1 + list2 -> LIST

RETURN [1, 2] + [3, 4] AS combined;  -- [1, 2, 3, 4]

element IN list -> BOOLEAN

RETURN 2 IN [1, 2, 3] AS contains;     -- true
RETURN 5 IN [1, 2, 3] AS contains;     -- false

MATCH (p:Person)
WHERE p.role IN ['admin', 'manager']
RETURN p.name;

keys(map) -> LIST<STRING>
keys(node) -> LIST<STRING>
keys(relationship) -> LIST<STRING>

RETURN keys({name: 'Alice', age: 30}) AS k;  -- ['name', 'age']

MATCH (n:Person)
RETURN keys(n) AS property_names;

values(map) -> LIST

RETURN values({a: 1, b: 2, c: 3}) AS vals;  -- [1, 2, 3]

properties(node) -> MAP
properties(relationship) -> MAP

MATCH (p:Person {name: 'Alice'})
RETURN properties(p) AS all_props;
-- {name: 'Alice', age: 30, email: 'alice@example.com'}

date() -> DATE                        -- Current date
date(string) -> DATE                  -- Parse ISO string
date({year, month, day}) -> DATE      -- From components

time() -> TIME
time(string) -> TIME

timestamp() -> TIMESTAMP
timestamp(string) -> TIMESTAMP

RETURN date() AS today;
RETURN date('2026-01-28') AS specific;
RETURN date({year: 2026, month: 1, day: 28}) AS from_parts;

RETURN timestamp() AS now;
RETURN timestamp('2026-01-28T14:30:00Z') AS specific_time;

duration(string) -> DURATION           -- ISO 8601 format
duration({days, hours, ...}) -> DURATION

RETURN duration('P7D') AS one_week;
RETURN duration('PT2H30M') AS two_half_hours;
RETURN duration({days: 7, hours: 12}) AS custom;

-- Add duration to date
RETURN date('2026-01-28') + duration('P7D') AS next_week;

-- Subtract dates
RETURN date('2026-01-28') - date('2026-01-01') AS days_between;

-- Compare timestamps
MATCH (e:Event)
WHERE e.start_time > timestamp() - duration('P30D')
RETURN e;

RETURN date('2026-01-28').year AS year;        -- 2026
RETURN date('2026-01-28').month AS month;      -- 1
RETURN date('2026-01-28').day AS day;          -- 28
RETURN date('2026-01-28').dayOfWeek AS dow;    -- 3 (Wednesday)
RETURN date('2026-01-28').dayOfYear AS doy;    -- 28

RETURN timestamp().hour AS hour;
RETURN timestamp().minute AS minute;
RETURN timestamp().second AS second;

type(relationship) -> STRING

MATCH (a)-[r]->(b)
RETURN type(r) AS relationship_type;

labels(node) -> LIST<STRING>

MATCH (n)
RETURN labels(n) AS node_labels;

-- Check for label
MATCH (n)
WHERE 'Person' IN labels(n)
RETURN n;

id(node) -> INTEGER
id(relationship) -> INTEGER

MATCH (n:Person)
RETURN id(n) AS internal_id, n.name;

-- To Integer
toInteger('42')        -- 42
toInteger(3.7)         -- 3
toInteger(true)        -- 1

-- To Float
toFloat('3.14')        -- 3.14
toFloat(42)            -- 42.0

-- To Boolean
toBoolean('true')      -- true
toBoolean(1)           -- true
toBoolean(0)           -- false

-- To String
toString(42)           -- '42'
toString(true)         -- 'true'

nodes(path) -> LIST<NODE>

MATCH p = (a)-[*]->(b)
RETURN nodes(p) AS path_nodes;

-- Node names
MATCH p = (a)-[*]->(b)
RETURN [n IN nodes(p) | n.name] AS names;

relationships(path) -> LIST<RELATIONSHIP>

MATCH p = (a)-[*]->(b)
RETURN relationships(p) AS path_rels;

-- Relationship types
MATCH p = (a)-[*]->(b)
RETURN [r IN relationships(p) | type(r)] AS types;

length(path) -> INTEGER

MATCH p = shortestPath((a)-[*]-(b))
RETURN length(p) AS hops;

geo_distance(point1, point2) -> FLOAT  -- Returns meters

RETURN geo_distance(latlon(40.7128, -74.0060), latlon(34.0522, -118.2437)) AS meters;

MATCH (s:Store)
RETURN s.name, geo_distance(s.location, $user_location) AS distance
ORDER BY distance
LIMIT 5;

geo_within_box(point, southwest, northeast) -> BOOLEAN

MATCH (s:Store)
WHERE geo_within_box(s.location, latlon(40.70, -74.05), latlon(40.75, -73.95))
RETURN s.name;

geo_within_polygon(point, polygon) -> BOOLEAN

vector_distance_l2(vector1, vector2) -> FLOAT

MATCH (d:Document)
RETURN d.title, vector_distance_l2(d.embedding, $query_vector) AS distance
ORDER BY distance
LIMIT 10;

vector_distance_cosine(vector1, vector2) -> FLOAT

vector_distance_dot(vector1, vector2) -> FLOAT

vector_dimension(vector) -> INTEGER

exists(property) -> BOOLEAN
EXISTS { pattern } -> BOOLEAN

-- Property exists
MATCH (p:Person)
WHERE exists(p.phone)
RETURN p.name;

-- Pattern exists
MATCH (p:Person)
WHERE EXISTS { (p)-[:MANAGES]->() }
RETURN p.name AS managers;

all(x IN list WHERE predicate) -> BOOLEAN
any(x IN list WHERE predicate) -> BOOLEAN
none(x IN list WHERE predicate) -> BOOLEAN
single(x IN list WHERE predicate) -> BOOLEAN

-- All elements satisfy
RETURN all(x IN [2, 4, 6] WHERE x % 2 = 0) AS all_even;  -- true

-- Any element satisfies
RETURN any(x IN [1, 2, 3] WHERE x > 2) AS has_large;  -- true

-- No element satisfies
RETURN none(x IN [1, 2, 3] WHERE x < 0) AS all_positive;  -- true

-- Exactly one satisfies
RETURN single(x IN [1, 2, 3] WHERE x > 2) AS exactly_one;  -- true

coalesce(value1, value2, ...) -> first non-null

RETURN coalesce(null, 'default') AS result;  -- 'default'
RETURN coalesce(null, null, 42) AS result;   -- 42

MATCH (p:Person)
RETURN coalesce(p.nickname, p.name) AS display_name;

CASE expression
  WHEN value1 THEN result1
  WHEN value2 THEN result2
  ELSE default
END

CASE
  WHEN condition1 THEN result1
  WHEN condition2 THEN result2
  ELSE default
END

-- Simple CASE
MATCH (p:Person)
RETURN p.name,
       CASE p.status
         WHEN 'active' THEN 'Active'
         WHEN 'pending' THEN 'Pending Approval'
         ELSE 'Inactive'
       END AS status_text;

-- Searched CASE
MATCH (p:Person)
RETURN p.name,
       CASE
         WHEN p.age < 18 THEN 'Minor'
         WHEN p.age < 65 THEN 'Adult'
         ELSE 'Senior'
       END AS age_group;