Chapter 3. Procedures & Functions

This chapter provides a reference of all the procedures and functions in the APOC library.

type qualified name signature description

procedure

apoc.algo.aStar

apoc.algo.aStar(startNode :: NODE?, endNode :: NODE?, relationshipTypesAndDirections :: STRING?, weightPropertyName :: STRING?, latPropertyName :: STRING?, lonPropertyName :: STRING?) :: (path :: PATH?, weight :: FLOAT?)

apoc.algo.aStar(startNode, endNode, 'KNOWS|<WORKS_WITH|IS_MANAGER_OF>', 'distance','lat','lon') YIELD path, weight - run A* with relationship property name as cost function

procedure

apoc.algo.aStarConfig

apoc.algo.aStarConfig(startNode :: NODE?, endNode :: NODE?, relationshipTypesAndDirections :: STRING?, config :: MAP?) :: (path :: PATH?, weight :: FLOAT?)

apoc.algo.aStar(startNode, endNode, 'KNOWS|<WORKS_WITH|IS_MANAGER_OF>', {weight:'dist',default:10,x:'lon',y:'lat'}) YIELD path, weight - run A* with relationship property name as cost function

procedure

apoc.algo.allSimplePaths

apoc.algo.allSimplePaths(startNode :: NODE?, endNode :: NODE?, relationshipTypesAndDirections :: STRING?, maxNodes :: INTEGER?) :: (path :: PATH?)

apoc.algo.allSimplePaths(startNode, endNode, 'KNOWS|<WORKS_WITH|IS_MANAGER_OF>', 5) YIELD path, weight - run allSimplePaths with relationships given and maxNodes

procedure

apoc.algo.cliques

apoc.algo.cliques(minSize :: NUMBER?) :: (clique :: LIST? OF NODE?)

apoc.algo.cliques(minSize) YIELD clique - search the graph and return all maximal cliques at least at large as the minimum size argument.

procedure

apoc.algo.cliquesWithNode

apoc.algo.cliquesWithNode(startNode :: NODE?, minSize :: NUMBER?) :: (clique :: LIST? OF NODE?)

apoc.algo.cliquesWithNode(startNode, minSize) YIELD clique - search the graph and return all maximal cliques that are at least as large than the minimum size argument and contain this node

procedure

apoc.algo.community

apoc.algo.community(times :: INTEGER?, labels :: LIST? OF STRING?, partitionKey :: STRING?, type :: STRING?, direction :: STRING?, weightKey :: STRING?, batchSize :: INTEGER?) :: VOID

CALL apoc.algo.community(times,labels,partitionKey,type,direction,weightKey,batchSize) - simple label propagation kernel

procedure

apoc.algo.cover

apoc.algo.cover(nodes :: ANY?) :: (rel :: RELATIONSHIP?)

apoc.algo.cover(nodes) yield rel - returns all relationships between this set of nodes

procedure

apoc.algo.dijkstra

apoc.algo.dijkstra(startNode :: NODE?, endNode :: NODE?, relationshipTypesAndDirections :: STRING?, weightPropertyName :: STRING?, defaultWeight = NaN :: FLOAT?, numberOfWantedPaths = 1 :: INTEGER?) :: (path :: PATH?, weight :: FLOAT?)

apoc.algo.dijkstra(startNode, endNode, 'KNOWS|<WORKS_WITH|IS_MANAGER_OF>', 'distance', defaultValue, numberOfWantedResults) YIELD path, weight - run dijkstra with relationship property name as cost function

procedure

apoc.algo.dijkstraWithDefaultWeight

apoc.algo.dijkstraWithDefaultWeight(startNode :: NODE?, endNode :: NODE?, relationshipTypesAndDirections :: STRING?, weightPropertyName :: STRING?, defaultWeight :: FLOAT?) :: (path :: PATH?, weight :: FLOAT?)

apoc.algo.dijkstraWithDefaultWeight(startNode, endNode, 'KNOWS|<WORKS_WITH|IS_MANAGER_OF>', 'distance', 10) YIELD path, weight - run dijkstra with relationship property name as cost function and a default weight if the property does not exist

procedure

apoc.algo.pageRank

apoc.algo.pageRank(nodes :: LIST? OF NODE?) :: (node :: NODE?, score :: FLOAT?)

CALL apoc.algo.pageRank(nodes) YIELD node, score - calculates page rank for given nodes

procedure

apoc.algo.pageRankStats

apoc.algo.pageRankStats(config :: MAP?) :: (nodes :: INTEGER?, relationships :: INTEGER?, iterations :: INTEGER?, readNodeMillis :: INTEGER?, readRelationshipMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, write :: BOOLEAN?, property :: STRING?)

CALL apoc.algo.pageRankStats({iterations:_,types:_,write:true,…​}) YIELD nodeCount - calculates page rank on graph for given nodes and potentially writes back

procedure

apoc.algo.pageRankWithConfig

apoc.algo.pageRankWithConfig(nodes :: LIST? OF NODE?, config :: MAP?) :: (node :: NODE?, score :: FLOAT?)

CALL apoc.algo.pageRankWithConfig(nodes,{iterations:_,types:_}) YIELD node, score, info - calculates page rank for given nodes

procedure

apoc.algo.pageRankWithCypher

apoc.algo.pageRankWithCypher(config :: MAP?) :: (nodes :: INTEGER?, relationships :: INTEGER?, iterations :: INTEGER?, readNodeMillis :: INTEGER?, readRelationshipMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, write :: BOOLEAN?, property :: STRING?)

CALL apoc.algo.pageRankWithCypher({iterations,node_cypher,rel_cypher,write,property,numCpu}) - calculates page rank based on cypher input

procedure

apoc.algo.wcc

apoc.algo.wcc() :: (nodeIds :: LIST? OF INTEGER?, stats :: MAP?)

CALL apoc.algo.wcc() YIELD number of weakly connected components

procedure

apoc.atomic.add

apoc.atomic.add(container :: ANY?, propertyName :: STRING?, number :: NUMBER?, times = 5 :: INTEGER?) :: (container :: ANY?, property :: STRING?, oldValue :: ANY?, newValue :: ANY?)

apoc.atomic.add(node/relatonship,propertyName,number) Sums the property’s value with the 'number' value

procedure

apoc.atomic.concat

apoc.atomic.concat(container :: ANY?, propertyName :: STRING?, string :: STRING?, times = 5 :: INTEGER?) :: (container :: ANY?, property :: STRING?, oldValue :: ANY?, newValue :: ANY?)

apoc.atomic.concat(node/relatonship,propertyName,string) Concats the property’s value with the 'string' value

procedure

apoc.atomic.insert

apoc.atomic.insert(container :: ANY?, propertyName :: STRING?, position :: INTEGER?, value :: ANY?, times = 5 :: INTEGER?) :: (container :: ANY?, property :: STRING?, oldValue :: ANY?, newValue :: ANY?)

apoc.atomic.insert(node/relatonship,propertyName,position,value) insert a value into the property’s array value at 'position'

procedure

apoc.atomic.remove

apoc.atomic.remove(container :: ANY?, propertyName :: STRING?, position :: INTEGER?, times = 5 :: INTEGER?) :: (container :: ANY?, property :: STRING?, oldValue :: ANY?, newValue :: ANY?)

apoc.atomic.remove(node/relatonship,propertyName,position) remove the element at position 'position'

procedure

apoc.atomic.subtract

apoc.atomic.subtract(container :: ANY?, propertyName :: STRING?, number :: NUMBER?, times = 5 :: INTEGER?) :: (container :: ANY?, property :: STRING?, oldValue :: ANY?, newValue :: ANY?)

apoc.atomic.subtract(node/relatonship,propertyName,number) Subtracts the 'number' value to the property’s value

procedure

apoc.atomic.update

apoc.atomic.update(container :: ANY?, propertyName :: STRING?, operation :: STRING?, times = 5 :: INTEGER?) :: (container :: ANY?, property :: STRING?, oldValue :: ANY?, newValue :: ANY?)

apoc.atomic.update(node/relatonship,propertyName,updateOperation) update a property’s value with a cypher operation (ex. "n.prop1+n.prop2")

procedure

apoc.bolt.execute

apoc.bolt.execute(url :: STRING?, kernelTransaction :: STRING?, params = {} :: MAP?, config = {} :: MAP?) :: (row :: MAP?)

 

procedure

apoc.bolt.load

apoc.bolt.load(url :: STRING?, kernelTransaction :: STRING?, params = {} :: MAP?, config = {} :: MAP?) :: (row :: MAP?)

 

procedure

apoc.case

apoc.case(conditionals :: LIST? OF ANY?, elseQuery = :: STRING?, params = {} :: MAP?) :: (value :: MAP?)

apoc.case([condition, query, condition, query, …​], elseQuery:'', params:{}) yield value - given a list of conditional / read-only query pairs, executes the query associated with the first conditional evaluating to true (or the else query if none are true) with the given parameters

procedure

apoc.cluster.graph

apoc.cluster.graph() :: (nodes :: LIST? OF NODE?, relationships :: LIST? OF RELATIONSHIP?)

 

procedure

apoc.coll.elements

apoc.coll.elements(values :: LIST? OF ANY?, limit = -1 :: INTEGER?, offset = 0 :: INTEGER?) :: (_1 :: ANY?, _2 :: ANY?, _3 :: ANY?, _4 :: ANY?, _5 :: ANY?, _6 :: ANY?, _7 :: ANY?, _8 :: ANY?, _9 :: ANY?, _10 :: ANY?, _1s :: STRING?, _2s :: STRING?, _3s :: STRING?, _4s :: STRING?, _5s :: STRING?, _6s :: STRING?, _7s :: STRING?, _8s :: STRING?, _9s :: STRING?, _10s :: STRING?, _1i :: INTEGER?, _2i :: INTEGER?, _3i :: INTEGER?, _4i :: INTEGER?, _5i :: INTEGER?, _6i :: INTEGER?, _7i :: INTEGER?, _8i :: INTEGER?, _9i :: INTEGER?, _10i :: INTEGER?, _1f :: FLOAT?, _2f :: FLOAT?, _3f :: FLOAT?, _4f :: FLOAT?, _5f :: FLOAT?, _6f :: FLOAT?, _7f :: FLOAT?, _8f :: FLOAT?, _9f :: FLOAT?, _10f :: FLOAT?, _1b :: BOOLEAN?, _2b :: BOOLEAN?, _3b :: BOOLEAN?, _4b :: BOOLEAN?, _5b :: BOOLEAN?, _6b :: BOOLEAN?, _7b :: BOOLEAN?, _8b :: BOOLEAN?, _9b :: BOOLEAN?, _10b :: BOOLEAN?, _1l :: LIST? OF ANY?, _2l :: LIST? OF ANY?, _3l :: LIST? OF ANY?, _4l :: LIST? OF ANY?, _5l :: LIST? OF ANY?, _6l :: LIST? OF ANY?, _7l :: LIST? OF ANY?, _8l :: LIST? OF ANY?, _9l :: LIST? OF ANY?, _10l :: LIST? OF ANY?, _1m :: MAP?, _2m :: MAP?, _3m :: MAP?, _4m :: MAP?, _5m :: MAP?, _6m :: MAP?, _7m :: MAP?, _8m :: MAP?, _9m :: MAP?, _10m :: MAP?, _1n :: NODE?, _2n :: NODE?, _3n :: NODE?, _4n :: NODE?, _5n :: NODE?, _6n :: NODE?, _7n :: NODE?, _8n :: NODE?, _9n :: NODE?, _10n :: NODE?, _1r :: RELATIONSHIP?, _2r :: RELATIONSHIP?, _3r :: RELATIONSHIP?, _4r :: RELATIONSHIP?, _5r :: RELATIONSHIP?, _6r :: RELATIONSHIP?, _7r :: RELATIONSHIP?, _8r :: RELATIONSHIP?, _9r :: RELATIONSHIP?, _10r :: RELATIONSHIP?, _1p :: PATH?, _2p :: PATH?, _3p :: PATH?, _4p :: PATH?, _5p :: PATH?, _6p :: PATH?, _7p :: PATH?, _8p :: PATH?, _9p :: PATH?, _10p :: PATH?, elements :: INTEGER?)

apoc.coll.elements(list,limit,offset) yield _1,_2,..,_10,_1s,_2i,_3f,_4m,_5l,_6n,_7r,_8p - deconstruct subset of mixed list into identifiers of the correct type

procedure

apoc.coll.partition

apoc.coll.partition(values :: LIST? OF ANY?, batchSize :: INTEGER?) :: (value :: LIST? OF ANY?)

apoc.coll.partition(list,batchSize)

procedure

apoc.coll.split

apoc.coll.split(values :: LIST? OF ANY?, value :: ANY?) :: (value :: LIST? OF ANY?)

apoc.coll.split(list,value) | splits collection on given values rows of lists, value itself will not be part of resulting lists

procedure

apoc.coll.zipToRows

apoc.coll.zipToRows(list1 :: LIST? OF ANY?, list2 :: LIST? OF ANY?) :: (value :: LIST? OF ANY?)

apoc.coll.zipToRows(list1,list2) - creates pairs like zip but emits one row per pair

procedure

apoc.config.list

apoc.config.list() :: (key :: STRING?, value :: ANY?)

apoc.config.list | Lists the Neo4j configuration as key,value table

procedure

apoc.config.map

apoc.config.map() :: (value :: MAP?)

apoc.config.map | Lists the Neo4j configuration as map

procedure

apoc.convert.setJsonProperty

apoc.convert.setJsonProperty(node :: NODE?, key :: STRING?, value :: ANY?) :: VOID

apoc.convert.setJsonProperty(node,key,complexValue) - sets value serialized to JSON as property with the given name on the node

procedure

apoc.convert.toTree

apoc.convert.toTree(paths :: LIST? OF PATH?, lowerCaseRels = true :: BOOLEAN?, config = {} :: MAP?) :: (value :: MAP?)

apoc.convert.toTree([paths],[lowerCaseRels=true], [config]) creates a stream of nested documents representing the at least one root of these paths

procedure

apoc.couchbase.append

apoc.couchbase.append(hostOrKey :: STRING?, bucket :: STRING?, documentId :: STRING?, json :: STRING?) :: (id :: STRING?, expiry :: INTEGER?, cas :: INTEGER?, mutationToken :: MAP?, content :: MAP?)

apoc.couchbase.append(hostOrKey, bucket, documentId, jsonDocument) yield id, expiry, cas, mutationToken, content - append a couchbase json document to an existing one.

procedure

apoc.couchbase.exists

apoc.couchbase.exists(hostOrKey :: STRING?, bucket :: STRING?, documentId :: STRING?) :: (value :: BOOLEAN?)

apoc.couchbase.exists(hostOrKey, bucket, documentId) yield value - check whether a couchbase json document with the given ID does exist.

procedure

apoc.couchbase.get

apoc.couchbase.get(hostOrKey :: STRING?, bucket :: STRING?, documentId :: STRING?) :: (id :: STRING?, expiry :: INTEGER?, cas :: INTEGER?, mutationToken :: MAP?, content :: MAP?)

apoc.couchbase.get(hostOrKey, bucket, documentId) yield id, expiry, cas, mutationToken, content - retrieves a couchbase json document by its unique ID.

procedure

apoc.couchbase.insert

apoc.couchbase.insert(hostOrKey :: STRING?, bucket :: STRING?, documentId :: STRING?, json :: STRING?) :: (id :: STRING?, expiry :: INTEGER?, cas :: INTEGER?, mutationToken :: MAP?, content :: MAP?)

apoc.couchbase.insert(hostOrKey, bucket, documentId, jsonDocument) yield id, expiry, cas, mutationToken, content - insert a couchbase json document with its unique ID.

procedure

apoc.couchbase.namedParamsQuery

apoc.couchbase.namedParamsQuery(hostOrKey :: STRING?, bucket :: STRING?, statement :: STRING?, paramNames :: LIST? OF STRING?, paramValues :: LIST? OF ANY?) :: (queryResult :: LIST? OF MAP?)

apoc.couchbase.namedParamsQuery(hostkOrKey, bucket, statement, paramNames, paramValues) yield queryResult - executes a N1QL statement with named parameters.

procedure

apoc.couchbase.posParamsQuery

apoc.couchbase.posParamsQuery(hostOrKey :: STRING?, bucket :: STRING?, statement :: STRING?, params :: LIST? OF ANY?) :: (queryResult :: LIST? OF MAP?)

apoc.couchbase.posParamsQuery(hostOrKey, bucket, statement, params) yield queryResult - executes a N1QL statement with positional parameters.

procedure

apoc.couchbase.prepend

apoc.couchbase.prepend(hostOrKey :: STRING?, bucket :: STRING?, documentId :: STRING?, json :: STRING?) :: (id :: STRING?, expiry :: INTEGER?, cas :: INTEGER?, mutationToken :: MAP?, content :: MAP?)

apoc.couchbase.prepend(hostOrKey, bucket, documentId, jsonDocument) yield id, expiry, cas, mutationToken, content - prepend a couchbase json document to an existing one.

procedure

apoc.couchbase.query

apoc.couchbase.query(hostOrKey :: STRING?, bucket :: STRING?, statement :: STRING?) :: (queryResult :: LIST? OF MAP?)

apoc.couchbase.query(hostOrKey, bucket, statement) yield queryResult - executes a plain un-parameterized N1QL statement.

procedure

apoc.couchbase.remove

apoc.couchbase.remove(hostOrKey :: STRING?, bucket :: STRING?, documentId :: STRING?) :: (id :: STRING?, expiry :: INTEGER?, cas :: INTEGER?, mutationToken :: MAP?, content :: MAP?)

apoc.couchbase.remove(hostOrKey, bucket, documentId) yield id, expiry, cas, mutationToken, content - remove the couchbase json document identified by its unique ID.

procedure

apoc.couchbase.replace

apoc.couchbase.replace(hostOrKey :: STRING?, bucket :: STRING?, documentId :: STRING?, json :: STRING?) :: (id :: STRING?, expiry :: INTEGER?, cas :: INTEGER?, mutationToken :: MAP?, content :: MAP?)

apoc.couchbase.replace(hostOrKey, bucket, documentId, jsonDocument) yield id, expiry, cas, mutationToken, content - replace the content of the couchbase json document identified by its unique ID.

procedure

apoc.couchbase.upsert

apoc.couchbase.upsert(hostOrKey :: STRING?, bucket :: STRING?, documentId :: STRING?, json :: STRING?) :: (id :: STRING?, expiry :: INTEGER?, cas :: INTEGER?, mutationToken :: MAP?, content :: MAP?)

apoc.couchbase.upsert(hostOrKey, bucket, documentId, jsonDocument) yield id, expiry, cas, mutationToken, content - insert or overwrite a couchbase json document with its unique ID.

procedure

apoc.create.addLabels

apoc.create.addLabels(nodes :: ANY?, label :: LIST? OF STRING?) :: (node :: NODE?)

apoc.create.addLabels( [node,id,ids,nodes], ['Label',…​]) - adds the given labels to the node or nodes

procedure

apoc.create.node

apoc.create.node(label :: LIST? OF STRING?, props :: MAP?) :: (node :: NODE?)

apoc.create.node(['Label'], {key:value,…​}) - create node with dynamic labels

procedure

apoc.create.nodes

apoc.create.nodes(label :: LIST? OF STRING?, props :: LIST? OF MAP?) :: (node :: NODE?)

apoc.create.nodes(['Label'], [{key:value,…​}]) create multiple nodes with dynamic labels

procedure

apoc.create.relationship

