Standard Functions

empty(())

exists(1 to 10)

foot(reverse(1 to 100))

head(1 to 100)

let $sort := sort(?, (), identity#1)
let $reverse-sort := sort(?, (), fn($x) { -$x })
return string-join((
  $sort((1, 5, 3, 2, 4)),
  '|',
  $reverse-sort((1, 5, 3, 2, 4))
))

map:for-each({ 1: 'one', 2: 'two' }, identity#1)

insert-before(1 to 3, 2, 'x')

head($input), tail($input) ! ($separator, .)

(1 to 3)
=> insert-separator('|')
=> string-join()

insert-separator((<_>1</_>, <_>2</_>, <_>3</_>), '; ')

for $pos in $at
return $input[$pos]

items-at(reverse(1 to 5), 1)

items-at(('one', 'two'), (2, 1))

items-at(('a', 'b'), 0)

remove(1 to 3, 2)

remove(1 to 5, (5, 3, 1))

replicate('A', 3)

let $nodes := replicate(<node/>, 2)
return $nodes[1] is $nodes[2]

reverse(1 to 5)

• If no start is specified, the sequence will start with the first item.
• If no end is specified, all remaining items are returned.
• If end is smaller than start, the items are returned in reverse order.
• If a negative start or end is specified, the counter starts from the end of the sequence.

slice(1 to 5, 3)

slice(1 to 5, 3, 4)

slice(1 to 10, -3)

slice(1 to 5, 4, 2)

slice(1 to 5, step := 2)

subsequence(1 to 10, 8)

subsequence(1 to 10, 3, 2)

subsequence(1 to 10, -1, 4)

tail(1 to 4)

trunk(reverse(1 to 4))

unordered(1 to 3)

void(fetch:binary('http://my.rest.service'))

atomic-equal(1, 1.0)

atomic-equal('a', xs:anyURI('a'))

atomic-equal(xs:double('NaN'), xs:double('NaN'))

atomic-equal(1, '1')

compare(1, 1.0)

compare(xs:double('NaN'), 0)

compare('a', 'A')

compare(
  'Strasse',
  'Straße',
  collation({ 'lang': 'de', 'strength': 'primary' })
)

compare(xs:hexBinary('41'), xs:base64Binary('QQ=='))

contains-subsequence(1 to 10, 4 to 6)

contains-subsequence(
  ('anna', 'berta', 'clara', 'dora'),
  ('CLARA', 'DORA'),
  fn($a, $b) { $a = lower-case($b) }
)

As BaseX is not schema-aware, all nodes have the same type annotations, and typed values are equal to string values. The options typed-values, type-annotations and type-variety are accepted and ignored.

deep-equal((), ())

deep-equal(1, 1.0)

deep-equal(
  <name sex='f' id='name1'>Sunita</name>,
  <name id="name1" sex="f">Sunita</name>
)

deep-equal((1, 2, 3), (3, 2, 1), { 'ordered': false() })

deep-equal('X', ' X ', { 'whitespace': 'normalize' })

deep-equal(sum#1, sum#2, {
  'items-equal': fn($a, $b) {
    if(($a, $b) instance of fn(*)*) {
      function-name($a) = function-name($b)
    }
  }
})

distinct-values((1, 2, 2, 3, 1))

distinct-values((2, 2.0e0, 2.0))

for $group in $values
group by $value := $group
where count($group) > 1
return $value

duplicate-values((1, 2, 3, 1.0, 1e0))

duplicate-values(1 to 100)

let $ids := duplicate-values(//@id)
where exists($ids)
return error((), 'Duplicate IDs found: ' || string-join($ids, ', '))

ends-with-subsequence(1 to 10, 8 to 10)

ends-with-subsequence(
  ('one', 'two', 'three'),
  ('t', 't'),
  starts-with#2
)

index-of((10, 20, 30, 20), 20)

starts-with-subsequence(1 to 10, 1 to 3)

starts-with-subsequence(
  1 to 10,
  ('a', 'bb', 'ccc'),
  fn($a, $b) { $a = string-length($b) }
)

exactly-one(1)

one-or-more(1 to 3)

zero-or-one(())

count(1 to 10)

all-equal((1, 1.0, 1e0))

all-equal((1, '1'))

all-equal(())

all-different(1 to 5)

all-different(())

avg(1 to 4)

max(1 to 10)

max(('Kafka', 'Camus', 'Tawada'))

min((3, 1.5, 2))

sum(1 to 100)

sum((), ())

apply(concat#5, array { 1 to 5 })

apply(fn($a) { sum($a) }, [ 1 to 5 ])

apply(substring#3, [ "abc", 2 ])

1. $action is called with $input and the result is adopted as new $input.
2. $predicate is called with $input. If the result is false, step 1 is repeated.
3. Otherwise, $input is returned.

do-until(
  (),
  fn($value, $pos) { $value, $pos * $pos },
  fn($value) { foot($value) > 50  }
)

do-until(
  (1, 0),
  fn($value) { $value[1] + $value[2], $value },
  fn($value) { avg($value) > 10 }
)

every(1 to 5)

every(1 to 5, fn { . > 3 })

every(())

declare function filter($input, $pred) {
  for-each(
    $input,
    fn($item) { if ($pred($item)) { $item } }
  )
};

An equivalent XQuery function is:

declare function filter(
  $input      as item()*,
  $predicate  as fn(item()) as xs:boolean?
) as item()* {
  $input[$predicate(.)]
};

filter(1 to 10, fn { . mod 2 eq 0 })

let $first-upper := fn($str) {
  let $first := substring($str, 1, 1)
  return $first eq upper-case($first)
}
return filter(('FooBar', 'foo', 'BAR'), $first-upper)

let $is-prime := fn($x) {
  $x gt 1 and (every $y in 2 to ($x - 1) satisfies $x mod $y != 0)
}
return filter(1 to 20, $is-prime)

$f($f($f($f($f(0, 1), 2), 3), 4), 5)

An equivalent XQuery function is:

declare function fold-left(
  $input   as item()*,
  $init    as item()*,
  $action  as fn(item()*, item()) as item()*
) as item()* {
  if (empty($input)) then $init
  else fold-left(
    tail($input),
    $action($init, head($input)),
    $action
  )
};

Note: Contrary to the official specification, the current position of the iteration can be retrieved via the third parameter of the higher-order function argument.

fold-left(1 to 5, 1, fn($result, $curr) { $result * $curr })

fold-left(1 to 5, '$seed',
  concat('$f(', ?, ', ', ?, ')')
)

let $from-digits := fold-left(?, 0,
  fn($n, $d) { 10 * $n + $d }
)
return (
  $from-digits(1 to 5),
  $from-digits((4, 2))
)

fold-left(
  1 to 10000000000,
  1,
  fn($n, $curr) { if($n > 100000) then $n else $n * $curr }
)

$f(1, $f(2, $f(3, $f(4, $f(5, 0)))))

Note that the order of the arguments of $fun are inverted compared to that in fn:fold-left:

declare function fold-right(
  $input   as item()*,
  $init    as item()*,
  $action  as fn(item(), item()*) as item()*
) as item()* {
  if (empty($input)) then $init
  else $action(
    head($input),
    fold-right(tail($input), $init, $action)
  )
};

Note: Contrary to the official specification, the current position of the iteration can be retrieved via the third parameter of the higher-order function argument.

fold-right(1 to 5, 1,
  fn($curr, $result) { $result * $curr }
)

fold-right(1 to 5, '$seed',
  concat('$f(', ?, ', ', ?, ')')
)

let $reverse := fold-right(?, (), fn($item, $rev) { $rev, $item })
return $reverse(1 to 5)

An equivalent XQuery function is:

declare function for-each(
  $input   as item()*,
  $action  as fn(item()) as item()*
) as item()* {
  for $item in $input
  return $action($item)
}

for-each(1 to 10, math:pow(?, 2))

let $fs := (
  upper-case#1,
  substring(?, 4),
  string-length#1
)
return for-each($fs, fn($f) { $f('foobar') })

("one", "two", "three") => for-each(upper-case(?))

An equivalent function is:

declare function for-each-pair(
  $input1  as item()*,
  $input2  as item()*,
  $action  as fn(item(), item()) as item()*
) as item()* {
  for $pos in 1 to min((count($input1), count($input2)))
  return $action($input1[$pos], $input2[$pos])
};

for-each-pair(
  for-each(1 to 10, fn { . mod 2 }),
  replicate(1, 5),
  fn($a, $b) { $a + $b }
)

let $number-words := fn($str) {
  string-join(
    for-each-pair(
      1 to 1000000000,
      tokenize($str, ' +'),
      concat(?, ': ', ?)
    ),
    ', '
  )
}
return $number-words('how are you?')

let $is-sorted := fn($input) {
  every $b in
    for-each-pair(
      $input,
      tail($input),
      fn($a, $b) { $a <= $b }
    )
  satisfies $b
}
return (
  $is-sorted(1 to 10),
  $is-sorted((1, 2, 42, 4, 5))
)

highest(8 to 12)

highest(98 to 102, key := string#1)

highest(1 to 7, (), fn { . idiv 3 })

index-where(
  (10, 11, 12, 14, 17, 21, 26),
  fn { . mod 2 = 0 }
)

index-where(
  (1, 8, 2, 7, 3),
  fn($item, $pos) { $item < 5 and $pos > 2 }
)

lowest(8 to 12)

lowest(98 to 102, key := string#1)

lowest(1 to 7, (), fn { . idiv 3 })

let $char-at := partial-apply(substring#3, { 3: 1 })
return $char-at("abc", 2)

partition((1 to 5), fn($seq) { count($seq) = 2 })

partition(
  ('Anita', 'Anne', 'Barbara', 'Catherine', 'Christine'), 
  fn($partition, $next) {
    substring(head($partition), 1, 1) ne substring($next, 1, 1)
  }
)

[ 'Anita', 'Anne' ],
[ 'Barbara' ],
[ 'Catherine', 'Christine' ]

some(-3 to 3)

some(1 to 5, fn { . > 3 })

some(())

sort(reverse(1 to 3))

reverse(sort(1 to 3))

sort((-2, 1, 3), key := abs#1)

sort($employees, (), fn { @name, @age })

sort((1, 'a'))

sort-by((-2, 1, 3), { 'key': abs#1 })

sort-by(1 to 3, { 'order': 'descending' })

sort-with((1, 4, 6, 5, 3), compare#2)

sort-with(
  (1, -2, 5, 10, -12, 8),
  fn($a, $b) { abs($a) - abs($b) }
)

let $persons := <persons>
  <person name='Josipa' age='8'/>
  <person name='Jade' age='6'/>
  <person name='Jie' age='8'/>
</persons>
return sort-with($persons/person, (
  fn($a, $b) { compare($a/@age, $b/@age) },
  fn($a, $b) { compare($a/@name, $b/@name) }
))

<person name="Jade" age="6"/>,
<person name="Jie" age="8"/>,
<person name="Josipa" age="8"/>

The function is equivalent to:

let $start := index-where($input, $from)[1]
  otherwise (count($input) + 1)
let $end   := index-where($input, $to)[. ge $start][1]
  otherwise (count($input) + 1)
return slice($input, $start, $end)

subsequence-where(1 to 5, fn { . >= 3 })

subsequence-where(1 to 5, fn { . >= 2 }, fn { . >= 4 })

let $drop-while := fn($input, $predicate) {
  subsequence-where($input, fn { not($predicate(.)) })
}
return $drop-while(1 to 5, fn { . <= 2 })

The function is equivalent to:

declare function take-while($input, $predicate, $pos := 1) {
  if(exists($input) and $predicate(head($input), $pos)) {
    head($input),
    take-while(tail($input), $predicate, $pos + 1)
  }
};

take-while((1, 5, 10, 20, 50, 100), fn { . <= 30 })

take-while(
  (1 to 100) ! random:integer(50),
  fn($item, $pos) { . >= 10 }
)

let $nodes := <xml>
  <node id='0'/>
  <node id='1' idref='0'/>
  <node id='2' idref='1'/>
  <node id='3' idref='1'/>
</xml>/node
return transitive-closure(
  head($nodes),
  fn($n) { $nodes[@idref = $n/@id] }
)

<node id='1' idref='0'/>,
<node id='2' idref='1'/>,
<node id='3' idref='1'/>

1. $predicate is called with $input.
2. If the result is true, $action is called with $input, the result is adopted as new $input, and step 2 is repeated.
3. Otherwise, $input is returned.

while-do(2, fn { . <= 100 }, fn { . * . })

while-do(
  1,
  fn($num, $pos) { $pos <= 10 },
  fn($num, $pos) { $num * $pos }
)

let $input := (0 to 4, 6 to 10)
return while-do(
  0,
  fn($n) { $n = $input },
  fn($n) { $n + 1 }
)

let $input := 3936256
return while-do(
  $input,
  fn($result) { abs($result * $result - $input) >= 0.0000000001 },
  fn($guess) { ($guess + $input div $guess) div 2 }
) => round(5)

true()

false()

boolean('Kafka')

boolean(''), boolean(())

not(true())

divide-decimals(10, 3)

divide-decimals(10, 7, 3)

abs(-3.5)

ceiling(2.1)

floor(2.9)

round(1.5)

round(15, -1)

round(9.9999, 1, 'floor')

round-half-to-even(2.5), round-half-to-even(3.5)

round-half-to-even(12345, -2)

is-NaN(0e0 div 0)

is-NaN('NaN')

number('3.5')

number('Kafka')

parse-integer('7B', 16)

parse-integer('11111111', 2)

parse-integer(' -1_000_000 ')

format-integer(123, '0')

format-integer(12, 'w')

format-integer(21, 'Ww;o', 'de')

format-integer(65535, '16^xxxx')

format-integer(15, '2^xxxx')

format-number(123, '0')

format-number(1.23, '0,0##', 'de')

format-number(1234, "0.000,0", { 'format-name': 'de' })

format-number(1010, '0^0', { 'exponent-separator': '^' })

format-number(1984.42, '00.0e0')

• number is a random double between 0 and 1
• next is a function that returns another random number generator
• permute is a function that returns a random permutation of its argument

let $rng := random-number-generator()
let $number := $rng?number
let $next-rng := $rng?next()
let $next-number := $next-rng?number
let $permutation := $rng?permute(1 to 5)
return ($number, $next-number, $permutation)

codepoints-to-string((72, 101, 108, 108, 111))

string-to-codepoints('AB')

codepoint-equal('Käthe', 'Ka' || char(0x308) || 'the')

collation({ 'language': 'de' })

collation({ 'language': 'de' })

for value $v in map:build(
  ('a', 'A', 'b'),
  collation-key(?, collation({ 'strength': 'primary' })),
  identity#1
)
return [ $v ]

[ "b" ]
[ ("a", "A") ]

contains-token(('a', 'b c', 'd'), 'c')

• a Unicode codepoint, supplied as an integer,
• an HTML5 character reference name, or
• the backslash-escape sequence \t, \n, \r, \b or \f.

char(65), char(0x41), char(0b01000001)

char('xcirc')

string-join(('auml', 'ouml', 'uuml', 'szlig') ! char(.))

string-to-codepoints(char('\t'))

for $cp in string-to-codepoints($value)
return codepoints-to-string($cp)

characters('AB')

graphemes("a" || char(0x308) || "b")

graphemes(char(0x1F476) || char(0x200D) || char(0x1F6D1))

graphemes(char('\r') || char('\n'))

concat('Gerhard', ' ', 'Richter')

concat(1 to 3)

concat()

string-join(1 to 3)

string-join(('one', 'two', 'three'), ', ')

• padding: string to pad with (default: ' '). It is repeated as often as required and cut to fit; it must not be empty.
• side: side on which the padding is added: end (default), start or both. With both, an odd padding character is appended at the end.

pad-string('abc', 6)

pad-string('abc', 6, { 'side': 'start' })

pad-string(42, 6, { 'padding': '0', 'side': 'start' })

pad-string('Chapter 1', 20, { 'padding': '.' })

pad-string('abcdef', 3)

substring('Camus', 2)

substring('Camus', 2, 3)

substring('Camus', 0, 3)

string-length('Kollwitz')

string-length('Ka' || char(0x308) || 'the')

normalize-space('  Mark   Rothko  ')

normalize-unicode('Ka' || char(0x308) || 'the') eq 'Käthe'

upper-case('Rothko')

lower-case('KAFKA')

translate('2026-07-28', '-', '/')

string(hash(''))

string(hash('', 'SHA-1'))

hash('', 'CRC-32') => string()

hash('BaseX', 'CRC-32') => string()

contains('Yoko Tawada', 'wad')

starts-with('Anselm Neft', 'Anselm')

ends-with('Mark Rothko', 'ko')

substring-before('Franz Kafka', ' ')

substring-after('Franz Kafka', ' ')

matches('Kafka', '^K')

replace('a1c', '\d', 'X')

replace('1aBc2', '[a-z]', 'X', 'i')

replace('1aBc2', '[a-z]', upper-case#1)

replace("Chapter 9", "[0-9]+", fn($match) { $match + 1 })

replace(
  "12°34′57″",
  "([0-9]+)°([0-9]+)′([0-9]+)″",
  fn($full-match, $groups) {
    message($full-match),
    ($groups[1] + $groups[2] ÷ 60 + $groups[3] ÷ 3600) || '°'
  }
)

tokenize('a b c')

tokenize('a, b,  c', ',\s*')

tokenize('a|b|c', '|', 'q')

analyze-string('Kafka 1924', '\d+')

matching-segments("The cat sat on the mat.", "\w+")?substring

matching-segments(
  "08-12-03",
  "^(\d+)\-(\d+)\-(\d+)$")?groups ! (?1?group, ?2?group, ?3?group
)

matching-segments("Chapter 5", "(Chapter|Appendix)(?=\s+([0-9]+))")?groups?2

matching-segments(
  "2026-06-25",
  "(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})"
)?groups?year?group

let $re := regex('\d+')
return $re?matches('Kafka 1924')

let $re := regex(',\s*')
return $re?tokenize('Kafka, Camus, Tawada')

decode-from-uri('S%C3%A3o%20Paulo%3F')

decode-from-uri('%00')

encode-for-uri('São Paulo?')

encode-for-uri('ABC123-~._ !"#<=>?')

escape-html-uri('http://basex.org/Käthe Kollwitz')

iri-to-uri('http://basex.org/Käthe Kollwitz')

resolve-uri('b.xml', 'http://basex.org/a/')

For a full description of behavior and the $options, see fn:parse-uri.

parse-uri("https://basex.org/download/")

{
  "uri": "https://basex.org/download/",
  "scheme": "https",
  "hierarchical": true(),
  "authority": "basex.org",
  "host": "basex.org",
  "path": "/download/",
  "path-segments": ("", "download", ""),
  "absolute": true()
}

For a full description of behavior and the $options, see fn:build-uri.

build-uri({
  "scheme": "https",
  "host": "docs.basex.org",
  "path": "/main"
})

years-from-duration(xs:yearMonthDuration('P2Y6M'))

months-from-duration(xs:yearMonthDuration('P2Y6M'))

days-from-duration(xs:dayTimeDuration('P3DT4H'))

hours-from-duration(xs:dayTimeDuration('P3DT4H'))

minutes-from-duration(xs:dayTimeDuration('PT90M'))

seconds-from-duration(xs:dayTimeDuration('PT1.5S'))

seconds(0)

seconds(86_400.1)

current-time() + seconds(100)

dateTime(xs:date('2026-07-28'), xs:time('14:30:00'))

build-dateTime({
  "year": 2026,
  "month": 4,
  "day": 8,
  "hours": 18,
  "minutes": 46,
  "seconds": 12,
  "timezone": xs:dayTimeDuration("PT2H")
})

unix-dateTime(0)

year-from-dateTime(xs:dateTime('2026-07-28T14:30:15.5'))

year-from-dateTime(xs:gYearMonth('2026-07'))

month-from-dateTime(xs:dateTime('2026-07-28T14:30:15.5'))

day-from-dateTime(xs:dateTime('2026-07-28T14:30:15.5'))

hours-from-dateTime(xs:dateTime('2026-07-28T14:30:15.5'))

minutes-from-dateTime(xs:dateTime('2026-07-28T14:30:15.5'))

seconds-from-dateTime(xs:dateTime('2026-07-28T14:30:15.5'))

timezone-from-dateTime(xs:dateTime('2026-07-28T14:30:00+02:00'))

year-from-date(xs:date('2026-07-28'))

month-from-date(xs:date('2026-07-28'))

day-from-date(xs:date('2026-07-28'))

timezone-from-date(xs:date('2026-07-28+02:00'))

hours-from-time(xs:time('14:30:15'))

minutes-from-time(xs:time('14:30:15'))

seconds-from-time(xs:time('14:30:15'))

timezone-from-time(xs:time('14:30:00+02:00'))

parts-of-dateTime(xs:dateTime('2026-04-08T18:46:12+02:00'))

adjust-dateTime-to-timezone(
  xs:dateTime('2026-07-28T14:30:00+02:00'),
  xs:dayTimeDuration('PT0S')
)

adjust-date-to-timezone(xs:date('2026-07-28'), xs:dayTimeDuration('PT2H'))

adjust-date-to-timezone(xs:date('2026-07-28+02:00'), ())

adjust-time-to-timezone(
  xs:time('14:30:00+02:00'),
  xs:dayTimeDuration('-PT5H')
)

civil-timezone(xs:dateTime('2001-01-01T11:11:11Z'))

civil-timezone(xs:dateTime('2001-07-01T11:11:11Z'))

let $dt := xs:dateTime('2024-07-01T01:01:01Z')
return adjust-dateTime-to-timezone($dt, civil-timezone($dt))

civil-timezone(xs:dateTime('2024-12-24T12:24:48'), 'Africa/Abidjan')

format-dateTime(xs:dateTime('2026-07-28T14:30:15.5'), '[H01]:[m01]')

format-date(xs:date('2026-07-28'), '[D1] [MNn] [Y]')

format-date(xs:date('2026-07-28'), '[D1]. [MNn] [Y]', 'de')

format-time(xs:time('14:30:00'), '[h].[m01] [PN]')

parse-ietf-date('28-Feb-1984 07:07:07')

parse-ietf-date('Wed, 01 Jun 2001 23:45:54 +02:00')

QName('http://basex.org/', 'p:a')

parse-QName('xml:node') => namespace-uri-from-QName()

let $qname := parse-QName('Q{http://gotcha.org/works}fine')
return string-join((
  namespace-uri-from-QName($qname),
  local-name-from-QName($qname)
), ': ')

resolve-QName('p:a', <e xmlns:p='http://basex.org/'/>)

prefix-from-QName(QName('http://basex.org/', 'p:a'))

local-name-from-QName(QName('http://basex.org/', 'p:a'))

namespace-uri-from-QName(QName('http://basex.org/', 'p:a'))

expanded-QName(xs:QName('country'))

expanded-QName(QName('http://eat.org/lunch', 'cake'))

base-uri(<a xml:base='http://basex.org/'/>)

document-uri(document { <a/> })

nilled(<a/>)

node-name(<xml/>)

string(<a>Kafka</a>)

data(<a>1</a>)

has-children(<a><b/></a>)

in-scope-namespaces(<xsi:a/>)

{
  "xsi": "http://www.w3.org/2001/XMLSchema-instance",
  "xml": "http://www.w3.org/XML/1998/namespace"
}

in-scope-prefixes(<a xmlns:p='http://basex.org/'/>)

lang('en', <a xml:lang='en-US'/>)

local-name(<p:a xmlns:p='http://basex.org/'/>)

name(<p:a xmlns:p='http://basex.org/'/>)

namespace-uri(<p:a xmlns:p='http://basex.org/'/>)

namespace-uri-for-prefix('p', <a xmlns:p='http://basex.org/'/>)

let $xml := document { <xml><a/></xml> }
return path($xml/xml/a, { 'indexes': false() })

let $xml := document {
  <xml xmlns='URI'><a/></xml>
}
let $namespaces := in-scope-namespaces($xml/*)
return path($xml/*:xml/*:a, { 'namespaces': $namespaces })

root(<a><b><c/></b></a>/b)

siblings(<xml><a/><b/><c/></xml>/b)

$nodes/self::node()
$nodes/.
$nodes union .
$nodes except ()

let $doc := <doc><b/><a/></doc>
return distinct-ordered-nodes(($doc/a, $doc/a, $doc/b))

let $xml := <a><b><c/></b></a>
return innermost(($xml, $xml//c))

let $xml := <a><b><c/></b></a>
return outermost(($xml, $xml//c))

id('x', document { <a><b xml:id='x'/></a> })

element-with-id('x', document { <a><b xml:id='x'/></a> })

idref('x', document { <a><b xml:id='x'/></a> })

let $node := <a/>
return generate-id($node) eq generate-id($node)

function-lookup(xs:QName('fn:abs'), 1)(-3)

function-name(true#0)

function-name(fn { . + 1 })

function-arity(true#0)

function-arity(fn { . + 1 })

function-identity({})

function-identity(abs#1)

declare
  %public
  %rest:GET
  %rest:path('/')
  %perm:allow('all')
function local:index($n) {
  <html>Welcome!</html>
};
function-annotations(local:index#1)

{ #xq:public: () },
{ #rest:GET: () },
{ #rest:path: '/' },
{ #perm:allow: 'all' }

let $add := fn($a, $b) { $a * $b }
let $double := %local:deprecated fn($a) { $a + $a }
for $ann in ($add, $double) =!> function-annotations()
where map:keys($ann) = #local:deprecated
return 'Deprecated function found.'

record(
  layout  as xs:string,
  child?  as xs:string?,
  type?   as enum('integer', 'decimal', 'double', 'boolean', 'string')
)

record(
  type  as enum('integer', 'decimal', 'double', 'boolean', 'string', 'skip')
)

element-to-map-plan(<a><b>3</b><b>4</b></a>)

{
  "a": {
    "layout": "list",
    "child": "b"
  },
  "b": {
    "layout": "simple",
    "type": "integer"
  }
}

element-to-map-plan((<a x="2">red</a>, <a x="3">blue</a>))

{
  "a": {
    "layout": "simple-plus"
  },
  "@x": {
    "type": "integer"
  }
}

let $plan := element-to-map-plan(
  <name><first>Jane</first><last>Smith</last></name>
)
return element-to-map(
  <name><first>John</first><last>Doe</last></name>,
  { 'plan': $plan }
)

{
  "name": {
    "first": "John",
    "last": "Doe"
  }
}

element-to-map(<foo>bar</foo>)

element-to-map(
  <name>
    <first>Jane</first>
    <last>Smith</last>
  </name>
)

element-to-map(
  <list>
    <item value='1'/>
    <item value='2'/>
  </list>,
  { 'attribute-marker': '' }
)

Calling jtree($X) is equivalent to the path expression $X/.: maps and arrays that appear as the left-hand operand of / are wrapped implicitly, so an explicit call is rarely needed.

jtree([ "a", "b", "c" ])/*[1]

jtree([ "a", "b" ])/* =!> jkey()

let $array := [ 1, 4.5, "eight", 10 ]
return $array/jnode(*, xs:integer) =!> jkey()

let $map := { 'Mo': 'Monday', 'Tu': 'Tuesday', 'We': 'Wednesday' }
return $map/(Mo|We|Fr|Su) =!> jkey()

let $array := [ [ 4, 18 ], [ 30, 4, 22 ] ]
return $array/descendant::*[. > 25]/ancestor-or-self::* =!> jkey()

let $array := [ 1, 3, 4.5, 7, "eight", 10 ]
return $array/jnode(*, xs:integer) =!> jvalue()

let $map := { 'Mo': 'Monday', 'Tu': 'Tuesday', 'We': 'Wednesday' }
return $map/(Mo|We|Fr|Su) =!> jvalue()

let $input := {
  "a": [ 10, 20 ],
  "b": ([ 30, 40 ], [], 0, [ 50 ])
}
return $input/b/* ! [ jposition(), jkey(), jvalue() ]

[ 1, 1, 30 ]
[ 1, 2, 40 ]
[ 4, 1, 50 ]

Retrieves and parses an XML document from a given URI and returns a document-node() item.

Within $options, the following keys can be specified:

Additionally, these BaseX XML Parsing options are supported, using lower-case option names:

doc('example.xml')

<root>
   <a> </a>
</root>

doc('example.xml', { 'strip-space': true() })

doc('book.xml', { 'xinclude': true(), 'trusted': true() })

Checks if an XML document can be retrieved and parsed from a given URI. Returns true if fn:doc($source, $options) would return a document node, and false otherwise.

The recognized options are the same as for fn:doc.

doc-available('https://example.org/example.xml')

collection('factbook')

uri-collection('factbook')

unparsed-text('notes.txt')

count(unparsed-text-lines('notes.txt'))

unparsed-text-available('notes.txt')

unparsed-binary('https://files.basex.org/releases/BaseX.jar')

• xpath-version: version of the supported XPath specification
• xsd-version: version of the supported XML Schema specification
• product-name: name of the product
• product-version: version of the product
• schema-aware: indicates whether schema-awareness is supported
• accepts-typed-data: indicates whether typed data is accepted
• supports-xinclude: indicates whether XInclude is supported
• supports-dtd: indicates whether DTDs are fully supported
• supports-invisible-xml: indicates whether Invisible XML is available
• supports-dynamic-xquery: indicates whether dynamic XQuery evaluation is supported
• supports-dynamic-xslt: indicates whether dynamic XSLT evaluation is supported

system-properties()?#product-name

system-properties()?#xpath-version

sort(map:keys(system-properties()) ! string())

environment-variable('PATH')

sort(available-environment-variables())

Parses a string as XML and returns a document-node() item.

If the $value is supplied as a binary (e.g., xs:base64Binary or xs:hexBinary), its encoding may be inferred from a byte order mark or an XML declaration. The input is then processed like a resource retrieved via fn:doc.

The recognized $options are the same as for fn:doc, with the following differences: the stable option does not apply; a base-uri can be supplied (defaulting to the static base URI of the function call); and xsd-validation does not support the values lax and type.

parse-xml('<Greeting>Hello, world!</Greeting>')

This function takes an XML fragment as a string or binary input and returns it as a document node.

If the $value is supplied as binary, its encoding is inferred as with fn:unparsed-text, and it is parsed as an external general parsed entity.

Within $options, the standard options are supported:

Additionally, this BaseX XML Parsing option is supported, using a lower-case option name:

parse-xml-fragment('<a/> <b/> <c/>')/node()

1. as a map…

   { "method": "xml", "cdata-section-elements": "div" }

2. or (for backward compliance) as an element:

   <output:serialization-parameters>
     <output:method value='xml'/>
     <output:cdata-section-elements value='div'/>
   </output:serialization-parameters>

serialize(1 to 3)

serialize(<xml id='1'></xml>)

serialize(<html/>, { 'method': 'html', 'html-version': 5.0 })

serialize({ 1: "one" }, { 'method': 'json' })

Assembles an XSD schema and returns a function that validates a document or element node against this schema. The returned function returns an empty sequence if the supplied node is empty. Otherwise, it returns a record with the field is-valid and, on demand, the validated node (typed-node) and details on the invalidities that were found (error-details).

The following $options are available:

As BaseX is not schema-aware, the returned node has no type annotations, and the options validation-mode (with the values lax and by-type), type and target-namespace are rejected with an error.

let $schema := <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
  <xs:element name='distance' type='xs:decimal'/>
</xs:schema>
let $validator := xsd-validator({ 'schema': $schema })
return (
  $validator(<distance>8.5</distance>)?is-valid,
  $validator(<distance>8.5km</distance>)?is-valid
)

With our custom html:parse function, additional conversion formats are available.

parse-html(
  '<!DOCTYPE html><html><head><meta charset="UTF-8"></head>' ||
  '<body>Hello, World!</body></html>'
)

<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta charset="UTF-8"/>
  </head>
  <body>Hello, World!</body>
</html>

The returned result is a document node whose root element is <html>, conforming to the HTML structure parsed from the input. The result is equivalent to reading the file as binary with unparsed-binary and parsing it via parse-html.

For more details and allowable options, see fn:html-doc.

With our custom html:doc function, additional parsing features are available.

html-doc('https://basex.org/download')//@href[contains(., '.zip')]!string()

With our custom json:parse function, additional conversion formats are available.

parse-json('{ "name": "john" }')

parse-json('[ 1, 2, 4, 8, 16 ]')

With our custom json:doc function, additional conversion formats are available.

json-doc("http://ip.jsontest.com/")?id

With our custom json:parse function, additional conversion formats are available.

json-to-xml('{ "message": "world" }')

document {
  <map xmlns="http://www.w3.org/2005/xpath-functions">
    <string key="message">world</string>
  </map>
}

The resulting string can also be created with our custom json:serialize function.

<map xmlns="http://www.w3.org/2005/xpath-functions">
  <string key="message">world</string>
</map>
=> xml-to-json()

With our custom csv:parse function, additional conversion formats are available.

csv-to-arrays(
  string-join(
    ('Name,City', 'Rossi,Rome', 'Da Silva,Rio de Janeiro'),
    char('\n')
  )
)

csv-to-arrays(
  string-join(('Product;Price', 'Laptop;1200', 'Mouse;25'), char('\n')),
  { 'separator': ';' }
)

• columns is a sequence of strings containing column names, if any
• column-index is a map from column names to (one-based) column positions
• rows is a sequence of arrays of strings representing the parsed rows of the CSV data
• get is a function that returns a field in the result that is identified by row and column. Its signature is function(xs:positiveInteger, (xs:positiveInteger | xs:string)) as xs:string? where the first argument is the (one-based) row number, and the second argument is the (one-based) column number or the column name.

For more details, and for the allowable options, see fn:parse-csv.

With our custom csv:parse function, additional conversion formats are available.

parse-csv(
  string-join(
    ('Name,City', 'Rossi,Rome', 'Da Silva,Rio de Janeiro'),
    char('\n')
  ),
  { 'header': true() }
)

{
  "columns": ("Name", "City"),
  "column-index": { "Name": 1, "City": 2},
  "rows": ([ "Rossi", "Rome" ], [ "Da Silva", "Rio de Janeiro" ]),
  "get": (anonymous-function)#2
}

parse-csv(
  string-join(('Laptop;1200', 'Mouse;25', 'Keyboard;45'), char('\n')),
  { 'separator': ';', 'header': ('Product', 'Price') }
)

{
  "columns": ("Product", "Price"),
  "column-index": { "Product": 1, "Price": 2},
  "rows": ([ "Laptop", "1200" ], [ "Mouse", "25" ], [ "Keyboard", "45" ]),
  "get": (anonymous-function)#2
}

The result is equivalent to reading the CSV file as binary using unparsed-binary and parsing the content with parse-csv. If the $source is the empty sequence, the function returns the empty sequence.

For more details and allowable options, see fn:csv-doc.

With our custom csv:doc function, additional conversion formats are available.

csv-doc('input.csv', { 'header': true() })

{
  "columns": ("Name", "Age"),
  "column-index": { "Name": 1, "Age": 2 },
  "rows": ([ "Alice", "30" ], [ "Bob", "25" ]),
  "get": (anonymous-function)#2
}

• columns holds the column names in a sequence of column elements (only present if there are column names)
• rows holds a sequence of row elements representing the rows of the CSV data. Each row has field elements with the field values. Their column attribute indicates the column name, if any

With our custom csv:parse function, additional conversion formats are available.

csv-to-xml(
  string-join(('Laptop;1200', 'Mouse;25', 'Keyboard;45'), char('\n')),
  { 'separator': ';', 'header': ('Product', 'Price') }
)

<csv xmlns="http://www.w3.org/2005/xpath-functions">
  <columns>
    <column>Product</column>
    <column>Price</column>
  </columns>
  <rows>
    <row>
      <field column="Product">Laptop</field>
      <field column="Price">1200</field>
    </row>
    <row>
      <field column="Product">Mouse</field>
      <field column="Price">25</field>
    </row>
    <row>
      <field column="Product">Keyboard</field>
      <field column="Price">45</field>
    </row>
  </rows>
</csv>

let $string := 'greeting: "Hello", " ", name. name: ["A"-"Z"], ["a"-"z"]+.'
return invisible-xml($string)('Hello World')

Loads an XQuery library module by its namespace URI and returns a map of its public functions and global variables.

Within $options, the following keys can be specified:

let $module := '
  module namespace m = "http://ex.org";
  declare %public function m:two() { 2 };'
let $functions := load-xquery-module(
  'http://ex.org',
  { 'content': $module }
)?functions
let $two := $functions(QName('http://ex.org', 'two'))?0
return $two()

let $uri := 'http://basex.org/modules/code'
let $functions := load-xquery-module(
  $uri,
  { 'location-hints': 'code.xqm' }
)?functions
let $run := $functions(QName($uri, 'run'))(0)
return $run()

Invokes an XSLT transformation and returns a map with the result documents. The key of the principal result document is the base output URI, or the string output; secondary result documents, generated by xsl:result-document, are returned under their own output URI. See XSLT Functions for the processors that can be used.

The following $options are available:

If Saxon is available, it is addressed via its s9api interface, and all options of the specification are supported. Otherwise, transformations are performed via Java’s JAXP interface: the options that cannot be assigned via this interface (initial-template, initial-mode, initial-function, global-context-item, initial-match-selection, static-params, template-params, tunnel-params, the package-* options) are rejected with an error, as is the delivery format raw, and secondary result documents are lost.

The options enable-trace and vendor-options are accepted and ignored, as are enable-assertions and enable-messages if the JAXP interface is used. Requested properties other than xsl:version are always rejected.

transform({
  'stylesheet-text':
    "<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
      version='1.0'><xsl:template match='/'><out><xsl:value-of
      select='//b'/></out></xsl:template></xsl:stylesheet>",
  'source-node': <a><b>89</b></a>
})?output

+ * - | || < <= = >= > != << >> is mod div idiv and or lt le eq ge gt ne to union intersect except otherwise

for-each-pair(1 to 3, 4  to 6, op('+'))

map:keys(map:filter(
  { 2: 1234, 3: 3, 4: 5678, 5: 5 },
  op('=')
))

schema-type(xs:QName('xs:integer'))?variety

schema-type(xs:QName('xs:integer'))?base-type()?name => string()

schema-type(xs:QName('xs:positiveInteger'))?constructor('42')
    instance of xs:positiveInteger

empty(schema-type(xs:QName('unknown-type')))

type-of('Hello')

type-of(1 to 10)

type-of((1, 'a'))

type-of(())

• name: QName of the type
• is-simple: indicates whether it is a simple type
• base-type: function returning the annotation of the base type
• primitive-type: function returning the annotation of the primitive type
• variety: variety of the type (atomic, list, union or mixed)
• members: function returning the annotations of the member types
• simple-content-type: function returning the annotation of the simple content type
• matches: function testing whether an atomic value is an instance of the type
• constructor: function constructing a value of the type

atomic-type-annotation(1e0)?variety

atomic-type-annotation(xs:byte(1))?base-type()?name => string()

atomic-type-annotation(1)?matches(2)

atomic-type-annotation(xs:byte(1))?constructor('127') instance of xs:byte

node-type-annotation(<a/>)?name => string()

node-type-annotation(attribute id { 1 })?name => string()

node-type-annotation(<a/>)?variety

current-date() eq current-date()

current-dateTime() eq current-dateTime()

current-time() eq current-time()

default-collation()

implicit-timezone()

('Kafka', 'Camus', 'Tawada')[last()]

(1 to 5)[position() gt 3]

static-base-uri()

error(xs:QName('err:FORG0001'), 'Wrong value')

'Hello' => trace() => void()