Utilisation de fn: random-number-generator pour produire des nombres aléatoires plus d'une fois

Le problème est que fn : la fonction de générateur de nombres aléatoires est déterministe. Les spécifications elles-mêmes expliquent que:

Les deux formes de la fonction sont · déterministes · : appel de la fonction deux fois avec les mêmes arguments, dans un même · périmètre d'exécution · , produit les mêmes résultats.

Vous devez utiliser correctement la fonction sous la touche next contenue dans la carte résultante de l'appel de la fonction random-number-generator . Comme le dit la spécification:

L'entrée avec la touche "suivant" est une fonction zéro-arité qui peut être appelée pour renvoyer un autre générateur de nombres aléatoires.

Dans le contexte de XSLT 3, je pense qu'une façon d'avoir un "nouveau" générateur de nombres aléatoires pour chaque nœud dont vous avez besoin est de définir un accumulateur:

<xsl:mode on-no-match="shallow-copy" use-accumulators="rng"/>

Votre question résume le problème:

J'essaye d'écrire une fonction simple pour me fournir une lettre aléatoire chaque fois que je l'appelle

Mais une fonction qui produit des résultats différents sur différentes invocations (avec les mêmes arguments) n'est pas une fonction vraie ("pure").

Une façon de sortir de cela est d'exploiter le fait que XSLT a déjà des fonctions "impures" d'un genre: une fonction qui crée un nouveau nœud retourne un nœud différent à chaque fois, et vous pouvez l'exposer en utilisant generate-id (). Vous pouvez donc écrire

<xsl:function name="my:random" as="xs:double">
  <xsl:variable name="dummy"><a/></xsl:variable>
  <xsl:sequence select="fn:random-number-generator(generate-id($dummy))?permute(1 to 10)"/>
</xsl:function>

Le seul problème avec ceci est que vous êtes juste sur les limites de ce qui est bien défini dans la spécification et l'optimiseur pourrait ne pas vous laisser partir avec de telles astuces. Il est préférable, si vous le pouvez, de trouver un moyen de passer un argument différent à la fonction à chaque fois qu'elle est appelée: par exemple, un numéro de séquence, ou generate-id () appliqué au nœud d'entrée que vous traitez actuellement.

Par souci d'exhaustivité, j'ai proposé cette solution mais elle ne fonctionne que pour de petits morceaux de texte en raison de la profondeur de la récursivité.

En passant, j'ai réalisé que ma solution était une perte de temps car J'utilise exist-db qui n'inclut pas le générateur de nombres aléatoires dans son implémentation XSLT.

<xsl:function name="gdpr:rngRecurseStart">
     <xsl:param name="text"></xsl:param>
     <xsl:variable name="chars" select="functx:chars($text)"/>

     <xsl:copy-of select="gdpr:rngRecurse($chars,random-number-generator(current-dateTime()),'')"></xsl:copy-of>
 </xsl:function>

 <xsl:function name="gdpr:rngRecurse">
     <xsl:param name="chars"></xsl:param>
     <xsl:param name="rngGenerator"></xsl:param>
     <xsl:param name="newText"></xsl:param>
     <xsl:variable name="curentchar" select="$chars[1]"></xsl:variable>
     <xsl:variable name="newRngGenerator" select="$rngGenerator?next()"/>
     <xsl:choose>
         <xsl:when test="count($chars) >1">
             <xsl:variable name="transformedChar" select="gdpr:randomLetter2($newRngGenerator,$curentchar)"/>
             <xsl:variable name="resultText" select="concat($newText, $transformedChar)"/>
             <xsl:copy-of select="gdpr:rngRecurse(subsequence($chars,2),$newRngGenerator,$resultText)"></xsl:copy-of>
         </xsl:when>
         <xsl:when test="count($chars) =1">
             <xsl:variable name="transformedChar" select="gdpr:randomLetter2($newRngGenerator,$curentchar)"/>
             <xsl:variable name="resultText" select="concat($newText, $transformedChar)"/>
             <xsl:copy-of select="$resultText"></xsl:copy-of>
         </xsl:when>
         <xsl:otherwise><xsl:copy-of select="$newText"></xsl:copy-of></xsl:otherwise>
     </xsl:choose>

 </xsl:function>