xrayGraphDB Documentation

MATCH (n:Person)
WITH collect(n.name) AS names
RETURN group_concat(names, ", ") AS full_list

MATCH (flight:Flight)
WITH collect(flight.altitude_ft) AS altitudes
RETURN histogram(altitudes, 10) AS altitude_distribution

MATCH (a:Aircraft)
WITH collect(a.speed_kt) AS speeds
RETURN percentilecont(speeds, 0.95) AS speed_95th_percentile

MATCH (s:Sensor)
WITH collect(s.temperature) AS temps
RETURN percentiledisc(temps, 0.5) AS median_temp,
       percentiledisc(temps, 0.75) AS q3_temp

MATCH (metric:Metric)
WITH collect(metric.latency_ms) AS latencies
RETURN quantile(latencies, 0.99) AS p99_latency,
       quantile(latencies, 0.90) AS p90_latency

MATCH (n:Transaction)
WITH collect(n.category) AS categories
RETURN topK(categories, 5) AS top_5_categories

MATCH (n:Transaction)
RETURN topK(n.category, 5) AS most_common_categories

MATCH (event:Event)
WITH collect(event.event_type) AS event_types
RETURN topKExact(event_types, 10) AS exact_top_10_events

MATCH (a:Aircraft)
WITH a.heading_deg AS actual_hdg, a.planned_hdg AS planned_hdg
RETURN angular_diff(actual_hdg, planned_hdg) AS heading_deviation

MATCH (a:Aircraft)
RETURN bank_angle(a.ground_speed_kt, a.turn_rate_dps) AS estimated_bank_deg,
       a.altitude_ft,
       a.callsign

MATCH (flight:Flight)-[:HAS_PREDICTION]->(pred:Prediction)
RETURN deviation_score(pred.altitude_ft, flight.altitude_ft, 500) AS altitude_score,
       deviation_score(pred.heading_deg, flight.heading_deg, 15) AS heading_score

MATCH (a1:Aircraft)-[:NEAR]-(a2:Aircraft)
WHERE a1.id < a2.id
RETURN distance_3d(a1.lat, a1.lon, a1.altitude_ft,
                   a2.lat, a2.lon, a2.altitude_ft) AS separation_m

MATCH (flight:Flight)
WITH AVG(flight.ground_speed_kt) AS mean_speed,
     STDEV(flight.ground_speed_kt) AS stddev_speed
MATCH (f:Flight)
RETURN f.callsign,
       envelope_score(f.ground_speed_kt, mean_speed, stddev_speed) AS anomaly_score

MATCH (a:Aircraft)
WITH collect(a.heading_deg) AS headings,
     collect(a.timestamp) AS times
RETURN heading_rate_of_change(headings, times) AS turn_rate_dps

MATCH (a:Aircraft)
WITH a,
     project_3d(a.lat, a.lon, a.altitude_ft,
                a.heading_deg, a.ground_speed_kt, a.climb_rate_fpm,
                a.turn_rate_dps, a.acceleration_ktps, 300) AS projected
RETURN a.callsign,
       projected[0] AS predicted_lat,
       projected[1] AS predicted_lon,
       projected[2] AS predicted_alt_ft,
       projected[3] AS predicted_heading,
       projected[4] AS predicted_speed_kt

MATCH (a:Aircraft)
WITH collect(a.altitude_ft) AS altitudes,
     collect(a.timestamp) AS times
RETURN rate_of_change(altitudes, times) AS climb_rate_fpm

MATCH (a:Aircraft)
RETURN a.callsign,
       signed_angular_diff(a.heading_deg, a.planned_heading) AS turn_required_deg

MATCH (a:Aircraft)
WITH a,
     speed_from_components(a.velocity_north_mps, a.velocity_east_mps, a.velocity_up_mps) AS speeds
RETURN a.callsign,
       speeds[0] AS ground_speed_kt,
       speeds[1] AS vertical_speed_fpm,
       speeds[2] AS total_speed_kt

MATCH (a:Aircraft)
RETURN a.callsign,
       a.ground_speed_kt,
       a.turn_rate_dps,
       turn_radius(a.ground_speed_kt, a.turn_rate_dps) AS radius_m

MATCH (a:Aircraft)
WITH a,
     velocity_3d(a.ground_speed_kt, a.heading_deg, a.climb_rate_fpm) AS velocity_components
RETURN a.callsign,
       velocity_components[0] AS velocity_north_mps,
       velocity_components[1] AS velocity_east_mps,
       velocity_components[2] AS velocity_up_mps

MATCH (u:User)
WITH u.permissions AS perms,
     7 AS ADMIN_MASK  // Binary: 0111
RETURN u.username,
       bit_and(perms, ADMIN_MASK) AS admin_flags

MATCH (f:Flag)
RETURN f.id,
       f.status_bits,
       bit_not(f.status_bits) AS inverted_bits

MATCH (app:Application)
WITH app.read_perms AS read_bits,
     app.write_perms AS write_bits
RETURN app.name,
       bit_or(read_bits, write_bits) AS combined_perms

MATCH (data:Bitfield)
RETURN data.id,
       data.mask,
       bit_shift_left(data.mask, 8) AS shifted_left_8

MATCH (sensor:Sensor)
WITH sensor.raw_value AS raw
RETURN sensor.id,
       raw,
       bit_shift_right(raw, 4) AS high_nibble

MATCH (packet:Packet)
RETURN packet.id,
       bit_xor(packet.header, packet.checksum) AS verification

MATCH (perms:Permissions)
RETURN perms.username,
       perms.flags,
       popcount(perms.flags) AS number_of_permissions

SELECT DATE_TRUNC('hour', created_at) AS hour, COUNT(*) AS cnt
FROM events
GROUP BY DATE_TRUNC('hour', created_at)
ORDER BY hour DESC

MATCH (e:Event)
RETURN toStartOfHour(e.created_at) AS hour, count(e) AS cnt
ORDER BY hour DESC

SELECT ts, value,
       AVG(value) OVER (ORDER BY ts ROWS 4 PRECEDING) AS moving_avg_5
FROM metrics
ORDER BY ts

MATCH (m:Metric)
WITH m.timestamp AS ts, m.value AS val
ORDER BY ts
WITH collect(val) AS values
WITH moving_avg(values, 5) AS moving_averages
UNWIND moving_averages AS avg_val
RETURN avg_val

SELECT category, COUNT(*) as freq
FROM transactions
GROUP BY category
ORDER BY freq DESC
LIMIT 10

MATCH (t:Transaction)
RETURN topK(t.category, 10) AS top_10_categories

MATCH (t:Transaction)
WITH collect(t.category) AS categories
RETURN topK(categories, 10) AS top_10_categories

SELECT id, value,
       AVG(value) OVER (ORDER BY ts ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING) AS centered_avg,
       ROW_NUMBER() OVER (ORDER BY ts) AS rank
FROM metrics

MATCH (m:Metric)
WITH m.category AS category, collect(m.value) AS values
WITH category, moving_avg(values, 5) AS moving_averages
RETURN category, moving_averages

MATCH (a:Aircraft)
RETURN a.callsign,
       case_when(a.altitude_ft > 35000, 'HIGH', 'LOW') AS altitude_category,
       case_when(a.ground_speed_kt > 450, 'FAST', 'NORMAL') AS speed_category

MATCH (a:Aircraft)
WITH a,
     case_when(a.status = 'LANDED', 1, case_when(a.status = 'AIRBORNE', 2, 3)) AS status_code
RETURN a.callsign,
       choose(status_code, 'Landed', 'Airborne', 'Unknown') AS status_name

MATCH (a:Aircraft)
RETURN a.callsign,
       coalesce_chain(a.icao_code, a.iata_code, a.flight_id) AS identifier,
       coalesce_chain(a.operator_name, a.airline, 'Unknown') AS operator

MATCH (a:Aircraft)
RETURN a.callsign,
       greatest(a.max_speed_kt, a.cruise_speed_kt, a.approach_speed_kt) AS max_capability,
       greatest(a.altitude_ft, a.service_ceiling_ft) AS altitude_record

MATCH (a:Aircraft)
RETURN a.callsign,
       ifnull(a.registration, 'N/A') AS registration,
       ifnull(a.manufacturer, 'Unknown') AS manufacturer,
       ifnull(a.weight_lbs, 0) AS weight

