Indexes - Revision history

CG: Text replacement - "syntaxhighlight" to "pre"

2023-12-01T16:39:47Z

Text replacement - "syntaxhighlight" to "pre"

CG: Text replacement - "" to ""

2023-12-01T16:33:40Z

Text replacement - "</syntaxhighlight>" to "</pre>"

CG: Text replacement - "" to "

2023-12-01T16:32:23Z

Text replacement - "<syntaxhighlight lang="xquery">" to "<pre lang='xquery'>"

CG at 13:46, 25 July 2022

2022-07-25T13:46:48Z

CG: Text replacement - "db:pre" to "db:get"

2022-07-20T11:43:28Z

Text replacement - "db:pre" to "db:get"

CG: Text replacement - "db:pre(" to "db:get("

2022-07-20T11:33:13Z

Text replacement - "db:pre(" to "db:get("

CG: Text replacement - "db:open" to "db:pre"

2022-07-19T18:55:56Z

Text replacement - "db:open" to "db:pre"

CG at 18:29, 18 July 2022

2022-07-18T18:29:26Z

CG at 10:17, 15 February 2021

2021-02-15T10:17:13Z

CG at 16:14, 13 July 2020

2020-07-13T16:14:03Z

@@ Line 193: / Line 193: @@
 The options that have been used for creating the full-text index will also be applied to the optimized full-text queries. However, the defaults can be overwritten if you supply options in your query. For example, if words were stemmed in the index, and if the query can be rewritten for index access, the query terms will be stemmed as well, unless stemming is not explicitly disabled. This is demonstrated in the following [[Commands#Command_Scripts|Command Script]]:
-<syntaxhighlight lang="xml">
+<pre lang="xml">
 <commands>
    <!-- Create database with stemmed full-text index -->
@@ Line 221: / Line 221: @@
 ; Commands
-<syntaxhighlight lang="xml">
+<pre lang="xml">
 SET ATTRINCLUDE id,name
 CREATE DB factbook http://files.basex.org/xml/factbook.xml'

@@ Line 22: / Line 22: @@
 (: will be rewritten to an empty sequence :)
 /non-existing-name
-</syntaxhighlight>
+</pre>
 The contents of the name indexes can be directly accessed with the XQuery functions {{Function|Index|index:element-names}} and {{Function|Index|index:attribute-names}}.
@@ Line 40: / Line 40: @@
 (: ...will be rewritten to... :)
 doc('factbook.xml')/mondial/country/province
-</syntaxhighlight>
+</pre>
 * The {{Code|fn:count}} function will be pre-evaluated by looking up the number in the index:
@@ Line 46: / Line 46: @@
 <pre lang='xquery'>
 count(doc('factbook')//country)
-</syntaxhighlight>
+</pre>
 * The distinct values of elements or attributes can be looked up in the index as well:
@@ Line 52: / Line 52: @@
 <pre lang='xquery'>
 distinct-values(db:get('factbook')//religions)
-</syntaxhighlight>
+</pre>
 The contents of the path index can be directly accessed with the XQuery function {{Function|Index|index:facets}}.
@@ Line 83: / Line 83: @@
    map { 'ftindex': true(), 'ftinclude': 'p div' }
+)
-</syntaxhighlight>
+</pre>
 ==Text Index==
@@ Line 100: / Line 100: @@
 where $c//city/name = 'Hanoi'
 return $c/name
-</syntaxhighlight>
+</pre>
 Before the actual index rewriting takes places, some preliminary optimizations are applied:
@@ Line 116: / Line 116: @@
    map { 'updindex':true(), 'textindex': true(), 'textinclude':'id' }
+)
-</syntaxhighlight>
+</pre>
 ===Range Queries===
@@ Line 129: / Line 129: @@
 let $max := '2014-04-19T23:59:59'
 return db:get('news')//entry[date-time > $min and date-time < $max]
-</syntaxhighlight>
+</pre>
 With {{Function|Database|db:text-range}}, you can access all text nodes whose values are between a minimum and maximum value.
@@ Line 148: / Line 148: @@
 (: 4th example :)
 fn:id('f0_119', db:get('factbook'))
-</syntaxhighlight>
+</pre>
 ''Attribute nodes'' (which you can use as starting points of navigation) can directly be retrieved from the index with the XQuery functions {{Function|Database|db:attribute}} and {{Function|Database|db:attribute-range}}. The index contents (''strings'') can be accessed with {{Function|Index|index:attributes}}.
@@ Line 165: / Line 165: @@
 (: 3rd example :)
 doc('graph.xml')/idref('edge8')
-</syntaxhighlight>
+</pre>
 ''Attribute nodes'' with a matching value (containing at least one from a set of given tokens) can be directly retrieved from the index with the XQuery function {{Function|Database|db:token}}. The index contents (''token strings'') can be accessed with {{Function|Index|index:tokens}}.
@@ Line 181: / Line 181: @@
 //religions[.//text() contains text { 'Catholic', 'Roman' }
      using case insensitive distance at most 2 words]
-</syntaxhighlight>
+</pre>
 The index provides support for the following full-text features (the values can be changed in the GUI or via the {{Command|SET}} command):
@@ Line 204: / Line 204: @@
    <xquery> /text[. contains text { 'houses' } using no stemming] </xquery>
 </commands>
-</syntaxhighlight>
+</pre>
 Text nodes can be directly requested from the index via the XQuery function {{Function|Full-Text|ft:search}}. The index contents can be accessed with {{Function|Full-Text|ft:tokens}}.
@@ Line 226: / Line 226: @@
 # Restore default
 SET ATTRINCLUDE
-</syntaxhighlight>
+</pre>
 ; XQuery
@@ Line 232: / Line 232: @@
 db:create('factbook', 'http://files.basex.org/xml/factbook.xml', '',
    map { 'attrinclude': 'id,name' })
-</syntaxhighlight>
+</pre>
 With {{Command|CREATE INDEX}} and {{Function|Database|db:optimize}}, new selective indexing options will be applied to an existing database.
@@ Line 250: / Line 250: @@
    return db:get($db)//person[name/text() = 'John']
+}
-</syntaxhighlight>
+</pre>
 * The following query contains two predicates that may both be rewritten for index access. If the automatically chosen rewriting is known not to be optimal, another index rewriting can enforced by surrounding the specific expression with the pragma:
