XQuery 3.1 Requirements and Use Cases

for $e in doc("employees.xml")/employees/employee,
    $d in $e/department
group by $d
return
   <department name="{$d}">
     {
       let $max := max($e/salary)
       return $e[salary=$max]
     }
   </department>

for $e in doc("employees.xml")/employees/employee,
    $d in $e/department
group by $d
return
   map {
     "department" : $d,
     "highest paid employee" :
       let $max := max($e/salary)
       return $e[salary=$max]
   } 

for $employee in doc("employees.xml")/*/employee
let $salary := $employee/salary
group by $department := $employee/department
let $max-salary := max($salary)
let $highest-earners := $employee[salary = $max-salary]
return
   <department name="{$department}">{ $highest-earners }</department>,

for $employee in doc("employees.xml")/*/employee
let $salary := $employee/salary
group by $job-type := $employee/job-type
let $totals := count($employee)
return
   <total-by-job-type type="{$job-type}">{ $totals }</total-by-job-type>

	  

for $employee in doc("employees.xml")/*/employee
let $salary := $employee/salary
group by $department := $employee/department
let $max-salary := max($salary)
let $highest-earners := $employee[salary = $max-salary]
return
   map { 
     "department" : $department,
     "highest earners" : $highest-earners 
   }
,
for $employee in doc("employees.xml")/*/employee
let $salary := $employee/salary
group by $job-type := $employee/job-type
let $totals := count($employee)
return
   map {
      "job type" : $job-type,
      "count(employee)" : $totals
   }

<gnt>
<s>
 <w pos="PP">I</w>
 <w pos="V" lemma="go">go</w>
 <pu>.</pu>
</s>
<s>
 <w pos="PP">She</w>
 <w pos="V" lemma="go">went</w>
 <pu>.</pu>
</s>
<s>
 <w pos="PP">He</w>
 <w pos="V" lemma="go">goes</w>
 <pu>.</pu>
</s>
<s>
 <w pos="PP">I</w>
 <w pos="V" lemma="see">see</w>
 <pu>.</pu>
</s>
<s>
 <w pos="PP">She</w>
 <w pos="V" lemma="see">sees</w>
 <pu>.</pu>
</s>
<s>
 <w pos="PP">I</w>
 <w pos="V" lemma="have">have</w>
 <pu>.</pu>
</s>
<s>
 <w pos="PP">She</w>
 <w pos="V" lemma="have">has</w>
 <pu>.</pu>
</s>
</gnt>

<verb lemma="go" count="3"/>
<verb lemma="see" count="2"/>
<verb lemma="have" count="2"/>

for $word in doc("gnt.xml")//w
let $lemma := $word/@lemma
where m:is-verb($word)
group by $lemma
order by count($word) descending
return
  <verb lemma="{ $lemma }" count="{count($word)}" />

for $word in doc("gnt.xml")//w
let $lemma := $word/@lemma
where m:is-verb($word)
group by $lemma
order by count($word) descending
return
  map { 
   "lemma" :  $lemma,
   "count" : count($word)
  }

declare function i:complex(
  $real as xs:double,
  $imaginary as xs:double
) as map(xs:boolean, xs:double)
{
  map { true() : $real, false() : $imaginary }
};

declare function i:real(
  $complex as map(xs:boolean, xs:double)
) as xs:double
{
  $complex(true())
};

declare function i:imaginary(
  $complex as map(xs:boolean, xs:double)
) as xs:double
{
  $complex(false())
};

declare function i:add(
  $arg1 as map(xs:boolean, xs:double),
  $arg2 as map(xs:boolean, xs:double)
) as map(xs:boolean, xs:double)
}
  i:complex(i:real($arg1)+i:real($arg2),
  i:imaginary($arg1)+i:imaginary($arg2))
};

declare function i:multiply(
  $arg1 as map(xs:boolean, xs:double),
  $arg2 as map(xs:boolean, xs:double)
) as map(xs:boolean, xs:double)
{
  i:complex(
    i:real($arg1)*i:real($arg2) - i:imaginary($arg1)*i:imaginary($arg2),
    i:real($arg1)*i:imaginary($arg2) + i:imaginary($arg1)*i:real($arg2))
};