MATCH (a:Aircraft)
RETURN a.callsign,
       least(a.min_speed_kt, a.landing_speed_kt, a.stall_speed_kt) AS min_safe_speed,
       least(a.created_at, a.first_flight_date) AS earliest_date

MATCH (a:Aircraft)
RETURN a.callsign,
       nullif(a.manufacturer, 'Unknown') AS known_manufacturer,
       nullif(a.registration, 'N/A') AS valid_registration,
       nullif(a.altitude_ft, 0) AS non_zero_altitude

CALL xray.dedup('Aircraft', 'icao24')
YIELD duplicates_found, vertices_deleted, vertices_kept
RETURN duplicates_found, vertices_deleted, vertices_kept

BULK_UPSERT_NODES (0x27):
  [u32 rows=100]
  [u16 cols=3]
  [u8 type=0x05][u32 len=5]["icao24"]  // key_column (upsert key)
  [u8 type=0x05][u32 len=8]["callsign"]
  [u8 type=0x04][u32 len=0]            // altitude
  // then row data
  ["ABC123"] ["N123US"] [35000.0]
  ["ABC124"] ["N456UA"] [28500.0]

CALL ttl.delete_expired('AdsReport', 'timestamp', 30, 'is_archived')
YIELD deleted_count, scanned_count, exempt_count
RETURN 'Deleted ' + deleted_count + ' reports older than 30 days. Scanned: ' + scanned_count + ', Exempt: ' + exempt_count

CREATE DATABASE swim

DROP DATABASE swim

from neo4j import GraphDatabase

driver = GraphDatabase.driver('bolt://localhost:7687', auth=('user', 'password'))

# Connect to swim database
swim_session = driver.session(database='swim')
result = swim_session.run('MATCH (a:Aircraft) RETURN COUNT(a) AS count')
print(result.single()['count'])

# Connect to default database
default_session = driver.session()
result = default_session.run('MATCH (n) RETURN COUNT(n) AS total')
print(result.single()['total'])

-- List all available databases
SHOW DATABASES

-- Use specific database (Bolt: pass in session config)
-- Via xrayProtocol: send database name in HELLO frame
-- Example: Switch to swim database for aviation data
USE DATABASE swim
MATCH (a:Aircraft {icao24: 'ABC1234'}) RETURN a

-- Different session: switch to xray database for code intelligence
USE DATABASE xray
MATCH (m:Method {name: 'parseAltitude'}) RETURN m

-- HELLO frame selecting 'swim' database
[u32 payload_len=50]
[u8 msg_type=0x01]   // HELLO
[u8 flags=0x00]
[u16 query_id=0x0000]
[u16 version=1]
[u16 capabilities=0x0003]
[u32 token_len=11]["user:pass"]
[u32 db_len=4]["swim"]  // Route to swim database

-- All subsequent EXECUTE frames on this connection target 'swim'
[u32 payload_len=...]
[u8 msg_type=0x03]  // EXECUTE
[u8 flags=0x00]
[u16 query_id=0x0001]
[u8 language=0]      // Cypher
[u32 query_len=40]   // MATCH (a:Aircraft) RETURN COUNT(a)
...

SHOW DATABASES

-- Switch to swim database
USE DATABASE swim

-- All subsequent queries operate on swim database
MATCH (a:Aircraft) RETURN COUNT(a) AS aircraft_count

-- Switch to xray database
USE DATABASE xray

-- Queries now operate on xray database
MATCH (c:Class {name: 'Parser'}) RETURN COUNT(c) AS class_count

-- Current date
RETURN date() AS today

-- Date from components
RETURN date({year: 2026, month: 4, day: 15}) AS flight_departure

-- Use in graph query
MATCH (r:AdsReport)
WHERE r.received_date > date({year: 2026, month: 3, day: 1})
RETURN COUNT(r) AS reports_since_march

-- Convert date string to milliseconds
RETURN date_to_millis('2026-04-15') AS millis

-- Use for timestamp comparison
WITH date_to_millis('2026-03-01') AS march_start
MATCH (r:AdsReport)
WHERE r.timestamp_ms > march_start
RETURN COUNT(r) AS reports

-- Current datetime with timezone
RETURN datetime() AS now

-- DateTime with UTC timezone
RETURN datetime({year: 2026, month: 4, day: 15, hour: 14, minute: 30, second: 0, timezone: 'UTC'}) AS scheduled_event

-- Use in event tracking
CREATE (e:Event {timestamp: datetime(), name: 'Takeoff', flight_id: 'UA123'})
RETURN e

-- Flight duration of 5 hours 30 minutes
RETURN duration({hours: 5, minutes: 30}) AS flight_duration

-- Use in calculations
MATCH (f:Flight)
WHERE f.scheduled_duration > duration({hours: 6})
RETURN f.callsign, f.scheduled_duration

-- Calculate flight time
MATCH (f:Flight)
WITH f, duration_between(f.departure_time, f.arrival_time) AS elapsed
RETURN f.callsign, elapsed.hours + ' hours ' + (elapsed.minutes % 60) + ' minutes' AS duration

-- Find long-running queries
MATCH (q:QueryLog)
WITH q, duration_between(q.start_time, q.end_time) AS exec_time
WHERE exec_time.seconds > 60
RETURN q.query_text, exec_time.seconds

-- Get current time as milliseconds
RETURN epoch_millis() AS current_timestamp_ms

-- Use for performance tracking
WITH epoch_millis() AS start_ms
MATCH (a:Aircraft) RETURN COUNT(a)
WITH epoch_millis() - start_ms AS query_time_ms
RETURN query_time_ms + ' ms' AS execution_time

-- Get current time as seconds
RETURN epoch_seconds() AS current_timestamp_s

-- Record timestamp in node
CREATE (a:AirspaceAlert {alert_id: 'AL001', detection_time: epoch_seconds()})
RETURN a

-- Current local datetime (no timezone)
RETURN localdatetime() AS local_now

-- LocalDateTime at specific local time
RETURN localdatetime({year: 2026, month: 4, day: 15, hour: 14, minute: 30}) AS local_departure

-- Use for scheduling without timezone conversion
MATCH (e:Event)
WHERE e.local_start_time > localdatetime({year: 2026, month: 4, day: 15, hour: 12, minute: 0})
RETURN e.name, e.local_start_time

-- Current local time
RETURN localtime() AS current_time

-- Create time at 14:30
RETURN localtime({hour: 14, minute: 30, second: 0}) AS afternoon_time

-- Find flights departing after 10:00 AM
MATCH (f:Flight)
WHERE f.departure_time > localtime({hour: 10, minute: 0})
RETURN f.callsign, f.departure_time

-- Convert milliseconds to readable date
RETURN millis_to_date(1745606400000) AS readable_date

-- Use with stored timestamps
MATCH (r:AdsReport)
RETURN r.callsign, millis_to_date(r.timestamp_ms) AS report_date
LIMIT 10

-- Convert datetime to milliseconds for JavaScript
MATCH (e:Event)
RETURN e.name, epochMillis(e.event_time) AS timestamp_js

-- Store in database with millisecond precision
CREATE (r:Report {recorded_at: epochMillis(datetime())})
RETURN r

-- Get current time
RETURN now() AS server_time

-- Record creation timestamp
CREATE (a:AirspaceAlert {alert_type: 'tfr', created_at: now(), alert_id: 'ALR20260415001'})
RETURN a

-- Find recent activity
MATCH (a:Activity)
WHERE a.timestamp > now() - duration({days: 1})
RETURN a.description, a.timestamp

-- Extract date from datetime
RETURN toDate(now()) AS today

-- Group reports by date
MATCH (r:AdsReport)
WITH toDate(r.timestamp) AS report_date, COUNT(r) AS count
RETURN report_date, count
ORDER BY report_date DESC

-- Find flights on a specific date
MATCH (f:Flight)
WHERE toDate(f.departure_time) = date({year: 2026, month: 4, day: 15})
RETURN f.callsign, f.departure_time

-- Truncate to start of day
RETURN toStartOfDay(now()) AS midnight_today

-- Find records from start of day
MATCH (r:AdsReport)
WHERE r.timestamp >= toStartOfDay(now())
RETURN COUNT(r) AS today_reports

-- Group by day
MATCH (r:AdsReport)
WITH toStartOfDay(r.timestamp) AS day, COUNT(r) AS daily_count
RETURN day, daily_count
ORDER BY day DESC