@@ Line 261: / Line 261: @@
    }]
    [religions/text() = 'Protestant']
-</syntaxhighlight>
+</pre>
 The option can also be assigned to predicates with dynamic values. In the following example, the comparison of the first comparison will be rewritten for index access. Without the pragma expression, the second comparison is preferred and chosen for the rewriting because the statically known string allows for an exact cost estimation:
@@ Line 271: / Line 271: @@
 where $country/religions/text() = 'Protestant'
 return $country
-</syntaxhighlight>
+</pre>
 Please note that:
@@ Line 297: / Line 297: @@
 return db:create($db || '-index', $index, $db || '-index.xml')
-</syntaxhighlight>
+</pre>
 In the following query, a text string is searched, and the text nodes of the original database are retrieved:
@@ Line 306: / Line 306: @@
 for $id in db:get($db || '-index')//*[@string = $text]/id
 return db:get-id($db, $id)/..
-</syntaxhighlight>
+</pre>
 With some extra effort, and if {{Option|UPDINDEX}} is enabled for both your original and your index database (see below), your index database will support updates as well (try it, it’s fun!).

@@ Line 19: / Line 19: @@
 The name index is e.g. applied to discard location steps that will never yield results:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 (: will be rewritten to an empty sequence :)
 /non-existing-name
@@ Line 36: / Line 36: @@
 * Descendant steps will be rewritten to multiple child steps. Child steps are evaluated faster, as fewer nodes have to be traversed:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 doc('factbook.xml')//province,
 (: ...will be rewritten to... :)
