Changes

This [[Module Library|XQuery Module]] contains functions for handling ''streamablelazy'' items.

In contrast to standard XQuery items, a streamable lazy item contains only a reference to the actual data. The , and the data itself will only be retrieved if it is requested by an expression, or if the item is to be serialized. Hence, a streamable item only uses a few bytespossible errors will be postponed, and no additional memory is will be occupied during serializationby a lazy item as long as its content has not been requested yet.

The following BaseX functions return streamable lazy items:

* Streamable Lazy Base64 binaries:

* Streamable Lazy strings:

Some functions are capable of consuming the contents of lazy items in a ''streamable'' fashion: data will never not be cached, but instead passed on to another target (file, the calling expression, etc.). The following streaming functions are currently available:

* [[Archive Module]] (most functions)* Conversion Module: <code>[[Conversion Module#convert:binary-to-bytes|convert:binary-to-bytes]]</code>, <code>[[Conversion Module#convert:binary-to-string|convert:binary-to-string]]</code>* Database Module: <code>[[Database Module#db:store|db:store]]</code>* File Module: <code>[[File Module#file:write-binary|file:write-binary]]</code>* , <code>[[Fetch File Module#file:write-text|file:write-text]]</code>(if no encoding is specified)* [[Hashing Module]] (all functions)

All functions and errors in this module are assigned to the {{Code|<code><nowiki>http://basex.org/modules/stream}} lazy</nowiki></code> namespace, which is statically bound to the {{Code|streamlazy}} prefix.<br/>All errors are assigned to the {{Code|http://basex.org/errors}} namespace, which is statically bound to the {{Code|bxerr}} prefix.

==streamlazy:materializecache== {{Mark|Updated with Version 8.0}}: Extended to sequences.

|{{Func|streamlazy:materializecache|$value items as item()*|item()*}}<br/>{{Func|lazy:cache|$items as item()*, $lazy as xs:boolean|item()*}}

|Returns a materialized instance Caches the data of the specified lazy {{Code|$valueitems}}in a sequence:<br />* if an item is streamable, its value data of lazy items will be retrieved, and a new cached inside the item containing the value will be returned.* other, non-streamable lazy items, or lazy items with cached data, will simply be passed through.Materialization * If {{Code|$lazy}} is set to {{Code|true()}}, caching will be deferred until the data is eventually requested. Streaming will be disabled: Data will always be cached before a stream is returned.Caching is advisable if a value is to an item will be processed more than once, and is expensive to retrieve. It is get mandatory whenever or if the data may not be available anymore at a value is invalidated before it is requested (see the example below)later stage.

|In the following example, a file will be deleted before its content is returned. To avoid a "file “file not found" found” errorwhen serializing the result, the content will first must be materializedcached:

let $data text := streamlazy:materializecache(file:read-text($file))return (file:delete($file), $datatext)

==streamlazy:is-streamablelazy== 

|{{Func|streamlazy:is-streamablelazy|$item as item()|item()xs:boolean}}

|Checks whether the specified {{Code|$item}} is streamablelazy.|} ==lazy:is-cached== {| width='100%'|-| width='120' | '''Signatures'''|{{Func|lazy:is-cached|$item as item()|xs:boolean}}|-| '''Summary'''|Checks whether the contents of the specified {{Code|$item}} are cached. The function will always return {{Code|true}} for non-lazy items.

 * UpdateUpdated: [[#stream:materialize|stream:materialize]] extended to sequences.