-- Truncate to start of hour
RETURN toStartOfHour(now()) AS hourly_boundary

-- Hourly aggregation
MATCH (r:AdsReport)
WITH toStartOfHour(r.timestamp) AS hour, COUNT(r) AS hourly_count, AVG(r.altitude) AS avg_alt
RETURN hour, hourly_count, avg_alt
ORDER BY hour DESC

-- Find reports from the last hour
MATCH (r:AdsReport)
WHERE r.timestamp >= toStartOfHour(now())
RETURN COUNT(r) AS recent_reports

-- Truncate to start of minute
RETURN toStartOfMinute(now()) AS minute_boundary

-- Minute-level aggregation
MATCH (r:AdsReport)
WITH toStartOfMinute(r.timestamp) AS minute, COUNT(r) AS reports_per_minute
WHERE reports_per_minute > 100  -- High activity threshold
RETURN minute, reports_per_minute
ORDER BY minute DESC

-- Find events in the last minute
MATCH (e:Event)
WHERE e.timestamp >= toStartOfMinute(now())
RETURN e.description, e.timestamp

RETURN bbox_from_radius(40.7128, -74.0060, 5000) AS nyc_5km_bbox
// Returns: [40.66856, -74.06269, 40.75704, -73.94931]
// Bounding box for 5km radius around New York City

RETURN bearing(40.7128, -74.0060, 51.5074, -0.1278) AS bearing_nyc_to_london
// Returns: 51.27 (approximately northeast)
// Initial bearing from NYC to London

RETURN cartesian_to_polar(3, 4) AS polar_coords
// Returns: [5.0, 0.9273]
// Converts point (3,4) to radius 5, angle ~53 degrees

RETURN deg_to_dms(40.7128) AS latitude_dms
// Returns: "40°42'46.08\"N"
// Converts NYC latitude to DMS format

RETURN distance(40.7128, -74.0060, 34.0522, -118.2437) AS distance_nyc_to_lax
// Returns: 3944000 (approximately 3944 km)
// Distance from NYC to LAX airport in meters

RETURN dms_to_deg("40°42'46.08\"N") AS decimal_latitude
// Returns: 40.7128
// Converts DMS format back to decimal degrees

RETURN ecef_to_wgs84(1334636, -4653242, 4137881) AS wgs84_coords
// Returns: [40.7128, -74.0060, 0]
// Converts satellite/GPS ECEF coordinates to lat/lon

RETURN geo.bearing(51.5074, -0.1278, 48.8566, 2.3522) AS bearing_london_to_paris
// Returns: 171.03 (approximately south)
// Initial bearing from London to Paris

RETURN geo.destination(40.7128, -74.0060, 45, 10000) AS dest_northeast_10km
// Returns: [40.80829, -73.93467]
// Point 10km northeast of NYC

RETURN geo.distance(40.6892, -74.0445, 40.8448, -73.8648) AS distance_jfk_to_lga
// Returns: 20000 (approximately 20 km)
// Distance between JFK and LaGuardia airports in meters

RETURN geo.is_ahead(40.7128, -74.0060, 45, 40.80, -73.93) AS target_ahead
// Returns: true
// Check if northeast point is ahead when heading 45° (northeast)

RETURN geo.reachable_score(40.7128, -74.0060, 100, 3600, 40.9, -73.8) AS reachability
// Returns: 0.95
// Score for reaching a point 20km away at 100 m/s in 1 hour

WITH [[40.7128, -74.0060], [40.80, -73.93], [40.90, -73.85]] AS path,
     [[40.7128, -74.0060], [40.8, -73.93], [40.9, -73.85]] AS waypoints
RETURN geo.route_score(path, waypoints) AS alignment_score
// Returns: 0.98
// Near-perfect alignment between actual and expected waypoints

RETURN geo.to_mgrs(40.7128, -74.0060) AS nyc_mgrs
// Returns: "18TWL8026064799"
// MGRS grid reference for New York City

RETURN geo.to_utm(40.7128, -74.0060) AS nyc_utm
// Returns: {easting: 583960, northing: 4507523, zone: 18}
// UTM coordinates for NYC (Zone 18N)

RETURN geo_destination(51.5074, -0.1278, 135, 50000) AS dest_southeast_50km
// Returns: [51.14287, 0.52194]
// Point 50km southeast of London

RETURN geo_midpoint(40.7128, -74.0060, 34.0522, -118.2437) AS us_midpoint
// Returns: [37.8825, -96.1253]
// Geographic center point between NYC and LAX

RETURN geohash_decode("dr5regw") AS decoded
// Returns: [40.714, -74.010]
// Decodes geohash back to coordinates near NYC

RETURN geohash_encode(40.7128, -74.0060, 7) AS nyc_geohash
// Returns: "dr5regw"
// 7-character geohash for NYC (~150m precision)

RETURN haversine(40.7128, -74.0060, 48.8566, 2.3522) AS distance_nyc_to_paris
// Returns: 5837000 (approximately 5837 km)
// Great-circle distance in meters

RETURN haversine_distance(37.7749, -122.4194, 34.0522, -118.2437) AS distance_sf_to_lax
// Returns: 559000 (approximately 559 km)
// Distance between San Francisco and Los Angeles

RETURN mercator_to_wgs84(-8235802, 4960145) AS wgs84_coords
// Returns: [40.7128, -74.0060]
// Converts Web Mercator to NYC coordinates

RETURN point({latitude: 40.7128, longitude: -74.0060}) AS nyc_point
// Returns: point{latitude: 40.7128, longitude: -74.0060}
// Creates a geographic point for NYC

WITH point({latitude: 40.7128, longitude: -74.0060}) AS p1,
     point({latitude: 40.9, longitude: -73.8}) AS p2
RETURN point.distance(p1, p2) AS distance_meters
// Returns: 23400 (approximately 23.4 km)
// Distance between two geographic points

WITH point({latitude: 40.7128, longitude: -74.0060}) AS nyc,
     point({latitude: 40.5, longitude: -74.3}) AS lower_left,
     point({latitude: 41.0, longitude: -73.7}) AS upper_right
RETURN point.withinbbox(nyc, lower_left, upper_right) AS in_bbox
// Returns: true
// NYC is within the defined bounding box

RETURN polar_to_cartesian(5, 0.9273) AS cartesian_coords
// Returns: [3.0, 4.0]
// Converts polar (r=5, θ≈53°) to Cartesian (3,4)

RETURN to_geojson(40.7128, -74.0060) AS geojson
// Returns: '{"type":"Point","coordinates":[-74.0060,40.7128]}'
// Standard GeoJSON format for NYC

RETURN to_wkt(40.7128, -74.0060) AS wkt
// Returns: 'POINT(-74.0060 40.7128)'
// Standard WKT format for NYC

RETURN utm_to_wgs84(583960, 4507523, 18, "N") AS wgs84_coords
// Returns: [40.7128, -74.0060]
// Converts UTM Zone 18N back to NYC coordinates

RETURN utm_zone(40.7128, -74.0060) AS zone_number
// Returns: 18
// NYC is in UTM Zone 18

RETURN wgs84_to_ecef(40.7128, -74.0060, 10) AS ecef_coords
// Returns: [1334636, -4653242, 4137881]
// ECEF representation of NYC at 10m altitude

RETURN wgs84_to_mercator(40.7128, -74.0060) AS mercator_coords
// Returns: [-8235802, 4960145]
// Web Mercator projection for NYC

RETURN wgs84_to_utm(40.7128, -74.0060) AS utm_coords
// Returns: [583960, 4507523, 18]
// NYC in UTM Zone 18N coordinates

MATCH (alice:User {name: "Alice"}), (bob:User {name: "Bob"})
RETURN xg.adamic_adar(alice, bob) AS prediction_score

MATCH (a:User)-[edge:FOLLOWS]->(b:User)
RETURN edge, xg.bridge_score(edge) AS bridge_likelihood
ORDER BY bridge_likelihood DESC LIMIT 10

MATCH (user:User)-[:POSTED]->(posts:Post)
WITH user, collect(posts) AS user_posts
RETURN user.name, xg.chain_avg_by(user_posts, "engagement_score") AS avg_engagement

MATCH (post:Post)<-[:POSTED]-(:User)
WITH collect(post) AS all_posts
RETURN xg.chain_count_by(all_posts, "category") AS category_distribution