@@ Line 44: / Line 44: @@
 * The {{Code|fn:count}} function will be pre-evaluated by looking up the number in the index:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 count(doc('factbook')//country)
 </syntaxhighlight>
@@ Line 50: / Line 50: @@
 * The distinct values of elements or attributes can be looked up in the index as well:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 distinct-values(db:get('factbook')//religions)
 </syntaxhighlight>
@@ Line 76: / Line 76: @@
 With XQuery, index structures can be created and dropped via {{Function|Database|db:optimize}}:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 (: Optimize specified database, create full-text index for texts of the specified elements :)
 db:optimize(
@@ Line 91: / Line 91: @@
 This index references text nodes of documents. It will be utilized to accelerate string comparisons in path expressions. The following queries will all be rewritten for index access:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 (: example 1 :)
 //*[text() = 'Germany'],
@@ Line 110: / Line 110: @@
 The {{Option|UPDINDEX}} option can be enabled to keep this index up-to-date:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 db:optimize(
    'mydb',
@@ Line 122: / Line 122: @@
 The text index also supports range queries based on string comparisons:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 (: example 1 :)
 db:get('Library')//Medium[Year >= '2011' and Year <= '2016'],
@@ Line 139: / Line 139: @@
 Similar to the text index, this index speeds up string and range comparisons on attribute values. Additionally, the XQuery function {{Code|fn:id}} takes advantage of the index whenever possible. The following queries will all be rewritten for index access:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 (: 1st example :)
 //country[@car_code = 'J'],
@@ Line 158: / Line 158: @@
 In many XML dialects, such as HTML or DITA, multiple tokens are stored in attribute values. The token index can be created to speed up the retrieval of these tokens. The XQuery functions {{Code|fn:contains-token}}, {{Code|fn:tokenize}} and {{Code|fn:idref}} are rewritten for index access whenever possible. If a token index exists, it will, e.g., be utilized for the following queries:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 (: 1st example :)
 //div[contains-token(@class, 'row')],
@@ Line 175: / Line 175: @@
 If the full-text index exists, the following queries will all be rewritten for index access:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 (: 1st example :)
 //country[name/text() contains text 'and'],
@@ Line 229: / Line 229: @@
 ; XQuery
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 db:create('factbook', 'http://files.basex.org/xml/factbook.xml', '',
    map { 'attrinclude': 'id,name' })
@@ Line 244: / Line 244: @@
 * In the query below, 10 databases will be addressed. If it is known in advance that these databases contain an up-to-date text index, the index rewriting can be enforced as follows:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 (# db:enforceindex #) {
    for $n in 1 to 10
@@ Line 254: / Line 254: @@
 * The following query contains two predicates that may both be rewritten for index access. If the automatically chosen rewriting is known not to be optimal, another index rewriting can enforced by surrounding the specific expression with the pragma:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 db:get('factbook')//country
    [(# db:enforceindex #) {
@@ Line 265: / Line 265: @@
 The option can also be assigned to predicates with dynamic values. In the following example, the comparison of the first comparison will be rewritten for index access. Without the pragma expression, the second comparison is preferred and chosen for the rewriting because the statically known string allows for an exact cost estimation:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 for $name in ('Germany', 'Italy')
 for $country in db:get('factbook')//country
@@ Line 284: / Line 284: @@
 With XQuery, it is comparatively easy to create your own, custom index structures. The following query demonstrates how you can create a {{Code|factbook-index}} database, which contains all texts of the original database in lower case:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 let $db := 'factbook'
@@ Line 301: / Line 301: @@
 In the following query, a text string is searched, and the text nodes of the original database are retrieved:
-<syntaxhighlight lang="xquery">
+<pre lang='xquery'>
 let $db := 'factbook'
 let $text := 'italian'

@@ Line 1: / Line 1: @@
 This article is part of the [[XQuery|XQuery Portal]]. It contains information on the available index structures.
-The query compiler tries to optimize and speed up queries by applying the index whenever it is possible and seems promising. To see how a query is rewritten, and if an index is used, you can turn on the [[GUI#Visualizations|Info View]] in the GUI or use the [[Command-Line Options#BaseX_Standalone|-V flag]] on the command line:
+The query compiler tries to optimize and speed up queries by applying the index whenever it is possible, and seems promising. To see how a query is rewritten, and if an index is used, you can turn on the [[GUI#Visualizations|Info View]] in the GUI or use the [[Command-Line Options#BaseX_Standalone|-V flag]] on the command line:
 * A message like <code>apply text index for "Japan"</code> indicates that the text index is applied to speed up the search of the shown string. The following message…
-* <code>no index results</code> indicates that a string in a path expression will never yield results. Because of that, the path does not need to be evaluated at all.
+* <code>no index results</code> indicates that a string in a path expression will never yield results. Hence, the path does not need to be evaluated at all.
 * If you cannot find any index optimization hints in the info output, it often helps if you rewrite and simplify your query.
@@ Line 66: / Line 66: @@
 =Value Indexes=
-Value indexes can be created and dropped by the user. Four types of values indexes are available: a text and attribute index, and an optional token and full-text index. By default, the text and attribute index will automatically be created.
+Value indexes can be created and dropped by the user. Four types of values indexes are available: a text and attribute index, and an optional token and full-text index. By default, the text, and attribute index will automatically be created.
 In the GUI, index structures can be managed in the dialog windows for creating new databases or displaying the database properties. On command-line, the commands {{Command|CREATE INDEX}} and {{Command|DROP INDEX}} are used to create and drop index structures. With {{Command|INFO INDEX}}, you get some insight into the contents of an index structure, and {{Command|SET}} allows you to change the index defaults for new databases:
@@ Line 156: / Line 156: @@
 ==Token Index==
-In many XML dialects, such as HTML or DITA, multiple tokens are stored in attribute values. The token index can be created to speed up the retrieval of these tokens. The XQuery functions {{Code|fn:contains-token}}, {{Code|fn:tokenize}} and {{Code|fn:idref}} are rewritten for index access whenever possible. If a token index exists, it will e.g. be utilized for the following queries:
+In many XML dialects, such as HTML or DITA, multiple tokens are stored in attribute values. The token index can be created to speed up the retrieval of these tokens. The XQuery functions {{Code|fn:contains-token}}, {{Code|fn:tokenize}} and {{Code|fn:idref}} are rewritten for index access whenever possible. If a token index exists, it will, e.g., be utilized for the following queries:
 <syntaxhighlight lang="xquery">
@@ Line 171: / Line 171: @@
 ==Full-Text Index==
-The [[Full-Text]] index contains the normalized tokens of text nodes of a document. It is utilized to speed up queries with the {{Code|contains text}} expression, and it is capable of processing wildcard and fuzzy search operations. Three evaluation strategies are available: the standard sequential database scan, a full-text index based evaluation and a hybrid one, combining both strategies (see [https://files.basex.org/publications/Gruen%20et%20al.%20%5B2009%5D,%20XQuery%20Full%20Text%20Implementation%20in%20BaseX.pdf XQuery Full Text implementation in BaseX]).
+The [[Full-Text]] index contains the normalized tokens of text nodes of a document. It is utilized to speed up queries with the {{Code|contains text}} expression, and it is capable of processing wildcard and fuzzy search operations. Three evaluation strategies are available: the standard sequential database scan, a full-text index-based evaluation and a hybrid one, combining both strategies (see [https://files.basex.org/publications/Gruen%20et%20al.%20%5B2009%5D,%20XQuery%20Full%20Text%20Implementation%20in%20BaseX.pdf XQuery Full Text implementation in BaseX]).
 If the full-text index exists, the following queries will all be rewritten for index access:
@@ Line 234: / Line 234: @@
 </syntaxhighlight>
-With {{Command|CREATE INDEX}} and {{Function|Database|db:optimize}}, new selective indexing options will ba applied to an existing database.
+With {{Command|CREATE INDEX}} and {{Function|Database|db:optimize}}, new selective indexing options will be applied to an existing database.
 ==Enforce Rewritings==
-In various cases, existing index structures will not be utilized by the query optimizer. This is usually the case if the name of the database is not a static string (e.g., because it is bound to a variable or passed on as argument of a function call). Furthermore, several candidates for index rewritings may exist, and the query optimizer may decide for a rewriting that turns out to be suboptimal.
+In various cases, existing index structures will not be utilized by the query optimizer. This is usually the case if the name of the database is not a static string (e.g. because it is bound to a variable or passed on as an argument of a function call). Furthermore, several candidates for index rewritings may exist, and the query optimizer may decide for a rewriting that turns out to be suboptimal.
 With the {{Option|ENFORCEINDEX}} option, certain index rewritings can be enforced. While the option can be globally enabled, it is usually better to supply it as [[XQuery Extensions#Pragmas|Pragma]]. Two examples:
@@ Line 263: / Line 263: @@
 </syntaxhighlight>
-The option can also be assigned to predicates with dynamic values. In the following example the comparison of the first comparison will be rewritten for index access. Without the pragma expression, the second comparison is preferred and chosen for the rewriting, because the statically known string allows for an exact cost estimation:
+The option can also be assigned to predicates with dynamic values. In the following example, the comparison of the first comparison will be rewritten for index access. Without the pragma expression, the second comparison is preferred and chosen for the rewriting because the statically known string allows for an exact cost estimation:
 <syntaxhighlight lang="xquery">
@@ Line 282: / Line 282: @@
 =Custom Index Structures=
-With XQuery, it is comparatively easy to create your own, custom index structures. The following query demonstrate how you can create a {{Code|factbook-index}} database, which contains all texts of the original database in lower case:
+With XQuery, it is comparatively easy to create your own, custom index structures. The following query demonstrates how you can create a {{Code|factbook-index}} database, which contains all texts of the original database in lower case:
 <syntaxhighlight lang="xquery">
@@ Line 312: / Line 312: @@
 =Performance=
-If main memory runs out while creating a value index, the current index structures will be partially written to disk and eventually merged. If the memory heuristics fail for some reason (i.e., because multiple index operations run at the same time, or because the applied JVM does not support explicit garbage collections), a fixed index split sizes may be chosen via the {{Option|SPLITSIZE}} option.
+If main memory runs out while creating a value index, the current index structures will be partially written to disk and eventually merged. If the memory heuristics fail for some reason (i.e. because multiple index operations run at the same time, or because the applied JVM does not support explicit garbage collections), a fixed index split sizes may be chosen via the {{Option|SPLITSIZE}} option.
-If {{Option|DEBUG}} is enabled, the command-line output might help you to find a good split size. The following example shows the output for creating a database for an XMark document with 1 GB, and with 128 MB assigned to the JVM:
+If {{Option|DEBUG}} is enabled, the command-line output might help you find a good split size. The following example shows the output for creating a database for an XMark document with 1 GB, and with 128 MB assigned to the JVM:
 <pre>
@@ Line 334: / Line 334: @@
 * The vertical bar <code>|</code> indicates that a partial index structure was written to disk.
 * The mean value of the recommendations can be assigned to the {{Option|SPLITSIZE}} option. Please note that the recommendation is only a vague proposal, so try different values if you get main-of-memory errors or indexing gets too slow. Greater values will require more main memory.
-* In the example, the full-text index was split 12 times. 116 million tokens were indexed, processing time was 2,5 minutes, and final main memory consumption (after writing the index to disk) was 76 MB. A good value for the split size option could be {{Code|15}}.
+* In the example, the full-text index was split 12 times. 116 million tokens were indexed, processing time was 2.5 minutes, and final main memory consumption (after writing the index to disk) was 76 MB. A good value for the split size option could be {{Code|15}}.
 =Updates=
@@ Line 341: / Line 341: @@
 * After the execution of one or more update operations, the {{Command|OPTIMIZE}} command or the {{Function|Database|db:optimize}} function can be called to rebuild the index structures.
-* The {{Option|UPDINDEX}} option can be activated before creating or optimizing the database. As a result, the text, attribute and token indexes will be incrementally updated after each database update. Please note that incremental updates are not available for the full-text index and database statistics. This is also explains why the UPTODATE flag, which is e.g. displayed via {{Command|INFO DB}} or {{Function|Database|db:info}}, will be set to {{Code|false}} until the database will be optimized again (various optimizations won’t be triggered. For example, count(//item) can be extremely fast if all meta data is up-to-date.
+* The {{Option|UPDINDEX}} option can be activated before creating or optimizing the database. As a result, the text, attribute and token indexes will be incrementally updated after each database update. Please note that incremental updates are not available for the full-text index and database statistics. This also explains why the UPTODATE flag, which is e.g. displayed via {{Command|INFO DB}} or {{Function|Database|db:info}}, will be set to {{Code|false}} until the database will be optimized again (various optimizations won’t be triggered. For example, count(//item) can be extremely fast if all metadata is up-to-date.
 * The {{Option|AUTOOPTIMIZE}} option can be enabled before creating or optimizing the database. All outdated index structures and statistics will then be recreated after each database update. This option should only be done for small and medium-sized databases.
 * Both options can be used side by side: {{Option|UPDINDEX}} will take care that the value index structures will be updated as part of the actual update operation. {{Option|AUTOOPTIMIZE}} will update the remaining data structures (full-text index, database statistics).
@@ Line 348: / Line 348: @@
 ;Version 9.1
 * Updated: [[#Enforce Rewritings|Enforce Rewritings]], support for comparisons with dynamic values.
 ;Version 9.0
 * Added: [[#Enforce Rewritings|Enforce Rewritings]]
 ;Version 8.4
 * Updated: [[#Name Index|Name Index]], [[#Path Index|Path Index]]
 ;Version 8.4
 * Added: [[#Token Index|Token Index]]
 ;Version 8.3
 ;Version 8.0
 * Added: AUTOOPTIMIZE option
 ;Version 7.2.1
 * Added: string-based range queries

@@ Line 305: / Line 305: @@
 let $text := 'italian'
 for $id in db:get($db || '-index')//*[@string = $text]/id
-return db:pre-id($db, $id)/..
+return db:get-id($db, $id)/..
 </syntaxhighlight>

@@ Line 51: / Line 51: @@
 <syntaxhighlight lang="xquery">
-distinct-values(db:open('factbook')//religions)
+distinct-values(db:pre('factbook')//religions)
 </syntaxhighlight>
@@ Line 97: / Line 97: @@
 doc('factbook.xml')//name[. = 'Germany'],
 (: example 3 :)
-for $c in db:open('factbook')//country
+for $c in db:pre('factbook')//country
 where $c//city/name = 'Hanoi'
 return $c/name
@@ Line 124: / Line 124: @@
 <syntaxhighlight lang="xquery">
 (: example 1 :)
-db:open('Library')//Medium[Year >= '2011' and Year <= '2016'],
+db:pre('Library')//Medium[Year >= '2011' and Year <= '2016'],
 (: example 2 :)
 let $min := '2014-04-16T00:00:00'
 let $max := '2014-04-19T23:59:59'
-return db:open('news')//entry[date-time > $min and date-time < $max]
+return db:pre('news')//entry[date-time > $min and date-time < $max]
 </syntaxhighlight>
@@ Line 147: / Line 147: @@
 //sea[@depth > '2100' and @depth < '4000']
 (: 4th example :)
-fn:id('f0_119', db:open('factbook'))
+fn:id('f0_119', db:pre('factbook'))
 </syntaxhighlight>
@@ Line 248: / Line 248: @@
    for $n in 1 to 10
    let $db := 'persons' || $n
-   return db:open($db)//person[name/text() = 'John']
+   return db:pre($db)//person[name/text() = 'John']
+}
 </syntaxhighlight>
@@ Line 255: / Line 255: @@
 <syntaxhighlight lang="xquery">
-db:open('factbook')//country
+db:pre('factbook')//country
    [(# db:enforceindex #) {
     @population > '10000000' and
@@ Line 267: / Line 267: @@
 <syntaxhighlight lang="xquery">
 for $name in ('Germany', 'Italy')
-for $country in db:open('factbook')//country
+for $country in db:pre('factbook')//country
 where (# db:enforceindex #) { $country/name = $name }
 where $country/religions/text() = 'Protestant'
@@ Line 288: / Line 288: @@
 let $index := <index>{
-   for $nodes in db:open($db)//text()
+   for $nodes in db:pre($db)//text()
    group by $text := lower-case($nodes)
    return <text string='{ $text }'>{
@@ Line 304: / Line 304: @@
 let $db := 'factbook'
 let $text := 'italian'
-for $id in db:open($db || '-index')//*[@string = $text]/id
+for $id in db:pre($db || '-index')//*[@string = $text]/id
-return db:open-id($db, $id)/..
+return db:pre-id($db, $id)/..
 </syntaxhighlight>

@@ Line 24: / Line 24: @@
 </syntaxhighlight>
-The contents of the name indexes can be directly accessed with the XQuery functions [[Index Module#index:element-names|index:element-names]] and [[Index Module#index:attribute-names|index:attribute-names]].
+The contents of the name indexes can be directly accessed with the XQuery functions {{Function|Index|index:element-names}} and {{Function|Index|index:attribute-names}}.
 If a database is updated, new names will be added incrementally, but the statistical information will get out-dated.
@@ Line 54: / Line 54: @@
 </syntaxhighlight>
-The contents of the path index can be directly accessed with the XQuery function [[Index Module#index:facets|index:facets]].
+The contents of the path index can be directly accessed with the XQuery function {{Function|Index|index:facets}}.
 If a database is updated, the statistics in the path index will be invalidated.

@@ Line 316: / Line 316: @@
 If {{Option|DEBUG}} is enabled, the command-line output might help you to find a good split size. The following example shows the output for creating a database for an XMark document with 1 GB, and with 128 MB assigned to the JVM:
-<syntaxhighlight>
+<pre>
 > basex -d -c"SET FTINDEX ON; SET TOKENINDEX ON; CREATE DB xmark 1gb.xml"
 Creating Database...
@@ Line 328: / Line 328: @@
 Indexing Full-Text...
 ..|.|.|.|...|...|..|.|..| 116.33 M operations, 138740.94 ms (106 MB). Recommended SPLITSIZE: 12.
-</syntaxhighlight>
+</pre>
 The output can be interpreted as follows: