Comma Separated Data

Jeni Tennison

If data.csv stays the same, then convert it to an XML file using sed or perl or whatever you fancy, and use that.

If data.csv changes, but doesn't contain any <s or &s, then you could create a wrapper XML document that accesses it as an external entity - data.xml:

 <?xml version="1.0"?>
 <!DOCTYPE data [
 <!ENTITY data SYSTEM 'data.csv'>
 ]>
 <data>&data;</data>

You could then access the data using the document() function, though you'd have to work through the CSV document using string manipulation functions in XSLT/XPath, which isn't all that fun.

Alternatively, if you're using an XSLT processor that accepts SAX events you could write a custom entity resolver that reads in the CSV document and generates SAX events to make the XSLT processor think that it's accessed an XML document. That would also allow you take advantage of the string manipulation support in whatever programming language you were using, such that the XSLT processor 'sees' the CSV file as elements.

Arnold, Curt

I need to separate the following data into separate fields:
 
<years  title = "year">1994, 1995, 1996, 1997, 
1998, 1999, 2000, 2001, 2002, 2003,   </year>
 
For instance, the output needs to read:
 
<tr><td>1994</td><td>1995</td><td>1996</td> 
... etc ... </tr>





It should be possible using recursive named template calls,
something like
 
<xsl:template name="displayyear">
    <xsl:param name="yearlist"/>
    <xsl:variable name="year" 
        select="substring-before($yearlist,',')"/>
    <xsl:choose>
        <xsl:when test="string-length($year) > 0">
            <td><xsl:value-of select="$year"/></td>
            <xsl:call-template name="displayyear">
                <xsl:with-param 
             name="yearlist"><xsl:value-of 
             select="substring-after($yearlist,',')"/>
               </xsl:with-param>
            </xsl:call-template>
       </xsl:when>
        <xsl:otherwise>
             <td><xsl:value-of select="$yearlist"/></td>
        </xsl:otherwise>
    </xsl:choose>
</xsl:template>

Jorg Heinicke

How to convert comma separated input to a table? HTML table out of this?

This resolves it using the divide template

Dimitre Novatchev

You have a CSV string (a list of characters), you need to inspect every character and to gradually accumulate the result -- a list of words, that were delimited by special characters (in this particular case by comma and/or white space).

A "generic accumulator" function over the elements of a list is the "foldl" function -- the classic king of generic list processing. We pass to "foldl" as parameter a function that will be called with two arguments -- the accumulated result until now (the list of tokens so far) and the next character in the input string. Based on these two arguments, this function updates the accumulated result appropriately -- it either appends the character to the last token, or "cuts" the last token and starts a new one.

And here's the solution:

 <xsl:stylesheet version="1.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:msxsl="urn:schemas-microsoft-com:xslt"
 xmlns:str-split2words-func="f:str-split2words-func"
 exclude-result-prefixes="xsl msxsl str-split2words-func" >
 
    <xsl:import href="str-foldl.xsl"/>
 
    <str-split2words-func:str-split2words-func/>
 
    <xsl:param name="pDelimiters" 
              select="', 	

'"/>
 
    <xsl:output indent="yes" omit-xml-declaration="yes"/>
    
     <xsl:template match="/">
       <xsl:call-template name="str-split-to-words">
         <xsl:with-param name="pStr" select="/*/*"/>
       </xsl:call-template>
     </xsl:template>
 
     <xsl:template name="str-split-to-words">
       <xsl:param name="pStr" select="dummy"/>
       
       <xsl:variable name="vsplit2wordsFun"
           select="document('')/*/str-split2words-func:*[1]"/>
 
       <xsl:call-template name="str-foldl">
         <xsl:with-param name="pFunc" select="$vsplit2wordsFun"/>
         <xsl:with-param name="pStr" select="$pStr"/>
         <xsl:with-param name="pA0" select="/.."/>
       </xsl:call-template>
 
     </xsl:template>
 
     <xsl:template match="str-split2words-func:*">
       <xsl:param name="arg1" select="/.."/>
       <xsl:param name="arg2"/>
          
       <xsl:choose>
         <xsl:when test="contains($pDelimiters, $arg2)">
             <xsl:copy-of select="$arg1/*"/>
             <xsl:if test="string($arg1/*[last()])">
               <word/>
             </xsl:if>
         </xsl:when>
         <xsl:otherwise>
           <xsl:copy-of 
               select="$arg1/*[position() < last()]"/>
           <word><xsl:value-of 
                 select="concat($arg1/*[last()], 
 $arg2)"/></word>
         </xsl:otherwise>
       </xsl:choose>
     </xsl:template>
 
 </xsl:stylesheet>
 

When applied on the following xml document:

The result is:

 <word>Fredrick</word>
     <word>Aaron</word><word>john
              </word><word>
 peter</word>