MATCH (user:User)-[:RATED]->(movie:Movie)
WITH user, collect(movie) AS movies
RETURN user.name, xg.chain_filter_eq(movies, "genre", "Action") AS action_movies

MATCH (user:User)-[:RATED]->(movie:Movie)
WITH user, collect(movie) AS rated_movies
RETURN user.name, xg.chain_filter_gt(rated_movies, "rating", 7.5) AS highly_rated

MATCH (person:Person)-[:HAS_TRANSACTION]->(txn:Transaction)
WITH person, collect(txn) AS transactions
RETURN person.name, xg.chain_filter_lt(transactions, "amount", 100.0) AS small_transactions

MATCH (user:User)-[:COMPLETED]->(course:Course)
WITH user, collect(course) AS user_courses
RETURN user.name, xg.chain_group_by(user_courses, "difficulty_level") AS courses_by_level

MATCH (team:Team)-[:HAS_MEMBER]->(player:Player)
WITH team, collect(player) AS members
RETURN team.name, xg.chain_map(members, "salary") AS all_salaries

MATCH (user:User)-[:AUTHORED]->(article:Article)
WITH user, collect(article) AS articles
RETURN user.name, xg.chain_max_by(articles, "view_count") AS most_viewed_article

MATCH (warehouse:Warehouse)-[:STORES]->(item:Item)
WITH warehouse, collect(item) AS inventory
RETURN warehouse.location, xg.chain_min_by(inventory, "stock_level") AS lowest_stock_item

MATCH (conference:Conference)-[:INCLUDES]->(session:Session)
WITH conference, collect(session) AS sessions
RETURN conference.name, xg.chain_sort_by(sessions, "start_time") AS ordered_schedule

MATCH (customer:Customer)-[:MADE_PURCHASE]->(order:Order)
WITH customer, collect(order) AS purchases
RETURN customer.name, xg.chain_sum_by(purchases, "total_amount") AS lifetime_value

MATCH (person1:Person {name: "John"}), (person2:Person {name: "Jane"})
RETURN xg.common_neighbor_count(person1, person2) AS mutual_friends

MATCH (node:Node)
WHERE node.community_id IS NOT NULL
WITH collect(node) AS partition
RETURN xg.community_modularity(partition) AS modularity_score

MATCH (a:Page)-[edge:LINKS_TO]->(b:Page)
WITH collect(edge) AS all_edges
RETURN xg.edge_weight_normalize(all_edges, "frequency") AS normalized_links

MATCH (n:Node)
WITH count(DISTINCT n) AS total_nodes
MATCH ()-[e:CONNECTED]->()
WITH total_nodes, count(DISTINCT e) AS total_edges
RETURN xg.graph_density(total_nodes, total_edges) AS density

MATCH (n:Node)
WITH count(n) AS total_nodes
RETURN xg.graph_diameter_approx(total_nodes) AS estimated_diameter

MATCH (n:Node)
WITH count(n) AS total_nodes
RETURN xg.graph_radius_approx(total_nodes) AS estimated_radius

MATCH (page:WebPage)
RETURN page.url, xg.hits_authority(page) AS authority_score
ORDER BY authority_score DESC LIMIT 20

MATCH (page:WebPage)
RETURN page.url, xg.hits_hub(page) AS hub_score
ORDER BY hub_score DESC LIMIT 20

MATCH (influencer:User {name: "Alice"})
RETURN xg.influence_spread(influencer, 3) AS reach_3_hops

MATCH (person:Person)
RETURN person.name, xg.katz_centrality(person, 0.1, 1.0) AS centrality
ORDER BY centrality DESC

MATCH (user1:User)-[]->(mutual:User)<-[]-(:User {name: "Bob"})
WITH DISTINCT user1, collect(DISTINCT mutual) AS mutual_friends
RETURN user1.name, xg.resource_allocation(user1, mutual_friends[0]) AS link_probability

MATCH (start:City {name: "New York"}), (end:City {name: "Los Angeles"})
MATCH path = shortestPath((start)-[:ROUTE*]->(end))
RETURN xg.shortest_path_weight(path) AS total_distance

MATCH (item:Item)
WHERE item.last_accessed IS NOT NULL
RETURN item.id, xg.temporal_decay_rank(item, 30) AS recency_score
ORDER BY recency_score DESC

MATCH (p:Person {name: 'Alice'})
RETURN p.name, crc32(p.email) AS email_hash
LIMIT 1

MATCH (d:Document)
RETURN d.id, fnv1a(d.content) % 8 AS shard_bucket
ORDER BY shard_bucket

MATCH (u:User)-[r:POSTED]->(t:Tweet)
WITH u, t, murmur3(t.content) AS content_hash
WHERE NOT (u)-[:DUPLICATE_DETECTED]->(t)
MATCH (u2:User)-[r2:POSTED]->(t2:Tweet)
WHERE murmur3(t2.content) = content_hash AND t2 <> t
CREATE (u)-[:DUPLICATE_DETECTED {confidence: 0.95}]->(t2)

MATCH (u:User)
WHERE size(keys(u)) > 10
RETURN u.id, keys(u) AS all_properties
ORDER BY u.created_at DESC
LIMIT 5

MATCH (n)
WHERE 'Account' IN labels(n)
RETURN n.id, labels(n) AS node_types
LIMIT 10

MATCH (s:Sensor)-[r:RECORDED {timestamp: {year: 2026, month: 4}}]->(v:Value)
WITH s.id, collect(r.temperature) AS temps
RETURN s.id, list.avg(temps) AS avg_temperature
ORDER BY avg_temperature DESC

WITH ['active', 'pending', 'verified'] AS allowed_statuses
MATCH (a:Account {status: 'pending'})
WHERE list.contains(allowed_statuses, a.status)
RETURN a.id, a.status
LIMIT 20

MATCH (u:User {id: 1})-[r:FOLLOWING]->(f:User)
WITH collect(f.id) AS current_following
WITH current_following, [2, 3, 4, 5] AS previous_following
RETURN list.difference(previous_following, current_following) AS unfollowed_ids

MATCH (p:Post)-[r:LIKED_BY]->(u:User)
WITH p.id, collect(u.category) AS categories
RETURN p.id, list.distinct(categories) AS unique_user_categories

MATCH (a:Article)
WITH collect(a.id) AS all_articles
RETURN list.drop(all_articles, 10) AS articles_after_skip_10

MATCH (g:Group)-[r:CONTAINS]->(t:Team)
WITH g.id, collect(collect(t.id)) AS nested_teams
RETURN g.id, list.flatten(nested_teams) AS all_team_ids

WITH ['red', 'green', 'blue', 'yellow'] AS colors
RETURN list.indexof(colors, 'blue') AS blue_position

MATCH (u1:User {id: 1})-[r1:KNOWS]->(c1:Contact)
MATCH (u2:User {id: 2})-[r2:KNOWS]->(c2:Contact)
WITH collect(c1.id) AS friends_u1, collect(c2.id) AS friends_u2
RETURN list.intersect(friends_u1, friends_u2) AS mutual_friends

MATCH (a:Author)-[r:WROTE]->(b:Book)
WITH a.name, collect(b.id) AS books
WHERE list.length(books) > 5
RETURN a.name, list.length(books) AS book_count
ORDER BY book_count DESC

MATCH (d:Device)-[r:RECORDED]->(m:Metric)
WITH d.id, collect(r.value) AS metric_values
RETURN d.id, list.max(metric_values) AS peak_value
WHERE list.max(metric_values) > 100

MATCH (s:Store)-[r:SOLD {date: {year: 2026, month: 4}}]->(p:Product)
WITH s.id, collect(r.price) AS prices
RETURN s.id, list.median(prices) AS median_price
ORDER BY median_price

MATCH (c:Cache)-[r:ACCESSED]->(i:Item)
WITH c.id, collect(r.latency_ms) AS latencies
WHERE list.min(latencies) > 10
RETURN c.id, list.min(latencies) AS min_latency

MATCH (api:APIEndpoint)-[r:INVOKED]->(t:Transaction)
WITH api.name, collect(r.response_time_ms) AS times
RETURN api.name,
  list.percentile(times, 0.50) AS p50,
  list.percentile(times, 0.95) AS p95,
  list.percentile(times, 0.99) AS p99

MATCH (inv:Investment)-[r:QUARTERLY_RETURN]->(q:Quarter)
WITH inv.name, collect(r.growth_factor) AS growth_factors
RETURN inv.name, list.product(growth_factors) AS total_growth
ORDER BY total_growth DESC

