@neo4j-cypher/language-support
Version:
Cypher language support
1,634 lines (1,633 loc) • 1.61 MB
text/typescript
import { DbSchema } from '../dbSchema';
import { Neo4jFunction, Neo4jProcedure } from '../types';
const mockSchema: DbSchema = {
functions: {
abs: {
name: 'abs',
category: 'Numeric',
description: 'Returns the absolute value of an `INTEGER` or `FLOAT`.',
isBuiltIn: true,
argumentDescription: [
{
isDeprecated: false,
description: 'input :: INTEGER | FLOAT',
name: 'input',
type: 'INTEGER | FLOAT',
},
],
signature: 'abs(input :: INTEGER | FLOAT) :: INTEGER | FLOAT',
returnDescription: 'INTEGER | FLOAT',
aggregating: false,
},
acos: {
name: 'acos',
category: 'Trigonometric',
description: 'Returns the arccosine of a `FLOAT` in radians.',
isBuiltIn: true,
argumentDescription: [
{
isDeprecated: false,
description: 'input :: FLOAT',
name: 'input',
type: 'FLOAT',
},
],
signature: 'acos(input :: FLOAT) :: FLOAT',
returnDescription: 'FLOAT',
aggregating: false,
},
all: {
name: 'all',
category: 'Predicate',
description:
'Returns true if the predicate holds for all elements in the given `LIST<ANY>`.',
isBuiltIn: true,
argumentDescription: [
{
isDeprecated: false,
description: 'variable :: ANY',
name: 'variable',
type: 'ANY',
},
{
isDeprecated: false,
description: 'list :: LIST<ANY>',
name: 'list',
type: 'LIST<ANY>',
},
],
signature:
'all(variable :: VARIABLE IN list :: LIST<ANY> WHERE predicate :: ANY) :: BOOLEAN',
returnDescription: 'BOOLEAN',
aggregating: false,
},
any: {
name: 'any',
category: 'Predicate',
description:
'Returns true if the predicate holds for at least one element in the given `LIST<ANY>`.',
isBuiltIn: true,
argumentDescription: [
{
isDeprecated: false,
description: 'variable :: ANY',
name: 'variable',
type: 'ANY',
},
{
isDeprecated: false,
description: 'list :: LIST<ANY>',
name: 'list',
type: 'LIST<ANY>',
},
],
signature:
'any(variable :: VARIABLE IN list :: LIST<ANY> WHERE predicate :: ANY) :: BOOLEAN',
returnDescription: 'BOOLEAN',
aggregating: false,
},
'apoc.agg.first': {
name: 'apoc.agg.first',
category: '',
description: 'Returns the first value from the given collection.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'value :: ANY',
name: 'value',
type: 'ANY',
},
],
signature: 'apoc.agg.first(value :: ANY) :: ANY',
returnDescription: 'ANY',
aggregating: true,
},
'apoc.agg.graph': {
name: 'apoc.agg.graph',
category: '',
description:
'Returns all distinct `NODE` and `RELATIONSHIP` values collected into a `MAP` with the keys `nodes` and `relationships`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'path :: ANY',
name: 'path',
type: 'ANY',
},
],
signature: 'apoc.agg.graph(path :: ANY) :: MAP',
returnDescription: 'MAP',
aggregating: true,
},
'apoc.agg.last': {
name: 'apoc.agg.last',
category: '',
description: 'Returns the last value from the given collection.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'value :: ANY',
name: 'value',
type: 'ANY',
},
],
signature: 'apoc.agg.last(value :: ANY) :: ANY',
returnDescription: 'ANY',
aggregating: true,
},
'apoc.agg.maxItems': {
name: 'apoc.agg.maxItems',
category: '',
description:
'Returns a `MAP` `{items: LIST<ANY>, value: ANY}` where the `value` key is the maximum value present, and `items` represent all items with the same value. The size of the list of items can be limited to a given max size.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'items :: ANY',
name: 'items',
type: 'ANY',
},
{
isDeprecated: false,
description: 'value :: ANY',
name: 'value',
type: 'ANY',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=-1, type=INTEGER}',
description: 'groupLimit = -1 :: INTEGER',
name: 'groupLimit',
type: 'INTEGER',
},
],
signature:
'apoc.agg.maxItems(items :: ANY, value :: ANY, groupLimit = -1 :: INTEGER) :: ANY',
returnDescription: 'ANY',
aggregating: true,
},
'apoc.agg.median': {
name: 'apoc.agg.median',
category: '',
description:
'Returns the mathematical median for all non-null `INTEGER` and `FLOAT` values.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'value :: ANY',
name: 'value',
type: 'ANY',
},
],
signature: 'apoc.agg.median(value :: ANY) :: ANY',
returnDescription: 'ANY',
aggregating: true,
},
'apoc.agg.minItems': {
name: 'apoc.agg.minItems',
category: '',
description:
'Returns a `MAP` `{items: LIST<ANY>, value: ANY}` where the `value` key is the minimum value present, and `items` represent all items with the same value. The size of the list of items can be limited to a given max size.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'items :: ANY',
name: 'items',
type: 'ANY',
},
{
isDeprecated: false,
description: 'value :: ANY',
name: 'value',
type: 'ANY',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=-1, type=INTEGER}',
description: 'groupLimit = -1 :: INTEGER',
name: 'groupLimit',
type: 'INTEGER',
},
],
signature:
'apoc.agg.minItems(items :: ANY, value :: ANY, groupLimit = -1 :: INTEGER) :: ANY',
returnDescription: 'ANY',
aggregating: true,
},
'apoc.agg.nth': {
name: 'apoc.agg.nth',
category: '',
description:
'Returns the nth value in the given collection (to fetch the last item of an unknown length collection, -1 can be used).',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'value :: ANY',
name: 'value',
type: 'ANY',
},
{
isDeprecated: false,
description: 'offset :: INTEGER',
name: 'offset',
type: 'INTEGER',
},
],
signature: 'apoc.agg.nth(value :: ANY, offset :: INTEGER) :: ANY',
returnDescription: 'ANY',
aggregating: true,
},
'apoc.agg.percentiles': {
name: 'apoc.agg.percentiles',
category: '',
description:
'Returns the given percentiles over the range of numerical values in the given collection.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'value :: INTEGER | FLOAT',
name: 'value',
type: 'INTEGER | FLOAT',
},
{
isDeprecated: false,
default:
'DefaultParameterValue{value=[0.5, 0.75, 0.9, 0.95, 0.99], type=LIST<FLOAT>}',
description:
'percentiles = [0.5, 0.75, 0.9, 0.95, 0.99] :: LIST<FLOAT>',
name: 'percentiles',
type: 'LIST<FLOAT>',
},
],
signature:
'apoc.agg.percentiles(value :: INTEGER | FLOAT, percentiles = [0.5, 0.75, 0.9, 0.95, 0.99] :: LIST<FLOAT>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: true,
},
'apoc.agg.product': {
name: 'apoc.agg.product',
category: '',
description:
'Returns the product of all non-null `INTEGER` and `FLOAT` values in the collection.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'value :: INTEGER | FLOAT',
name: 'value',
type: 'INTEGER | FLOAT',
},
],
signature:
'apoc.agg.product(value :: INTEGER | FLOAT) :: INTEGER | FLOAT',
returnDescription: 'INTEGER | FLOAT',
aggregating: true,
},
'apoc.agg.slice': {
name: 'apoc.agg.slice',
category: '',
description:
'Returns a subset of non-null values from the given collection (the collection is considered to be zero-indexed).\nTo specify the range from start until the end of the collection, the length should be set to -1.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'value :: ANY',
name: 'value',
type: 'ANY',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=0, type=INTEGER}',
description: 'from = 0 :: INTEGER',
name: 'from',
type: 'INTEGER',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=-1, type=INTEGER}',
description: 'to = -1 :: INTEGER',
name: 'to',
type: 'INTEGER',
},
],
signature:
'apoc.agg.slice(value :: ANY, from = 0 :: INTEGER, to = -1 :: INTEGER) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: true,
},
'apoc.agg.statistics': {
name: 'apoc.agg.statistics',
category: '',
description:
'Returns the following statistics on the `INTEGER` and `FLOAT` values in the given collection: percentiles, min, minNonZero, max, total, mean, stdev.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'value :: INTEGER | FLOAT',
name: 'value',
type: 'INTEGER | FLOAT',
},
{
isDeprecated: false,
default:
'DefaultParameterValue{value=[0.5, 0.75, 0.9, 0.95, 0.99], type=LIST<FLOAT>}',
description:
'percentiles = [0.5, 0.75, 0.9, 0.95, 0.99] :: LIST<FLOAT>',
name: 'percentiles',
type: 'LIST<FLOAT>',
},
],
signature:
'apoc.agg.statistics(value :: INTEGER | FLOAT, percentiles = [0.5, 0.75, 0.9, 0.95, 0.99] :: LIST<FLOAT>) :: MAP',
returnDescription: 'MAP',
aggregating: true,
},
'apoc.any.isDeleted': {
name: 'apoc.any.isDeleted',
category: '',
description:
'Returns true if the given `NODE` or `RELATIONSHIP` no longer exists.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'object :: ANY',
name: 'object',
type: 'ANY',
},
],
signature: 'apoc.any.isDeleted(object :: ANY) :: BOOLEAN',
returnDescription: 'BOOLEAN',
aggregating: false,
},
'apoc.any.properties': {
name: 'apoc.any.properties',
category: '',
description:
'Returns all properties of the given object.\nThe object can be a virtual `NODE`, a real `NODE`, a virtual `RELATIONSHIP`, a real `RELATIONSHIP`, or a `MAP`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'object :: ANY',
name: 'object',
type: 'ANY',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=null, type=LIST<STRING>}',
description: 'keys = null :: LIST<STRING>',
name: 'keys',
type: 'LIST<STRING>',
},
],
signature:
'apoc.any.properties(object :: ANY, keys = null :: LIST<STRING>) :: MAP',
returnDescription: 'MAP',
aggregating: false,
},
'apoc.any.property': {
name: 'apoc.any.property',
category: '',
description:
'Returns the property for the given key from an object.\nThe object can be a virtual `NODE`, a real `NODE`, a virtual `RELATIONSHIP`, a real `RELATIONSHIP`, or a `MAP`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'object :: ANY',
name: 'object',
type: 'ANY',
},
{
isDeprecated: false,
description: 'key :: STRING',
name: 'key',
type: 'STRING',
},
],
signature: 'apoc.any.property(object :: ANY, key :: STRING) :: ANY',
returnDescription: 'ANY',
aggregating: false,
},
'apoc.bitwise.op': {
name: 'apoc.bitwise.op',
category: '',
description: 'Returns the result of the bitwise operation',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'a :: INTEGER',
name: 'a',
type: 'INTEGER',
},
{
isDeprecated: false,
description: 'operator :: STRING',
name: 'operator',
type: 'STRING',
},
{
isDeprecated: false,
description: 'b :: INTEGER',
name: 'b',
type: 'INTEGER',
},
],
signature:
'apoc.bitwise.op(a :: INTEGER, operator :: STRING, b :: INTEGER) :: INTEGER',
returnDescription: 'INTEGER',
aggregating: false,
},
'apoc.coll.avg': {
name: 'apoc.coll.avg',
category: '',
description:
'Returns the average of the numbers in the `LIST<INTEGER | FLOAT>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<INTEGER | FLOAT>',
name: 'coll',
type: 'LIST<INTEGER | FLOAT>',
},
],
signature: 'apoc.coll.avg(coll :: LIST<INTEGER | FLOAT>) :: FLOAT',
returnDescription: 'FLOAT',
aggregating: false,
},
'apoc.coll.combinations': {
name: 'apoc.coll.combinations',
category: '',
description:
'Returns a collection of all combinations of `LIST<ANY>` elements between the selection size `minSelect` and `maxSelect` (default: `minSelect`).',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'minSelect :: INTEGER',
name: 'minSelect',
type: 'INTEGER',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=-1, type=INTEGER}',
description: 'maxSelect = -1 :: INTEGER',
name: 'maxSelect',
type: 'INTEGER',
},
],
signature:
'apoc.coll.combinations(coll :: LIST<ANY>, minSelect :: INTEGER, maxSelect = -1 :: INTEGER) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.contains': {
name: 'apoc.coll.contains',
category: '',
description:
'Returns whether or not the given value exists in the given collection (using a HashSet).',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'value :: ANY',
name: 'value',
type: 'ANY',
},
],
signature:
'apoc.coll.contains(coll :: LIST<ANY>, value :: ANY) :: BOOLEAN',
returnDescription: 'BOOLEAN',
aggregating: false,
},
'apoc.coll.containsAll': {
name: 'apoc.coll.containsAll',
category: '',
description:
'Returns whether or not all of the given values exist in the given collection (using a HashSet).',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll1 :: LIST<ANY>',
name: 'coll1',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'coll2 :: LIST<ANY>',
name: 'coll2',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.containsAll(coll1 :: LIST<ANY>, coll2 :: LIST<ANY>) :: BOOLEAN',
returnDescription: 'BOOLEAN',
aggregating: false,
},
'apoc.coll.containsAllSorted': {
name: 'apoc.coll.containsAllSorted',
category: '',
description:
'Returns whether or not all of the given values in the second `LIST<ANY>` exist in an already sorted collection (using a binary search).',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll1 :: LIST<ANY>',
name: 'coll1',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'coll2 :: LIST<ANY>',
name: 'coll2',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.containsAllSorted(coll1 :: LIST<ANY>, coll2 :: LIST<ANY>) :: BOOLEAN',
returnDescription: 'BOOLEAN',
aggregating: false,
},
'apoc.coll.containsDuplicates': {
name: 'apoc.coll.containsDuplicates',
category: '',
description: 'Returns true if a collection contains duplicate elements.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.containsDuplicates(coll :: LIST<ANY>) :: BOOLEAN',
returnDescription: 'BOOLEAN',
aggregating: false,
},
'apoc.coll.containsSorted': {
name: 'apoc.coll.containsSorted',
category: '',
description:
'Returns whether or not the given value exists in an already sorted collection (using a binary search).',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'value :: ANY',
name: 'value',
type: 'ANY',
},
],
signature:
'apoc.coll.containsSorted(coll :: LIST<ANY>, value :: ANY) :: BOOLEAN',
returnDescription: 'BOOLEAN',
aggregating: false,
},
'apoc.coll.different': {
name: 'apoc.coll.different',
category: '',
description:
'Returns true if all the values in the given `LIST<ANY>` are unique.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.different(coll :: LIST<ANY>) :: BOOLEAN',
returnDescription: 'BOOLEAN',
aggregating: false,
},
'apoc.coll.disjunction': {
name: 'apoc.coll.disjunction',
category: '',
description: 'Returns the disjunct set from two `LIST<ANY>` values.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list1 :: LIST<ANY>',
name: 'list1',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'list2 :: LIST<ANY>',
name: 'list2',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.disjunction(list1 :: LIST<ANY>, list2 :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.dropDuplicateNeighbors': {
name: 'apoc.coll.dropDuplicateNeighbors',
category: '',
description: 'Removes duplicate consecutive objects in the `LIST<ANY>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list :: LIST<ANY>',
name: 'list',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.dropDuplicateNeighbors(list :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.duplicates': {
name: 'apoc.coll.duplicates',
category: '',
description:
'Returns a `LIST<ANY>` of duplicate items in the collection.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.duplicates(coll :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.duplicatesWithCount': {
name: 'apoc.coll.duplicatesWithCount',
category: '',
description:
'Returns a `LIST<ANY>` of duplicate items in the collection and their count, keyed by `item` and `count`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.duplicatesWithCount(coll :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.fill': {
name: 'apoc.coll.fill',
category: '',
description: 'Returns a `LIST<ANY>` with the given count of items.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'items :: STRING',
name: 'items',
type: 'STRING',
},
{
isDeprecated: false,
description: 'count :: INTEGER',
name: 'count',
type: 'INTEGER',
},
],
signature:
'apoc.coll.fill(items :: STRING, count :: INTEGER) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.flatten': {
name: 'apoc.coll.flatten',
category: '',
description:
'Flattens the given `LIST<ANY>` (to flatten nested `LIST<ANY>` values, set recursive to true).',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=false, type=BOOLEAN}',
description: 'recursive = false :: BOOLEAN',
name: 'recursive',
type: 'BOOLEAN',
},
],
signature:
'apoc.coll.flatten(coll :: LIST<ANY>, recursive = false :: BOOLEAN) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.frequencies': {
name: 'apoc.coll.frequencies',
category: '',
description:
'Returns a `LIST<ANY>` of frequencies of the items in the collection, keyed by `item` and `count`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.frequencies(coll :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.frequenciesAsMap': {
name: 'apoc.coll.frequenciesAsMap',
category: '',
description:
'Returns a `MAP` of frequencies of the items in the collection, keyed by `item` and `count`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.frequenciesAsMap(coll :: LIST<ANY>) :: MAP',
returnDescription: 'MAP',
aggregating: false,
},
'apoc.coll.indexOf': {
name: 'apoc.coll.indexOf',
category: '',
description:
'Returns the index for the first occurrence of the specified value in the `LIST<ANY>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'value :: ANY',
name: 'value',
type: 'ANY',
},
],
signature:
'apoc.coll.indexOf(coll :: LIST<ANY>, value :: ANY) :: INTEGER',
returnDescription: 'INTEGER',
aggregating: false,
},
'apoc.coll.insert': {
name: 'apoc.coll.insert',
category: '',
description:
'Inserts a value into the specified index in the `LIST<ANY>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'index :: INTEGER',
name: 'index',
type: 'INTEGER',
},
{
isDeprecated: false,
description: 'value :: ANY',
name: 'value',
type: 'ANY',
},
],
signature:
'apoc.coll.insert(coll :: LIST<ANY>, index :: INTEGER, value :: ANY) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.insertAll': {
name: 'apoc.coll.insertAll',
category: '',
description:
'Inserts all of the values into the `LIST<ANY>`, starting at the specified index.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'index :: INTEGER',
name: 'index',
type: 'INTEGER',
},
{
isDeprecated: false,
description: 'values :: LIST<ANY>',
name: 'values',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.insertAll(coll :: LIST<ANY>, index :: INTEGER, values :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.intersection': {
name: 'apoc.coll.intersection',
category: '',
description:
'Returns the distinct intersection of two `LIST<ANY>` values.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list1 :: LIST<ANY>',
name: 'list1',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'list2 :: LIST<ANY>',
name: 'list2',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.intersection(list1 :: LIST<ANY>, list2 :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.isEqualCollection': {
name: 'apoc.coll.isEqualCollection',
category: '',
description:
'Returns true if the two collections contain the same elements with the same cardinality in any order (using a HashMap).',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'values :: LIST<ANY>',
name: 'values',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.isEqualCollection(coll :: LIST<ANY>, values :: LIST<ANY>) :: BOOLEAN',
returnDescription: 'BOOLEAN',
aggregating: false,
},
'apoc.coll.max': {
name: 'apoc.coll.max',
category: '',
description:
'Returns the maximum of all values in the given `LIST<ANY>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'values :: LIST<ANY>',
name: 'values',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.max(values :: LIST<ANY>) :: ANY',
returnDescription: 'ANY',
aggregating: false,
},
'apoc.coll.min': {
name: 'apoc.coll.min',
category: '',
description:
'Returns the minimum of all values in the given `LIST<ANY>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'values :: LIST<ANY>',
name: 'values',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.min(values :: LIST<ANY>) :: ANY',
returnDescription: 'ANY',
aggregating: false,
},
'apoc.coll.occurrences': {
name: 'apoc.coll.occurrences',
category: '',
description: 'Returns the count of the given item in the collection.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'item :: ANY',
name: 'item',
type: 'ANY',
},
],
signature:
'apoc.coll.occurrences(coll :: LIST<ANY>, item :: ANY) :: INTEGER',
returnDescription: 'INTEGER',
aggregating: false,
},
'apoc.coll.pairWithOffset': {
name: 'apoc.coll.pairWithOffset',
category: '',
description: 'Returns a `LIST<ANY>` of pairs defined by the offset.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'offset :: INTEGER',
name: 'offset',
type: 'INTEGER',
},
],
signature:
'apoc.coll.pairWithOffset(coll :: LIST<ANY>, offset :: INTEGER) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.pairs': {
name: 'apoc.coll.pairs',
category: '',
description:
'Returns a `LIST<ANY>` of adjacent elements in the `LIST<ANY>` ([1,2],[2,3],[3,null]).',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list :: LIST<ANY>',
name: 'list',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.pairs(list :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.pairsMin': {
name: 'apoc.coll.pairsMin',
category: '',
description:
'Returns `LIST<ANY>` values of adjacent elements in the `LIST<ANY>` ([1,2],[2,3]), skipping the final element.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list :: LIST<ANY>',
name: 'list',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.pairsMin(list :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.partition': {
name: 'apoc.coll.partition',
category: '',
description:
'Partitions the original `LIST<ANY>` into a new `LIST<ANY>` of the given batch size.\nThe final `LIST<ANY>` may be smaller than the given batch size.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'batchSize :: INTEGER',
name: 'batchSize',
type: 'INTEGER',
},
],
signature:
'apoc.coll.partition(coll :: LIST<ANY>, batchSize :: INTEGER) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.randomItem': {
name: 'apoc.coll.randomItem',
category: '',
description:
'Returns a random item from the `LIST<ANY>`, or null on `LIST<NOTHING>` or `LIST<NULL>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.randomItem(coll :: LIST<ANY>) :: ANY',
returnDescription: 'ANY',
aggregating: false,
},
'apoc.coll.randomItems': {
name: 'apoc.coll.randomItems',
category: '',
description:
'Returns a `LIST<ANY>` of `itemCount` random items from the original `LIST<ANY>` (optionally allowing elements in the original `LIST<ANY>` to be selected more than once).',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'itemCount :: INTEGER',
name: 'itemCount',
type: 'INTEGER',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=false, type=BOOLEAN}',
description: 'allowRepick = false :: BOOLEAN',
name: 'allowRepick',
type: 'BOOLEAN',
},
],
signature:
'apoc.coll.randomItems(coll :: LIST<ANY>, itemCount :: INTEGER, allowRepick = false :: BOOLEAN) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.remove': {
name: 'apoc.coll.remove',
category: '',
description:
'Removes a range of values from the `LIST<ANY>`, beginning at position index for the given length of values.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'index :: INTEGER',
name: 'index',
type: 'INTEGER',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=1, type=INTEGER}',
description: 'length = 1 :: INTEGER',
name: 'length',
type: 'INTEGER',
},
],
signature:
'apoc.coll.remove(coll :: LIST<ANY>, index :: INTEGER, length = 1 :: INTEGER) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.removeAll': {
name: 'apoc.coll.removeAll',
category: '',
description:
'Returns the first `LIST<ANY>` with all elements also present in the second `LIST<ANY>` removed.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list1 :: LIST<ANY>',
name: 'list1',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'list2 :: LIST<ANY>',
name: 'list2',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.removeAll(list1 :: LIST<ANY>, list2 :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.runningTotal': {
name: 'apoc.coll.runningTotal',
category: '',
description: 'Returns an accumulative `LIST<INTEGER | FLOAT>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list :: LIST<INTEGER | FLOAT>',
name: 'list',
type: 'LIST<INTEGER | FLOAT>',
},
],
signature:
'apoc.coll.runningTotal(list :: LIST<INTEGER | FLOAT>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.set': {
name: 'apoc.coll.set',
category: '',
description: 'Sets the element at the given index to the new value.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'index :: INTEGER',
name: 'index',
type: 'INTEGER',
},
{
isDeprecated: false,
description: 'value :: ANY',
name: 'value',
type: 'ANY',
},
],
signature:
'apoc.coll.set(coll :: LIST<ANY>, index :: INTEGER, value :: ANY) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.shuffle': {
name: 'apoc.coll.shuffle',
category: '',
description: 'Returns the `LIST<ANY>` shuffled.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.shuffle(coll :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.sort': {
name: 'apoc.coll.sort',
category: '',
description: 'Sorts the given `LIST<ANY>` into ascending order.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.sort(coll :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.sortMaps': {
name: 'apoc.coll.sortMaps',
category: '',
description:
'Sorts the given `LIST<MAP<STRING, ANY>>` into descending order, based on the `MAP` property indicated by `prop`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list :: LIST<MAP>',
name: 'list',
type: 'LIST<MAP>',
},
{
isDeprecated: false,
description: 'prop :: STRING',
name: 'prop',
type: 'STRING',
},
],
signature:
'apoc.coll.sortMaps(list :: LIST<MAP>, prop :: STRING) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.sortMulti': {
name: 'apoc.coll.sortMulti',
category: '',
description:
'Sorts the given `LIST<MAP<STRING, ANY>>` by the given fields.\nTo indicate that a field should be sorted according to ascending values, prefix it with a caret (^).\nIt is also possible to add limits to the `LIST<MAP<STRING, ANY>>` and to skip values.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<MAP>',
name: 'coll',
type: 'LIST<MAP>',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=[], type=LIST<STRING>}',
description: 'orderFields = [] :: LIST<STRING>',
name: 'orderFields',
type: 'LIST<STRING>',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=-1, type=INTEGER}',
description: 'limit = -1 :: INTEGER',
name: 'limit',
type: 'INTEGER',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=0, type=INTEGER}',
description: 'skip = 0 :: INTEGER',
name: 'skip',
type: 'INTEGER',
},
],
signature:
'apoc.coll.sortMulti(coll :: LIST<MAP>, orderFields = [] :: LIST<STRING>, limit = -1 :: INTEGER, skip = 0 :: INTEGER) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.sortNodes': {
name: 'apoc.coll.sortNodes',
category: '',
description:
'Sorts the given `LIST<NODE>` by the property of the nodes into descending order.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<NODE>',
name: 'coll',
type: 'LIST<NODE>',
},
{
isDeprecated: false,
description: 'prop :: STRING',
name: 'prop',
type: 'STRING',
},
],
signature:
'apoc.coll.sortNodes(coll :: LIST<NODE>, prop :: STRING) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.sortText': {
name: 'apoc.coll.sortText',
category: '',
description: 'Sorts the given `LIST<STRING>` into ascending order.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<STRING>',
name: 'coll',
type: 'LIST<STRING>',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value={}, type=MAP}',
description: 'conf = {} :: MAP',
name: 'conf',
type: 'MAP',
},
],
signature:
'apoc.coll.sortText(coll :: LIST<STRING>, conf = {} :: MAP) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.stdev': {
name: 'apoc.coll.stdev',
category: '',
description:
'Returns sample or population standard deviation with `isBiasCorrected` true or false respectively.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list :: LIST<INTEGER | FLOAT>',
name: 'list',
type: 'LIST<INTEGER | FLOAT>',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=true, type=BOOLEAN}',
description: 'isBiasCorrected = true :: BOOLEAN',
name: 'isBiasCorrected',
type: 'BOOLEAN',
},
],
signature:
'apoc.coll.stdev(list :: LIST<INTEGER | FLOAT>, isBiasCorrected = true :: BOOLEAN) :: INTEGER | FLOAT',
returnDescription: 'INTEGER | FLOAT',
aggregating: false,
},
'apoc.coll.subtract': {
name: 'apoc.coll.subtract',
category: '',
description:
'Returns the first `LIST<ANY>` as a set with all the elements of the second `LIST<ANY>` removed.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list1 :: LIST<ANY>',
name: 'list1',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'list2 :: LIST<ANY>',
name: 'list2',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.subtract(list1 :: LIST<ANY>, list2 :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.sum': {
name: 'apoc.coll.sum',
category: '',
description:
'Returns the sum of all the `INTEGER | FLOAT` in the `LIST<INTEGER | FLOAT>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<INTEGER | FLOAT>',
name: 'coll',
type: 'LIST<INTEGER | FLOAT>',
},
],
signature: 'apoc.coll.sum(coll :: LIST<INTEGER | FLOAT>) :: FLOAT',
returnDescription: 'FLOAT',
aggregating: false,
},
'apoc.coll.sumLongs': {
name: 'apoc.coll.sumLongs',
category: '',
description:
'Returns the sum of all the `INTEGER | FLOAT` in the `LIST<INTEGER | FLOAT>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<INTEGER | FLOAT>',
name: 'coll',
type: 'LIST<INTEGER | FLOAT>',
},
],
signature: 'apoc.coll.sumLongs(coll :: LIST<INTEGER | FLOAT>) :: INTEGER',
returnDescription: 'INTEGER',
aggregating: false,
},
'apoc.coll.toSet': {
name: 'apoc.coll.toSet',
category: '',
description: 'Returns a unique `LIST<ANY>` from the given `LIST<ANY>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'coll :: LIST<ANY>',
name: 'coll',
type: 'LIST<ANY>',
},
],
signature: 'apoc.coll.toSet(coll :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.union': {
name: 'apoc.coll.union',
category: '',
description:
'Returns the distinct union of the two given `LIST<ANY>` values.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list1 :: LIST<ANY>',
name: 'list1',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'list2 :: LIST<ANY>',
name: 'list2',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.union(list1 :: LIST<ANY>, list2 :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.unionAll': {
name: 'apoc.coll.unionAll',
category: '',
description:
'Returns the full union of the two given `LIST<ANY>` values (duplicates included).',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list1 :: LIST<ANY>',
name: 'list1',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'list2 :: LIST<ANY>',
name: 'list2',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.unionAll(list1 :: LIST<ANY>, list2 :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.coll.zip': {
name: 'apoc.coll.zip',
category: '',
description:
'Returns the two given `LIST<ANY>` values zipped together as a `LIST<LIST<ANY>>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list1 :: LIST<ANY>',
name: 'list1',
type: 'LIST<ANY>',
},
{
isDeprecated: false,
description: 'list2 :: LIST<ANY>',
name: 'list2',
type: 'LIST<ANY>',
},
],
signature:
'apoc.coll.zip(list1 :: LIST<ANY>, list2 :: LIST<ANY>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.convert.fromJsonList': {
name: 'apoc.convert.fromJsonList',
category: '',
description: 'Converts the given JSON list into a Cypher `LIST<STRING>`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'list :: STRING',
name: 'list',
type: 'STRING',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=, type=STRING}',
description: 'path = :: STRING',
name: 'path',
type: 'STRING',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=null, type=LIST<STRING>}',
description: 'pathOptions = null :: LIST<STRING>',
name: 'pathOptions',
type: 'LIST<STRING>',
},
],
signature:
'apoc.convert.fromJsonList(list :: STRING, path = :: STRING, pathOptions = null :: LIST<STRING>) :: LIST<ANY>',
returnDescription: 'LIST<ANY>',
aggregating: false,
},
'apoc.convert.fromJsonMap': {
name: 'apoc.convert.fromJsonMap',
category: '',
description: 'Converts the given JSON map into a Cypher `MAP`.',
isBuiltIn: false,
argumentDescription: [
{
isDeprecated: false,
description: 'map :: STRING',
name: 'map',
type: 'STRING',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=, type=STRING}',
description: 'path = :: STRING',
name: 'path',
type: 'STRING',
},
{
isDeprecated: false,
default: 'DefaultParameterValue{value=null, type=LIST<STRING>}',
description: 'pathOptions = null :: LIST<STRING>',
name: 'pathOptions',
type: 'LIST<STRING>',
},
],
signature:
'apoc.convert.fromJsonMap(map :: STRING, path = :: STRING, pathOptions = null :: LIST<STRING>) :: MAP',
returnDescription: 'MAP',
aggregating: false,
},
'apoc.convert.getJsonProperty': {
name: 'apoc.convert.getJsonPro