i:add(i:complex(2, 3), i:complex(1, -6)),
i:multiply(i:complex(2, -1), i:complex(3, 4))

{ "true" : 3, "false" : -3 },
{ "true" : 10, "false" : 5 }

<book>
<isbn>0470192747</isbn>
<publisher>Wiley</publisher>
<title>XSLT 2.0 and XPath 2.0 Programmer's Reference</title>
</book>

<author>
<name>Michael H. Kay</name>
<isbn>0470192747</isbn>
<isbn>...</isbn>
</author>

declare variable $index := map:merge( //book ! map { isbn : . });

<table>{
  for $a in //author
  return <tr>
    <td>{ $a/name/string() }</td>
    <td>{ string-join($a/isbn ! $index(.)/title/string(), ", ") }</td>
  </tr>
}</table>

<customer id="c123">...</customer>
<product id="p789">...</product>
<order customer="c123" product="p789">...</order>

<customer id="c123">
<order product="p789">...</order>
</customer>
<product id="p789">...</product>

<customer id="c123">...</customer>
<product id="p789">
<order customer id="c123">...</order>
</product>

declare variable $flat-input-functions := 
  map {
    'orders-for-customer' : 
       function($c as element(customer)) as element(order)* { $c/../order[@customer=$c/@id] },
    'orders-for-product' : 
       function($p as element(product)) as element(order)* { $p/../order[@product=$p/@id] },
    'customer-for-order' : 
       function($o as element(order)) as element(customer) { $o/../customer[@id=$o/@customer] },
    'product-for-order' : 
       function($o as element(order)) as element(product) { $o/../product[@id=$o/@product] }
  };

(: General interface module :)

module namespace this="http://example.com/search-interface/";

declare function this:search(
    $words as xs:string*, $collection as map(xs:string, function(*)))
{
  for $d in $collection('select')[. contains text {$words} any word]
  order by $collection('score', $d, $words)
  count $c
  where $c <= 10
  return $collection('snippet', $d, $words)
};

(: Specific implementation example :)

import module namespace s="http://example.com/search-interface/";

declare variable $twitter as map(xs:string, function(*)) :=
  map {
    'select' : 
       function() as node()* { collection("twitter") },
    'score' : 
       function($n as node(), $words as xs:string*) as xs:double
        { 
          let score $s1 := $n contains text {$words} any word
          let score $s2 := $n contains text {$words} all words
          return $s1 + $s2
        },
    'snippet' : 
       function($node as node(), $words as xs:string*) as node() { $node }
  };

declare variable $blog as map(xs:string, function(*)) :=
  map {
    'select' : 
       function() as node()* { collection("blogs")/body },
    'score' : 
       function($n as node(), $words as xs:string*) as xs:double
        {
          let $s1 := avg(
            for $p score $s in $n/para[. contains text {$words} any word]
            return $s
          )
          let $s2 := avg(
            for $p score $s in $n/comment[. contains text {$words} weight 0.5 any word]
            return $s
          )
          let score $s3 := $n/title contains text {$words} weight 5.0 any word
          return $s1 + $s2 + $s3
        },
    'snippet' : 
       function($node as node(), $words as xs:string*) as node()
        { 
          <result>
           {
             $node/title, $node/para[1], $node/comment[1]
           }
          </result>  
        }
  };

declare variable $books as map(xs:string, function(*)) :=
  map {
   'select' : 
      function() as node()* { collection()//chapter },
   'score' : 
      function($n as node(), $words as xs:string*) as xs:double
        { 
          let score $s1 := $n contains text {$words} any word
          let score $s2 := $n/title contains text {$words} weight 5.0 any word
          return $s1 + $s2
          },
   'snippet' : 
      function($node as node(), $words as xs:string*) as node()
       { 
         <result>
          {
            $node/title,
            ((for $p score $s in $node/p[. contains text {$words} all words]
              order by $s
              return $p),
             (for $p score $s in $node/p[. contains text {$words} any word]
              order by $s
              return $p))[1]
          }
         </result> 
       }
  };

(: Get top 10 from various sources :)
s:search(("fire","earthquake"),$books),
s:search(("fire","earthquake"),$twitter),
s:search(("fire","earthquake"),$blog)

(: Specific implementations :)
declare namespace xh="http://www.w3.org/1999/xhtml";
declare variable $xhtml as map(xs:string, function(*)) :=
  map {
    'title' : 
       function($n as document-node()) as xs:string? { $n/xh:head/xh:title },
    'author' : 
       function($n as document-node()) as xs:string? { $n/xh:head/xh:meta[@name='author']/@content },
    'pubdate' : 
       function($n as document-node()) as xs:string? { $n/xh:head/xh:meta[@name='created']/@content },
    'publisher' : 
       function($n as document-node()) as xs:string? { () }
    };

declare variable $medline-citation as map(xs:string, function(*)) :=
  map {
    'title' : 
       function($n as document-node()) as xs:string? 
        { 
          $n/MedlineCitation/Article/ArticleTitle 
        },
    'author': 
       function($n as document-node()) as xs:string?
        {
          string-join(
            for $a in $n/MedlineCitation//Author 
            return concat($a/LastName, ", ", $a/ForeName) 
            , 
            "; "
          )
        },
    'pubdate' : 
       function($n as document-node()) as xs:string?
        {
          let $d := $n/MedlineCitation/Article/PubDate
          return string-join(($d/Day,$d/Month,$d/Year), " ")
        },
    'publisher' : 
       function($n as document-node()) as xs:string?
        {  
          $n/MedlineCitation/MedlineJournalIngo/MedlineTA 
        }
  };

declare function xdmp:xslt-invoke($path as xs:string, $input as node(),
  $params as map(xs:QName, item()*)) as document-node()* external;

let $params := map {
  xs:QName("toc") := true(),
  xs:QName("index") := doc("index_terms.xml")
}
return xdmp:xslt-invoke("my-stylesheet.xsl", doc("my-doc.xml"), $params)

declare function my:doc($uri as xs:string, $options as map(xs:string, item()*)) as document-node()? external;

(: Enable lax XML Schema validation :)
my:doc("validate-me.xml", map {
  "schema-validation" : true(),
  "lax-validation" : true()
}),

(: Enable whitespace stripping, and a custom URI resolution :)
my:doc("../relative-uri.xml", map {
  "strip-whitespace" : true(),
  "uri-resolver" : resolve-uri(?, base-uri())
})

declare function local:play(
  $secret-number as xs:integer,
  $guessed-number as xs:integer,
  $translator as function(xs:string) as xs:string)
{
  switch (true())
  case $guessed-number eq $secret-number
    return $translator("You won!")
  case $guessed-number lt $secret-number
    return $translator("The secret number is greater.")
  default (: $guessed-number gt $secret-number :)
    return $translator("The secret number is lower.")
};

local:play(76, 86, function($x) { $x }), (: Keep English :)

local:play(76, 86, map {
  "You won!" : "Du hast gewonnen!",
  "The secret number is greater." : "Die geheime Zahl ist groesser.",
  "The secret number is lower." :  Die geheime Zahl ist kleiner." }
),

local:play(76, 86, $automated-translator-based-on-natural-language-processing)

{
     "firstname": "Mildred",
     "lastname": "Moore",
     "age": 32,
     "address":
     {
         "street": "91 High Street",
         "town": "Biscester",
         "county": "Oxfordshire",
         "postcode": "OX6 3PD"
     },
     "phone":
     [
         {
           "type": "home",
           "number": "01869 378073"
         },
         {
           "type": "mobile",
           "number": "07356 740756"
         }
     ]
}

        json-doc("mildred.json")?phone?*[?type = 'mobile']?number

"07356 740756"

{ "accounting" : [
      { "firstName" : "John",
        "lastName"  : "Doe",
        "age"       : 23 },

      { "firstName" : "Mary",
        "lastName"  : "Smith",
        "age"       : 32 }
                 ],
  "sales"     : [
      { "firstName" : "Sally",
        "lastName"  : "Green",
        "age"       : 27 },

      { "firstName" : "Jim",
        "lastName"  : "Galley",
        "age"       : 41 }
                  ]
}

<department name="accounting">
  <employee>
    <firstName>John</firstName>
    <lastName>Doe</lastName>
    <age>23</age>
  </employee>
  <employee>
    <firstName>Mary</firstName>
    <lastName>Smith</lastName>
    <age>32</age>
  </employee>
</department>
<department name="sales">
  <employee>
    <firstName>Sally</firstName>
    <lastName>Green</lastName>
    <age>27</age>
  </employee>
  <employee>
    <firstName>Jim</firstName>
    <lastName>Galley</lastName>
    <age>41</age>
  </employee>
</department>

let $input := json-doc('employees.json')
for $k in map:keys($input)
return
  <department name="{ $k }">
    {
    let $array := $input($k)
    for $i in 1 to array:size($array)
    let $emp := $array($i)
    return
      <employee>
        <firstName>{ $emp('firstName') }</firstName>
        <lastName>{ $emp('lastName') }</lastName>
        <age>{ $emp('age') }</age>
      </employee>
    }
  </department>

{
    "book": {
        "title": "Data on the Web",
        "year": 2000,
        "author": [
            {
                "last": "Abiteboul",
                "first": "Serge"
            },
            {
                "last": "Buneman",
                "first": "Peter"
            },
            {
                "last": "Suciu",
                "first": "Dan"
            }
        ],
        "publisher": "Morgan Kaufmann Publishers",
        "price": 39.95
    }
}

declare function local:deep-put($input as item()*, $key as xs:string, $value as item()*) as item()* 
{                                                             
  let $mf := function($k, $v) {
                if ($k eq $key) 
                then map{$k : $value} 
                else map{$k : local:deep-put($v, $key, $value)} 
             }
  for $i in $input 
  return
    if ($i instance of map(*))
    then map:merge(map:for-each($i, $mf))
    else if ($i instance of array(*))
    then array{ local:deep-put($i?*, $key, $value) }
    else $i
};

local:deep-put(json-doc("bookinfo.json"), "first", "John")

{
  "name" : "Sarah",
  "age" : 13,
  "gender" : "female",
  "friends" : [ "Jim", "Mary", "Jennifer"]
}

{
  "name" : "Jim",
  "age" : 13,
  "gender" : "male",
  "friends" : [ "Sarah" ]
}
          

for $sarah in collection("users"),
    $friend in collection("users")
where $sarah("name") = "Sarah"
  and $friend("name") = $sarah("friends")?*
return $friend 

{ "product" : "broiler", "store number" : 1, "quantity" : 20  },
{ "product" : "toaster", "store number" : 2, "quantity" : 100 },
{ "product" : "toaster", "store number" : 2, "quantity" : 50 },
{ "product" : "toaster", "store number" : 3, "quantity" : 50 },
{ "product" : "blender", "store number" : 3, "quantity" : 100 },
{ "product" : "blender", "store number" : 3, "quantity" : 150 },
{ "product" : "socks", "store number" : 1, "quantity" : 500 },
{ "product" : "socks", "store number" : 2, "quantity" : 10 },
{ "product" : "shirt", "store number" : 3, "quantity" : 10 }

{
  "blender" : 250,
  "broiler" : 20,
  "shirt" : 10,
  "socks" : 510,
  "toaster" : 200
  }       

map:merge((
  for $sales in collection("sales")
  let $pname := $sales("product")
  group by $pname
  return map { $pname : sum(for $s in $sales return $s("quantity")) }
))    

{ "name" : "broiler", "category" : "kitchen", "price" : 100, "cost" : 70 },
{ "name" : "toaster", "category" : "kitchen", "price" : 30, "cost" : 10 },
{ "name" : "blender", "category" : "kitchen", "price" : 50, "cost" : 25 },
{ "name" : "socks", "category" : "clothes", "price" : 5, "cost" : 2 },
{ "name" : "shirt", "category" : "clothes", "price" : 10, "cost" : 3 }

{ "store number" : 1, "state" : CA },
{ "store number" : 2, "state" : CA },
{ "store number" : 3, "state" : MA },
{ "store number" : 4, "state" : MA }
        

            [
              { "CA" : 
                [
                  {"kitchen" : { "broiler" : 20, "toaster" : 150 }},
                  {"clothes" : { "socks" : 510 }}
                ]
              },
              { "MA" : 
                [ 
                  { "kitchen" : { "blender" : 250, "toaster" : 50 }},
                  { "clothes" : { "shirt" : 10 }}
                ]
              }
            ]
        

array {
  for $store in json-doc('stores.json') ? *
  let $state := $store?state
  group by $state
  return
    map {
      $state :  array {
        for $product in json-doc('products.json') ? *
        let $category := $product?category
        group by $category
        return
          map {
            $category :  map:merge((
              for $sales in json-doc('sales.json') ? *
              where $sales?("store number") = $store?("store number") and $sales?product = $product?name
              let $pname := $sales?product
              group by $pname
              return map { $pname :  sum(for $s in $sales return $s?quantity)}
            ))
          }
      }
   }
}
        

{
  "creator" : "Satellites plugin version 0.6.4",
  "satellites" : {
    "AAU CUBESAT" : {
      "tle1" : "1 27846U 03031G 10322.04074654  .00000056  00000-0  45693-4 0  8768",
      "visible" : false
    },
    "AJISAI (EGS)" : {
      "tle1" : "1 16908U 86061A 10321.84797408 -.00000083  00000-0  10000-3 0  3696",
      "visible" : true
    },
    "AKARI (ASTRO-F)" : {
      "tle1" : "1 28939U 06005A 10321.96319841  .00000176  00000-0  48808-4 0  4294",
      "visible" : true
    }
  }
}

{
  "visible" : [
     "AJISAI (EGS)",
     "AKARI (ASTRO-F)"
  ],
  "invisible" : [
     "AAU CUBESAT"
  ]
}       

let $sats := json-doc("satellites.json")("satellites")
return map {
  "visible" : array {
     map:keys($sats)[$sats(.)("visible")]
  },
  "invisible" : array {
     map:keys($sats)[not($sats(.)("visible"))]
  }
}

<mediawiki>
  <siteinfo>
    <sitename>Wikipedia</sitename>

    <page>
      <title>Kawasaki's theorem</title>
      <id>14511776</id>
      <revision>
        <id>435519187</id>
        <timestamp>2011-06-21T20:08:56Z</timestamp>
        <contributor>
          <username>Some jerk on the Internet</username>
          <id>6636894</id>
        </contributor>

!!! SNIP !!!

    <page>
      <title>Origami techniques</title>
      <id>193590</id>
      <revision>
        <id>447687387</id>
        <timestamp>2011-08-31T17:21:49Z</timestamp>
        <contributor>
          <username>Dmcq</username>
          <id>3784322</id>
        </contributor>

!!! SNIP !!!

    <page>
      <title>Mathematics of paper folding</title>
      <id>232840</id>
      <revision>
        <id>440970828</id>
        <timestamp>2011-07-23T09:10:42Z</timestamp>
        <contributor>
          <username>Tabletop</username>
          <id>173687</id>
        </contributor>
       

[
 {
  "title" : "Kawasaki's theorem",
  "id" : "14511776",
  "timestamp" : "2011-06-21T20:08:56Z",
  "authors" : ["Some jerk on the Internet" ]
 },
 {
  "title" : "Origami techniques",
  "id" : "193590",
  "timestamp" : "2011-08-31T17:21:49Z",
  "authors" : ["Dmcq" ]
 },
 {
  "title" : "Mathematics of paper folding",
  "id" : "232840",
  "timestamp" : "2011-07-23T09:10:42Z",
  "authors" : ["Tabletop" ]
 }
]
          

array {
 for $page in doc("Wikipedia-Origami.xml")//page
 return map {
  "title": string($page/title),
  "id" : string($page/id),
  "last updated" : string($page/revision[1]/timestamp),
  "authors" : array {
       for $a in $page/revision/contributor/username
       return string($a)
  }
 }
}          

var data = {
   "color" : "blue",
   "closed" : true,
   "points" : [[10,10], [20,10], [20,20], [10,20]]
   };
          

var query =
 "declare variable stroke := attribute stroke { $data("color") };
  declare variable points := attribute points { $data("points")?*?* };
  if (closed) then
    <svg><polygon>{ $stroke, $points }</polygon></svg>
  else
    <svg><polyline>{ $stroke, $points }</polyline></svg>" 

jsoniq(data, query)
          

<svg><polygon stroke="blue" points="10 10 20 10 20 20 10 20" /></svg>

{
  "col labels" : ["singular", "plural"],
  "row labels" : ["1p", "2p", "3p"],
  "data" :
     [
        ["spinne", "spinnen"],
        ["spinnst", "spinnt"],
        ["spinnt", "spinnen"]
     ]
}

<html>
  <body>

    <table>
      <tr> (: Column headings :)
         {
            <th> </th>,
            for $th in json-doc("table.json")("col labels")?*
            return <th>{ $th }</th>
         }
      </tr>
      {  (: Data for each row :)
         for $r at $i in json-doc("table.json")("data")?*
         return
            <tr>
             {
               <th>{ json-doc("table.json")("row labels")[$i]) }</th>,
               for $c in $r?*
               return <td>{ $c }</td>
             }
            </tr>
      }
    </table>

  </body>
</html>    

[
  { "color" : "Green" },
  { "color" : "Pink" },
  { "color" : "Lilac" },
  { "color" : "Turquoise" },
  { "color" : "Peach" },
  { "color" : "Opal" },
  { "color" : "Champagne" }
}
	  

<table>
  <tr>
    <td>Green</td>
    <td>Pink</td>
    <td>Lilac</td>
  </tr>
  <tr>
    <td>Turquoise</td>
    <td>Peach</td>
    <td>Opal</td>
  </tr>
  <tr>
    <td>Champagne</td>
  </tr>
</table>
	  

<table>{
  for tumbling window $w in json-doc("colors.json")?*
    start at $x when fn:true()
    end at $y when $y - $x = 2
  return
    <tr>{
      for $i in $w
      return
        <td>{ $i }</td>
    }</tr>
}</table>
	  

[
  { "userid" : "W0342", "firstname" : "Walter", "lastname" : "Denisovich" },
  { "userid" : "M0535", "firstname" : "Mick", "lastname" : "Goulish" }
]       

[
  { "userid" : "W0342", "ticker" : "DIS", "shares" : 153212312 },
  { "userid" : "M0535", "ticker" : "DIS", "shares" : 10 },
  { "userid" : "M0535", "ticker" : "AIG", "shares" : 23412 }
]       

array {
  for $u in vendor:table("Users")
  order by $u("userid")
  return map {
    "userid" : $u("userid"),
    "first" :  $u("firstname"),
    "last" :   $u("lastname"),
    "holdings" : array {
         for $h in vendor:table("Holdings")
         where $h("userid") = $u("userid")
         order by $h("ticker")
         return {
            "ticker" : $u("ticker"),
            "share" : $u("shares")
         }
    }
  }
}       

{
  "user" : "Deadbeat Jim",
  "credit card" : VISA 4111 1111 1111 1111,
  "product" : "lottery tickets",
  "quantity" : 243
}
        

{
  "name" : "Deadbeat Jim",
  "address" : "1 E 161st St, Bronx, NY 10451",
  "risk tolerance" : "high"
}
        

let $dbj := collection("users")[ .("name") = "Deadbeat Jim" ]
return insert map { "status" : "credit card declined" } into $dbj
        

{
  "name" : "Deadbeat Jim",
  "address" : "1 E 161st St, Bronx, NY 10451",
  "status" : "credit card declined",
  "risk tolerance" : "high"
}
        

{
    "encoding" : "UTF-8",
    "feed" : {
        "author" : [
            {
                "name" : {
                    "$t" : "YouTube"
                },
                "uri" : {
                    "$t" : "http://www.youtube.com/"
                }
            }
        ],
        "category" : [
            {
                "scheme" : "http://schemas.google.com/g/2005#kind",
                "term" : "http://gdata.youtube.com/schemas/2007#video"
            }
        ],
        "entry" : [
            {
                "app$control" : {
                    "yt$state" : {
                        "$t" : "Syndication of this video was restricted by its owner.",
                        "name" : "restricted",
                        "reasonCode" : "limitedSyndication"
                    }
                },
                "author" : [
                    {
                        "name" : {
                            "$t" : "beyonceVEVO"
                        },
                        "uri" : {
                            "$t" : "http://gdata.youtube.com/feeds/api/users/beyoncevevo"
                        }
                    }
                ]
!!! SNIP !!!         

let $feed := json-doc("incoming.json")
return
  if ($entry("app$control")("yt$state")("name") = "restricted")
     map:remove($feed, "entry")
  else
     $feed