MATCH (t:Timeline)-[r:EVENT_AT]->(e:Event)
WITH collect(e.timestamp) AS chronological
RETURN list.reverse(chronological) AS reverse_chronological

MATCH (q:Queue)-[r:TASK_IN]->(t:Task)
WITH collect(t.id) AS all_tasks
RETURN list.slice(all_tasks, 10, 20) AS page_2_tasks

MATCH (c:Country)-[r:EXPORTS]->(g:Good)
WITH c.name, collect(r.value_usd) AS trade_values
RETURN c.name, list.sort(trade_values) AS sorted_exports
ORDER BY c.name

MATCH (m:Machine)-[r:PRODUCED]->(p:Part)
WITH m.id, collect(r.weight_grams) AS weights
WHERE list.stddev(weights) > 2.5
RETURN m.id, list.stddev(weights) AS weight_variance

MATCH (o:Order)-[r:CONTAINS]->(i:Item)
WITH o.id, collect(r.quantity * r.unit_price) AS amounts
RETURN o.id, list.sum(amounts) AS order_total
ORDER BY order_total DESC

MATCH (u:User)-[r:VIEWED]->(v:Video)
WITH u.id, collect(v.id ORDER BY r.timestamp DESC) AS watched
RETURN u.id, list.take(watched, 5) AS last_5_videos

MATCH (t:Team {id: 1})-[r:MEMBER_OF]->(p:Person)
MATCH (t)-[r2:AFFILIATE_OF]->(a:Affiliate)
WITH collect(p.id) AS core_members, collect(a.person_id) AS affiliates
RETURN list.union(core_members, affiliates) AS all_participants

MATCH (p:Portfolio)-[r:HOLDING]->(s:Stock)
WITH p.id, collect(r.return_percent) AS returns
RETURN p.id, list.variance(returns) AS portfolio_variance
ORDER BY portfolio_variance DESC

WITH ['A', 'B', 'C'] AS keys, [1, 2, 3] AS values
RETURN list.zip(keys, values) AS key_value_pairs

MATCH p = (a:Author {name: 'Alice'})-[:COLLABORATED*1..3]->(z:Author {name: 'Zoe'})
WITH p, nodes(p) AS collaboration_chain
RETURN [node IN collaboration_chain | node.name] AS author_names
LIMIT 1

UNWIND range(1, 10, 2) AS odd_number
MATCH (n {id: odd_number})
RETURN collect(n.value) AS odd_values

MATCH (m:Month)
WHERE m.number IN range_generate(1, 12, 3)
RETURN m.name

MATCH p = (s:Source)-[*1..5]->(t:Target)
WITH p, relationships(p) AS edge_path
RETURN [rel IN edge_path | type(rel)] AS relationship_types

MATCH (h:HeadNode)-[r:LINKED]->(n:NextNode)
WITH collect(n.id) AS all_nodes
RETURN tail(all_nodes) AS nodes_after_first

MATCH (p:Publication)-[r:WRITTEN_BY]->(a:Author)
WITH collect(a.field) AS author_fields
RETURN toset(author_fields) AS unique_fields

MATCH (p:Patient)-[r:TEST_RESULT]->(t:Test)
WITH collect(r.value) AS all_results
RETURN uniformsample(all_results, 50) AS sample_results

MATCH (c:Config)
RETURN c.id,
  map_get(c.settings, 'timeout', 30) AS timeout,
  map_get(c.settings, 'retries', 3) AS retries

MATCH (p:Product)
WHERE map_has_key(p.attributes, 'weight_kg')
RETURN p.id, p.attributes AS all_attributes
LIMIT 10

MATCH (u:User {id: 123})
RETURN u.id, map_keys(u.profile) AS profile_fields

MATCH (u:User {id: 1})
WITH u.base_settings AS base, u.custom_overrides AS custom
RETURN map_merge(base, custom) AS final_settings

MATCH (s:Store {id: 1})
RETURN s.id, map_values(s.inventory) AS stock_counts

MATCH (r:Report)
WITH r.metrics AS metrics_map
RETURN values(metrics_map) AS all_metrics

MATCH (t:Transaction)
WHERE abs(t.balance_change) > 1000
RETURN t.id, abs(t.balance_change) AS magnitude
ORDER BY magnitude DESC

WITH 0.5 AS cosine_value
RETURN acos(cosine_value) AS angle_radians

WITH 0.866 AS sine_value
RETURN asin(sine_value) AS angle_radians

MATCH (r:Road)
RETURN r.id, atan(r.slope) AS gradient_angle

MATCH (a:Aircraft)-[r:POSITION]->(p:Point)
RETURN a.id, atan2(p.lat_change, p.lon_change) AS bearing_radians

MATCH (c:Container)
RETURN c.id, cbrt(c.volume_cubic_units) AS side_length

MATCH (i:Invoice)
RETURN i.id, ceil(i.amount / 100) AS hundreds_required

MATCH (s:Setting)
RETURN s.id, clamp(s.refresh_interval, 100, 5000) AS bounded_interval

MATCH (w:Wave)
RETURN w.id, cos(w.phase_radians) AS amplitude

WITH 1.5 AS exponent
RETURN cosh(exponent) AS hyperbolic_value

MATCH (d:Direction)
RETURN d.id, degrees(d.heading_radians) AS heading_degrees

RETURN e() * e() AS e_squared

MATCH (g:Growth)
RETURN g.id, exp(g.growth_rate * g.time_years) AS multiplier

MATCH (p:Price)
RETURN p.id, floor(p.amount) AS whole_dollars

MATCH (g:GeoPoint)
RETURN g.id, haversin(g.latitude_radians) AS hav_value

MATCH (p1:Point {id: 1}), (p2:Point {id: 2})
RETURN hypot(p1.x - p2.x, p1.y - p2.y) AS distance

WITH 100 AS start, 200 AS end, 0.3 AS progress
RETURN lerp(start, end, progress) AS current_value

MATCH (m:Metric)
RETURN m.id, log(m.value) AS log_value
WHERE m.value > 0

MATCH (s:Sound)
RETURN s.id, 20 * log10(s.amplitude) AS decibels

MATCH (d:Dataset)
RETURN d.id, log2(d.cardinality) AS information_bits

MATCH (c:Comparison)
RETURN c.id, max_val(c.value_a, c.value_b) AS larger

MATCH (s:Schedule)
RETURN s.task_id, min_val(s.deadline, s.estimated_end) AS critical_date

MATCH (i:Item)
WHERE mod(i.id, 10) = 0
RETURN i.id AS every_tenth_item

MATCH (c:Circle)
RETURN c.id, pi() * c.radius * c.radius AS area

MATCH (c:Compound)
RETURN c.id, power(2, c.doubling_count) AS final_amount

MATCH (d:Direction)
RETURN d.id, sin(radians(d.bearing_degrees)) AS sine_component

MATCH (u:User)
WHERE rand() < 0.05
RETURN u.id AS sampled_user

MATCH (r:Rating)
RETURN r.id, round(r.score) AS rounded_score

MATCH (t:Transaction)
RETURN t.id,
  CASE sign(t.amount)
    WHEN -1 THEN 'Withdrawal'
    WHEN 1 THEN 'Deposit'
    ELSE 'No Change'
  END AS transaction_type

MATCH (o:OscillatingSignal)
RETURN o.id, sin(o.phase) AS amplitude

WITH 2.0 AS exponent
RETURN sinh(exponent) AS hyperbolic_sine

MATCH (n:Node)
RETURN n.id, sqrt(n.variance) AS standard_deviation
WHERE n.variance >= 0

MATCH (a:Angle)
RETURN a.id, tan(a.radians) AS slope

MATCH (v:Vector)
RETURN v.id, tanh(v.value) AS normalized_value

MATCH (i:Interest)
RETURN i.id, truncate(i.rate, 4) AS rate_4_decimals

CALL mv.create("top_users", "MATCH (u:User)-[c:CREATED]->(p:Post) RETURN u.id, COUNT(p) AS post_count ORDER BY post_count DESC LIMIT 100") YIELD name, status RETURN name, status;

CALL mv.drop("top_users") YIELD name, status RETURN name, status;

CALL mv.due() YIELD name, query, overdue_sec WHERE overdue_sec > 300 RETURN name, overdue_sec ORDER BY overdue_sec DESC;