apoc.create.relationship(from :: NODE?, relType :: STRING?, props :: MAP?, to :: NODE?) :: (rel :: RELATIONSHIP?)

apoc.create.relationship(person1,'KNOWS',{key:value,…​}, person2) create relationship with dynamic rel-type

procedure

apoc.create.removeLabels

apoc.create.removeLabels(nodes :: ANY?, label :: LIST? OF STRING?) :: (node :: NODE?)

apoc.create.removeLabels( [node,id,ids,nodes], ['Label',…​]) - removes the given labels from the node or nodes

procedure

apoc.create.removeProperties

apoc.create.removeProperties(nodes :: ANY?, keys :: LIST? OF STRING?) :: (node :: NODE?)

apoc.create.removeProperties( [node,id,ids,nodes], [keys]) - removes the given property from the nodes(s)

procedure

apoc.create.removeRelProperties

apoc.create.removeRelProperties(rels :: ANY?, keys :: LIST? OF STRING?) :: (rel :: RELATIONSHIP?)

apoc.create.removeRelProperties( [rel,id,ids,rels], [keys], [values]) - removes the given property from the relationship(s)

procedure

apoc.create.setLabels

apoc.create.setLabels(nodes :: ANY?, label :: LIST? OF STRING?) :: (node :: NODE?)

apoc.create.setLabels( [node,id,ids,nodes], ['Label',…​]) - sets the given labels, non matching labels are removed on the node or nodes

procedure

apoc.create.setProperties

apoc.create.setProperties(nodes :: ANY?, keys :: LIST? OF STRING?, values :: LIST? OF ANY?) :: (node :: NODE?)

apoc.create.setProperties( [node,id,ids,nodes], [keys], [values]) - sets the given property on the nodes(s)

procedure

apoc.create.setProperty

apoc.create.setProperty(nodes :: ANY?, key :: STRING?, value :: ANY?) :: (node :: NODE?)

apoc.create.setProperty( [node,id,ids,nodes], key, value) - sets the given property on the node(s)

procedure

apoc.create.setRelProperties

apoc.create.setRelProperties(rels :: ANY?, keys :: LIST? OF STRING?, values :: LIST? OF ANY?) :: (rel :: RELATIONSHIP?)

apoc.create.setRelProperties( [rel,id,ids,rels], [keys], [values]) - sets the given property on the relationship(s)

procedure

apoc.create.setRelProperty

apoc.create.setRelProperty(relationships :: ANY?, key :: STRING?, value :: ANY?) :: (rel :: RELATIONSHIP?)

apoc.create.setRelProperty( [rel,id,ids,rels], key, value) - sets the given property on the relationship(s)

procedure

apoc.create.uuids

apoc.create.uuids(count :: INTEGER?) :: (row :: INTEGER?, uuid :: STRING?)

apoc.create.uuids(count) yield uuid - creates 'count' UUIDs

procedure

apoc.create.vNode

apoc.create.vNode(label :: LIST? OF STRING?, props :: MAP?) :: (node :: NODE?)

apoc.create.vNode(['Label'], {key:value,…​}) returns a virtual node

procedure

apoc.create.vNodes

apoc.create.vNodes(label :: LIST? OF STRING?, props :: LIST? OF MAP?) :: (node :: NODE?)

apoc.create.vNodes(['Label'], [{key:value,…​}]) returns virtual nodes

procedure

apoc.create.vPattern

apoc.create.vPattern(from :: MAP?, relType :: STRING?, props :: MAP?, to :: MAP?) :: (from :: NODE?, rel :: RELATIONSHIP?, to :: NODE?)

apoc.create.vPattern({_labels:['LabelA'],key:value},'KNOWS',{key:value,…​}, {_labels:['LabelB'],key:value}) returns a virtual pattern

procedure

apoc.create.vPatternFull

apoc.create.vPatternFull(labelsN :: LIST? OF STRING?, n :: MAP?, relType :: STRING?, props :: MAP?, labelsM :: LIST? OF STRING?, m :: MAP?) :: (from :: NODE?, rel :: RELATIONSHIP?, to :: NODE?)

apoc.create.vPatternFull(['LabelA'],{key:value},'KNOWS',{key:value,…​},['LabelB'],{key:value}) returns a virtual pattern

procedure

apoc.create.vRelationship

apoc.create.vRelationship(from :: NODE?, relType :: STRING?, props :: MAP?, to :: NODE?) :: (rel :: RELATIONSHIP?)

apoc.create.vRelationship(nodeFrom,'KNOWS',{key:value,…​}, nodeTo) returns a virtual relationship

procedure

apoc.custom.asFunction

apoc.custom.asFunction(name :: STRING?, statement :: STRING?, outputs = :: STRING?, inputs = null :: LIST? OF LIST? OF STRING?, forceSingle = false :: BOOLEAN?, description = null :: STRING?) :: VOID

apoc.custom.asFunction(name, statement, outputs, inputs, forceSingle, description) - register a custom cypher function

procedure

apoc.custom.asProcedure

apoc.custom.asProcedure(name :: STRING?, statement :: STRING?, mode = read :: STRING?, outputs = null :: LIST? OF LIST? OF STRING?, inputs = null :: LIST? OF LIST? OF STRING?, description = null :: STRING?) :: VOID

apoc.custom.asProcedure(name, statement, mode, outputs, inputs, description) - register a custom cypher procedure

procedure

apoc.custom.list

apoc.custom.list() :: (type :: STRING?, name :: STRING?, description :: STRING?, mode :: STRING?, statement :: STRING?, inputs :: LIST? OF LIST? OF STRING?, outputs :: ANY?, forceSingle :: BOOLEAN?)

apoc.custom.list() - provide a list of custom procedures/function registered

procedure

apoc.cypher.doIt

apoc.cypher.doIt(cypher :: STRING?, params :: MAP?) :: (value :: MAP?)

apoc.cypher.doIt(fragment, params) yield value - executes writing fragment with the given parameters

procedure

apoc.cypher.mapParallel

apoc.cypher.mapParallel(fragment :: STRING?, params :: MAP?, list :: LIST? OF ANY?) :: (value :: MAP?)

apoc.cypher.mapParallel(fragment, params, list-to-parallelize) yield value - executes fragment in parallel batches with the list segments being assigned to _

procedure

apoc.cypher.mapParallel2

apoc.cypher.mapParallel2(fragment :: STRING?, params :: MAP?, list :: LIST? OF ANY?, partitions :: INTEGER?, timeout = 10 :: INTEGER?) :: (value :: MAP?)

apoc.cypher.mapParallel2(fragment, params, list-to-parallelize) yield value - executes fragment in parallel batches with the list segments being assigned to _

procedure

apoc.cypher.parallel

apoc.cypher.parallel(fragment :: STRING?, params :: MAP?, parallelizeOn :: STRING?) :: (value :: MAP?)

 

procedure

apoc.cypher.parallel2

apoc.cypher.parallel2(fragment :: STRING?, params :: MAP?, parallelizeOn :: STRING?) :: (value :: MAP?)

 

procedure

apoc.cypher.run

apoc.cypher.run(cypher :: STRING?, params :: MAP?) :: (value :: MAP?)

apoc.cypher.run(fragment, params) yield value - executes reading fragment with the given parameters

procedure

apoc.cypher.runFile

apoc.cypher.runFile(file :: STRING?, config = {} :: MAP?) :: (row :: INTEGER?, result :: MAP?)

apoc.cypher.runFile(file or url,[{statistics:true,timeout:10,parameters:{}}]) - runs each statement in the file, all semicolon separated - currently no schema operations

procedure

apoc.cypher.runFiles

apoc.cypher.runFiles(file :: LIST? OF STRING?, config = {} :: MAP?) :: (row :: INTEGER?, result :: MAP?)

apoc.cypher.runFiles([files or urls],[{statistics:true,timeout:10,parameters:{}}])) - runs each statement in the files, all semicolon separated

procedure

apoc.cypher.runMany

apoc.cypher.runMany(cypher :: STRING?, params :: MAP?, config = {} :: MAP?) :: (row :: INTEGER?, result :: MAP?)

apoc.cypher.runMany('cypher;\nstatements;',{params},[{statistics:true,timeout:10}]) - runs each semicolon separated statement and returns summary - currently no schema operations

procedure

apoc.cypher.runSchemaFile

apoc.cypher.runSchemaFile(file :: STRING?, config = {} :: MAP?) :: (row :: INTEGER?, result :: MAP?)

apoc.cypher.runSchemaFile(file or url,[{statistics:true,timeout:10}]) - allows only schema operations, runs each schema statement in the file, all semicolon separated

procedure

apoc.cypher.runSchemaFiles

apoc.cypher.runSchemaFiles(file :: LIST? OF STRING?, config = {} :: MAP?) :: (row :: INTEGER?, result :: MAP?)

apoc.cypher.runSchemaFiles([files or urls],{statistics:true,timeout:10}) - allows only schema operations, runs each schema statement in the files, all semicolon separated

procedure

apoc.cypher.runTimeboxed

apoc.cypher.runTimeboxed(cypher :: STRING?, params :: MAP?, timeout :: INTEGER?) :: (value :: MAP?)

apoc.cypher.runTimeboxed('cypherStatement',{params}, timeout) - abort kernelTransaction after timeout ms if not finished

procedure

apoc.date.expire

apoc.date.expire(node :: NODE?, time :: INTEGER?, timeUnit :: STRING?) :: VOID

CALL apoc.date.expire(node,time,'time-unit') - expire node in given time by setting :TTL label and ttl property

procedure

apoc.date.expireIn

apoc.date.expireIn(node :: NODE?, timeDelta :: INTEGER?, timeUnit :: STRING?) :: VOID

CALL apoc.date.expire.in(node,time,'time-unit') - expire node in given time-delta by setting :TTL label and ttl property

procedure

apoc.do.case

apoc.do.case(conditionals :: LIST? OF ANY?, elseQuery = :: STRING?, params = {} :: MAP?) :: (value :: MAP?)

apoc.do.case([condition, query, condition, query, …​], elseQuery:'', params:{}) yield value - given a list of conditional / writing query pairs, executes the query associated with the first conditional evaluating to true (or the else query if none are true) with the given parameters

procedure

apoc.do.when

apoc.do.when(condition :: BOOLEAN?, ifQuery :: STRING?, elseQuery = :: STRING?, params = {} :: MAP?) :: (value :: MAP?)

apoc.do.when(condition, ifQuery, elseQuery:'', params:{}) yield value - based on the conditional, executes writing ifQuery or elseQuery with the given parameters

procedure

apoc.es.get

apoc.es.get(host :: STRING?, index :: STRING?, type :: STRING?, id :: STRING?, query :: ANY?, payload :: ANY?) :: (value :: MAP?)

apoc.es.get(host-or-port,index-or-null,type-or-null,id-or-null,query-or-null,payload-or-null) yield value - perform a GET operation on elastic search

procedure

apoc.es.getRaw

apoc.es.getRaw(host :: STRING?, path :: STRING?, payload :: ANY?) :: (value :: MAP?)

apoc.es.getRaw(host-or-port,path,payload-or-null) yield value - perform a raw GET operation on elastic search

procedure

apoc.es.post

apoc.es.post(host :: STRING?, index :: STRING?, type :: STRING?, query :: ANY?, payload = {} :: MAP?) :: (value :: MAP?)

apoc.es.post(host-or-port,index-or-null,type-or-null,query-or-null,payload-or-null) yield value - perform a POST operation on elastic search

procedure

apoc.es.postRaw

apoc.es.postRaw(host :: STRING?, path :: STRING?, payload :: ANY?) :: (value :: MAP?)

apoc.es.postRaw(host-or-port,path,payload-or-null) yield value - perform a raw POST operation on elastic search

procedure

apoc.es.put

apoc.es.put(host :: STRING?, index :: STRING?, type :: STRING?, id :: STRING?, query :: ANY?, payload = {} :: MAP?) :: (value :: MAP?)

apoc.es.put(host-or-port,index-or-null,type-or-null,id-or-null,query-or-null,payload-or-null) yield value - perform a PUT operation on elastic search

procedure

apoc.es.query

apoc.es.query(host :: STRING?, index :: STRING?, type :: STRING?, query :: ANY?, payload :: ANY?) :: (value :: MAP?)

apoc.es.query(host-or-port,index-or-null,type-or-null,query-or-null,payload-or-null) yield value - perform a SEARCH operation on elastic search

procedure

apoc.es.stats

apoc.es.stats(host :: STRING?) :: (value :: MAP?)

apoc.es.stats(host-url-Key) - elastic search statistics

procedure

apoc.example.movies

apoc.example.movies() :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.example.movies() | Creates the sample movies graph

procedure

apoc.export.csv.all

apoc.export.csv.all(file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.export.csv.all(file,config) - exports whole database as csv to the provided file

procedure

apoc.export.csv.data

apoc.export.csv.data(nodes :: LIST? OF NODE?, rels :: LIST? OF RELATIONSHIP?, file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.export.csv.data(nodes,rels,file,config) - exports given nodes and relationships as csv to the provided file

procedure

apoc.export.csv.graph

apoc.export.csv.graph(graph :: MAP?, file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.export.csv.graph(graph,file,config) - exports given graph object as csv to the provided file

procedure

apoc.export.csv.query

apoc.export.csv.query(query :: STRING?, file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.export.csv.query(query,file,{config,…​,params:{params}}) - exports results from the cypher statement as csv to the provided file

procedure

apoc.export.cypher.all

apoc.export.cypher.all(file = :: STRING?, config = {} :: MAP?) :: (file :: STRING?, batches :: INTEGER?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, cypherStatements :: STRING?, nodeStatements :: STRING?, relationshipStatements :: STRING?, schemaStatements :: STRING?, cleanupStatements :: STRING?)

apoc.export.cypher.all(file,config) - exports whole database incl. indexes as cypher statements to the provided file

procedure

apoc.export.cypher.data

apoc.export.cypher.data(nodes :: LIST? OF NODE?, rels :: LIST? OF RELATIONSHIP?, file = :: STRING?, config = {} :: MAP?) :: (file :: STRING?, batches :: INTEGER?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, cypherStatements :: STRING?, nodeStatements :: STRING?, relationshipStatements :: STRING?, schemaStatements :: STRING?, cleanupStatements :: STRING?)

apoc.export.cypher.data(nodes,rels,file,config) - exports given nodes and relationships incl. indexes as cypher statements to the provided file

procedure

apoc.export.cypher.graph

apoc.export.cypher.graph(graph :: MAP?, file = :: STRING?, config = {} :: MAP?) :: (file :: STRING?, batches :: INTEGER?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, cypherStatements :: STRING?, nodeStatements :: STRING?, relationshipStatements :: STRING?, schemaStatements :: STRING?, cleanupStatements :: STRING?)

apoc.export.cypher.graph(graph,file,config) - exports given graph object incl. indexes as cypher statements to the provided file

procedure

apoc.export.cypher.query

apoc.export.cypher.query(query :: STRING?, file = :: STRING?, config = {} :: MAP?) :: (file :: STRING?, batches :: INTEGER?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, cypherStatements :: STRING?, nodeStatements :: STRING?, relationshipStatements :: STRING?, schemaStatements :: STRING?, cleanupStatements :: STRING?)

apoc.export.cypher.query(query,file,config) - exports nodes and relationships from the cypher statement incl. indexes as cypher statements to the provided file

procedure

apoc.export.cypher.schema

apoc.export.cypher.schema(file = :: STRING?, config = {} :: MAP?) :: (file :: STRING?, batches :: INTEGER?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, cypherStatements :: STRING?, nodeStatements :: STRING?, relationshipStatements :: STRING?, schemaStatements :: STRING?, cleanupStatements :: STRING?)

apoc.export.cypher.schema(file,config) - exports all schema indexes and constraints to cypher

procedure

apoc.export.cypherAll

apoc.export.cypherAll(file :: STRING?, config :: MAP?) :: (file :: STRING?, batches :: INTEGER?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, cypherStatements :: STRING?, nodeStatements :: STRING?, relationshipStatements :: STRING?, schemaStatements :: STRING?, cleanupStatements :: STRING?)

apoc.export.cypherAll(file,config) - exports whole database incl. indexes as cypher statements to the provided file

procedure

apoc.export.cypherData

apoc.export.cypherData(nodes :: LIST? OF NODE?, rels :: LIST? OF RELATIONSHIP?, file :: STRING?, config :: MAP?) :: (file :: STRING?, batches :: INTEGER?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, cypherStatements :: STRING?, nodeStatements :: STRING?, relationshipStatements :: STRING?, schemaStatements :: STRING?, cleanupStatements :: STRING?)

apoc.export.cypherData(nodes,rels,file,config) - exports given nodes and relationships incl. indexes as cypher statements to the provided file

procedure

apoc.export.cypherGraph

apoc.export.cypherGraph(graph :: MAP?, file :: STRING?, config :: MAP?) :: (file :: STRING?, batches :: INTEGER?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, cypherStatements :: STRING?, nodeStatements :: STRING?, relationshipStatements :: STRING?, schemaStatements :: STRING?, cleanupStatements :: STRING?)

apoc.export.cypherGraph(graph,file,config) - exports given graph object incl. indexes as cypher statements to the provided file

procedure

apoc.export.cypherQuery

apoc.export.cypherQuery(query :: STRING?, file :: STRING?, config :: MAP?) :: (file :: STRING?, batches :: INTEGER?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, cypherStatements :: STRING?, nodeStatements :: STRING?, relationshipStatements :: STRING?, schemaStatements :: STRING?, cleanupStatements :: STRING?)

apoc.export.cypherQuery(query,file,config) - exports nodes and relationships from the cypher kernelTransaction incl. indexes as cypher statements to the provided file

procedure

apoc.export.graphml.all

apoc.export.graphml.all(file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.export.graphml.all(file,config) - exports whole database as graphml to the provided file

procedure

apoc.export.graphml.data

apoc.export.graphml.data(nodes :: LIST? OF NODE?, rels :: LIST? OF RELATIONSHIP?, file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.export.graphml.data(nodes,rels,file,config) - exports given nodes and relationships as graphml to the provided file

procedure

apoc.export.graphml.graph

apoc.export.graphml.graph(graph :: MAP?, file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.export.graphml.graph(graph,file,config) - exports given graph object as graphml to the provided file

procedure

apoc.export.graphml.query

apoc.export.graphml.query(query :: STRING?, file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.export.graphml.query(query,file,config) - exports nodes and relationships from the cypher statement as graphml to the provided file

procedure

apoc.export.json.all

apoc.export.json.all(file :: STRING?, config = {} :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.export.json.all(file,config) - exports whole database as json to the provided file

procedure

apoc.export.json.data

apoc.export.json.data(nodes :: LIST? OF NODE?, rels :: LIST? OF RELATIONSHIP?, file :: STRING?, config = {} :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.export.json.data(nodes,rels,file,config) - exports given nodes and relationships as json to the provided file

procedure

apoc.export.json.graph

apoc.export.json.graph(graph :: MAP?, file :: STRING?, config = {} :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.export.json.graph(graph,file,config) - exports given graph object as json to the provided file

procedure

apoc.export.json.query

apoc.export.json.query(query :: STRING?, file :: STRING?, config = {} :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.export.json.query(query,file,{config,…​,params:{params}}) - exports results from the cypher statement as json to the provided file

procedure

apoc.export.xls.all

apoc.export.xls.all(file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

 

procedure

apoc.export.xls.data

apoc.export.xls.data(nodes :: LIST? OF NODE?, rels :: LIST? OF RELATIONSHIP?, file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

 

procedure

apoc.export.xls.graph

apoc.export.xls.graph(graph :: MAP?, file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

 

procedure

apoc.export.xls.query

apoc.export.xls.query(query :: STRING?, file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

 

procedure

apoc.generate.ba

apoc.generate.ba(noNodes :: INTEGER?, edgesPerNode :: INTEGER?, label :: STRING?, type :: STRING?) :: VOID

apoc.generate.ba(noNodes, edgesPerNode, label, type) - generates a random graph according to the Barabasi-Albert model

procedure

apoc.generate.complete

apoc.generate.complete(noNodes :: INTEGER?, label :: STRING?, type :: STRING?) :: VOID

apoc.generate.complete(noNodes, label, type) - generates a random complete graph

procedure

apoc.generate.er

apoc.generate.er(noNodes :: INTEGER?, noEdges :: INTEGER?, label :: STRING?, type :: STRING?) :: VOID

apoc.generate.er(noNodes, noEdges, label, type) - generates a random graph according to the Erdos-Renyi model

procedure

apoc.generate.simple

apoc.generate.simple(degrees :: LIST? OF INTEGER?, label :: STRING?, type :: STRING?) :: VOID

apoc.generate.simple(degrees, label, type) - generates a simple random graph according to the given degree distribution

procedure

apoc.generate.ws

apoc.generate.ws(noNodes :: INTEGER?, degree :: INTEGER?, beta :: FLOAT?, label :: STRING?, type :: STRING?) :: VOID

apoc.generate.ws(noNodes, degree, beta, label, type) - generates a random graph according to the Watts-Strogatz model

procedure

apoc.gephi.add

apoc.gephi.add(urlOrKey :: STRING?, workspace :: STRING?, data :: ANY?, weightproperty = null :: STRING?, exportproperties = [] :: LIST? OF STRING?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.gephi.add(url-or-key, workspace, data, weightproperty, ['exportproperty']) | streams passed in data to Gephi

procedure

apoc.get.nodes

apoc.get.nodes(nodes :: ANY?) :: (node :: NODE?)

apoc.get.nodes(node|id|[ids]) - quickly returns all nodes with these id’s

procedure

apoc.get.rels

apoc.get.rels(relationships :: ANY?) :: (rel :: RELATIONSHIP?)

apoc.get.rels(rel|id|[ids]) - quickly returns all relationships with these id’s

procedure

apoc.graph.from

apoc.graph.from(data :: ANY?, name :: STRING?, properties :: MAP?) :: (graph :: MAP?)

apoc.graph.from(data,'name',{properties}) | creates a virtual graph object for later processing it tries its best to extract the graph information from the data you pass in

procedure

apoc.graph.fromCypher

apoc.graph.fromCypher(kernelTransaction :: STRING?, params :: MAP?, name :: STRING?, properties :: MAP?) :: (graph :: MAP?)

apoc.graph.fromCypher('kernelTransaction',{params},'name',{properties}) - creates a virtual graph object for later processing

procedure

apoc.graph.fromDB

apoc.graph.fromDB(name :: STRING?, properties :: MAP?) :: (graph :: MAP?)

apoc.graph.fromDB('name',{properties}) - creates a virtual graph object for later processing

procedure

apoc.graph.fromData

apoc.graph.fromData(nodes :: LIST? OF NODE?, relationships :: LIST? OF RELATIONSHIP?, name :: STRING?, properties :: MAP?) :: (graph :: MAP?)

apoc.graph.fromData([nodes],[relationships],'name',{properties}) | creates a virtual graph object for later processing

procedure

apoc.graph.fromDocument

apoc.graph.fromDocument(json :: ANY?, config = {} :: MAP?) :: (graph :: MAP?)

apoc.graph.fromDocument({json}, {config}) yield graph - transform JSON documents into graph structures

procedure

apoc.graph.fromPath

apoc.graph.fromPath(path :: PATH?, name :: STRING?, properties :: MAP?) :: (graph :: MAP?)

apoc.graph.fromPaths(path,'name',{properties}) - creates a virtual graph object for later processing

procedure

apoc.graph.fromPaths

apoc.graph.fromPaths(paths :: LIST? OF PATH?, name :: STRING?, properties :: MAP?) :: (graph :: MAP?)

apoc.graph.fromPaths([paths],'name',{properties}) - creates a virtual graph object for later processing

procedure

apoc.graph.validateDocument

apoc.graph.validateDocument(json :: ANY?, config = {} :: MAP?) :: (row :: MAP?)

apoc.graph.validateDocument({json}, {config}) yield row - validates the json, return the result of the validation

procedure

apoc.help

apoc.help(proc :: STRING?) :: (type :: STRING?, name :: STRING?, text :: STRING?, signature :: STRING?, roles :: LIST? OF STRING?, writes :: BOOLEAN?)

Provides descriptions of available procedures. To narrow the results, supply a search string. To also search in the description text, append + to the end of the search string.

procedure

apoc.import.csv

apoc.import.csv(nodes :: LIST? OF MAP?, relationships :: LIST? OF MAP?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

 

procedure

apoc.import.graphml

apoc.import.graphml(file :: STRING?, config :: MAP?) :: (file :: STRING?, source :: STRING?, format :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, properties :: INTEGER?, time :: INTEGER?, rows :: INTEGER?, batchSize :: INTEGER?, batches :: INTEGER?, done :: BOOLEAN?, data :: STRING?)

apoc.import.graphml(file,config) - imports graphml file

procedure

apoc.index.addAllNodes

apoc.index.addAllNodes(index :: STRING?, structure :: MAP?, options = {} :: MAP?) :: (label :: STRING?, property :: STRING?, nodeCount :: INTEGER?)

apoc.index.addAllNodes('name',{label1:['prop1',…​],…​}, {options}) YIELD type, name, config - create a free text search index

procedure

apoc.index.addAllNodesExtended

apoc.index.addAllNodesExtended(index :: STRING?, structure :: MAP?, options :: MAP?) :: (label :: STRING?, property :: STRING?, nodeCount :: INTEGER?)

apoc.index.addAllNodesExtended('name',{label1:['prop1',…​],…​}, {options}) YIELD type, name, config - create a free text search index with special options

procedure

apoc.index.addNode

apoc.index.addNode(node :: NODE?, properties :: LIST? OF STRING?) :: VOID

apoc.index.addNode(node,['prop1',…​]) add node to an index for each label it has

procedure

apoc.index.addNodeByLabel

apoc.index.addNodeByLabel(label :: STRING?, node :: NODE?, properties :: LIST? OF STRING?) :: VOID

apoc.index.addNodeByLabel(node,'Label',['prop1',…​]) add node to an index for the given label

procedure

apoc.index.addNodeByName

apoc.index.addNodeByName(name :: STRING?, node :: NODE?, properties :: LIST? OF STRING?) :: VOID

apoc.index.addNodeByName('name',node,['prop1',…​]) add node to an index for the given name

procedure

apoc.index.addNodeMap

apoc.index.addNodeMap(node :: NODE?, properties :: MAP?) :: VOID

apoc.index.addNodeMap(node,{key:value}) add node to an index for each label it has with the given attributes which can also be computed

procedure

apoc.index.addNodeMapByName

apoc.index.addNodeMapByName(index :: STRING?, node :: NODE?, properties :: MAP?) :: VOID

apoc.index.addNodeMapByName(index, node,{key:value}) add node to an index for each label it has with the given attributes which can also be computed

procedure

apoc.index.addRelationship

apoc.index.addRelationship(relationship :: RELATIONSHIP?, properties :: LIST? OF STRING?) :: VOID

apoc.index.addRelationship(rel,['prop1',…​]) add relationship to an index for its type

procedure

apoc.index.addRelationshipByName

apoc.index.addRelationshipByName(name :: STRING?, relationship :: RELATIONSHIP?, properties :: LIST? OF STRING?) :: VOID

apoc.index.addRelationshipByName('name',rel,['prop1',…​]) add relationship to an index for the given name

procedure

apoc.index.addRelationshipMap

apoc.index.addRelationshipMap(relationship :: RELATIONSHIP?, docuemnt :: MAP?) :: VOID

apoc.index.addRelationshipMap(rel,{key:value}) add relationship to an index for its type indexing the given document which can be computed

procedure

apoc.index.addRelationshipMapByName

apoc.index.addRelationshipMapByName(index :: STRING?, relationship :: RELATIONSHIP?, docuemnt :: MAP?) :: VOID

apoc.index.addRelationshipMapByName(index, rel,{key:value}) add relationship to an index for its type indexing the given document which can be computed

procedure

apoc.index.between

apoc.index.between(from :: NODE?, type :: STRING?, to :: NODE?, query :: STRING?) :: (rel :: RELATIONSHIP?, weight :: FLOAT?, start :: NODE?, end :: NODE?)

apoc.index.between(node1,'TYPE',node2,'prop:value*') YIELD rel - lucene query on relationship index with the given type name bound by either or both sides (each node parameter can be null)

procedure

apoc.index.forNodes

apoc.index.forNodes(name :: STRING?, config = {} :: MAP?) :: (type :: STRING?, name :: STRING?, config :: MAP?)

apoc.index.forNodes('name',{config}) YIELD type,name,config - gets or creates node index

procedure

apoc.index.forRelationships

apoc.index.forRelationships(name :: STRING?, config = {} :: MAP?) :: (type :: STRING?, name :: STRING?, config :: MAP?)

apoc.index.forRelationships('name',{config}) YIELD type,name,config - gets or creates relationship index

procedure

apoc.index.in

apoc.index.in(to :: NODE?, type :: STRING?, query :: STRING?) :: (node :: NODE?, weight :: FLOAT?)

apoc.index.in(node,'TYPE','prop:value*') YIELD node lucene query on relationship index with the given type name for incoming relationship of the given node, returns start-nodes

procedure

apoc.index.list

apoc.index.list() :: (type :: STRING?, name :: STRING?, config :: MAP?)

apoc.index.list() - YIELD type,name,config - lists all manual indexes

procedure

apoc.index.nodes

apoc.index.nodes(label :: STRING?, query :: STRING?) :: (node :: NODE?, weight :: FLOAT?)

apoc.index.nodes('Label','prop:value*') YIELD node - lucene query on node index with the given label name

procedure

apoc.index.orderedByText

apoc.index.orderedByText(label :: STRING?, key :: STRING?, operator :: STRING?, value :: STRING?, relevance :: BOOLEAN?, limit :: INTEGER?) :: (node :: NODE?)

just use a cypher query with a range predicate on an indexed field and wait for index backed order by in 3.5

procedure

apoc.index.orderedRange

apoc.index.orderedRange(label :: STRING?, key :: STRING?, min :: ANY?, max :: ANY?, relevance :: BOOLEAN?, limit :: INTEGER?) :: (node :: NODE?)

deprecated, just there for compatibility. Use plain cypher instead

procedure

apoc.index.out

apoc.index.out(from :: NODE?, type :: STRING?, query :: STRING?) :: (node :: NODE?, weight :: FLOAT?)

out(node,'TYPE','prop:value*') YIELD node - lucene query on relationship index with the given type name for outgoing relationship of the given node, returns end-nodes

procedure

apoc.index.related

apoc.index.related(nodes :: LIST? OF NODE?, label :: STRING?, key :: STRING?, relationship :: STRING?, limit :: INTEGER?) :: (node :: NODE?)

apoc.index.relatedNodes([nodes],label,key,'<TYPE'/'TYPE>'/'TYPE',limit) yield node - schema range scan which keeps index order and adds limit and checks opposite node of relationship against the given set of nodes

procedure

apoc.index.relationships

apoc.index.relationships(type :: STRING?, query :: STRING?) :: (rel :: RELATIONSHIP?, weight :: FLOAT?, start :: NODE?, end :: NODE?)

apoc.index.relationships('TYPE','prop:value*') YIELD rel - lucene query on relationship index with the given type name

procedure

apoc.index.remove

apoc.index.remove(name :: STRING?) :: (type :: STRING?, name :: STRING?, config :: MAP?)

apoc.index.remove('name') YIELD type,name,config - removes an manual index

procedure

apoc.index.removeNodeByName

apoc.index.removeNodeByName(name :: STRING?, node :: NODE?) :: VOID

apoc.index.removeNodeByName('name',node) remove node from an index for the given name

procedure

apoc.index.removeRelationshipByName

apoc.index.removeRelationshipByName(name :: STRING?, relationship :: RELATIONSHIP?) :: VOID

apoc.index.removeRelationshipByName('name',rel) remove relationship from an index for the given name

procedure

apoc.index.search

apoc.index.search(index :: STRING?, query :: STRING?, numberOfResults = 100 :: INTEGER?) :: (node :: NODE?, weight :: FLOAT?)

apoc.index.search('name', 'query', [maxNumberOfResults]) YIELD node, weight - search for nodes in the free text index matching the given query

procedure

apoc.load.csv

apoc.load.csv(url :: STRING?, config = {} :: MAP?) :: (lineNo :: INTEGER?, list :: LIST? OF ANY?, strings :: LIST? OF STRING?, map :: MAP?, stringMap :: MAP?)

apoc.load.csv('url',{config}) YIELD lineNo, list, map - load CSV fom URL as stream of values, config contains any of: {skip:1,limit:5,header:false,sep:'TAB',ignore:['tmp'],nullValues:['na'],arraySep:';',mapping:{years:{type:'int',arraySep:'-',array:false,name:'age',ignore:false}}

procedure

apoc.load.driver

apoc.load.driver(driverClass :: STRING?) :: VOID

apoc.load.driver('org.apache.derby.jdbc.EmbeddedDriver') register JDBC driver of source database

procedure

apoc.load.html

apoc.load.html(url :: STRING?, query = {} :: MAP?, config = {} :: MAP?) :: (value :: MAP?)

apoc.load.html('url',{name: jquery, name2: jquery}, config) YIELD value - Load Html page and return the result as a Map

procedure

apoc.load.jdbc

apoc.load.jdbc(jdbc :: STRING?, tableOrSql :: STRING?, params = [] :: LIST? OF ANY?, config = {} :: MAP?) :: (row :: MAP?)

apoc.load.jdbc('key or url','table or statement', params, config) YIELD row - load from relational database, from a full table or a sql statement

procedure

apoc.load.jdbcParams

apoc.load.jdbcParams(jdbc :: STRING?, sql :: STRING?, params :: LIST? OF ANY?, config = {} :: MAP?) :: (row :: MAP?)

deprecated - please use: apoc.load.jdbc('key or url','',[params]) YIELD row - load from relational database, from a sql statement with parameters

procedure

apoc.load.jdbcUpdate

apoc.load.jdbcUpdate(jdbc :: STRING?, query :: STRING?, params = [] :: LIST? OF ANY?, config = {} :: MAP?) :: (row :: MAP?)

apoc.load.jdbcUpdate('key or url','statement',[params],config) YIELD row - update relational database, from a SQL statement with optional parameters

procedure

apoc.load.json

apoc.load.json(url :: STRING?, path = :: STRING?, config = {} :: MAP?) :: (value :: MAP?)

apoc.load.json('url',path, config) YIELD value - import JSON as stream of values if the JSON was an array or a single value if it was a map

procedure

apoc.load.jsonArray

apoc.load.jsonArray(url :: STRING?, path = :: STRING?) :: (value :: ANY?)

apoc.load.jsonArray('url') YIELD value - load array from JSON URL (e.g. web-api) to import JSON as stream of values

procedure

apoc.load.jsonParams

apoc.load.jsonParams(urlOrKey :: STRING?, headers :: MAP?, payload :: STRING?, path = :: STRING?, config = {} :: MAP?) :: (value :: MAP?)

apoc.load.jsonParams('url',{header:value},payload, config) YIELD value - load from JSON URL (e.g. web-api) while sending headers / payload to import JSON as stream of values if the JSON was an array or a single value if it was a map

procedure

apoc.load.ldap

apoc.load.ldap(connection :: ANY?, search :: MAP?) :: (entry :: MAP?)

apoc.load.ldap("key" or {connectionMap},{searchMap}) Load entries from an ldap source (yield entry)

procedure

apoc.load.xls

apoc.load.xls(url :: STRING?, selector :: STRING?, config = {} :: MAP?) :: (lineNo :: INTEGER?, list :: LIST? OF ANY?, map :: MAP?)

apoc.load.xls('url','selector',{config}) YIELD lineNo, list, map - load XLS fom URL as stream of row values, config contains any of: {skip:1,limit:5,header:false,ignore:['tmp'],arraySep:';',mapping:{years:{type:'int',arraySep:'-',array:false,name:'age',ignore:false, dateFormat:'iso_date', dateParse:['dd-MM-yyyy']}}

procedure

apoc.load.xml

apoc.load.xml(url :: STRING?, path = / :: STRING?, config = {} :: MAP?, simple = false :: BOOLEAN?) :: (value :: MAP?)

apoc.load.xml('http://example.com/test.xml', 'xPath',config, false) YIELD value as doc CREATE (p:Person) SET p.name = doc.name load from XML URL (e.g. web-api) to import XML as single nested map with attributes and _type, _text and _childrenx fields.

procedure

apoc.load.xmlSimple

apoc.load.xmlSimple(url :: STRING?) :: (value :: MAP?)

apoc.load.xmlSimple('http://example.com/test.xml') YIELD value as doc CREATE (p:Person) SET p.name = doc.name load from XML URL (e.g. web-api) to import XML as single nested map with attributes and _type, _text and _children fields. This method does intentionally not work with XML mixed content.

procedure

apoc.lock.all

apoc.lock.all(nodes :: LIST? OF NODE?, rels :: LIST? OF RELATIONSHIP?) :: VOID

apoc.lock.all([nodes],[relationships]) acquires a write lock on the given nodes and relationships

procedure

apoc.lock.nodes

apoc.lock.nodes(nodes :: LIST? OF NODE?) :: VOID

apoc.lock.nodes([nodes]) acquires a write lock on the given nodes

procedure

apoc.lock.read.nodes

apoc.lock.read.nodes(nodes :: LIST? OF NODE?) :: VOID

apoc.lock.read.nodes([nodes]) acquires a read lock on the given nodes

procedure

apoc.lock.read.rels

apoc.lock.read.rels(rels :: LIST? OF RELATIONSHIP?) :: VOID

apoc.lock.read.rels([relationships]) acquires a read lock on the given relationship

procedure

apoc.lock.rels

apoc.lock.rels(rels :: LIST? OF RELATIONSHIP?) :: VOID

apoc.lock.rels([relationships]) acquires a write lock on the given relationship

procedure

apoc.log.debug

apoc.log.debug(message :: STRING?, params = [] :: LIST? OF ANY?) :: VOID

apoc.log.debug(message, params) - logs debug message

procedure

apoc.log.error

apoc.log.error(message :: STRING?, params = [] :: LIST? OF ANY?) :: VOID

apoc.log.error(message, params) - logs error message

procedure

apoc.log.info

apoc.log.info(message :: STRING?, params = [] :: LIST? OF ANY?) :: VOID

apoc.log.info(message, params) - logs info message

procedure

apoc.log.stream

apoc.log.stream(path :: STRING?, config = {} :: MAP?) :: (lineNo :: INTEGER?, line :: STRING?, path :: STRING?)

apoc.log.stream('neo4j.log', { last: n }) - retrieve log file contents, optionally return only the last n lines

procedure

apoc.log.warn

apoc.log.warn(message :: STRING?, params = [] :: LIST? OF ANY?) :: VOID

apoc.log.warn(message, params) - logs warn message

procedure

apoc.math.regr

apoc.math.regr(label :: STRING?, propertyY :: STRING?, propertyX :: STRING?) :: (r2 :: FLOAT?, avgX :: FLOAT?, avgY :: FLOAT?, slope :: FLOAT?)

apoc.math.regr(label, propertyY, propertyX) - It calculates the coefficient of determination (R-squared) for the values of propertyY and propertyX in the provided label

procedure

apoc.merge.node

apoc.merge.node(label :: LIST? OF STRING?, identProps :: MAP?, props = {} :: MAP?, onMatchProps = {} :: MAP?) :: (node :: NODE?)

"apoc.merge.node.eager(['Label'], identProps:{key:value, …​}, onCreateProps:{key:value,…​}, onMatchProps:{key:value,…​}}) - merge nodes with dynamic labels, with support for setting properties ON CREATE or ON MATCH

procedure

apoc.merge.node.eager

apoc.merge.node.eager(label :: LIST? OF STRING?, identProps :: MAP?, props = {} :: MAP?, onMatchProps = {} :: MAP?) :: (node :: NODE?)

apoc.merge.node.eager(['Label'], identProps:{key:value, …​}, onCreateProps:{key:value,…​}, onMatchProps:{key:value,…​}}) - merge nodes eagerly, with dynamic labels, with support for setting properties ON CREATE or ON MATCH

procedure

apoc.merge.relationship

apoc.merge.relationship(startNode :: NODE?, relationshipType :: STRING?, identProps :: MAP?, props :: MAP?, endNode :: NODE?, onMatchProps = {} :: MAP?) :: (rel :: RELATIONSHIP?)

apoc.merge.relationship(startNode, relType, identProps:{key:value, …​}, onCreateProps:{key:value, …​}, endNode, onMatchProps:{key:value, …​}) - merge relationship with dynamic type, with support for setting properties ON CREATE or ON MATCH

procedure

apoc.merge.relationship.eager

apoc.merge.relationship.eager(startNode :: NODE?, relationshipType :: STRING?, identProps :: MAP?, props :: MAP?, endNode :: NODE?, onMatchProps = {} :: MAP?) :: (rel :: RELATIONSHIP?)

apoc.merge.relationship(startNode, relType, identProps:{key:value, …​}, onCreateProps:{key:value, …​}, endNode, onMatchProps:{key:value, …​}) - merge relationship with dynamic type, with support for setting properties ON CREATE or ON MATCH

procedure

apoc.meta.data

apoc.meta.data(config = {} :: MAP?) :: (label :: STRING?, property :: STRING?, count :: INTEGER?, unique :: BOOLEAN?, index :: BOOLEAN?, existence :: BOOLEAN?, type :: STRING?, array :: BOOLEAN?, sample :: LIST? OF ANY?, leftCount :: INTEGER?, rightCount :: INTEGER?, left :: INTEGER?, right :: INTEGER?, other :: LIST? OF STRING?, otherLabels :: LIST? OF STRING?, elementType :: STRING?)

apoc.meta.data({config}) - examines a subset of the graph to provide a tabular meta information

procedure

apoc.meta.graph

apoc.meta.graph(config = {} :: MAP?) :: (nodes :: LIST? OF NODE?, relationships :: LIST? OF RELATIONSHIP?)

apoc.meta.graph - examines the full graph to create the meta-graph

procedure

apoc.meta.graphSample

apoc.meta.graphSample(config = {} :: MAP?) :: (nodes :: LIST? OF NODE?, relationships :: LIST? OF RELATIONSHIP?)

apoc.meta.graphSample() - examines the database statistics to build the meta graph, very fast, might report extra relationships

procedure

apoc.meta.schema

apoc.meta.schema(config = {} :: MAP?) :: (value :: MAP?)

apoc.meta.schema({config}) - examines a subset of the graph to provide a map-like meta information

procedure

apoc.meta.stats

apoc.meta.stats() :: (labelCount :: INTEGER?, relTypeCount :: INTEGER?, propertyKeyCount :: INTEGER?, nodeCount :: INTEGER?, relCount :: INTEGER?, labels :: MAP?, relTypes :: MAP?, relTypesCount :: MAP?, stats :: MAP?)

apoc.meta.stats yield labelCount, relTypeCount, propertyKeyCount, nodeCount, relCount, labels, relTypes, stats | returns the information stored in the transactional database statistics

procedure

apoc.meta.subGraph

apoc.meta.subGraph(config :: MAP?) :: (nodes :: LIST? OF NODE?, relationships :: LIST? OF RELATIONSHIP?)

apoc.meta.subGraph({labels:[labels],rels:[rel-types], excludes:[labels,rel-types]}) - examines a sample sub graph to create the meta-graph

procedure

apoc.metrics.get

apoc.metrics.get(metricName :: STRING?, config = {} :: MAP?) :: (timestamp :: INTEGER?, metric :: STRING?, map :: MAP?)

apoc.metrics.get(metricName, {}) - retrieve a system metric by its metric name. Additional configuration options may be passed matching the options available for apoc.load.csv.

procedure

apoc.metrics.list

apoc.metrics.list() :: (name :: STRING?, lastUpdated :: INTEGER?)

apoc.metrics.list() - get a list of available metrics

procedure

apoc.metrics.storage

apoc.metrics.storage(directorySetting :: STRING?) :: (setting :: STRING?, freeSpaceBytes :: INTEGER?, totalSpaceBytes :: INTEGER?, usableSpaceBytes :: INTEGER?, percentFree :: FLOAT?)

apoc.metrics.storage(directorySetting) - retrieve storage metrics about the devices Neo4j uses for data storage. directorySetting may be any valid neo4j directory setting name, such as 'dbms.directories.data'. If null is provided as a directorySetting, you will get back all available directory settings. For a list of available directory settings, see the Neo4j operations manual reference on configuration settings. Directory settings are not paths, they are a neo4j.conf setting key name

procedure

apoc.model.jdbc

apoc.model.jdbc(jdbc :: STRING?, config = {} :: MAP?) :: (nodes :: LIST? OF NODE?, relationships :: LIST? OF RELATIONSHIP?)

apoc.model.jdbc('key or url', {schema:'<schema>', write: <true/false>, filters: { tables:[], views: [], columns: []}) YIELD nodes, relationships - load schema from relational database

procedure

apoc.mongodb.count

apoc.mongodb.count(host :: STRING?, db :: STRING?, collection :: STRING?, query :: MAP?) :: (value :: INTEGER?)

apoc.mongodb.count(host-or-port,db-or-null,collection-or-null,query-or-null) yield value - perform a find operation on mongodb collection

procedure

apoc.mongodb.delete

apoc.mongodb.delete(host :: STRING?, db :: STRING?, collection :: STRING?, query :: MAP?) :: (value :: INTEGER?)

apoc.mongodb.delete(host-or-port,db-or-null,collection-or-null,list-of-maps) - delete the given documents from the mongodb collection and returns the number of affected documents

procedure

apoc.mongodb.find

apoc.mongodb.find(host :: STRING?, db :: STRING?, collection :: STRING?, query :: MAP?, project :: MAP?, sort :: MAP?, compatibleValues = false :: BOOLEAN?, skip = 0 :: INTEGER?, limit = 0 :: INTEGER?) :: (value :: MAP?)

apoc.mongodb.find(host-or-port,db-or-null,collection-or-null,query-or-null,projection-or-null,sort-or-null,pagination,[compatibleValues=true|false],skip-or-null,limit-or-null) yield value - perform a find,project,sort operation on mongodb collection

procedure

apoc.mongodb.first

apoc.mongodb.first(host :: STRING?, db :: STRING?, collection :: STRING?, query :: MAP?, compatibleValues = false :: BOOLEAN?) :: (value :: MAP?)

apoc.mongodb.first(host-or-port,db-or-null,collection-or-null,query-or-null,[compatibleValues=true|false]) yield value - perform a first operation on mongodb collection

procedure

apoc.mongodb.get

apoc.mongodb.get(host :: STRING?, db :: STRING?, collection :: STRING?, query :: MAP?, compatibleValues = false :: BOOLEAN?, skip = 0 :: INTEGER?, limit = 0 :: INTEGER?) :: (value :: MAP?)

apoc.mongodb.get(host-or-port,db-or-null,collection-or-null,query-or-null,[compatibleValues=true|false],skip-or-null,limit-or-null) yield value - perform a find operation on mongodb collection

procedure

apoc.mongodb.insert

apoc.mongodb.insert(host :: STRING?, db :: STRING?, collection :: STRING?, documents :: LIST? OF MAP?) :: VOID

apoc.mongodb.insert(host-or-port,db-or-null,collection-or-null,list-of-maps) - inserts the given documents into the mongodb collection

procedure

apoc.mongodb.update

apoc.mongodb.update(host :: STRING?, db :: STRING?, collection :: STRING?, query :: MAP?, update :: MAP?) :: (value :: INTEGER?)

apoc.mongodb.update(host-or-port,db-or-null,collection-or-null,list-of-maps) - updates the given documents from the mongodb collection and returns the number of affected documents

procedure

apoc.monitor.ids

apoc.monitor.ids() :: (nodeIds :: INTEGER?, relIds :: INTEGER?, propIds :: INTEGER?, relTypeIds :: INTEGER?)

apoc.monitor.ids() returns the object ids in use for this neo4j instance

procedure

apoc.monitor.kernel

apoc.monitor.kernel() :: (readOnly :: BOOLEAN?, kernelVersion :: STRING?, storeId :: STRING?, kernelStartTime :: STRING?, databaseName :: STRING?, storeLogVersion :: INTEGER?, storeCreationDate :: STRING?)

apoc.monitor.kernel() returns informations about the neo4j kernel

procedure

apoc.monitor.locks

apoc.monitor.locks(minWaitTime :: INTEGER?) :: (advertedDeadLocks :: INTEGER?, lockCount :: INTEGER?, contendedLockCount :: INTEGER?, minimumWaitTimeMs :: INTEGER?, contendedLocks :: LIST? OF MAP?, info :: STRING?)

deprecated, the information is not provided by neo4j anymore. apoc.monitor.locks(minWaitTime) yield advertedDeadLocks, lockCount, contendedLockCount, minimumWaitTimeMs, contendedLocks, info

procedure

apoc.monitor.store

apoc.monitor.store() :: (logSize :: INTEGER?, stringStoreSize :: INTEGER?, arrayStoreSize :: INTEGER?, relStoreSize :: INTEGER?, propStoreSize :: INTEGER?, totalStoreSize :: INTEGER?, nodeStoreSize :: INTEGER?)

apoc.monitor.store() returns informations about the sizes of the different parts of the neo4j graph store

procedure

apoc.monitor.tx

apoc.monitor.tx() :: (rolledBackTx :: INTEGER?, peakTx :: INTEGER?, lastTxId :: INTEGER?, currentOpenedTx :: INTEGER?, totalOpenedTx :: INTEGER?, totalTx :: INTEGER?)

apoc.monitor.tx() returns informations about the neo4j transaction manager

procedure

apoc.neighbors.athop

apoc.neighbors.athop(node :: NODE?, types = :: STRING?, distance = 1 :: INTEGER?) :: (node :: NODE?)

apoc.neighbors.athop(node, rel-direction-pattern, distance) - returns distinct nodes of the given relationships in the pattern at a distance, can use '>' or '<' for all outgoing or incoming relationships

procedure

apoc.neighbors.athop.count

apoc.neighbors.athop.count(node :: NODE?, types = :: STRING?, distance = 1 :: INTEGER?) :: (value :: INTEGER?)

apoc.neighbors.athop.count(node, rel-direction-pattern, distance) - returns distinct nodes of the given relationships in the pattern at a distance, can use '>' or '<' for all outgoing or incoming relationships

procedure

apoc.neighbors.byhop

apoc.neighbors.byhop(node :: NODE?, types = :: STRING?, distance = 1 :: INTEGER?) :: (nodes :: LIST? OF NODE?)

apoc.neighbors.byhop(node, rel-direction-pattern, distance) - returns distinct nodes of the given relationships in the pattern at each distance, can use '>' or '<' for all outgoing or incoming relationships

procedure

apoc.neighbors.byhop.count

apoc.neighbors.byhop.count(node :: NODE?, types = :: STRING?, distance = 1 :: INTEGER?) :: (value :: LIST? OF ANY?)

apoc.neighbors.byhop.count(node, rel-direction-pattern, distance) - returns distinct nodes of the given relationships in the pattern at each distance, can use '>' or '<' for all outgoing or incoming relationships

procedure

apoc.neighbors.tohop

apoc.neighbors.tohop(node :: NODE?, types = :: STRING?, distance = 1 :: INTEGER?) :: (node :: NODE?)

apoc.neighbors.tohop(node, rel-direction-pattern, distance) - returns distinct nodes of the given relationships in the pattern up to a certain distance, can use '>' or '<' for all outgoing or incoming relationships

procedure

apoc.neighbors.tohop.count

apoc.neighbors.tohop.count(node :: NODE?, types = :: STRING?, distance = 1 :: INTEGER?) :: (value :: INTEGER?)

apoc.neighbors.tohop.count(node, rel-direction-pattern, distance) - returns distinct count of nodes of the given relationships in the pattern up to a certain distance, can use '>' or '<' for all outgoing or incoming relationships

procedure

apoc.nodes.collapse

apoc.nodes.collapse(nodes :: LIST? OF NODE?, config = {} :: MAP?) :: (from :: NODE?, rel :: RELATIONSHIP?, to :: NODE?)

apoc.nodes.collapse([nodes…​],[{properties:'overwrite' or 'discard' or 'combine'}]) yield from, rel, to merge nodes onto first in list

procedure

apoc.nodes.delete

apoc.nodes.delete(nodes :: ANY?, batchSize :: INTEGER?) :: (value :: INTEGER?)

apoc.nodes.delete(node|nodes|id|[ids]) - quickly delete all nodes with these ids

procedure

apoc.nodes.get

apoc.nodes.get(nodes :: ANY?) :: (node :: NODE?)

apoc.nodes.get(node|nodes|id|[ids]) - quickly returns all nodes with these ids

procedure

apoc.nodes.group

apoc.nodes.group(labels :: LIST? OF STRING?, groupByProperties :: LIST? OF STRING?, aggregations = [{=count}, {=count}] :: LIST? OF MAP?, config = {} :: MAP?) :: (nodes :: LIST? OF NODE?, relationships :: LIST? OF RELATIONSHIP?, node :: NODE?, relationship :: RELATIONSHIP?)

 

procedure

apoc.nodes.link

apoc.nodes.link(nodes :: LIST? OF NODE?, type :: STRING?) :: VOID

apoc.nodes.link([nodes],'REL_TYPE') - creates a linked list of nodes from first to last

procedure

apoc.nodes.rels

apoc.nodes.rels(relationships :: ANY?) :: (rel :: RELATIONSHIP?)

apoc.get.rels(rel|id|[ids]) - quickly returns all relationships with these ids

procedure

apoc.path.expand

apoc.path.expand(start :: ANY?, relationshipFilter :: STRING?, labelFilter :: STRING?, minLevel :: INTEGER?, maxLevel :: INTEGER?) :: (path :: PATH?)

apoc.path.expand(startNode <id>|Node|list, 'TYPE|TYPE_OUT>|<TYPE_IN', '+YesLabel|-NoLabel', minLevel, maxLevel ) yield path - expand from start node following the given relationships from min to max-level adhering to the label filters

procedure

apoc.path.expandConfig

apoc.path.expandConfig(start :: ANY?, config :: MAP?) :: (path :: PATH?)

apoc.path.expandConfig(startNode <id>|Node|list, {minLevel,maxLevel,uniqueness,relationshipFilter,labelFilter,uniqueness:'RELATIONSHIP_PATH',bfs:true, filterStartNode:false, limit:-1, optional:false, endNodes:[], terminatorNodes:[], sequence, beginSequenceAtStart:true}) yield path - expand from start node following the given relationships from min to max-level adhering to the label filters.

procedure

apoc.path.spanningTree

apoc.path.spanningTree(start :: ANY?, config :: MAP?) :: (path :: PATH?)

apoc.path.spanningTree(startNode <id>|Node|list, {maxLevel,relationshipFilter,labelFilter,bfs:true, filterStartNode:false, limit:-1, optional:false, endNodes:[], terminatorNodes:[], sequence, beginSequenceAtStart:true}) yield path - expand a spanning tree reachable from start node following relationships to max-level adhering to the label filters

procedure

apoc.path.subgraphAll

apoc.path.subgraphAll(start :: ANY?, config :: MAP?) :: (nodes :: LIST? OF NODE?, relationships :: LIST? OF RELATIONSHIP?)

apoc.path.subgraphAll(startNode <id>|Node|list, {maxLevel,relationshipFilter,labelFilter,bfs:true, filterStartNode:false, limit:-1, endNodes:[], terminatorNodes:[], sequence, beginSequenceAtStart:true}) yield nodes, relationships - expand the subgraph reachable from start node following relationships to max-level adhering to the label filters, and also return all relationships within the subgraph

procedure

apoc.path.subgraphNodes

apoc.path.subgraphNodes(start :: ANY?, config :: MAP?) :: (node :: NODE?)

apoc.path.subgraphNodes(startNode <id>|Node|list, {maxLevel,relationshipFilter,labelFilter,bfs:true, filterStartNode:false, limit:-1, optional:false, endNodes:[], terminatorNodes:[], sequence, beginSequenceAtStart:true}) yield node - expand the subgraph nodes reachable from start node following relationships to max-level adhering to the label filters

procedure

apoc.periodic.cancel

apoc.periodic.cancel(name :: STRING?) :: (name :: STRING?, delay :: INTEGER?, rate :: INTEGER?, done :: BOOLEAN?, cancelled :: BOOLEAN?)

apoc.periodic.cancel(name) - cancel job with the given name

procedure

apoc.periodic.commit

apoc.periodic.commit(statement :: STRING?, params = {} :: MAP?) :: (updates :: INTEGER?, executions :: INTEGER?, runtime :: INTEGER?, batches :: INTEGER?, failedBatches :: INTEGER?, batchErrors :: MAP?, failedCommits :: INTEGER?, commitErrors :: MAP?, wasTerminated :: BOOLEAN?)

apoc.periodic.commit(statement,params) - runs the given statement in separate transactions until it returns 0

procedure

apoc.periodic.countdown

apoc.periodic.countdown(name :: STRING?, statement :: STRING?, rate :: INTEGER?) :: (name :: STRING?, delay :: INTEGER?, rate :: INTEGER?, done :: BOOLEAN?, cancelled :: BOOLEAN?)

apoc.periodic.countdown('name',statement,repeat-rate-in-seconds) submit a repeatedly-called background statement until it returns 0

procedure

apoc.periodic.iterate

apoc.periodic.iterate(cypherIterate :: STRING?, cypherAction :: STRING?, config :: MAP?) :: (batches :: INTEGER?, total :: INTEGER?, timeTaken :: INTEGER?, committedOperations :: INTEGER?, failedOperations :: INTEGER?, failedBatches :: INTEGER?, retries :: INTEGER?, errorMessages :: MAP?, batch :: MAP?, operations :: MAP?, wasTerminated :: BOOLEAN?, failedParams :: MAP?)

apoc.periodic.iterate('statement returning items', 'statement per item', {batchSize:1000,iterateList:true,parallel:false,params:{},concurrency:50,retries:0}) YIELD batches, total - run the second statement for each item returned by the first statement. Returns number of batches and total processed rows

procedure

apoc.periodic.list

apoc.periodic.list() :: (name :: STRING?, delay :: INTEGER?, rate :: INTEGER?, done :: BOOLEAN?, cancelled :: BOOLEAN?)

apoc.periodic.list - list all jobs

procedure

apoc.periodic.repeat

apoc.periodic.repeat(name :: STRING?, statement :: STRING?, rate :: INTEGER?, config = {} :: MAP?) :: (name :: STRING?, delay :: INTEGER?, rate :: INTEGER?, done :: BOOLEAN?, cancelled :: BOOLEAN?)

apoc.periodic.repeat('name',statement,repeat-rate-in-seconds, config) submit a repeatedly-called background statement. Fourth parameter 'config' is optional and can contain 'params' entry for nested statement.

procedure

apoc.periodic.rock_n_roll

apoc.periodic.rock_n_roll(cypherIterate :: STRING?, cypherAction :: STRING?, batchSize :: INTEGER?) :: (batches :: INTEGER?, total :: INTEGER?, timeTaken :: INTEGER?, committedOperations :: INTEGER?, failedOperations :: INTEGER?, failedBatches :: INTEGER?, retries :: INTEGER?, errorMessages :: MAP?, batch :: MAP?, operations :: MAP?, wasTerminated :: BOOLEAN?, failedParams :: MAP?)

apoc.periodic.rock_n_roll('some cypher for iteration', 'some cypher as action on each iteration', 10000) YIELD batches, total - run the action statement in batches over the iterator statement’s results in a separate thread. Returns number of batches and total processed rows

procedure

apoc.periodic.rock_n_roll_while

apoc.periodic.rock_n_roll_while(cypherLoop :: STRING?, cypherIterate :: STRING?, cypherAction :: STRING?, batchSize :: INTEGER?) :: (loop :: ANY?, batches :: INTEGER?, total :: INTEGER?)

apoc.periodic.rock_n_roll_while('some cypher for knowing when to stop', 'some cypher for iteration', 'some cypher as action on each iteration', 10000) YIELD batches, total - run the action statement in batches over the iterator statement’s results in a separate thread. Returns number of batches and total processed rows

procedure

apoc.periodic.submit

apoc.periodic.submit(name :: STRING?, statement :: STRING?) :: (name :: STRING?, delay :: INTEGER?, rate :: INTEGER?, done :: BOOLEAN?, cancelled :: BOOLEAN?)

apoc.periodic.submit('name',statement) - submit a one-off background statement

procedure

apoc.refactor.categorize

apoc.refactor.categorize(sourceKey :: STRING?, type :: STRING?, outgoing :: BOOLEAN?, label :: STRING?, targetKey :: STRING?, copiedKeys :: LIST? OF STRING?, batchSize :: INTEGER?) :: VOID

apoc.refactor.categorize(sourceKey, type, outgoing, label, targetKey, copiedKeys, batchSize) turn each unique propertyKey into a category node and connect to it

procedure

apoc.refactor.cloneNodes

apoc.refactor.cloneNodes(nodes :: LIST? OF NODE?, withRelationships = false :: BOOLEAN?, skipProperties = [] :: LIST? OF STRING?) :: (input :: INTEGER?, output :: NODE?, error :: STRING?)

apoc.refactor.cloneNodes([node1,node2,…​]) clone nodes with their labels and properties

procedure

apoc.refactor.cloneNodesWithRelationships

apoc.refactor.cloneNodesWithRelationships(nodes :: LIST? OF NODE?) :: (input :: INTEGER?, output :: NODE?, error :: STRING?)

apoc.refactor.cloneNodesWithRelationships([node1,node2,…​]) clone nodes with their labels, properties and relationships

procedure

apoc.refactor.cloneSubgraph

apoc.refactor.cloneSubgraph(nodes :: LIST? OF NODE?, rels = [] :: LIST? OF RELATIONSHIP?, config = {} :: MAP?) :: (input :: INTEGER?, output :: NODE?, error :: STRING?)

apoc.refactor.cloneSubgraph([node1,node2,…​], [rel1,rel2,…​]:[], {standinNodes:[], skipProperties:[]}) YIELD input, output, error | clone nodes with their labels and properties (optionally skipping any properties in the skipProperties list via the config map), and clone the given relationships (will exist between cloned nodes only). If no relationships are provided, all relationships between the given nodes will be cloned. Relationships can be optionally redirected according to standinNodes node pairings (this is a list of list-pairs of nodes), so given a node in the original subgraph (first of the pair), an existing node (second of the pair) can act as a standin for it within the cloned subgraph. Cloned relationships will be redirected to the standin.

procedure

apoc.refactor.cloneSubgraphFromPaths

apoc.refactor.cloneSubgraphFromPaths(paths :: LIST? OF PATH?, config = {} :: MAP?) :: (input :: INTEGER?, output :: NODE?, error :: STRING?)

apoc.refactor.cloneSubgraphFromPaths([path1, path2, …​], {standinNodes:[], skipProperties:[]}) YIELD input, output, error | from the subgraph formed from the given paths, clone nodes with their labels and properties (optionally skipping any properties in the skipProperties list via the config map), and clone the relationships (will exist between cloned nodes only). Relationships can be optionally redirected according to standinNodes node pairings (this is a list of list-pairs of nodes), so given a node in the original subgraph (first of the pair), an existing node (second of the pair) can act as a standin for it within the cloned subgraph. Cloned relationships will be redirected to the standin.

procedure

apoc.refactor.collapseNode

apoc.refactor.collapseNode(nodes :: ANY?, type :: STRING?) :: (input :: INTEGER?, output :: RELATIONSHIP?, error :: STRING?)

apoc.refactor.collapseNode([node1,node2],'TYPE') collapse node to relationship, node with one rel becomes self-relationship

procedure

apoc.refactor.extractNode

apoc.refactor.extractNode(relationships :: ANY?, labels :: LIST? OF STRING?, outType :: STRING?, inType :: STRING?) :: (input :: INTEGER?, output :: NODE?, error :: STRING?)

apoc.refactor.extractNode([rel1,rel2,…​], [labels],'OUT','IN') extract node from relationships

procedure

apoc.refactor.from

apoc.refactor.from(relationship :: RELATIONSHIP?, newNode :: NODE?) :: (input :: INTEGER?, output :: RELATIONSHIP?, error :: STRING?)

apoc.refactor.from(rel, startNode) redirect relationship to use new start-node

procedure

apoc.refactor.invert

apoc.refactor.invert(relationship :: RELATIONSHIP?) :: (input :: INTEGER?, output :: RELATIONSHIP?, error :: STRING?)

apoc.refactor.invert(rel) inverts relationship direction

procedure

apoc.refactor.mergeNodes

apoc.refactor.mergeNodes(nodes :: LIST? OF NODE?, config = {} :: MAP?) :: (node :: NODE?)

apoc.refactor.mergeNodes([node1,node2],[{properties:'overwrite' or 'discard' or 'combine'}]) merge nodes onto first in list

procedure

apoc.refactor.mergeRelationships

apoc.refactor.mergeRelationships(rels :: LIST? OF RELATIONSHIP?, config = {} :: MAP?) :: (rel :: RELATIONSHIP?)

apoc.refactor.mergeRelationships([rel1,rel2]) merge relationships onto first in list

procedure

apoc.refactor.normalizeAsBoolean

apoc.refactor.normalizeAsBoolean(entity :: ANY?, propertyKey :: STRING?, true_values :: LIST? OF ANY?, false_values :: LIST? OF ANY?) :: VOID

apoc.refactor.normalizeAsBoolean(entity, propertyKey, true_values, false_values) normalize/convert a property to be boolean

procedure

apoc.refactor.rename.label

apoc.refactor.rename.label(oldLabel :: STRING?, newLabel :: STRING?, nodes = [] :: LIST? OF NODE?) :: (batches :: INTEGER?, total :: INTEGER?, timeTaken :: INTEGER?, committedOperations :: INTEGER?, failedOperations :: INTEGER?, failedBatches :: INTEGER?, retries :: INTEGER?, errorMessages :: MAP?, batch :: MAP?, operations :: MAP?, constraints :: LIST? OF STRING?, indexes :: LIST? OF STRING?)

apoc.refactor.rename.label(oldLabel, newLabel, [nodes]) | rename a label from 'oldLabel' to 'newLabel' for all nodes. If 'nodes' is provided renaming is applied to this set only

procedure

apoc.refactor.rename.nodeProperty

apoc.refactor.rename.nodeProperty(oldName :: STRING?, newName :: STRING?, nodes = [] :: LIST? OF ANY?) :: (batches :: INTEGER?, total :: INTEGER?, timeTaken :: INTEGER?, committedOperations :: INTEGER?, failedOperations :: INTEGER?, failedBatches :: INTEGER?, retries :: INTEGER?, errorMessages :: MAP?, batch :: MAP?, operations :: MAP?, constraints :: LIST? OF STRING?, indexes :: LIST? OF STRING?)

apoc.refactor.rename.nodeProperty(oldName, newName, [nodes]) | rename all node’s property from 'oldName' to 'newName'. If 'nodes' is provided renaming is applied to this set only

procedure

apoc.refactor.rename.type

apoc.refactor.rename.type(oldType :: STRING?, newType :: STRING?, rels = [] :: LIST? OF RELATIONSHIP?) :: (batches :: INTEGER?, total :: INTEGER?, timeTaken :: INTEGER?, committedOperations :: INTEGER?, failedOperations :: INTEGER?, failedBatches :: INTEGER?, retries :: INTEGER?, errorMessages :: MAP?, batch :: MAP?, operations :: MAP?, constraints :: LIST? OF STRING?, indexes :: LIST? OF STRING?)

apoc.refactor.rename.type(oldType, newType, [rels]) | rename all relationships with type 'oldType' to 'newType'. If 'rels' is provided renaming is applied to this set only

procedure

apoc.refactor.rename.typeProperty

apoc.refactor.rename.typeProperty(oldName :: STRING?, newName :: STRING?, rels = [] :: LIST? OF ANY?) :: (batches :: INTEGER?, total :: INTEGER?, timeTaken :: INTEGER?, committedOperations :: INTEGER?, failedOperations :: INTEGER?, failedBatches :: INTEGER?, retries :: INTEGER?, errorMessages :: MAP?, batch :: MAP?, operations :: MAP?, constraints :: LIST? OF STRING?, indexes :: LIST? OF STRING?)

apoc.refactor.rename.typeProperty(oldName, newName, [rels]) | rename all relationship’s property from 'oldName' to 'newName'. If 'rels' is provided renaming is applied to this set only

procedure

apoc.refactor.setType

apoc.refactor.setType(relationship :: RELATIONSHIP?, newType :: STRING?) :: (input :: INTEGER?, output :: RELATIONSHIP?, error :: STRING?)

apoc.refactor.setType(rel, 'NEW-TYPE') change relationship-type

procedure

apoc.refactor.to

apoc.refactor.to(relationship :: RELATIONSHIP?, newNode :: NODE?) :: (input :: INTEGER?, output :: RELATIONSHIP?, error :: STRING?)

apoc.refactor.to(rel, endNode) redirect relationship to use new end-node

procedure

apoc.schema.assert

apoc.schema.assert(indexes :: MAP?, constraints :: MAP?, dropExisting = true :: BOOLEAN?) :: (label :: STRING?, key :: STRING?, keys :: LIST? OF STRING?, unique :: BOOLEAN?, action :: STRING?)

apoc.schema.assert({indexLabel:, …​}, {constraintLabel:[constraintKeys], …​}, dropExisting : true) yield label, key, keys, unique, action - drops all other existing indexes and constraints when dropExisting is true (default is true), and asserts that at the end of the operation the given indexes and unique constraints are there, each label:key pair is considered one constraint/label. Non-constraint indexes can define compound indexes with label:[key1,key2…​] pairings.

procedure

apoc.schema.nodes

apoc.schema.nodes(config = {} :: MAP?) :: (name :: STRING?, label :: STRING?, properties :: LIST? OF STRING?, status :: STRING?, type :: STRING?, failure :: STRING?, populationProgress :: FLOAT?, size :: INTEGER?, valuesSelectivity :: FLOAT?, userDescription :: STRING?)

CALL apoc.schema.nodes([config]) yield name, label, properties, status, type

procedure

apoc.schema.properties.distinct

apoc.schema.properties.distinct(label :: STRING?, key :: STRING?) :: (value :: LIST? OF ANY?)

apoc.schema.properties.distinct(label, key) - quickly returns all distinct values for a given key

procedure

apoc.schema.properties.distinctCount

apoc.schema.properties.distinctCount(label = :: STRING?, key = :: STRING?) :: (label :: STRING?, key :: STRING?, value :: ANY?, count :: INTEGER?)

apoc.schema.properties.distinctCount([label], [key]) YIELD label, key, value, count - quickly returns all distinct values and counts for a given key

procedure

apoc.schema.relationships

apoc.schema.relationships(config = {} :: MAP?) :: (name :: STRING?, type :: STRING?, properties :: LIST? OF STRING?, status :: STRING?)

CALL apoc.schema.relationships([config]) yield name, startLabel, type, endLabel, properties, status

procedure

apoc.search.multiSearchReduced

apoc.search.multiSearchReduced(LabelPropertyMap :: ANY?, operator :: STRING?, value :: STRING?) :: (id :: INTEGER?, labels :: LIST? OF STRING?, values :: MAP?)

Do a parallel search over multiple indexes returning a reduced representation of the nodes found: node id, labels and the searched properties. apoc.search.multiSearchReduced( map of label and properties which will be searched upon, operator: EXACT | CONTAINS | STARTS WITH | ENDS WITH, searchValue ). Multiple search results for the same node are merged into one record.

procedure

apoc.search.node

apoc.search.node(LabelPropertyMap :: ANY?, operator :: STRING?, value :: STRING?) :: (node :: NODE?)

Do a parallel search over multiple indexes returning nodes. usage apoc.search.node( map of label and properties which will be searched upon, operator: EXACT | CONTAINS | STARTS WITH | ENDS WITH, searchValue ) returns all the DISTINCT Nodes found in the different searches.

procedure

apoc.search.nodeAll

apoc.search.nodeAll(LabelPropertyMap :: ANY?, operator :: STRING?, value :: STRING?) :: (node :: NODE?)

Do a parallel search over multiple indexes returning nodes. usage apoc.search.nodeAll( map of label and properties which will be searched upon, operator: EXACT | CONTAINS | STARTS WITH | ENDS WITH, searchValue ) returns all the Nodes found in the different searches.

procedure

apoc.search.nodeAllReduced

apoc.search.nodeAllReduced(LabelPropertyMap :: ANY?, operator :: STRING?, value :: ANY?) :: (id :: INTEGER?, labels :: LIST? OF STRING?, values :: MAP?)

Do a parallel search over multiple indexes returning a reduced representation of the nodes found: node id, labels and the searched property. apoc.search.nodeShortAll( map of label and properties which will be searched upon, operator: EXACT / CONTAINS / STARTS WITH | ENDS WITH / = / <> / < / > …​, value ). All 'hits' are returned.

procedure

apoc.search.nodeReduced

apoc.search.nodeReduced(LabelPropertyMap :: ANY?, operator :: STRING?, value :: STRING?) :: (id :: INTEGER?, labels :: LIST? OF STRING?, values :: MAP?)

Do a parallel search over multiple indexes returning a reduced representation of the nodes found: node id, labels and the searched properties. apoc.search.nodeReduced( map of label and properties which will be searched upon, operator: EXACT | CONTAINS | STARTS WITH | ENDS WITH, searchValue ). Multiple search results for the same node are merged into one record.

procedure

apoc.spatial.geocode

apoc.spatial.geocode(location :: STRING?, maxResults :: INTEGER?) :: (location :: MAP?, data :: MAP?, latitude :: FLOAT?, longitude :: FLOAT?, description :: STRING?)

 

procedure

apoc.spatial.geocode

apoc.spatial.geocode(location :: STRING?, maxResults = 100 :: INTEGER?, quotaException = false :: BOOLEAN?) :: (location :: MAP?, data :: MAP?, latitude :: FLOAT?, longitude :: FLOAT?, description :: STRING?)

apoc.spatial.geocode('address') YIELD location, latitude, longitude, description, osmData - look up geographic location of address from a geocoding service (the default one is OpenStreetMap)

procedure

apoc.spatial.geocodeOnce

apoc.spatial.geocodeOnce(location :: STRING?) :: (location :: MAP?, data :: MAP?, latitude :: FLOAT?, longitude :: FLOAT?, description :: STRING?)

apoc.spatial.geocodeOnce('address') YIELD location, latitude, longitude, description, osmData - look up geographic location of address from a geocoding service (the default one is OpenStreetMap)

procedure

apoc.spatial.reverseGeocode

apoc.spatial.reverseGeocode(latitude :: FLOAT?, longitude :: FLOAT?, maxResults = 100 :: INTEGER?) :: (location :: MAP?, data :: MAP?, latitude :: FLOAT?, longitude :: FLOAT?, description :: STRING?)

 

procedure

apoc.spatial.reverseGeocode

apoc.spatial.reverseGeocode(latitude :: FLOAT?, longitude :: FLOAT?, quotaException = false :: BOOLEAN?) :: (location :: MAP?, data :: MAP?, latitude :: FLOAT?, longitude :: FLOAT?, description :: STRING?)

apoc.spatial.reverseGeocode(latitude,longitude) YIELD location, latitude, longitude, description - look up address from latitude and longitude from a geocoding service (the default one is OpenStreetMap)

procedure

apoc.spatial.sortByDistance

apoc.spatial.sortByDistance(paths :: LIST? OF PATH?) :: (path :: PATH?, distance :: FLOAT?)

apoc.spatial.sortPathsByDistance(List<Path>) sort the given paths based on the geo informations (lat/long) in ascending order

procedure

apoc.static.get

apoc.static.get(key :: STRING?) :: (value :: ANY?)

apoc.static.get(name) - returns statically stored value from config (apoc.static.<key>) or server lifetime storage

procedure

apoc.static.getAll

apoc.static.getAll(prefix :: STRING?) :: (value :: MAP?)

apoc.static.getAll(prefix) - returns statically stored values from config (apoc.static.<prefix>.*) or server lifetime storage

procedure

apoc.static.list

apoc.static.list(prefix :: STRING?) :: (key :: STRING?, value :: ANY?)

apoc.static.list(prefix) - returns statically stored values from config (apoc.static.<prefix>.*) or server lifetime storage

procedure

apoc.static.set

apoc.static.set(key :: STRING?, value :: ANY?) :: (value :: ANY?)

apoc.static.set(name, value) - stores value under key for server livetime storage, returns previously stored or configured value

procedure

apoc.stats.degrees

apoc.stats.degrees(types = :: STRING?) :: (type :: STRING?, direction :: STRING?, total :: INTEGER?, p50 :: INTEGER?, p75 :: INTEGER?, p90 :: INTEGER?, p95 :: INTEGER?, p99 :: INTEGER?, p999 :: INTEGER?, max :: INTEGER?, min :: INTEGER?, mean :: FLOAT?)

 

procedure

apoc.text.doubleMetaphone

apoc.text.doubleMetaphone(value :: ANY?) :: (value :: STRING?)

apoc.text.doubleMetaphone(value) yield value - Compute the Double Metaphone phonetic encoding of all words of the text value which can be a single string or a list of strings

procedure

apoc.text.phonetic

apoc.text.phonetic(value :: ANY?) :: (value :: STRING?)

apoc.text.phonetic(value) yield value - Compute the US_ENGLISH phonetic soundex encoding of all words of the text value which can be a single string or a list of strings

procedure

apoc.text.phoneticDelta

apoc.text.phoneticDelta(text1 :: STRING?, text2 :: STRING?) :: (phonetic1 :: STRING?, phonetic2 :: STRING?, delta :: INTEGER?)

apoc.text.phoneticDelta(text1, text2) yield phonetic1, phonetic2, delta - Compute the US_ENGLISH soundex character difference between two given strings

procedure

apoc.trigger.add

apoc.trigger.add(name :: STRING?, kernelTransaction :: STRING?, selector :: MAP?, config = {} :: MAP?) :: (name :: STRING?, query :: STRING?, selector :: MAP?, params :: MAP?, installed :: BOOLEAN?, paused :: BOOLEAN?)

 

procedure

apoc.trigger.list

apoc.trigger.list() :: (name :: STRING?, query :: STRING?, selector :: MAP?, params :: MAP?, installed :: BOOLEAN?, paused :: BOOLEAN?)

 

procedure

apoc.trigger.pause

apoc.trigger.pause(name :: STRING?) :: (name :: STRING?, query :: STRING?, selector :: MAP?, params :: MAP?, installed :: BOOLEAN?, paused :: BOOLEAN?)

 

procedure

apoc.trigger.remove

apoc.trigger.remove(name :: STRING?) :: (name :: STRING?, query :: STRING?, selector :: MAP?, params :: MAP?, installed :: BOOLEAN?, paused :: BOOLEAN?)

 

procedure

apoc.trigger.removeAll

apoc.trigger.removeAll() :: (name :: STRING?, query :: STRING?, selector :: MAP?, params :: MAP?, installed :: BOOLEAN?, paused :: BOOLEAN?)

 

procedure

apoc.trigger.resume

apoc.trigger.resume(name :: STRING?) :: (name :: STRING?, query :: STRING?, selector :: MAP?, params :: MAP?, installed :: BOOLEAN?, paused :: BOOLEAN?)

 

procedure

apoc.util.sleep

apoc.util.sleep(duration :: INTEGER?) :: VOID

apoc.util.sleep(<duration>) | sleeps for <duration> millis, transaction termination is honored

procedure

apoc.util.validate

apoc.util.validate(predicate :: BOOLEAN?, message :: STRING?, params :: LIST? OF ANY?) :: VOID

apoc.util.validate(predicate, message, params) | if the predicate yields to true raise an exception

procedure

apoc.uuid.install

apoc.uuid.install(label :: STRING?, config = {} :: MAP?) :: (label :: STRING?, installed :: BOOLEAN?, properties :: MAP?)

 

procedure

apoc.uuid.list

apoc.uuid.list() :: (label :: STRING?, installed :: BOOLEAN?, properties :: MAP?)

 

procedure

apoc.uuid.remove

apoc.uuid.remove(label :: STRING?) :: (label :: STRING?, installed :: BOOLEAN?, properties :: MAP?)

 

procedure

apoc.uuid.removeAll

apoc.uuid.removeAll() :: (label :: STRING?, installed :: BOOLEAN?, properties :: MAP?)

 

procedure

apoc.warmup.run

apoc.warmup.run(loadProperties = false :: BOOLEAN?, loadDynamicProperties = false :: BOOLEAN?, loadIndexes = false :: BOOLEAN?) :: (pageSize :: INTEGER?, totalTime :: INTEGER?, transactionWasTerminated :: BOOLEAN?, nodesPerPage :: INTEGER?, nodesTotal :: INTEGER?, nodePages :: INTEGER?, nodesTime :: INTEGER?, relsPerPage :: INTEGER?, relsTotal :: INTEGER?, relPages :: INTEGER?, relsTime :: INTEGER?, relGroupsPerPage :: INTEGER?, relGroupsTotal :: INTEGER?, relGroupPages :: INTEGER?, relGroupsTime :: INTEGER?, propertiesLoaded :: BOOLEAN?, dynamicPropertiesLoaded :: BOOLEAN?, propsPerPage :: INTEGER?, propRecordsTotal :: INTEGER?, propPages :: INTEGER?, propsTime :: INTEGER?, stringPropsPerPage :: INTEGER?, stringPropRecordsTotal :: INTEGER?, stringPropPages :: INTEGER?, stringPropsTime :: INTEGER?, arrayPropsPerPage :: INTEGER?, arrayPropRecordsTotal :: INTEGER?, arrayPropPages :: INTEGER?, arrayPropsTime :: INTEGER?, indexesLoaded :: BOOLEAN?, indexPages :: INTEGER?, indexTime :: INTEGER?)

apoc.warmup.run(loadProperties=false,loadDynamicProperties=false,loadIndexes=false) - quickly loads all nodes and rels into memory by skipping one page at a time

procedure

apoc.when

apoc.when(condition :: BOOLEAN?, ifQuery :: STRING?, elseQuery = :: STRING?, params = {} :: MAP?) :: (value :: MAP?)

apoc.when(condition, ifQuery, elseQuery:'', params:{}) yield value - based on the conditional, executes read-only ifQuery or elseQuery with the given parameters

procedure

apoc.xml.import

apoc.xml.import(url :: STRING?, config = {} :: MAP?) :: (node :: NODE?)

 

function

apoc.agg.first

apoc.agg.first(value :: ANY?) :: (ANY?)

apoc.agg.first(value) - returns first value

function

apoc.agg.graph

apoc.agg.graph(element :: ANY?) :: (MAP?)

apoc.agg.graph(path) - returns map of graph {nodes, relationships} of all distinct nodes and relationships

function

apoc.agg.last

apoc.agg.last(value :: ANY?) :: (ANY?)

apoc.agg.last(value) - returns last value

function

apoc.agg.maxItems

apoc.agg.maxItems(item :: ANY?, value :: ANY?, groupLimit = -1 :: INTEGER?) :: (ANY?)

apoc.agg.maxItems(item, value, groupLimit: -1) - returns a map {items:[], value:n} where value is the maximum value present, and items are all items with the same value. The number of items can be optionally limited.

function

apoc.agg.median

apoc.agg.median(value :: ANY?) :: (ANY?)

apoc.agg.median(number) - returns median for non-null numeric values

function

apoc.agg.minItems

apoc.agg.minItems(item :: ANY?, value :: ANY?, groupLimit = -1 :: INTEGER?) :: (ANY?)

apoc.agg.minItems(item, value, groupLimit: -1) - returns a map {items:[], value:n} where value is the minimum value present, and items are all items with the same value. The number of items can be optionally limited.

function

apoc.agg.nth

apoc.agg.nth(value :: ANY?, value :: INTEGER?) :: (ANY?)

apoc.agg.nth(value,offset) - returns value of nth row (or -1 for last)

function

apoc.agg.percentiles

apoc.agg.percentiles(value :: NUMBER?, percentiles = [0.5, 0.75, 0.9, 0.95, 0.99] :: LIST? OF FLOAT?) :: (LIST? OF ANY?)

apoc.agg.percentiles(value,[percentiles = 0.5,0.75,0.9,0.95,0.99]) - returns given percentiles for values

function

apoc.agg.product

apoc.agg.product(number :: NUMBER?) :: (NUMBER?)

apoc.agg.product(number) - returns given product for non-null values

function

apoc.agg.slice

apoc.agg.slice(value :: ANY?, from = 0 :: INTEGER?, to = -1 :: INTEGER?) :: (LIST? OF ANY?)

apoc.agg.slice(value, start, length) - returns subset of non-null values, start is 0 based and length can be -1

function

apoc.agg.statistics

apoc.agg.statistics(value :: NUMBER?, percentiles = [0.5, 0.75, 0.9, 0.95, 0.99] :: LIST? OF FLOAT?) :: (MAP?)

apoc.agg.statistics(value,[percentiles = 0.5,0.75,0.9,0.95,0.99]) - returns numeric statistics (percentiles, min,minNonZero,max,total,mean,stdev) for values

function

apoc.algo.cosineSimilarity

apoc.algo.cosineSimilarity(vector1 :: LIST? OF NUMBER?, vector2 :: LIST? OF NUMBER?) :: (FLOAT?)

apoc.algo.cosineSimilarity([vector1], [vector2]) given two collection vectors, calculate cosine similarity

function

apoc.algo.euclideanDistance

apoc.algo.euclideanDistance(vector1 :: LIST? OF NUMBER?, vector2 :: LIST? OF NUMBER?) :: (FLOAT?)

apoc.algo.euclideanDistance([vector1], [vector2]) given two collection vectors, calculate the euclidean distance (square root of the sum of the squared differences)

function

apoc.algo.euclideanSimilarity

apoc.algo.euclideanSimilarity(vector1 :: LIST? OF NUMBER?, vector2 :: LIST? OF NUMBER?) :: (FLOAT?)

apoc.algo.euclideanSimilarity([vector1], [vector2]) given two collection vectors, calculate similarity based on euclidean distance

function

apoc.any.properties

apoc.any.properties(thing :: ANY?, keys = null :: LIST? OF STRING?) :: (MAP?)

returns properties for virtual and real, nodes, rels and maps

function

apoc.any.property

apoc.any.property(thing :: ANY?, key :: STRING?) :: (ANY?)

returns property for virtual and real, nodes, rels and maps

function

apoc.bitwise.op

apoc.bitwise.op(a :: INTEGER?, operator :: STRING?, b :: INTEGER?) :: (INTEGER?)

apoc.bitwise.op(60,'|',13) bitwise operations a & b, a | b, a ^ b, ~a, a >> b, a >>> b, a << b. returns the result of the bitwise operation

function

apoc.coll.avg

apoc.coll.avg(numbers :: LIST? OF NUMBER?) :: (FLOAT?)

apoc.coll.avg([0.5,1,2.3])

function

apoc.coll.combinations

apoc.coll.combinations(coll :: LIST? OF ANY?, minSelect :: INTEGER?, maxSelect = -1 :: INTEGER?) :: (LIST? OF ANY?)

apoc.coll.combinations(coll, minSelect, maxSelect:minSelect) - Returns collection of all combinations of list elements of selection size between minSelect and maxSelect (default:minSelect), inclusive

function

apoc.coll.contains

apoc.coll.contains(coll :: LIST? OF ANY?, value :: ANY?) :: (BOOLEAN?)

apoc.coll.contains(coll, value) optimized contains operation (using a HashSet) (returns single row or not)

function

apoc.coll.containsAll

apoc.coll.containsAll(coll :: LIST? OF ANY?, values :: LIST? OF ANY?) :: (BOOLEAN?)

apoc.coll.containsAll(coll, values) optimized contains-all operation (using a HashSet) (returns single row or not)

function

apoc.coll.containsAllSorted

apoc.coll.containsAllSorted(coll :: LIST? OF ANY?, values :: LIST? OF ANY?) :: (BOOLEAN?)

apoc.coll.containsAllSorted(coll, value) optimized contains-all on a sorted list operation (Collections.binarySearch) (returns single row or not)

function

apoc.coll.containsDuplicates

apoc.coll.containsDuplicates(coll :: LIST? OF ANY?) :: (BOOLEAN?)

apoc.coll.containsDuplicates(coll) - returns true if a collection contains duplicate elements

function

apoc.coll.containsSorted

apoc.coll.containsSorted(coll :: LIST? OF ANY?, value :: ANY?) :: (BOOLEAN?)

apoc.coll.containsSorted(coll, value) optimized contains on a sorted list operation (Collections.binarySearch) (returns single row or not)

function

apoc.coll.different

apoc.coll.different(values :: LIST? OF ANY?) :: (BOOLEAN?)

apoc.coll.different(values) - returns true if values are different

function

apoc.coll.disjunction

apoc.coll.disjunction(first :: LIST? OF ANY?, second :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.disjunction(first, second) - returns the disjunct set of the two lists

function

apoc.coll.dropDuplicateNeighbors

apoc.coll.dropDuplicateNeighbors(list :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.dropDuplicateNeighbors(list) - remove duplicate consecutive objects in a list

function

apoc.coll.duplicates

apoc.coll.duplicates(coll :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.duplicates(coll) - returns a list of duplicate items in the collection

function

apoc.coll.duplicatesWithCount

apoc.coll.duplicatesWithCount(coll :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.duplicatesWithCount(coll) - returns a list of duplicate items in the collection and their count, keyed by item and count (e.g., [{item: xyz, count:2}, {item:zyx, count:5}])

function

apoc.coll.flatten

apoc.coll.flatten(coll :: LIST? OF ANY?, recursive = false :: BOOLEAN?) :: (LIST? OF ANY?)

apoc.coll.flatten(coll, [recursive]) - flattens list (nested if recursive is true)

function

apoc.coll.frequencies

apoc.coll.frequencies(coll :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.frequencies(coll) - returns a list of frequencies of the items in the collection, keyed by item and count (e.g., [{item: xyz, count:2}, {item:zyx, count:5}, {item:abc, count:1}])

function

apoc.coll.frequenciesAsMap

apoc.coll.frequenciesAsMap(coll :: LIST? OF ANY?) :: (MAP?)

apoc.coll.frequenciesAsMap(coll) - return a map of frequencies of the items in the collection, key item, value count (e.g., {1:2, 2:1})

function

apoc.coll.indexOf

apoc.coll.indexOf(coll :: LIST? OF ANY?, value :: ANY?) :: (INTEGER?)

apoc.coll.indexOf(coll, value) | position of value in the list

function

apoc.coll.insert

apoc.coll.insert(coll :: LIST? OF ANY?, index :: INTEGER?, value :: ANY?) :: (LIST? OF ANY?)

apoc.coll.insert(coll, index, value) | insert value at index

function

apoc.coll.insertAll

apoc.coll.insertAll(coll :: LIST? OF ANY?, index :: INTEGER?, values :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.insertAll(coll, index, values) | insert values at index

function

apoc.coll.intersection

apoc.coll.intersection(first :: LIST? OF ANY?, second :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.intersection(first, second) - returns the unique intersection of the two lists

function

apoc.coll.max

apoc.coll.max(values :: LIST? OF ANY?) :: (ANY?)

apoc.coll.max([0.5,1,2.3])

function

apoc.coll.min

apoc.coll.min(values :: LIST? OF ANY?) :: (ANY?)

apoc.coll.min([0.5,1,2.3])

function

apoc.coll.occurrences

apoc.coll.occurrences(coll :: LIST? OF ANY?, item :: ANY?) :: (INTEGER?)

apoc.coll.occurrences(coll, item) - returns the count of the given item in the collection

function

apoc.coll.pairs

apoc.coll.pairs(list :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.pairs([1,2,3]) returns [1,2],[2,3],[3,null]

function

apoc.coll.pairsMin

apoc.coll.pairsMin(list :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.pairsMin([1,2,3]) returns [1,2],[2,3]

function

apoc.coll.randomItem

apoc.coll.randomItem(coll :: LIST? OF ANY?) :: (ANY?)

apoc.coll.randomItem(coll)- returns a random item from the list, or null on an empty or null list

function

apoc.coll.randomItems

apoc.coll.randomItems(coll :: LIST? OF ANY?, itemCount :: INTEGER?, allowRepick = false :: BOOLEAN?) :: (LIST? OF ANY?)

apoc.coll.randomItems(coll, itemCount, allowRepick: false) - returns a list of itemCount random items from the original list, optionally allowing picked elements to be picked again

function

apoc.coll.remove

apoc.coll.remove(coll :: LIST? OF ANY?, index :: INTEGER?, length = 1 :: INTEGER?) :: (LIST? OF ANY?)

apoc.coll.remove(coll, index, [length=1]) | remove range of values from index to length

function

apoc.coll.removeAll

apoc.coll.removeAll(first :: LIST? OF ANY?, second :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.removeAll(first, second) - returns first list with all elements of second list removed

function

apoc.coll.reverse

apoc.coll.reverse(coll :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.reverse(coll) - returns reversed list

function

apoc.coll.set

apoc.coll.set(coll :: LIST? OF ANY?, index :: INTEGER?, value :: ANY?) :: (LIST? OF ANY?)

apoc.coll.set(coll, index, value) | set index to value

function

apoc.coll.shuffle

apoc.coll.shuffle(coll :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.shuffle(coll) - returns the shuffled list

function

apoc.coll.sort

apoc.coll.sort(coll :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.sort(coll) sort on Collections

function

apoc.coll.sortMaps

apoc.coll.sortMaps(coll :: LIST? OF MAP?, prop :: STRING?) :: (LIST? OF ANY?)

apoc.coll.sortMaps([maps], 'name') - sort maps by property

function

apoc.coll.sortMulti

apoc.coll.sortMulti(coll :: LIST? OF MAP?, orderFields = [] :: LIST? OF STRING?, limit = -1 :: INTEGER?, skip = 0 :: INTEGER?) :: (LIST? OF ANY?)

apoc.coll.sortMulti(coll, ['^name','age'],[limit],[skip]) - sort list of maps by several sort fields (ascending with ^ prefix) and optionally applies limit and skip

function

apoc.coll.sortNodes

apoc.coll.sortNodes(coll :: LIST? OF NODE?, prop :: STRING?) :: (LIST? OF ANY?)

apoc.coll.sortNodes([nodes], 'name') sort nodes by property

function

apoc.coll.subtract

apoc.coll.subtract(first :: LIST? OF ANY?, second :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.subtract(first, second) - returns unique set of first list with all elements of second list removed

function

apoc.coll.sum

apoc.coll.sum(numbers :: LIST? OF NUMBER?) :: (FLOAT?)

apoc.coll.sum([0.5,1,2.3])

function

apoc.coll.sumLongs

apoc.coll.sumLongs(numbers :: LIST? OF NUMBER?) :: (INTEGER?)

apoc.coll.sumLongs([1,3,3])

function

apoc.coll.toSet

apoc.coll.toSet(values :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.toSet([list]) returns a unique list backed by a set

function

apoc.coll.union

apoc.coll.union(first :: LIST? OF ANY?, second :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.union(first, second) - creates the distinct union of the 2 lists

function

apoc.coll.unionAll

apoc.coll.unionAll(first :: LIST? OF ANY?, second :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.unionAll(first, second) - creates the full union with duplicates of the two lists

function

apoc.coll.zip

apoc.coll.zip(list1 :: LIST? OF ANY?, list2 :: LIST? OF ANY?) :: (LIST? OF ANY?)

apoc.coll.zip([list1],[list2])

function

apoc.convert.fromJsonList

apoc.convert.fromJsonList(list :: STRING?, path = :: STRING?) :: (LIST? OF ANY?)

apoc.convert.fromJsonList('[1,2,3]'[,'json-path'])

function

apoc.convert.fromJsonMap

apoc.convert.fromJsonMap(map :: STRING?, path = :: STRING?) :: (MAP?)

apoc.convert.fromJsonMap('{"a":42,"b":"foo","c":[1,2,3]}'[,'json-path'])

function

apoc.convert.getJsonProperty

apoc.convert.getJsonProperty(node :: NODE?, key :: STRING?, path = :: STRING?) :: (ANY?)

apoc.convert.getJsonProperty(node,key[,'json-path']) - converts serialized JSON in property back to original object

function

apoc.convert.getJsonPropertyMap

apoc.convert.getJsonPropertyMap(node :: NODE?, key :: STRING?, path = :: STRING?) :: (MAP?)

apoc.convert.getJsonPropertyMap(node,key[,'json-path']) - converts serialized JSON in property back to map

function

apoc.convert.toBoolean

apoc.convert.toBoolean(bool :: ANY?) :: (BOOLEAN?)

apoc.convert.toBoolean(value) | tries it’s best to convert the value to a boolean

function

apoc.convert.toBooleanList

apoc.convert.toBooleanList(list :: ANY?) :: (LIST? OF ANY?)

apoc.convert.toBooleanList(value) | tries it’s best to convert the value to a list of booleans

function

apoc.convert.toFloat

apoc.convert.toFloat(object :: ANY?) :: (FLOAT?)

apoc.convert.toFloat(value) | tries it’s best to convert the value to a float

function

apoc.convert.toIntList

apoc.convert.toIntList(list :: ANY?) :: (LIST? OF ANY?)

apoc.convert.toIntList(value) | tries it’s best to convert the value to a list of integers

function

apoc.convert.toInteger

apoc.convert.toInteger(object :: ANY?) :: (INTEGER?)

apoc.convert.toInteger(value) | tries it’s best to convert the value to an integer

function

apoc.convert.toJson

apoc.convert.toJson(value :: ANY?) :: (STRING?)

apoc.convert.toJson([1,2,3]) or toJson({a:42,b:"foo",c:[1,2,3]})

function

apoc.convert.toList

apoc.convert.toList(list :: ANY?) :: (LIST? OF ANY?)

apoc.convert.toList(value) | tries it’s best to convert the value to a list

function

apoc.convert.toMap

apoc.convert.toMap(map :: ANY?) :: (MAP?)

apoc.convert.toMap(value) | tries it’s best to convert the value to a map

function

apoc.convert.toNode

apoc.convert.toNode(node :: ANY?) :: (NODE?)

apoc.convert.toNode(value) | tries it’s best to convert the value to a node

function

apoc.convert.toNodeList

apoc.convert.toNodeList(list :: ANY?) :: (LIST? OF ANY?)

apoc.convert.toNodeList(value) | tries it’s best to convert the value to a list of nodes

function

apoc.convert.toRelationship

apoc.convert.toRelationship(relationship :: ANY?) :: (RELATIONSHIP?)

apoc.convert.toRelationship(value) | tries it’s best to convert the value to a relationship

function

apoc.convert.toRelationshipList

apoc.convert.toRelationshipList(list :: ANY?) :: (LIST? OF ANY?)

apoc.convert.toRelationshipList(value) | tries it’s best to convert the value to a list of relationships

function

apoc.convert.toSet

apoc.convert.toSet(list :: ANY?) :: (LIST? OF ANY?)

apoc.convert.toSet(value) | tries it’s best to convert the value to a set

function

apoc.convert.toSortedJsonMap

apoc.convert.toSortedJsonMap(value :: ANY?, ignoreCase = true :: BOOLEAN?) :: (STRING?)

apoc.convert.toSortedJsonMap(node|map, ignoreCase:true) - returns a JSON map with keys sorted alphabetically, with optional case sensitivity

function

apoc.convert.toString

apoc.convert.toString(string :: ANY?) :: (STRING?)

apoc.convert.toString(value) | tries it’s best to convert the value to a string

function

apoc.convert.toStringList

apoc.convert.toStringList(list :: ANY?) :: (LIST? OF ANY?)

apoc.convert.toStringList(value) | tries it’s best to convert the value to a list of strings

function

apoc.create.uuid

apoc.create.uuid() :: (STRING?)

apoc.create.uuid() - creates an UUID

function

apoc.create.vNode

apoc.create.vNode(label :: LIST? OF STRING?, props = {} :: MAP?) :: (NODE?)

apoc.create.vNode(['Label'], {key:value,…​}) returns a virtual node

function

apoc.create.vRelationship

apoc.create.vRelationship(from :: NODE?, relType :: STRING?, props :: MAP?, to :: NODE?) :: (RELATIONSHIP?)

apoc.create.vRelationship(nodeFrom,'KNOWS',{key:value,…​}, nodeTo) returns a virtual relationship

function

apoc.cypher.runFirstColumn

apoc.cypher.runFirstColumn(cypher :: STRING?, params :: MAP?, expectMultipleValues = true :: BOOLEAN?) :: (ANY?)

use either apoc.cypher.runFirstColumnMany for a list return or apoc.cypher.runFirstColumnSingle for returning the first row of the first column

function

apoc.cypher.runFirstColumnMany

apoc.cypher.runFirstColumnMany(cypher :: STRING?, params :: MAP?) :: (LIST? OF ANY?)

apoc.cypher.runFirstColumnMany(statement, params) - executes statement with given parameters, returns first column only collected into a list, params are available as identifiers

function

apoc.cypher.runFirstColumnSingle

apoc.cypher.runFirstColumnSingle(cypher :: STRING?, params :: MAP?) :: (ANY?)

apoc.cypher.runFirstColumnSingle(statement, params) - executes statement with given parameters, returns first element of the first column only, params are available as identifiers

function

apoc.data.domain

apoc.data.domain(url_or_email_address :: STRING?) :: (STRING?)

apoc.data.domain('url_or_email_address') YIELD domain - extract the domain name from a url or an email address. If nothing was found, yield null.

function

apoc.data.email

apoc.data.email(email_address :: STRING?) :: (MAP?)

apoc.data.email('email_address') as {personal,user,domain} - extract the personal name, user and domain as a map

function

apoc.data.url

apoc.data.url(url :: STRING?) :: (MAP?)

apoc.data.url('url') as {protocol,host,port,path,query,file,anchor,user} | turn URL into map structure

function

apoc.date.add

apoc.date.add(time :: INTEGER?, unit :: STRING?, addValue :: INTEGER?, addUnit :: STRING?) :: (INTEGER?)

apoc.date.add(12345, 'ms', -365, 'd') given a timestamp in one time unit, adds a value of the specified time unit

function

apoc.date.convert

apoc.date.convert(time :: INTEGER?, unit :: STRING?, toUnit :: STRING?) :: (INTEGER?)

apoc.date.convert(12345, 'ms', 'd') convert a timestamp in one time unit into one of a different time unit

function

apoc.date.convertFormat

apoc.date.convertFormat(temporal :: STRING?, currentFormat :: STRING?, convertTo = yyyy-MM-dd :: STRING?) :: (STRING?)

apoc.date.convertFormat('Tue, 14 May 2019 14:52:06 -0400', 'rfc_1123_date_time', 'iso_date_time') convert a String of one date format into a String of another date format.

function

apoc.date.currentTimestamp

apoc.date.currentTimestamp() :: (INTEGER?)

apoc.date.currentTimestamp() - returns System.currentTimeMillis()

function

apoc.date.field

apoc.date.field(time :: INTEGER?, unit = d :: STRING?, timezone = UTC :: STRING?) :: (INTEGER?)

apoc.date.field(12345,('ms|s|m|h|d|month|year'),('TZ')

function

apoc.date.fields

apoc.date.fields(date :: STRING?, pattern = yyyy-MM-dd HH:mm:ss :: STRING?) :: (MAP?)

apoc.date.fields('2012-12-23',('yyyy-MM-dd')) - return columns and a map representation of date parsed with the given format with entries for years,months,weekdays,days,hours,minutes,seconds,zoneid

function

apoc.date.format

apoc.date.format(time :: INTEGER?, unit = ms :: STRING?, format = yyyy-MM-dd HH:mm:ss :: STRING?, timezone = :: STRING?) :: (STRING?)

apoc.date.format(12345,('ms|s|m|h|d'),('yyyy-MM-dd HH:mm:ss zzz'),('TZ')) get string representation of time value optionally using the specified unit (default ms) using specified format (default ISO) and specified time zone (default current TZ)

function

apoc.date.fromISO8601

apoc.date.fromISO8601(time :: STRING?) :: (INTEGER?)

apoc.date.fromISO8601('yyyy-MM-ddTHH:mm:ss.SSSZ') return number representation of time in EPOCH format

function

apoc.date.parse

apoc.date.parse(time :: STRING?, unit = ms :: STRING?, format = yyyy-MM-dd HH:mm:ss :: STRING?, timezone = :: STRING?) :: (INTEGER?)

apoc.date.parse('2012-12-23','ms|s|m|h|d','yyyy-MM-dd') parse date string using the specified format into the specified time unit

function

apoc.date.systemTimezone

apoc.date.systemTimezone() :: (STRING?)

apoc.date.systemTimezone() returns the system timezone display name

function

apoc.date.toISO8601

apoc.date.toISO8601(time :: INTEGER?, unit = ms :: STRING?) :: (STRING?)

apoc.date.toISO8601(12345,('ms|s|m|h|d') return string representation of time in ISO8601 format

function

apoc.date.toYears

apoc.date.toYears(value :: ANY?, format = yyyy-MM-dd HH:mm:ss :: STRING?) :: (FLOAT?)

toYears(timestap) or toYears(date[,format]) converts timestamp into floating point years

function

apoc.diff.nodes

apoc.diff.nodes(leftNode :: NODE?, rightNode :: NODE?) :: (MAP?)

 

function

apoc.hashing.fingerprint

apoc.hashing.fingerprint(some object :: ANY?, propertyExcludes = [] :: LIST? OF STRING?) :: (STRING?)

calculate a checksum (md5) over a node or a relationship. This deals gracefully with array properties. Two identical entities do share the same hash.

function

apoc.hashing.fingerprintGraph

apoc.hashing.fingerprintGraph(propertyExcludes = [] :: LIST? OF STRING?) :: (STRING?)

calculate a checksum (md5) over a the full graph. Be aware that this function does use in-memomry datastructures depending on the size of your graph.

function

apoc.index.between.count

apoc.index.between.count(from :: NODE?, type :: STRING?, to :: NODE?, query :: STRING?) :: (INTEGER?)

apoc.index.between.count(node1,'TYPE',node2,'prop:value*') YIELD value - lucene query on relationship index with the given type name bound by either or both sides (each node parameter can be null)

function

apoc.index.in.count

apoc.index.in.count(to :: NODE?, type :: STRING?, query :: STRING?) :: (INTEGER?)

apoc.index.in.count(node1,'TYPE',node2,'prop:value*') YIELD value - lucene query on relationship index with the given type name for incoming relationship of the given node, returns count-start-nodes

function

apoc.index.nodes.count

apoc.index.nodes.count(label :: STRING?, query :: STRING?) :: (INTEGER?)

apoc.index.nodes.count('Label','prop:value*') YIELD value - lucene query on node index with the given label name

function

apoc.index.out.count

apoc.index.out.count(from :: NODE?, type :: STRING?, query :: STRING?) :: (INTEGER?)

apoc.index.out.count(node,'TYPE','prop:value*') YIELD value - lucene query on relationship index with the given type name for outgoing relationship of the given node, returns count-end-nodes

function

apoc.index.relationships.count

apoc.index.relationships.count(type :: STRING?, query :: STRING?) :: (INTEGER?)

apoc.index.relationships.count('Type','prop:value*') YIELD value - lucene query on relationship index with the given type name

function

apoc.json.path

apoc.json.path(json :: STRING?, path = $ :: STRING?) :: (ANY?)

apoc.json.path('{json}','json-path')

function

apoc.label.exists

apoc.label.exists(node :: ANY?, label :: STRING?) :: (BOOLEAN?)

apoc.label.exists(element, label) - returns true or false related to label existance

function

apoc.map.clean

apoc.map.clean(map :: MAP?, keys :: LIST? OF STRING?, values :: LIST? OF ANY?) :: (MAP?)

apoc.map.clean(map,[skip,keys],[skip,values]) yield map filters the keys and values contained in those lists, good for data cleaning from CSV/JSON

function

apoc.map.flatten

apoc.map.flatten(map :: MAP?, delimiter = . :: STRING?) :: (MAP?)

apoc.map.flatten(map, delimiter:'.') yield map - flattens nested items in map using dot notation

function

apoc.map.fromLists

apoc.map.fromLists(keys :: LIST? OF STRING?, values :: LIST? OF ANY?) :: (MAP?)

apoc.map.fromLists([keys],[values])

function

apoc.map.fromNodes

apoc.map.fromNodes(label :: STRING?, property :: STRING?) :: (MAP?)

apoc.map.fromNodes(label, property)

function

apoc.map.fromPairs

apoc.map.fromPairs(pairs :: LIST? OF LIST? OF ANY?) :: (MAP?)

apoc.map.fromPairs([[key,value],[key2,value2],…​])

function

apoc.map.fromValues

apoc.map.fromValues(values :: LIST? OF ANY?) :: (MAP?)

apoc.map.fromValues([key1,value1,key2,value2,…​])

function

apoc.map.get

apoc.map.get(map :: MAP?, key :: STRING?, value = null :: ANY?, fail = true :: BOOLEAN?) :: (ANY?)

apoc.map.get(map,key,[default],[fail=true]) - returns value for key or throws exception if key doesn’t exist and no default given

function

apoc.map.groupBy

apoc.map.groupBy(values :: LIST? OF ANY?, key :: STRING?) :: (MAP?)

apoc.map.groupBy([maps/nodes/relationships],'key') yield value - creates a map of the list keyed by the given property, with single values

function

apoc.map.groupByMulti

apoc.map.groupByMulti(values :: LIST? OF ANY?, key :: STRING?) :: (MAP?)

apoc.map.groupByMulti([maps/nodes/relationships],'key') yield value - creates a map of the list keyed by the given property, with list values

function

apoc.map.merge

apoc.map.merge(first :: MAP?, second :: MAP?) :: (MAP?)

apoc.map.merge(first,second) - merges two maps

function

apoc.map.mergeList

apoc.map.mergeList(maps :: LIST? OF MAP?) :: (MAP?)

apoc.map.mergeList([{maps}]) yield value - merges all maps in the list into one

function

apoc.map.mget

apoc.map.mget(map :: MAP?, keys :: LIST? OF STRING?, values = [] :: LIST? OF ANY?, fail = true :: BOOLEAN?) :: (LIST? OF ANY?)

apoc.map.mget(map,key,[defaults],[fail=true]) - returns list of values for keys or throws exception if one of the key doesn’t exist and no default value given at that position

function

apoc.map.removeKey

apoc.map.removeKey(map :: MAP?, key :: STRING?) :: (MAP?)

apoc.map.removeKey(map,key)

function

apoc.map.removeKeys

apoc.map.removeKeys(map :: MAP?, keys :: LIST? OF STRING?) :: (MAP?)

apoc.map.removeKeys(map,keys)

function

apoc.map.setEntry

apoc.map.setEntry(map :: MAP?, key :: STRING?, value :: ANY?) :: (MAP?)

apoc.map.setEntry(map,key,value)

function

apoc.map.setKey

apoc.map.setKey(map :: MAP?, key :: STRING?, value :: ANY?) :: (MAP?)

apoc.map.setKey(map,key,value)

function

apoc.map.setLists

apoc.map.setLists(map :: MAP?, keys :: LIST? OF STRING?, values :: LIST? OF ANY?) :: (MAP?)

apoc.map.setLists(map,[keys],[values])

function

apoc.map.setPairs

apoc.map.setPairs(map :: MAP?, pairs :: LIST? OF LIST? OF ANY?) :: (MAP?)

apoc.map.setPairs(map,[[key1,value1],[key2,value2])

function

apoc.map.setValues

apoc.map.setValues(map :: MAP?, pairs :: LIST? OF ANY?) :: (MAP?)

apoc.map.setValues(map,[key1,value1,key2,value2])

function

apoc.map.sortedProperties

apoc.map.sortedProperties(map :: MAP?, ignoreCase = true :: BOOLEAN?) :: (LIST? OF ANY?)

apoc.map.sortedProperties(map, ignoreCase:true) - returns a list of key/value list pairs, with pairs sorted by keys alphabetically, with optional case sensitivity

function

apoc.map.submap

apoc.map.submap(map :: MAP?, keys :: LIST? OF STRING?, values = [] :: LIST? OF ANY?, fail = true :: BOOLEAN?) :: (MAP?)

apoc.map.submap(map,keys,[defaults],[fail=true]) - returns submap for keys or throws exception if one of the key doesn’t exist and no default value given at that position

function

apoc.map.updateTree

apoc.map.updateTree(tree :: MAP?, key :: STRING?, data :: LIST? OF LIST? OF ANY?) :: (MAP?)

apoc.map.updateTree(tree,key,) returns map - adds the {data} map on each level of the nested tree, where the key-value pairs match

function

apoc.map.values

apoc.map.values(map :: MAP?, keys = [] :: LIST? OF STRING?, addNullsForMissing = false :: BOOLEAN?) :: (LIST? OF ANY?)

apoc.map.values(map, [key1,key2,key3,…​],[addNullsForMissing]) returns list of values indicated by the keys

function

apoc.math.maxByte

apoc.math.maxByte() :: (INTEGER?)

apoc.math.maxByte() | return the maximum value an byte can have

function

apoc.math.maxDouble

apoc.math.maxDouble() :: (FLOAT?)

apoc.math.maxDouble() | return the largest positive finite value of type double

function

apoc.math.maxInt

apoc.math.maxInt() :: (INTEGER?)

apoc.math.maxInt() | return the maximum value an int can have

function

apoc.math.maxLong

apoc.math.maxLong() :: (INTEGER?)

apoc.math.maxLong() | return the maximum value a long can have

function

apoc.math.minByte

apoc.math.minByte() :: (INTEGER?)

apoc.math.minByte() | return the minimum value an byte can have

function

apoc.math.minDouble

apoc.math.minDouble() :: (FLOAT?)

apoc.math.minDouble() | return the smallest positive nonzero value of type double

function

apoc.math.minInt

apoc.math.minInt() :: (INTEGER?)

apoc.math.minInt() | return the minimum value an int can have

function

apoc.math.minLong

apoc.math.minLong() :: (INTEGER?)

apoc.math.minLong() | return the minimum value a long can have

function

apoc.math.round

apoc.math.round(value :: FLOAT?, precision = 0 :: INTEGER?, mode = HALF_UP :: STRING?) :: (FLOAT?)

apoc.math.round(value,[prec],mode=[CEILING,FLOOR,UP,DOWN,HALF_EVEN,HALF_DOWN,HALF_UP,DOWN,UNNECESSARY])

function

apoc.meta.cypher.isType

apoc.meta.cypher.isType(value :: ANY?, type :: STRING?) :: (BOOLEAN?)

apoc.meta.cypher.isType(value,type) - returns a row if type name matches none if not (INTEGER,FLOAT,STRING,BOOLEAN,RELATIONSHIP,NODE,PATH,NULL,MAP,LIST OF <TYPE>,POINT,DATE,DATE_TIME,LOCAL_TIME,LOCAL_DATE_TIME,TIME,DURATION)

function

apoc.meta.cypher.type

apoc.meta.cypher.type(value :: ANY?) :: (STRING?)

apoc.meta.cypher.type(value) - type name of a value (INTEGER,FLOAT,STRING,BOOLEAN,RELATIONSHIP,NODE,PATH,NULL,MAP,LIST OF <TYPE>,POINT,DATE,DATE_TIME,LOCAL_TIME,LOCAL_DATE_TIME,TIME,DURATION)

function

apoc.meta.cypher.types

apoc.meta.cypher.types(properties :: ANY?) :: (MAP?)

apoc.meta.cypher.types(node-relationship-map) - returns a map of keys to types

function

apoc.meta.isType

apoc.meta.isType(value :: ANY?, type :: STRING?) :: (BOOLEAN?)

apoc.meta.isType(value,type) - returns a row if type name matches none if not (INTEGER,FLOAT,STRING,BOOLEAN,RELATIONSHIP,NODE,PATH,NULL,UNKNOWN,MAP,LIST)

function

apoc.meta.type

apoc.meta.type(value :: ANY?) :: (STRING?)

apoc.meta.type(value) - type name of a value (INTEGER,FLOAT,STRING,BOOLEAN,RELATIONSHIP,NODE,PATH,NULL,UNKNOWN,MAP,LIST)

function

apoc.meta.typeName

apoc.meta.typeName(value :: ANY?) :: (STRING?)

apoc.meta.typeName(value) - type name of a value (INTEGER,FLOAT,STRING,BOOLEAN,RELATIONSHIP,NODE,PATH,NULL,UNKNOWN,MAP,LIST)

function

apoc.meta.types

apoc.meta.types(properties :: ANY?) :: (MAP?)

apoc.meta.types(node-relationship-map) - returns a map of keys to types

function

apoc.node.degree

apoc.node.degree(node :: NODE?, types = :: STRING?) :: (INTEGER?)

apoc.node.degree(node, rel-direction-pattern) - returns total degrees of the given relationships in the pattern, can use '>' or '<' for all outgoing or incoming relationships

function

apoc.node.degree.in

apoc.node.degree.in(node :: NODE?, types = :: STRING?) :: (INTEGER?)

apoc.node.degree.in(node, relationshipName) - returns total number number of incoming relationships

function

apoc.node.degree.out

apoc.node.degree.out(node :: NODE?, types = :: STRING?) :: (INTEGER?)

apoc.node.degree.out(node, relationshipName) - returns total number number of outgoing relationships

function

apoc.node.id

apoc.node.id(node :: NODE?) :: (INTEGER?)

returns id for (virtual) nodes

function

apoc.node.labels

apoc.node.labels(node :: NODE?) :: (LIST? OF ANY?)

returns labels for (virtual) nodes

function

apoc.node.relationship.exists

apoc.node.relationship.exists(node :: NODE?, types = :: STRING?) :: (BOOLEAN?)

apoc.node.relationship.exists(node, rel-direction-pattern) - returns true when the node has the relationships of the pattern

function

apoc.node.relationship.types

apoc.node.relationship.types(node :: NODE?, types = :: STRING?) :: (LIST? OF ANY?)

apoc.node.relationship.types(node, rel-direction-pattern) - returns a list of distinct relationship types

function

apoc.node.relationships.exist

apoc.node.relationships.exist(node :: NODE?, types = :: STRING?) :: (MAP?)

apoc.node.relationships.exist(node, rel-direction-pattern) - returns a map with rel-pattern, boolean for the given relationship patterns

function

apoc.nodes.connected

apoc.nodes.connected(start :: NODE?, start :: NODE?, types = :: STRING?) :: (BOOLEAN?)

apoc.nodes.connected(start, end, rel-direction-pattern) - returns true when the node is connected to the other node, optimized for dense nodes

function

apoc.nodes.isDense

apoc.nodes.isDense(node :: NODE?) :: (BOOLEAN?)

apoc.nodes.isDense(node) - returns true if it is a dense node

function

apoc.number.arabicToRoman

apoc.number.arabicToRoman(number :: ANY?) :: (STRING?)

apoc.number.arabicToRoman(number) | convert arabic numbers to roman

function

apoc.number.exact.add

apoc.number.exact.add(stringA :: STRING?, stringB :: STRING?) :: (STRING?)

 

function

apoc.number.exact.div

apoc.number.exact.div(stringA :: STRING?, stringB :: STRING?, precision = 0 :: INTEGER?, roundingMode = HALF_UP :: STRING?) :: (STRING?)

 

function

apoc.number.exact.mul

apoc.number.exact.mul(stringA :: STRING?, stringB :: STRING?, precision = 0 :: INTEGER?, roundingMode = HALF_UP :: STRING?) :: (STRING?)

 

function

apoc.number.exact.sub

apoc.number.exact.sub(stringA :: STRING?, stringB :: STRING?) :: (STRING?)

 

function

apoc.number.exact.toExact

apoc.number.exact.toExact(number :: INTEGER?) :: (INTEGER?)

 

function

apoc.number.exact.toFloat

apoc.number.exact.toFloat(stringA :: STRING?, precision = 0 :: INTEGER?, roundingMode = HALF_UP :: STRING?) :: (FLOAT?)

 

function

apoc.number.exact.toInteger

apoc.number.exact.toInteger(stringA :: STRING?, precision = 0 :: INTEGER?, roundingMode = HALF_UP :: STRING?) :: (INTEGER?)

 

function

apoc.number.format

apoc.number.format(number :: ANY?, pattern = :: STRING?, lang = :: STRING?) :: (STRING?)

apoc.number.format(number) | format a long or double using the default system pattern and language to produce a string

function

apoc.number.parseFloat

apoc.number.parseFloat(text :: STRING?, pattern = :: STRING?, lang = :: STRING?) :: (FLOAT?)

apoc.number.parseFloat(text) | parse a text using the default system pattern and language to produce a double

function

apoc.number.parseInt

apoc.number.parseInt(text :: STRING?, pattern = :: STRING?, lang = :: STRING?) :: (INTEGER?)

apoc.number.parseInt(text) | parse a text using the default system pattern and language to produce a long

function

apoc.number.romanToArabic

apoc.number.romanToArabic(romanNumber :: STRING?) :: (NUMBER?)

apoc.number.romanToArabic(romanNumber) | convert roman numbers to arabic

function

apoc.path.combine

apoc.path.combine(first :: PATH?, second :: PATH?) :: (PATH?)

 

function

apoc.path.create

apoc.path.create(startNode :: NODE?, rels = [] :: LIST? OF RELATIONSHIP?) :: (PATH?)

 

function

apoc.path.elements

apoc.path.elements(path :: PATH?) :: (LIST? OF ANY?)

 

function

apoc.path.slice

apoc.path.slice(path :: PATH?, offset = 0 :: INTEGER?, length = -1 :: INTEGER?) :: (PATH?)

 

function

apoc.rel.id

apoc.rel.id(rel :: RELATIONSHIP?) :: (INTEGER?)

returns id for (virtual) relationships

function

apoc.rel.type

apoc.rel.type(rel :: RELATIONSHIP?) :: (STRING?)

returns type for (virtual) relationships

function

apoc.schema.node.constraintExists

apoc.schema.node.constraintExists(labelName :: STRING?, propertyName :: LIST? OF STRING?) :: (BOOLEAN?)

RETURN apoc.schema.node.constraintExists(labelName, propertyNames)

function

apoc.schema.node.indexExists

apoc.schema.node.indexExists(labelName :: STRING?, propertyName :: LIST? OF STRING?) :: (BOOLEAN?)

RETURN apoc.schema.node.indexExists(labelName, propertyNames)

function

apoc.schema.relationship.constraintExists

apoc.schema.relationship.constraintExists(type :: STRING?, propertyName :: LIST? OF STRING?) :: (BOOLEAN?)

RETURN apoc.schema.relationship.constraintExists(type, propertyNames)

function

apoc.scoring.existence

apoc.scoring.existence(score :: INTEGER?, exists :: BOOLEAN?) :: (FLOAT?)

apoc.scoring.existence(5, true) returns the provided score if true, 0 if false

function

apoc.scoring.pareto

apoc.scoring.pareto(minimumThreshold :: INTEGER?, eightyPercentValue :: INTEGER?, maximumValue :: INTEGER?, score :: INTEGER?) :: (FLOAT?)

apoc.scoring.pareto(10, 20, 100, 11) applies a Pareto scoring function over the inputs

function

apoc.static.get

apoc.static.get(key :: STRING?) :: (ANY?)

apoc.static.get(name) - returns statically stored value from config (apoc.static.<key>) or server lifetime storage

function

apoc.static.getAll

apoc.static.getAll(prefix :: STRING?) :: (MAP?)

apoc.static.getAll(prefix) - returns statically stored values from config (apoc.static.<prefix>.*) or server lifetime storage

function

apoc.temporal.format

apoc.temporal.format(temporal :: ANY?, format = yyyy-MM-dd :: STRING?) :: (STRING?)

apoc.temporal.format(input, format) | Format a temporal value

function

apoc.temporal.formatDuration

apoc.temporal.formatDuration(input :: ANY?, format :: STRING?) :: (STRING?)

apoc.temporal.formatDuration(input, format) | Format a Duration

function

apoc.text.base64Decode

apoc.text.base64Decode(text :: STRING?) :: (STRING?)

apoc.text.base64Decode(text) YIELD value - Decode Base64 encoded string

function

apoc.text.base64Encode

apoc.text.base64Encode(text :: STRING?) :: (STRING?)

apoc.text.base64Encode(text) YIELD value - Encode a string with Base64

function

apoc.text.base64UrlDecode

apoc.text.base64UrlDecode(url :: STRING?) :: (STRING?)

apoc.text.base64UrlDecode(url) YIELD value - Decode Base64 encoded url

function

apoc.text.base64UrlEncode

apoc.text.base64UrlEncode(url :: STRING?) :: (STRING?)

apoc.text.base64UrlEncode(text) YIELD value - Encode a url with Base64

function

apoc.text.byteCount

apoc.text.byteCount(text :: STRING?, charset = UTF-8 :: STRING?) :: (INTEGER?)

apoc.text.byteCount(text,[charset]) - return size of text in bytes

function

apoc.text.bytes

apoc.text.bytes(text :: STRING?, charset = UTF-8 :: STRING?) :: (LIST? OF ANY?)

apoc.text.bytes(text,[charset]) - return bytes of the text

function

apoc.text.camelCase

apoc.text.camelCase(text :: STRING?) :: (STRING?)

apoc.text.camelCase(text) YIELD value - Convert a string to camelCase

function

apoc.text.capitalize

apoc.text.capitalize(text :: STRING?) :: (STRING?)

apoc.text.capitalize(text) YIELD value - capitalise the first letter of the word

function

apoc.text.capitalizeAll

apoc.text.capitalizeAll(text :: STRING?) :: (STRING?)

apoc.text.capitalizeAll(text) YIELD value - capitalise the first letter of every word in the text

function

apoc.text.charAt

apoc.text.charAt(text :: STRING?, index :: INTEGER?) :: (INTEGER?)

apoc.text.charAt(text, index) - the decimal value of the character at the given index

function

apoc.text.clean

apoc.text.clean(text :: STRING?) :: (STRING?)

apoc.text.clean(text) - strip the given string of everything except alpha numeric characters and convert it to lower case.

function

apoc.text.code

apoc.text.code(codepoint :: INTEGER?) :: (STRING?)

apoc.text.code(codepoint) - Returns the unicode character of the given codepoint

function

apoc.text.compareCleaned

apoc.text.compareCleaned(text1 :: STRING?, text2 :: STRING?) :: (BOOLEAN?)

apoc.text.compareCleaned(text1, text2) - compare the given strings stripped of everything except alpha numeric characters converted to lower case.

function

apoc.text.decapitalize

apoc.text.decapitalize(text :: STRING?) :: (STRING?)

apoc.text.decapitalize(text) YIELD value - decapitalize the first letter of the word

function

apoc.text.decapitalizeAll

apoc.text.decapitalizeAll(text :: STRING?) :: (STRING?)

apoc.text.decapitalizeAll(text) YIELD value - decapitalize the first letter of all words

function

apoc.text.distance

apoc.text.distance(text1 :: STRING?, text2 :: STRING?) :: (INTEGER?)

apoc.text.distance(text1, text2) - compare the given strings with the Levenshtein distance algorithm.

function

apoc.text.doubleMetaphone

apoc.text.doubleMetaphone(value :: STRING?) :: (STRING?)

apoc.text.doubleMetaphone(value) yield value - Compute the Double Metaphone phonetic encoding of all words of the text value

function

apoc.text.format

apoc.text.format(text :: STRING?, params :: LIST? OF ANY?, language = en :: STRING?) :: (STRING?)

apoc.text.format(text,[params],language) - sprintf format the string with the params given

function

apoc.text.fuzzyMatch

apoc.text.fuzzyMatch(text1 :: STRING?, text2 :: STRING?) :: (BOOLEAN?)

apoc.text.fuzzyMatch(text1, text2) - check if 2 words can be matched in a fuzzy way. Depending on the length of the String it will allow more characters that needs to be edited to match the second String.

function

apoc.text.hammingDistance

apoc.text.hammingDistance(text1 :: STRING?, text2 :: STRING?) :: (INTEGER?)

apoc.text.hammingDistance(text1, text2) - compare the given strings with the Hamming distance algorithm.

function

apoc.text.hexCharAt

apoc.text.hexCharAt(text :: STRING?, index :: INTEGER?) :: (STRING?)

apoc.text.hexCharAt(text, index) - the hex value string of the character at the given index

function

apoc.text.hexValue

apoc.text.hexValue(value :: INTEGER?) :: (STRING?)

apoc.text.hexValue(value) - the hex value string of the given number

function

apoc.text.indexOf

apoc.text.indexOf(text :: STRING?, lookup :: STRING?, from = 0 :: INTEGER?, to = -1 :: INTEGER?) :: (INTEGER?)

apoc.text.indexOf(text, lookup, from=0, to=-1==len) - find the first occurence of the lookup string in the text, from inclusive, to exclusive, -1 if not found, null if text is null.

function

apoc.text.indexesOf

apoc.text.indexesOf(text :: STRING?, lookup :: STRING?, from = 0 :: INTEGER?, to = -1 :: INTEGER?) :: (LIST? OF ANY?)

apoc.text.indexesOf(text, lookup, from=0, to=-1==len) - finds all occurences of the lookup string in the text, return list, from inclusive, to exclusive, empty list if not found, null if text is null.

function

apoc.text.jaroWinklerDistance

apoc.text.jaroWinklerDistance(text1 :: STRING?, text2 :: STRING?) :: (FLOAT?)

apoc.text.jaroWinklerDistance(text1, text2) - compare the given strings with the Jaro-Winkler distance algorithm.

function

apoc.text.join

apoc.text.join(texts :: LIST? OF STRING?, delimiter :: STRING?) :: (STRING?)

apoc.text.join(['text1','text2',…​], delimiter) - join the given strings with the given delimiter.

function

apoc.text.levenshteinDistance

apoc.text.levenshteinDistance(text1 :: STRING?, text2 :: STRING?) :: (INTEGER?)

apoc.text.levenshteinDistance(text1, text2) - compare the given strings with the Levenshtein distance algorithm.

function

apoc.text.levenshteinSimilarity

apoc.text.levenshteinSimilarity(text1 :: STRING?, text2 :: STRING?) :: (FLOAT?)

apoc.text.levenshteinSimilarity(text1, text2) - calculate the similarity (a value within 0 and 1) between two texts.

function

apoc.text.lpad

apoc.text.lpad(text :: STRING?, count :: INTEGER?, delim = :: STRING?) :: (STRING?)

apoc.text.lpad(text,count,delim) YIELD value - left pad the string to the given width

function

apoc.text.phonetic

apoc.text.phonetic(value :: STRING?) :: (STRING?)

apoc.text.phonetic(text) yield value - Compute the US_ENGLISH phonetic soundex encoding of all words of the text

function

apoc.text.random

apoc.text.random(length :: INTEGER?, valid = A-Za-z0-9 :: STRING?) :: (STRING?)

apoc.text.random(length, valid) YIELD value - generate a random string

function

apoc.text.regexGroups

apoc.text.regexGroups(text :: STRING?, regex :: STRING?) :: (LIST? OF ANY?)

apoc.text.regexGroups(text, regex) - return all matching groups of the regex on the given text.

function

apoc.text.regreplace

apoc.text.regreplace(text :: STRING?, regex :: STRING?, replacement :: STRING?) :: (STRING?)

apoc.text.regreplace(text, regex, replacement) - replace each substring of the given string that matches the given regular expression with the given replacement.

function

apoc.text.replace

apoc.text.replace(text :: STRING?, regex :: STRING?, replacement :: STRING?) :: (STRING?)

apoc.text.replace(text, regex, replacement) - replace each substring of the given string that matches the given regular expression with the given replacement.

function

apoc.text.rpad

apoc.text.rpad(text :: STRING?, count :: INTEGER?, delim = :: STRING?) :: (STRING?)

apoc.text.rpad(text,count,delim) YIELD value - right pad the string to the given width

function

apoc.text.slug

apoc.text.slug(text :: STRING?, delim = - :: STRING?) :: (STRING?)

apoc.text.slug(text, delim) - slug the text with the given delimiter

function

apoc.text.snakeCase

apoc.text.snakeCase(text :: STRING?) :: (STRING?)

apoc.text.snakeCase(text) YIELD value - Convert a string to snake-case

function

apoc.text.sorensenDiceSimilarity

apoc.text.sorensenDiceSimilarity(text1 :: STRING?, text2 :: STRING?, languageTag = en :: STRING?) :: (FLOAT?)

apoc.text.sorensenDiceSimilarityWithLanguage(text1, text2, languageTag) - compare the given strings with the Sørensen–Dice coefficient formula, with the provided IETF language tag

function

apoc.text.split

apoc.text.split(text :: STRING?, regex :: STRING?, limit = 0 :: INTEGER?) :: (LIST? OF ANY?)

apoc.text.split(text, regex, limit) - splits the given text around matches of the given regex.

function

apoc.text.swapCase

apoc.text.swapCase(text :: STRING?) :: (STRING?)

apoc.text.swapCase(text) YIELD value - Swap the case of a string

function

apoc.text.toCypher

apoc.text.toCypher(value :: ANY?, config = {} :: MAP?) :: (STRING?)

apoc.text.toCypher(value, {skipKeys,keepKeys,skipValues,keepValues,skipNull,node,relationship,start,end}) | tries it’s best to convert the value to a cypher-property-string

function

apoc.text.toUpperCase

apoc.text.toUpperCase(text :: STRING?) :: (STRING?)

apoc.text.toUpperCase(text) YIELD value - Convert a string to UPPER_CASE

function

apoc.text.upperCamelCase

apoc.text.upperCamelCase(text :: STRING?) :: (STRING?)

apoc.text.upperCamelCase(text) YIELD value - Convert a string to camelCase

function

apoc.text.urldecode

apoc.text.urldecode(text :: STRING?) :: (STRING?)

apoc.text.urldecode(text) - return the urldecoded text

function

apoc.text.urlencode

apoc.text.urlencode(text :: STRING?) :: (STRING?)

apoc.text.urlencode(text) - return the urlencoded text

function

apoc.trigger.nodesByLabel

apoc.trigger.nodesByLabel(labelEntries :: ANY?, label :: STRING?) :: (LIST? OF ANY?)

 

function

apoc.trigger.propertiesByKey

apoc.trigger.propertiesByKey(propertyEntries :: MAP?, key :: STRING?) :: (LIST? OF ANY?)

 

function

apoc.util.md5

apoc.util.md5(values :: LIST? OF ANY?) :: (STRING?)

apoc.util.md5([values]) | computes the md5 of the concatenation of all string values of the list

function

apoc.util.sha1

apoc.util.sha1(values :: LIST? OF ANY?) :: (STRING?)

apoc.util.sha1([values]) | computes the sha1 of the concatenation of all string values of the list

function

apoc.util.sha256

apoc.util.sha256(values :: LIST? OF ANY?) :: (STRING?)

apoc.util.sha256([values]) | computes the sha256 of the concatenation of all string values of the list

function

apoc.util.sha384

apoc.util.sha384(values :: LIST? OF ANY?) :: (STRING?)

apoc.util.sha384([values]) | computes the sha384 of the concatenation of all string values of the list

function

apoc.util.sha512

apoc.util.sha512(values :: LIST? OF ANY?) :: (STRING?)

apoc.util.sha512([values]) | computes the sha512 of the concatenation of all string values of the list

function

apoc.version

apoc.version() :: (STRING?)

RETURN apoc.version() | return the current APOC installed version

function

apoc.xml.parse

apoc.xml.parse(data :: STRING?, path = / :: STRING?, config = {} :: MAP?, simple = false :: BOOLEAN?) :: (MAP?)

RETURN apoc.xml.parse(<xml string>, <xPath string>, config, false) AS value