Extended Functions Reference

ArcadeDB provides a comprehensive set of extended functions organized by namespace. These functions are available in both SQL and Cypher queries, providing powerful data manipulation capabilities.

Overview

These extended functions provide:

Zero configuration - Functions are available immediately without any installation
Native performance - Direct integration with the query engine
Type safety - Proper type handling and error messages
Cross-language support - Available in both SQL and Cypher queries
APOC compatibility - Full support for the apoc. prefix for Neo4j migration

For a complete reference of all graph algorithms including complexity analysis, use cases, and examples, see the Graph Algorithms Appendix.

APOC Prefix Compatibility

ArcadeDB automatically supports the apoc. prefix for all extended functions and procedures. This means existing Neo4j/APOC queries work without modification.

When ArcadeDB encounters a function or procedure call with the apoc. prefix, it automatically strips the prefix and resolves to the corresponding ArcadeDB function:

APOC Call Resolves To Result

APOC Call	Resolves To	Result
`apoc.text.indexOf("hello", "l")`	`text.indexOf("hello", "l")`	Same function
`apoc.map.merge({a:1}, {b:2})`	`map.merge({a:1}, {b:2})`	Same function
`CALL apoc.merge.relationship(…)`	`CALL merge.relationship(…)`	Same procedure

apoc.text.indexOf("hello", "l")

text.indexOf("hello", "l")

Same function

apoc.map.merge({a:1}, {b:2})

map.merge({a:1}, {b:2})

Same function

CALL apoc.merge.relationship(…)

CALL merge.relationship(…)

Same procedure

This compatibility layer is:

Automatic - No configuration required
Case-insensitive - APOC.TEXT.INDEXOF works the same as apoc.text.indexOf
Zero overhead - Simple string prefix check, no performance impact

Example - These queries are equivalent:

-- Neo4j/APOC style (works in ArcadeDB)
RETURN apoc.text.join(["a", "b", "c"], ",") AS result

-- ArcadeDB native style
RETURN text.join(["a", "b", "c"], ",") AS result

Function Namespaces

Functions are organized into the following namespaces:

Namespace Description

Namespace	Description
`agg.*`	Aggregation and collection functions
`algo.*`	Graph algorithms (Dijkstra, A*, shortest paths, and 45+ more — see Graph Algorithms Appendix)
`coll.*`	Collection/list operations (flatten, sort, distinct, min/max)
`convert.*`	Type conversion functions
`create.*`	Creation functions (UUIDs, virtual nodes/relationships)
`date.*`	Date/time operations
`map.*`	Map/object operations
`math.*`	Mathematical functions
`merge.*`	Merge procedures for nodes and relationships
`meta.*`	Schema and database introspection procedures
`node.*`	Node/vertex operations (degree, labels, relationships)
`path.*`	Path operations (create, combine, slice, expansion)
`rel.*`	Relationship/edge operations (type, endpoints)
`text.*`	String manipulation and text processing
`util.*`	Utility functions (hashing, compression, validation)
`vector.*`	Vector/embedding operations (similarity, distance, quantization)

agg.*

Aggregation and collection functions

algo.*

Graph algorithms (Dijkstra, A*, shortest paths, and 45+ more — see Graph Algorithms Appendix)

coll.*

Collection/list operations (flatten, sort, distinct, min/max)

convert.*

Type conversion functions

create.*

Creation functions (UUIDs, virtual nodes/relationships)

date.*

Date/time operations

map.*

Map/object operations

math.*

Mathematical functions

merge.*

Merge procedures for nodes and relationships

meta.*

Schema and database introspection procedures

node.*

Node/vertex operations (degree, labels, relationships)

path.*

Path operations (create, combine, slice, expansion)

rel.*

Relationship/edge operations (type, endpoints)

text.*

String manipulation and text processing

util.*

Utility functions (hashing, compression, validation)

vector.*

Vector/embedding operations (similarity, distance, quantization)

Function Categories

Detailed reference is split per category. Pick a category from the left navigation, or jump straight in:

Aggregation — agg.first, agg.last, agg.median, percentiles
Collection & Map — coll. and map. operations
Convert & Create — type conversion, UUIDs, virtual nodes
Date & Math — date/time operations and extended math
Graph Elements — node. and rel. operations
Path & Algorithms — algo.* procedures and path expansion
Schema & Meta — meta. and merge. procedures
Text — string manipulation, similarity, distance
Utility — hashing, compression, validation
Vector — similarity, distance, quantization, sparse vectors

Migration Guide

Converting APOC Queries to ArcadeDB

Good news: In most cases, no changes are required!

ArcadeDB automatically supports the apoc. prefix, so your existing Neo4j/APOC queries will work without modification:

-- This Neo4j/APOC query works directly in ArcadeDB
RETURN apoc.text.join(["a", "b"], ",")

-- This procedure call also works directly
CALL apoc.merge.relationship(a, "KNOWS", {}, {}, b) YIELD rel

Optional: Removing the APOC Prefix

If you prefer to use the cleaner ArcadeDB-native syntax, you can optionally remove the apoc. prefix:

Functions - Remove the apoc. prefix

-- Neo4j/APOC style (works in ArcadeDB)
RETURN apoc.text.join(["a", "b"], ",")

-- ArcadeDB native style (also works)
RETURN text.join(["a", "b"], ",")

Procedures - Remove the apoc. prefix

-- Neo4j/APOC style (works in ArcadeDB)
CALL apoc.merge.relationship(a, "KNOWS", {}, {}, b) YIELD rel

-- ArcadeDB native style (also works)
CALL merge.relationship(a, "KNOWS", {}, {}, b) YIELD rel

Function signatures are 100% compatible - Parameters are in the same order with the same semantics

Unsupported APOC Functions

Some APOC procedures are not yet implemented in ArcadeDB:

Periodic/batch operations (apoc.periodic.*) - Use ArcadeDB’s transaction API
Schema modification operations (apoc.schema.*) - Use ArcadeDB’s Schema API
Refactoring procedures (apoc.refactor.*) - Use ArcadeDB’s native capabilities
Export/import procedures (apoc.export.*, apoc.import.*) - Use ArcadeDB’s native import/export