CALL mv.list() YIELD name, query RETURN name, LENGTH(query) AS query_length ORDER BY name;

CALL mv.refresh("top_users") YIELD name, query, status WITH query CALL apoc.cypher.run(query, {}) YIELD value RETURN name, status, COUNT(value) AS row_count;

CALL mv.set_interval("top_users", 3600) YIELD name, interval_sec RETURN name, interval_sec;

MATCH (e:Event)-[:CONTAINS]->(p:Particle) WHERE e.id = "evt_001" WITH COLLECT(p.px) AS px, COLLECT(p.py) AS py, COLLECT(p.pz) AS pz RETURN particle.aplanarity(px, py, pz) AS aplanarity;

MATCH (e:Event {id: "evt_042"}) RETURN particle.corrected_mass(125.5, 47.3) AS corrected_mass;

MATCH (j1:Jet {id: "jet_1"}), (j2:Jet {id: "jet_2"}) RETURN particle.delta_r(j1.eta, j1.phi, j2.eta, j2.phi) AS separation_deltaR;

MATCH (d:DecayChain {id: "B_decay_001"}) RETURN particle.dira([1.254, -0.387, 2.105], [0.891, -0.143, 0.883]) AS dira_cosine;

MATCH (decay:Decay) RETURN particle.flight_distance([0.012, 0.008, 0.003], [3.450, 2.134, 1.678]) AS flight_distance_mm;

MATCH (e:Event)-[:CONTAINS]->(p:Particle) WHERE e.id = "evt_089" WITH COLLECT(p.px) AS px, COLLECT(p.py) AS py, COLLECT(p.pz) AS pz RETURN particle.fox_wolfram(px, py, pz, 2) AS fw_moment_2;

MATCH (t:Track {id: "trk_234"}), (v:Vertex {id: "pv_001"}) RETURN particle.impact_parameter(t, v) AS impact_parameter_um;

RETURN particle.invariant_mass(125.5, 0.8, 2.1, 45.3, 127.2, -1.2, 1.9, 44.7) AS invariant_mass_GeV;

MATCH (l1:Lepton {type: "muon"}), (l2:Lepton {type: "muon"}) WHERE l1.charge != l2.charge RETURN particle.invariant_mass_pt(28.3, 1.2, 2.45, 0.1057, 35.7, -0.8, 5.63, 0.1057) AS dilepton_mass_GeV;

MATCH (e:Event {id: "evt_156"})-[:CONTAINS]->(p:Particle) WITH COLLECT(p.px) AS px, COLLECT(p.py) AS py RETURN particle.missing_et(px, py) AS missing_energy_GeV;

MATCH (j:Jet {id: "jet_45"}) RETURN particle.pseudorapidity(j.px, j.py, j.pz) AS eta;

MATCH (p:Particle {id: "pho_78"}) RETURN particle.rapidity(p.energy, p.pz) AS rapidity_y;

MATCH (e:Event {id: "evt_203"})-[:CONTAINS]->(p:Particle) WITH COLLECT(p.px) AS px, COLLECT(p.py) AS py, COLLECT(p.pz) AS pz RETURN particle.sphericity(px, py, pz) AS sphericity_value;

MATCH (e:Event)-[:CONTAINS]->(p:Particle) WHERE e.run_number = 2024 WITH COLLECT(p.px) AS px, COLLECT(p.py) AS py, COLLECT(p.pz) AS pz RETURN particle.thrust(px, py, pz) AS thrust_axis ORDER BY thrust_axis DESC LIMIT 1;

MATCH (l:Lepton {type: "muon"}) WHERE l.px IS NOT NULL RETURN l.id, particle.transverse_momentum(l.px, l.py) AS pT_GeV ORDER BY pT_GeV DESC LIMIT 10;

MATCH (v:Vertex {id: "sv_001"})-[:CONTAINS]->(t:Track) WITH v, COLLECT(t) AS tracks RETURN v.id, particle.vertex_chi2(tracks) AS chi2_fit WHERE chi2_fit < 10.0;

MATCH (fn:Function {name: "process_transaction"}) RETURN fn.name, atg_boundary_values(fn) AS test_boundaries;

MATCH (fn:Function) RETURN fn.name, atg_coverage(fn) AS coverage_score ORDER BY coverage_score ASC LIMIT 20;

MATCH (fn:Function {module: "core_engine"}) RETURN fn.name, atg_mutation_score(fn) AS mutation_score WHERE mutation_score > 0.85 ORDER BY mutation_score DESC;

MATCH (fn:Function {in_hot_path: true}) RETURN fn.name, atg_test_priority(fn) AS priority ORDER BY priority DESC LIMIT 15;

RETURN mil.ballistic_range(850.0, 35.0) AS range_meters;

MATCH (r:Radar {id: "radar_01"}) RETURN mil.radar_horizon(45.0, 8000.0) AS horizon_km UNION RETURN mil.radar_horizon(45.0) AS horizon_sea_level;

MATCH (s:Ship {id: "SS_001"}) RETURN ocean.drift(s.lat, s.lon, 1.2, 45.0, 3600.0) AS drifted_position;

RETURN ocean.sound_speed(15.5, 35.0, 1000.0) AS sound_speed_ms;

WITH 6.371e6 AS earth_radius_m, 5.972e24 AS earth_mass_kg RETURN orbital.escape_velocity(earth_radius_m, earth_mass_kg) AS escape_velocity_ms;

WITH 6.678e6 AS leo_m, 4.224e7 AS geo_m, 5.972e24 AS earth_mass_kg RETURN orbital.hohmann(leo_m, geo_m, earth_mass_kg) AS transfer_deltav;

WITH 4.224e7 AS geostationary_sma_m, 5.972e24 AS earth_mass_kg RETURN orbital.period(geostationary_sma_m, earth_mass_kg) / 86400.0 AS period_days;

WITH 6.678e6 AS leo_orbit_m, 5.972e24 AS earth_mass_kg RETURN orbital.velocity(leo_orbit_m, earth_mass_kg) AS leo_velocity_ms;

WITH 2.662e7 AS gps_orbit_radius_m, 3874.0 AS gps_velocity_ms RETURN physics.gps_correction(gps_orbit_radius_m, gps_velocity_ms) AS relativistic_correction;

WITH 0.9 * 299792458 AS relativistic_velocity_ms RETURN physics.lorentz(relativistic_velocity_ms) AS gamma_factor;

WITH 10000000.0 AS high_velocity_ms RETURN physics.time_dilation(high_velocity_ms) AS time_dilation_factor;

MATCH (u:User {id: 1})
WHERE isempty(u.tags)
RETURN u.name, u.tags AS empty_tags

MATCH (r:Reading {sensor_id: 'A1'})
WHERE NOT isinf(r.temperature)
RETURN r.timestamp, r.temperature
LIMIT 10

MATCH (m:Measurement)
WHERE isnan(m.calibration_factor)
RETURN m.id, m.device, m.calibration_factor AS invalid_value
ORDER BY m.timestamp DESC

CALL xray.flow_trace('LoanApproval', 'loan_id', '12345', 5)
YIELD step, depth, node_name, node_type, condition, action
RETURN step, depth, node_name, node_type, condition, action
ORDER BY step

CALL xray.flow_validate('OrderProcessing')
YIELD flow_name, node_count, valid, issues
WHERE NOT valid
RETURN flow_name, node_count, issues

HELLO Frame:
  [u32 0x0000002A]        // payload length: 42 bytes
  [u8 0x01]              // msg_type: HELLO
  [u8 0x00]              // flags: no compression
  [u16 0x0001 LE]        // query_id: 1
  [payload: 42 bytes]    // auth + version

HELLO payload (frame msg_type=0x01):
  [u16 0x0001 LE]        // version: 1
  [u16 0x0007 LE]        // capabilities: PROFILE|EXPLAIN|COMPRESSED
  [u32 0x0000000C LE]    // token_len: 12
  [12 bytes: "admin:pass"]
  [u32 0x00000000 LE]    // db_len: 0 (use default)
  // Server responds: HELLO_OK (0x02) frame

EXECUTE payload (frame msg_type=0x03):
  [u8 0x00]              // language: Cypher
  [u32 0x0000001F LE]    // query_len: 31
  [31 bytes: "MATCH (n:User) RETURN n LIMIT 1"]
  [u32 0x00000000 LE]    // param_count: 0
  [u32 0x00000001 LE]    // options: PROFILE
  // Server responds: SCHEMA, BATCH(es), COMPLETE