We need just one more small step in order to obtain the ultimate tokenizer -- if we manage to pass the list of delimiters to the accumulating function that we pass as parameter to str-foldl, then we have the most general tokenizer function. You'll never anymore need to code your own tokenizer, just call this one with your parameters.

The solution is to always specify the list of delimiters as the first element of the "accumulator" list:

 <xsl:stylesheet version="1.0"
 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 xmlns:msxsl="urn:schemas-microsoft-com:xslt"
 xmlns:str-split2words-func="f:str-split2words-func"
 exclude-result-prefixes="xsl msxsl str-split2words-func" >
 
    <xsl:import href="str-foldl.xsl"/>
 
    <str-split2words-func:str-split2words-func/>
 
    <xsl:output indent="yes" omit-xml-declaration="yes"/>
    
     <xsl:template match="/">
       <xsl:call-template name="str-split-to-words">
         <xsl:with-param name="pStr" select="/*/*"/>
         <xsl:with-param name="pDelimiters" 
         select="',  	

'"/>
       </xsl:call-template>
     </xsl:template>
 
     <xsl:template name="str-split-to-words">
       <xsl:param name="pStr"/>
       <xsl:param name="pDelimiters"/>
       
       <xsl:variable name="vsplit2wordsFun"             
 select="document('')/*/str-split2words-func:*[1]"/>
                     
       <xsl:variable name="vrtfParams">
        <delimiters><xsl:value-of 
                 select="$pDelimiters"/></delimiters>
       </xsl:variable>
 
       <xsl:variable name="vResult">
 	      <xsl:call-template name="str-foldl">
 	        <xsl:with-param name="pFunc" 
	       select="$vsplit2wordsFun"/>
 	        <xsl:with-param name="pStr" select="$pStr"/>
 	        <xsl:with-param name="pA0" 
 select="msxsl:node-set($vrtfParams)"/>
 	      </xsl:call-template>
       </xsl:variable>
       
       <xsl:copy-of select="msxsl:node-set($vResult)/word"/>
 
     </xsl:template>
 
     <xsl:template match="str-split2words-func:*">
       <xsl:param name="arg1" select="/.."/>
       <xsl:param name="arg2"/>
          
       <xsl:copy-of select="$arg1/*[1]"/>
       <xsl:copy-of select="$arg1/word[position() != last()]"/>
       
       <xsl:choose>
         <xsl:when test="contains($arg1/*[1], $arg2)">
           <xsl:if test="string($arg1/word[last()])">
              <xsl:copy-of select="$arg1/word[last()]"/>
           </xsl:if>
           <word/>
         </xsl:when>
         <xsl:otherwise>
           <word><xsl:value-of 
 select="concat($arg1/word[last()], $arg2)"/></word>
         </xsl:otherwise>
       </xsl:choose>
     </xsl:template>
 
 </xsl:stylesheet>
 

And with the same xml source document, here's the result:

Stuart Brown

You can use a recursive template to break down the string:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                version="1.0">

  <xsl:template match="data">
    <xsl:variable name="dataString" select="text()"/>
    <xsl:call-template name="commaSplit">
      <xsl:with-param name="dataString" select="$dataString"/>
      <xsl:with-param name="position" select="1"/>
    </xsl:call-template>
  </xsl:template>

  <xsl:template name="commaSplit">
    <xsl:param name="dataString"/>
    <xsl:param name="position"/>
    <xsl:choose>
      <xsl:when test="contains($dataString,',')">
        <!-- Select the first value to process -->
        <xsl:call-template name="doWhatever">
          <xsl:with-param name="doWith"
	  select="substring-before($dataString,',')"/>
          <xsl:with-param name="position" select="$position"/>
        </xsl:call-template>
        <!-- Recurse with remainder of string -->
        <xsl:call-template name="commaSplit">
          <xsl:with-param name="dataString"
select="substring-after($dataString,',')"/>
          <xsl:with-param name="position" select="$position + 1"/>
        </xsl:call-template>
      </xsl:when>
      <xsl:otherwise>
        <!-- This is the last value so we don't recurse -->
        <xsl:call-template name="doWhatever">
          <xsl:with-param name="doWith" select="$dataString"/>
          <xsl:with-param name="position" select="$position"/>
        </xsl:call-template>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <!-- Process of individual value here -->
  <xsl:template name="doWhatever">
    <xsl:param name="doWith"/>
    <xsl:param name="position"/>
    <outputValueInElementWithABigLongName position="{$position}">
      <xsl:value-of select="$doWith"/>
    </outputValueInElementWithABigLongName>
  </xsl:template>

  <xsl:template match="*">
    <xsl:apply-templates/>
  </xsl:template>

</xsl:stylesheet>

There's plenty of other examples of this kind of this in the archives.