SCHEMA + BATCH + COMPLETE payload chain:
  SCHEMA (0x04): [u16 0x0001 LE] [u8 0x03] [u32 0x00000001] ['n']
    // 1 column, type INT64 (0x03), name_len=1, name='n'
  BATCH (0x05): [u32 0x00000001 LE] [u8 0x03] [i64 0x000000000000012C LE]
    // 1 row, column type INT64, value=300
  COMPLETE (0x06): [u32 0x00000001 LE] [u32 0x000003E8 LE] [u32 0x000000FA LE]
    // total_rows=1, exec_time=1000 µs, compile_time=250 µs

BULK_INSERT_NODES (0x21) payload:
  [u32 0x00000002 LE]    // rows: 2
  [u16 0x0003 LE]        // cols: 3 (id, name, age)
  // Column definitions:
  [u8 0x05] [u32 0x00000002] ['id']       // STRING, name_len=2
  [u8 0x05] [u32 0x00000004] ['name']    // STRING, name_len=4
  [u8 0x03] [u32 0x00000003] ['age']     // INT64, name_len=3
  // Column data (row 1):
  [u8 0x05] [u32 0x00000002] ['42'] [u8 0x05] [u32 0x00000004] ['Alice'] [u8 0x03] [i64 28]
  // Column data (row 2):
  [u8 0x05] [u32 0x00000002] ['43'] [u8 0x05] [u32 0x00000003] ['Bob'] [u8 0x03] [i64 35]

MATCH (doc:Document {id: 'doc_001'})
SET doc.embedding = embed(doc.content)
RETURN doc.id, size(doc.embedding) AS dimensions

WITH embed('machine learning') AS query_emb
MATCH (doc:Document)
WHERE doc.embedding IS NOT NULL
WITH doc, vector_dot_product(query_emb, doc.embedding) AS similarity
RETURN doc.title, similarity
ORDER BY similarity DESC
LIMIT 5

MATCH (doc:Document)
WHERE doc.embedding IS NOT NULL
SET doc.normalized_embedding = vector_normalize(doc.embedding)
RETURN count(doc) AS documents_normalized

WITH [3.0, 4.0] AS vec
RETURN vector_norm(vec) AS magnitude

WITH [1.0, 2.0, 3.0] AS vec
RETURN vector_scale(vec, 2.5) AS scaled

WITH [1.0, 2.0, 3.0] AS v1, [4.0, 5.0, 6.0] AS v2
RETURN vector_add(v1, v2) AS sum_vec

MATCH (doc:Document)
WHERE doc.embedding IS NOT NULL
RETURN doc.id, vector_dimension(doc.embedding) AS dims
LIMIT 1

MATCH (doc:Document)
WITH doc,
     'information retrieval' AS query,
     1000 AS total_docs,
     450 AS avg_length
RETURN doc.title,
       bm25_score(query, doc.content, total_docs, avg_length) AS score
ORDER BY score DESC
LIMIT 10

WITH 'neural' AS term,
     'deep learning requires neural networks' AS doc,
     500 AS corpus_size,
     42 AS docs_with_term
RETURN tf_idf(term, doc, corpus_size, docs_with_term) AS score

WITH 'The quick brown fox' AS text1,
     'A fast brown fox' AS text2
RETURN text_similarity(text1, text2) AS similarity

WITH 'kitten' AS s1, 'sitting' AS s2
RETURN levenshtein_distance(s1, s2) AS edit_distance

WITH 'analysis' AS word1, 'analytics' AS word2
RETURN ngram_similarity(word1, word2, 3) AS trigram_sim

WITH embed('natural language processing') AS query_vec
MATCH (doc:Document)
WHERE doc.embedding IS NOT NULL
WITH doc, relevance_score(query_vec, doc.embedding) AS score
RETURN doc.title, score
ORDER BY score DESC
LIMIT 5

WITH 'What is machine learning?' AS query,
     ['ML is a type of AI',
      'Cooking is fun',
      'Algorithms enable machine learning'] AS candidates
RETURN context_rank(query, candidates) AS ranked_candidates

MATCH (article:Article {id: 'art_123'})
RETURN extract_keywords(article.body, 10) AS top_keywords

MATCH (doc:Document {id: 'doc_001'})
WITH text_chunk_by_size(doc.content, 256) AS chunks
UNWIND chunks AS chunk
RETURN chunk AS text_chunk
LIMIT 5

MATCH (doc:Document)
WITH text_chunk_by_words(doc.content, 100) AS chunks
UNWIND chunks AS chunk
SET doc.chunks = chunks
RETURN count(doc) AS documents_chunked

MATCH (manual:Manual {product: 'XR-2000'})
WITH text_chunk_overlap(manual.text, 512, 64) AS chunks
UNWIND chunks AS chunk
CREATE (chunk_node:Chunk {text: chunk})
RETURN count(chunk_node) AS chunks_created

MATCH (prompt:Prompt {name: 'rag_context'})
RETURN estimate_tokens(prompt.template) AS token_count

MATCH (doc:Document)
WHERE fits_in_context(doc.content, 2048)
RETURN doc.title, estimate_tokens(doc.content) AS tokens
LIMIT 20

MATCH (doc:Document {id: 'doc_001'})
WITH truncate_to_tokens(doc.content, 1024) AS truncated
RETURN truncated AS limited_context

MATCH (query:Query {id: 'q_789'})
WITH context_utilization(query.prompt, 4096) AS usage
WHERE usage > 0.8
RETURN query.id, usage AS context_percent

WITH {user: 'Alice', topic: 'quantum computing'} AS vars
RETURN format_prompt(
  'Hello {user}, tell me about {topic}',
  vars
) AS formatted_prompt

MATCH (person:Person {id: 'p_456'})
RETURN graph_context(person, 2) AS neighborhood_summary

MATCH (article:Article)
WHERE word_count(article.body) > 500
RETURN article.title, word_count(article.body) AS word_len
ORDER BY word_len DESC
LIMIT 10

MATCH (summary:Summary)
WHERE sentence_count(summary.content) BETWEEN 5 AND 20
RETURN summary.id, sentence_count(summary.content) AS sentences

MATCH (content:Content)
WITH readability_score(content.body) AS readability
WHERE readability < 12.0
RETURN content.id, readability AS flesch_kincaid_grade

MATCH (doc:Document)
RETURN doc.id, text_fingerprint(doc.content) AS content_hash
LIMIT 100

WITH [['doc_1', 'doc_2', 'doc_3'],
      ['doc_2', 'doc_1', 'doc_4']] AS rankings
RETURN reciprocal_rank_fusion(rankings, 60) AS fused_ranking

CALL engine.create_model("User", "age", "envelope", 10, 2.5) YIELD status

CALL engine.drain_events(50) YIELD vertex_gid, sigma, expected, actual

CALL engine.drop_model("User", "age") YIELD status

CALL engine.show_model_types() YIELD type, parameters

CALL engine.show_models() YIELD label, property, type, status

MATCH (n:User) RETURN n.name, degree(n) ORDER BY degree(n) DESC

MATCH (s:User)-[r:FOLLOWS]->(t) RETURN s.name, endnode(r) as target

RETURN frombytestring("SGVsbG8gV29ybGQ=") AS decoded_value

WITH [1, 2, 3, 4, 5] AS nums RETURN head(nums) AS first_element

MATCH (n:User) WHERE n.name = "Alice" RETURN id(n) AS user_id

MATCH (n:User) RETURN n.name, indegree(n) AS incoming_edges

WITH '{"user": "Alice", "age": 30}' AS json_str RETURN json_extract(json_str, "$.user")

WITH [10, 20, 30, 40] AS values RETURN last(values) AS final_element

WITH [1, 2, 3, 4, 5] AS list RETURN length(list) AS list_size

MATCH (n:User) RETURN n.name, outdegree(n) AS outgoing_edges

WITH "3.14159" AS num_str RETURN parse_float(num_str) AS pi_value

WITH "FF" AS hex_str RETURN parse_int(hex_str, 16) AS decimal_value

MATCH (n:User {name: "Bob"}) RETURN properties(n) AS user_properties

MATCH (n:User) RETURN n.name, propertysize(n, "description") AS size_bytes

RETURN randomuuid() AS new_uuid

MATCH (n:User)-[r]->() RETURN n.name, size(r) AS rel_count

MATCH (s:User)-[r:FOLLOWS]->(t) RETURN startnode(r) as follower, s.name

RETURN timestamp() AS current_time_ms

MATCH (n:User {name: "Carol"}) RETURN to_json(properties(n)) AS json_output

WITH ["true", "false", "1", "0"] AS bool_strs RETURN [b in bool_strs | toboolean(b)]

WITH [[1, 0, 1]] AS int_list RETURN tobooleanlist(int_list[0])

RETURN tobytestring("Hello") AS encoded

RETURN toenum("Status", "ACTIVE") AS status_enum

WITH ["1.5", "2.7", "3.9"] AS nums RETURN [n in nums | tofloat(n)]

WITH [["1.2", "3.4"]] AS num_strs RETURN tofloatlist(num_strs[0])

WITH "42" AS num_str RETURN tointeger(num_str) AS int_value

WITH [["10", "20", "30"]] AS int_strs RETURN tointegerlist(int_strs[0])

MATCH (u:User)-[r:FOLLOWS]->(v) RETURN type(r) AS relationship_type

RETURN [typeof(1), typeof("text"), typeof([1,2,3]), typeof({a: 1})]

RETURN uuid_generate() AS generated_uuid

RETURN valuetype(42) AS int_type, valuetype("text") AS string_type

RETURN base64_decode("SGVsbG8gV29ybGQ=") AS decoded_text

RETURN base64_encode("Hello World") AS encoded_text

WITH "xrayGraphDB" AS text RETURN char_length(text) AS char_count

RETURN concat("Hello", " ", "World", "!") AS greeting

WITH "xrayGraphDB" AS text RETURN contains(text, "Graph") AS has_graph

WITH "database.cpp" AS filename RETURN ends_with_func(filename, ".cpp") AS is_cpp_file

WITH "query.cypher" AS file RETURN endswith(file, ".cypher") AS is_cypher

RETURN format_number(1234.5678, "#,##0.00") AS formatted

RETURN hex_decode("48656c6c6f") AS decoded_hex

RETURN hex_encode("Hello") AS hex_encoded

WITH "xrayGraphDB" AS text RETURN indexof(text, "Graph") AS graph_pos

WITH ["Alice", "Bob", "Carol"] AS names RETURN join(names, ", ") AS name_list

WITH "xrayGraphDB" AS text RETURN left(text, 4) AS first_four

WITH "42" AS num RETURN lpad(num, 5, "0") AS padded_num

WITH "  leading spaces" AS text RETURN ltrim(text) AS trimmed

RETURN pad_number(7, 4, "0") AS zero_padded

WITH "user@example.com" AS email RETURN regex_match(email, "([^@]+)@(.+)") AS parts

WITH "x" AS char RETURN repeat(char, 10) AS repeated_x

WITH "Hello World" AS text RETURN replace(text, "World", "xrayGraphDB") AS replaced

WITH "old value" AS text RETURN replace_string(text, "old", "new") AS new_text

WITH "stressed" AS word RETURN reverse(word) AS reversed_word

WITH "GraphDB" AS text RETURN reverse_string(text) AS backwards

WITH "xrayGraphDB" AS text RETURN right(text, 2) AS last_two

WITH "42" AS num RETURN rpad(num, 5, ".") AS right_padded

WITH "trailing spaces  " AS text RETURN rtrim(text) AS trimmed

WITH "Alice,Bob,Carol" AS names RETURN split(names, ",") AS name_list

WITH "xrayGraphDB" AS text RETURN starts_with_func(text, "xray") AS starts_x

WITH "GraphQL" AS text RETURN startswith(text, "Graph") AS starts_g

WITH "xrayGraphDB" AS text RETURN substring(text, 4, 5) AS substr

RETURN to_string(42) AS num_as_string, to_string([1,2,3]) AS list_as_string

WITH "XRAYGRAPHDB" AS text RETURN tolower(text) AS lowercase

RETURN tostring(true) AS bool_string, tostring(3.14) AS float_string

RETURN tostringornull(42) AS num_str, tostringornull(null) AS null_result

WITH "xrayGraphDB" AS text RETURN toupper(text) AS uppercase

WITH "  whitespace  " AS text RETURN trim(text) AS trimmed_text

MATCH (n:User) WHERE assert(n.age > 0, "Age must be positive") RETURN n.name, n.age

CREATE (n:Task {id: counter("task_id", 1000), name: "Process payment", created: timestamp()}) RETURN n.id, n.name

RETURN explain_analyze("MATCH (n:Product) WHERE n.price > 100 RETURN n LIMIT 10") AS plan

MATCH p = (src:Airport {code: "LAX"})-[:ROUTE*1..5]->(dst:Airport {code: "JFK"}) RETURN gethopscounter(p) AS num_hops, length(p) AS path_length LIMIT 1

WITH graph_snapshot("Account") AS snap1, graph_snapshot("Account") AS snap2 RETURN graph_diff(snap1, snap2) AS changes

RETURN graph_snapshot("Transaction") AS txn_snapshot, graph_snapshot() AS full_snapshot

RETURN username() AS current_user, roles() AS assigned_roles

MATCH (a:AuditLog) WHERE a.performed_by = username() AND a.timestamp > timestamp() - 86400000 RETURN COUNT(a) AS actions_last_24h

MATCH (s:Sensor {location: "LAX_Terminal1"}) WHERE s.temperature_c IS NOT NULL RETURN s.location, s.temperature_c, c_to_f(s.temperature_c) AS temperature_f

RETURN celsius_to_fahrenheit(0) AS freezing, celsius_to_fahrenheit(25) AS room_temp, celsius_to_fahrenheit(100) AS boiling

MATCH (f:Flight {id: "UA123"}) RETURN f.id, f.cruise_altitude_ft, convert(f.cruise_altitude_ft, "feet", "meters") AS cruise_altitude_m

MATCH (w:WeatherReport) WHERE w.temp_f > 95 RETURN w.station_code, w.temp_f, f_to_c(w.temp_f) AS temp_c

RETURN fahrenheit_to_celsius(32) AS freezing, fahrenheit_to_celsius(98.6) AS body_temp, fahrenheit_to_celsius(212) AS boiling

MATCH (a:Aircraft {model: "B787"}) RETURN a.model, a.wingspan_ft, feet_to_meters(a.wingspan_ft) AS wingspan_m

MATCH (t:TrajectoryPoint) WHERE t.vertical_rate_fpm > 1000 RETURN t.timestamp, t.vertical_rate_fpm, fpm_to_mps(t.vertical_rate_fpm) AS vertical_rate_mps

MATCH (r:Runway {airport: "JFK"}) RETURN r.name, r.length_ft, ft_to_m(r.length_ft) AS length_m

MATCH (c:Cargo {id: "CARGO_001"}) RETURN c.id, c.weight_kg, kg_to_lb(c.weight_kg) AS weight_lb

MATCH (p:Person) WHERE p.weight_kg IS NOT NULL RETURN p.name, p.weight_kg, kilograms_to_pounds(p.weight_kg) AS weight_lbs ORDER BY p.weight_kg DESC LIMIT 5

MATCH (r:Route) WHERE r.distance_km > 5000 RETURN r.origin, r.destination, r.distance_km, kilometers_to_miles(r.distance_km) AS distance_mi

MATCH (s:Segment {type: "LON_to_BOS"}) RETURN s.type, s.distance_km, km_to_mi(s.distance_km) AS distance_miles

MATCH (v:Vector {source: "ADS-B"}) WHERE v.speed_knots > 450 RETURN v.timestamp, v.speed_knots, knots_to_mps(v.speed_knots) AS speed_mps

MATCH (i:Item {warehouse: "PHX"}) RETURN i.name, i.weight_lb, lb_to_kg(i.weight_lb) AS weight_kg

MATCH (b:Building {city: "New York"}) RETURN b.name, b.height_m, m_to_ft(b.height_m) AS height_ft

MATCH (altimeter:Sensor) RETURN altimeter.id, altimeter.altitude_m, meters_to_feet(altimeter.altitude_m) AS altitude_ft

MATCH (c:City) WHERE c.distance_from_airport_mi > 10 RETURN c.name, c.distance_from_airport_mi, mi_to_km(c.distance_from_airport_mi) AS distance_km