Help with xslt syntax error

Discussion in 'XML' started by Chris Kettenbach, Aug 25, 2005.

  1. Hi Peter,
    I get error when processing the stylesheet. It errors here.

    <xsl:for-each select="registration[count(.|key('entry',company
    [1])=1]">

    specifically:

    Expression does not return a DOM node.
    registration[-->count(.|key('entry',company[1])=1]<--

    Ideas?


    Thanks,
    Chris

    "Peter Flynn" <> wrote in message
    news:...
    > Chris Kettenbach wrote:
    >
    >> Good Morning,
    >> Sorry for xposting. Just need a liitle help.
    >> I have an xml file that's generated from a database. How do I select
    >> distinct values from a field

    >
    > XML doesn't have fields -- the database did but this isn't a database any
    > more. In XML they're called elements (they've got a lot in common with
    > fields but they ain't the same).
    >
    >> in xslt and then loop through the records and
    >> produce output.

    >
    > It looks like you need to process the information grouped by company name,
    > and there's a technique in XSLT 1.0 for doing this called Muenchian
    > grouping
    > (it won't be needed in XSLT 2 because that has a built-in group-processing
    > command, but XSLT 2 is not a Recommendation yet).
    >
    > Check the XSLT FAQ for "Muenchian" to find examples.
    >
    > ///Peter
    >
    > [Group and followup corrected to comp.text.xml]
    >
    >> Example
    >>
    >> <registrations>
    >> <registration>
    >> <company>Awesome Printers</company>
    >> <first>John</first>
    >> <last>Smith</last>
    >> </registration>
    >> <registration>
    >> <company>Awesome Printers</company>
    >> <first>Bob</first>
    >> <last>Roberts</last>
    >> </registration>
    >> <registration>
    >> <company>Awesome Printers</company>
    >> <first>John</first>
    >> <last>Johnson</last>
    >> </registration>
    >> <registration>
    >> <company>Other Company</company>
    >> <first>Tom</first>
    >> <last>Thomas</last>
    >> </registration>
    >> <registration>
    >> <company>Other Company</company>
    >> <first>Dan</first>
    >> <last>Daniels</last>
    >> </registration>
    >> </registrations>
    >> ++++++++++++++++++++++++++++++++++++++++++++++++
    >> I want the out put to be something like this
    >>
    >> <table>
    >> <tr>
    >> <td>Company Name</td>
    >> <td>Employees</td>
    >> </tr>
    >> <tr>
    >> <td>Awesome Printers</td>
    >> <td>John Smith<br/>
    >> Bob Roberts<br/>
    >> John Johnson<br/></td>
    >> </tr>
    >> <tr>
    >> <td>Other Company</td>
    >> <td>Tom Thomas<br/>
    >> Dan Daniels<br/></td>
    >> </tr>
    >> </table>
    >>
    >> Effectively writing unique company names once and then putting only the
    >> employees from that company into the employee table cell.

    >
    > If you scrolled down this far then you've been rewarded :)
    >
    > The trick is to use lookup keys to test the selected group of elements
    > against, in order to pick only the first ocurrence in each group; then
    > output the group header at that point; and only then go and process all
    > the
    > elements in the group to extract the detail from each of them.
    >
    > The syntax is tricky because it's very compact. It selects all
    > registration
    > elements, but subjects each of them to the test that [the number of nodes
    > in
    > the union of (the current node and the first node with the current company
    > value returned by the lookup) is equal to 1] -- in effect meaning they are
    > one and the same node, ie the first in their company name grouping. You'll
    > probably need to read that 3 or 4 times -- it took me a week to grok it.
    >
    > <?xml version="1.0" encoding="iso-8859-1"?>
    > <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    > version="1.0">
    >
    > <xsl:eek:utput method="html"/>
    >
    > <xsl:key name="entry" match="registration" use="company"/>
    >
    > <xsl:template match="/">
    > <html>
    > <head>
    > <title>Registrations</title>
    > </head>
    > <body>
    > <xsl:apply-templates/>
    > </body>
    > </html>
    > </xsl:template>
    >
    > <xsl:template match="registrations">
    > <table>
    > <xsl:for-each select="registration[count(.|key('entry',company
    > [1])=1]">
    > <xsl:sort select="company"/>
    > <tr>
    > <th valign="top">
    > <xsl:value-of select="company"/>
    > </th>
    > <td valign="top">
    > <xsl:for-each select="key('entry',current()/company)">
    > <xsl:sort select="last"/>
    > <xsl:value-of select="first"/>
    > <xsl:text> </xsl:text>
    > <xsl:value-of select="last"/>
    > <xsl:if test="position()!=last()">
    > <br/>
    > </xsl:if>
    > </xsl:for-each>
    > </td>
    > </tr>
    > </xsl:for-each>
    > </table>
    > </xsl:template>
    >
    > </xsl:stylesheet>
    >
    > ///Peter
    >
     
    Chris Kettenbach, Aug 25, 2005
    #1
    1. Advertising

  2. Unbalanced left <--> right parenthenses



    "Chris Kettenbach" <> wrote in message
    news:...
    > Hi Peter,
    > I get error when processing the stylesheet. It errors here.
    >
    > <xsl:for-each select="registration[count(.|key('entry',company
    > [1])=1]">
    >
    > specifically:
    >
    > Expression does not return a DOM node.
    > registration[-->count(.|key('entry',company[1])=1]<--
    >
    > Ideas?
    >
    >
    > Thanks,
    > Chris
    >
    > "Peter Flynn" <> wrote in message
    > news:...
    >> Chris Kettenbach wrote:
    >>
    >>> Good Morning,
    >>> Sorry for xposting. Just need a liitle help.
    >>> I have an xml file that's generated from a database. How do I select
    >>> distinct values from a field

    >>
    >> XML doesn't have fields -- the database did but this isn't a database any
    >> more. In XML they're called elements (they've got a lot in common with
    >> fields but they ain't the same).
    >>
    >>> in xslt and then loop through the records and
    >>> produce output.

    >>
    >> It looks like you need to process the information grouped by company
    >> name,
    >> and there's a technique in XSLT 1.0 for doing this called Muenchian
    >> grouping
    >> (it won't be needed in XSLT 2 because that has a built-in
    >> group-processing
    >> command, but XSLT 2 is not a Recommendation yet).
    >>
    >> Check the XSLT FAQ for "Muenchian" to find examples.
    >>
    >> ///Peter
    >>
    >> [Group and followup corrected to comp.text.xml]
    >>
    >>> Example
    >>>
    >>> <registrations>
    >>> <registration>
    >>> <company>Awesome Printers</company>
    >>> <first>John</first>
    >>> <last>Smith</last>
    >>> </registration>
    >>> <registration>
    >>> <company>Awesome Printers</company>
    >>> <first>Bob</first>
    >>> <last>Roberts</last>
    >>> </registration>
    >>> <registration>
    >>> <company>Awesome Printers</company>
    >>> <first>John</first>
    >>> <last>Johnson</last>
    >>> </registration>
    >>> <registration>
    >>> <company>Other Company</company>
    >>> <first>Tom</first>
    >>> <last>Thomas</last>
    >>> </registration>
    >>> <registration>
    >>> <company>Other Company</company>
    >>> <first>Dan</first>
    >>> <last>Daniels</last>
    >>> </registration>
    >>> </registrations>
    >>> ++++++++++++++++++++++++++++++++++++++++++++++++
    >>> I want the out put to be something like this
    >>>
    >>> <table>
    >>> <tr>
    >>> <td>Company Name</td>
    >>> <td>Employees</td>
    >>> </tr>
    >>> <tr>
    >>> <td>Awesome Printers</td>
    >>> <td>John Smith<br/>
    >>> Bob Roberts<br/>
    >>> John Johnson<br/></td>
    >>> </tr>
    >>> <tr>
    >>> <td>Other Company</td>
    >>> <td>Tom Thomas<br/>
    >>> Dan Daniels<br/></td>
    >>> </tr>
    >>> </table>
    >>>
    >>> Effectively writing unique company names once and then putting only the
    >>> employees from that company into the employee table cell.

    >>
    >> If you scrolled down this far then you've been rewarded :)
    >>
    >> The trick is to use lookup keys to test the selected group of elements
    >> against, in order to pick only the first ocurrence in each group; then
    >> output the group header at that point; and only then go and process all
    >> the
    >> elements in the group to extract the detail from each of them.
    >>
    >> The syntax is tricky because it's very compact. It selects all
    >> registration
    >> elements, but subjects each of them to the test that [the number of nodes
    >> in
    >> the union of (the current node and the first node with the current
    >> company
    >> value returned by the lookup) is equal to 1] -- in effect meaning they
    >> are
    >> one and the same node, ie the first in their company name grouping.
    >> You'll
    >> probably need to read that 3 or 4 times -- it took me a week to grok it.
    >>
    >> <?xml version="1.0" encoding="iso-8859-1"?>
    >> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    >> version="1.0">
    >>
    >> <xsl:eek:utput method="html"/>
    >>
    >> <xsl:key name="entry" match="registration" use="company"/>
    >>
    >> <xsl:template match="/">
    >> <html>
    >> <head>
    >> <title>Registrations</title>
    >> </head>
    >> <body>
    >> <xsl:apply-templates/>
    >> </body>
    >> </html>
    >> </xsl:template>
    >>
    >> <xsl:template match="registrations">
    >> <table>
    >> <xsl:for-each select="registration[count(.|key('entry',company
    >> [1])=1]">
    >> <xsl:sort select="company"/>
    >> <tr>
    >> <th valign="top">
    >> <xsl:value-of select="company"/>
    >> </th>
    >> <td valign="top">
    >> <xsl:for-each select="key('entry',current()/company)">
    >> <xsl:sort select="last"/>
    >> <xsl:value-of select="first"/>
    >> <xsl:text> </xsl:text>
    >> <xsl:value-of select="last"/>
    >> <xsl:if test="position()!=last()">
    >> <br/>
    >> </xsl:if>
    >> </xsl:for-each>
    >> </td>
    >> </tr>
    >> </xsl:for-each>
    >> </table>
    >> </xsl:template>
    >>
    >> </xsl:stylesheet>
    >>
    >> ///Peter
    >>

    >
    >
    >
     
    Dimitre Novatchev, Aug 25, 2005
    #2
    1. Advertising

  3. Do you have an example of how it should look?
    Thanks for your help.
    Chris


    "Dimitre Novatchev" <> wrote in message
    news:430e1bdc$0$80641$...
    > Unbalanced left <--> right parenthenses
    >
    >
    >
    > "Chris Kettenbach" <> wrote in message
    > news:...
    >> Hi Peter,
    >> I get error when processing the stylesheet. It errors here.
    >>
    >> <xsl:for-each select="registration[count(.|key('entry',company
    >> [1])=1]">
    >>
    >> specifically:
    >>
    >> Expression does not return a DOM node.
    >> registration[-->count(.|key('entry',company[1])=1]<--
    >>
    >> Ideas?
    >>
    >>
    >> Thanks,
    >> Chris
    >>
    >> "Peter Flynn" <> wrote in message
    >> news:...
    >>> Chris Kettenbach wrote:
    >>>
    >>>> Good Morning,
    >>>> Sorry for xposting. Just need a liitle help.
    >>>> I have an xml file that's generated from a database. How do I select
    >>>> distinct values from a field
    >>>
    >>> XML doesn't have fields -- the database did but this isn't a database
    >>> any
    >>> more. In XML they're called elements (they've got a lot in common with
    >>> fields but they ain't the same).
    >>>
    >>>> in xslt and then loop through the records and
    >>>> produce output.
    >>>
    >>> It looks like you need to process the information grouped by company
    >>> name,
    >>> and there's a technique in XSLT 1.0 for doing this called Muenchian
    >>> grouping
    >>> (it won't be needed in XSLT 2 because that has a built-in
    >>> group-processing
    >>> command, but XSLT 2 is not a Recommendation yet).
    >>>
    >>> Check the XSLT FAQ for "Muenchian" to find examples.
    >>>
    >>> ///Peter
    >>>
    >>> [Group and followup corrected to comp.text.xml]
    >>>
    >>>> Example
    >>>>
    >>>> <registrations>
    >>>> <registration>
    >>>> <company>Awesome Printers</company>
    >>>> <first>John</first>
    >>>> <last>Smith</last>
    >>>> </registration>
    >>>> <registration>
    >>>> <company>Awesome Printers</company>
    >>>> <first>Bob</first>
    >>>> <last>Roberts</last>
    >>>> </registration>
    >>>> <registration>
    >>>> <company>Awesome Printers</company>
    >>>> <first>John</first>
    >>>> <last>Johnson</last>
    >>>> </registration>
    >>>> <registration>
    >>>> <company>Other Company</company>
    >>>> <first>Tom</first>
    >>>> <last>Thomas</last>
    >>>> </registration>
    >>>> <registration>
    >>>> <company>Other Company</company>
    >>>> <first>Dan</first>
    >>>> <last>Daniels</last>
    >>>> </registration>
    >>>> </registrations>
    >>>> ++++++++++++++++++++++++++++++++++++++++++++++++
    >>>> I want the out put to be something like this
    >>>>
    >>>> <table>
    >>>> <tr>
    >>>> <td>Company Name</td>
    >>>> <td>Employees</td>
    >>>> </tr>
    >>>> <tr>
    >>>> <td>Awesome Printers</td>
    >>>> <td>John Smith<br/>
    >>>> Bob Roberts<br/>
    >>>> John Johnson<br/></td>
    >>>> </tr>
    >>>> <tr>
    >>>> <td>Other Company</td>
    >>>> <td>Tom Thomas<br/>
    >>>> Dan Daniels<br/></td>
    >>>> </tr>
    >>>> </table>
    >>>>
    >>>> Effectively writing unique company names once and then putting only the
    >>>> employees from that company into the employee table cell.
    >>>
    >>> If you scrolled down this far then you've been rewarded :)
    >>>
    >>> The trick is to use lookup keys to test the selected group of elements
    >>> against, in order to pick only the first ocurrence in each group; then
    >>> output the group header at that point; and only then go and process all
    >>> the
    >>> elements in the group to extract the detail from each of them.
    >>>
    >>> The syntax is tricky because it's very compact. It selects all
    >>> registration
    >>> elements, but subjects each of them to the test that [the number of
    >>> nodes
    >>> in
    >>> the union of (the current node and the first node with the current
    >>> company
    >>> value returned by the lookup) is equal to 1] -- in effect meaning they
    >>> are
    >>> one and the same node, ie the first in their company name grouping.
    >>> You'll
    >>> probably need to read that 3 or 4 times -- it took me a week to grok it.
    >>>
    >>> <?xml version="1.0" encoding="iso-8859-1"?>
    >>> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    >>> version="1.0">
    >>>
    >>> <xsl:eek:utput method="html"/>
    >>>
    >>> <xsl:key name="entry" match="registration" use="company"/>
    >>>
    >>> <xsl:template match="/">
    >>> <html>
    >>> <head>
    >>> <title>Registrations</title>
    >>> </head>
    >>> <body>
    >>> <xsl:apply-templates/>
    >>> </body>
    >>> </html>
    >>> </xsl:template>
    >>>
    >>> <xsl:template match="registrations">
    >>> <table>
    >>> <xsl:for-each select="registration[count(.|key('entry',company
    >>> [1])=1]">
    >>> <xsl:sort select="company"/>
    >>> <tr>
    >>> <th valign="top">
    >>> <xsl:value-of select="company"/>
    >>> </th>
    >>> <td valign="top">
    >>> <xsl:for-each select="key('entry',current()/company)">
    >>> <xsl:sort select="last"/>
    >>> <xsl:value-of select="first"/>
    >>> <xsl:text> </xsl:text>
    >>> <xsl:value-of select="last"/>
    >>> <xsl:if test="position()!=last()">
    >>> <br/>
    >>> </xsl:if>
    >>> </xsl:for-each>
    >>> </td>
    >>> </tr>
    >>> </xsl:for-each>
    >>> </table>
    >>> </xsl:template>
    >>>
    >>> </xsl:stylesheet>
    >>>
    >>> ///Peter
    >>>

    >>
    >>
    >>

    >
    >
     
    Chris Kettenbach, Aug 25, 2005
    #3
  4. "Chris Kettenbach" <> wrote in message
    news:...
    > Do you have an example of how it should look?
    > Thanks for your help.
    > Chris


    I am not a compiler, but I have developed a tool that may help -- use the
    XPath Visualizer to play with XPath and learn it the fun way.


    Cheers,
    Dimitre Novatchev

    P.S. By not answering your question and directing you to serious
    self-training with the XPath Visualizer I am actually saving you a lot of
    time -- just try it and you'll see :eek:)



    >
    >
    > "Dimitre Novatchev" <> wrote in message
    > news:430e1bdc$0$80641$...
    >> Unbalanced left <--> right parenthenses
    >>
    >>
    >>
    >> "Chris Kettenbach" <> wrote in message
    >> news:...
    >>> Hi Peter,
    >>> I get error when processing the stylesheet. It errors here.
    >>>
    >>> <xsl:for-each select="registration[count(.|key('entry',company
    >>> [1])=1]">
    >>>
    >>> specifically:
    >>>
    >>> Expression does not return a DOM node.
    >>> registration[-->count(.|key('entry',company[1])=1]<--
    >>>
    >>> Ideas?
    >>>
    >>>
    >>> Thanks,
    >>> Chris
    >>>
    >>> "Peter Flynn" <> wrote in message
    >>> news:...
    >>>> Chris Kettenbach wrote:
    >>>>
    >>>>> Good Morning,
    >>>>> Sorry for xposting. Just need a liitle help.
    >>>>> I have an xml file that's generated from a database. How do I select
    >>>>> distinct values from a field
    >>>>
    >>>> XML doesn't have fields -- the database did but this isn't a database
    >>>> any
    >>>> more. In XML they're called elements (they've got a lot in common with
    >>>> fields but they ain't the same).
    >>>>
    >>>>> in xslt and then loop through the records and
    >>>>> produce output.
    >>>>
    >>>> It looks like you need to process the information grouped by company
    >>>> name,
    >>>> and there's a technique in XSLT 1.0 for doing this called Muenchian
    >>>> grouping
    >>>> (it won't be needed in XSLT 2 because that has a built-in
    >>>> group-processing
    >>>> command, but XSLT 2 is not a Recommendation yet).
    >>>>
    >>>> Check the XSLT FAQ for "Muenchian" to find examples.
    >>>>
    >>>> ///Peter
    >>>>
    >>>> [Group and followup corrected to comp.text.xml]
    >>>>
    >>>>> Example
    >>>>>
    >>>>> <registrations>
    >>>>> <registration>
    >>>>> <company>Awesome Printers</company>
    >>>>> <first>John</first>
    >>>>> <last>Smith</last>
    >>>>> </registration>
    >>>>> <registration>
    >>>>> <company>Awesome Printers</company>
    >>>>> <first>Bob</first>
    >>>>> <last>Roberts</last>
    >>>>> </registration>
    >>>>> <registration>
    >>>>> <company>Awesome Printers</company>
    >>>>> <first>John</first>
    >>>>> <last>Johnson</last>
    >>>>> </registration>
    >>>>> <registration>
    >>>>> <company>Other Company</company>
    >>>>> <first>Tom</first>
    >>>>> <last>Thomas</last>
    >>>>> </registration>
    >>>>> <registration>
    >>>>> <company>Other Company</company>
    >>>>> <first>Dan</first>
    >>>>> <last>Daniels</last>
    >>>>> </registration>
    >>>>> </registrations>
    >>>>> ++++++++++++++++++++++++++++++++++++++++++++++++
    >>>>> I want the out put to be something like this
    >>>>>
    >>>>> <table>
    >>>>> <tr>
    >>>>> <td>Company Name</td>
    >>>>> <td>Employees</td>
    >>>>> </tr>
    >>>>> <tr>
    >>>>> <td>Awesome Printers</td>
    >>>>> <td>John Smith<br/>
    >>>>> Bob Roberts<br/>
    >>>>> John Johnson<br/></td>
    >>>>> </tr>
    >>>>> <tr>
    >>>>> <td>Other Company</td>
    >>>>> <td>Tom Thomas<br/>
    >>>>> Dan Daniels<br/></td>
    >>>>> </tr>
    >>>>> </table>
    >>>>>
    >>>>> Effectively writing unique company names once and then putting only
    >>>>> the
    >>>>> employees from that company into the employee table cell.
    >>>>
    >>>> If you scrolled down this far then you've been rewarded :)
    >>>>
    >>>> The trick is to use lookup keys to test the selected group of elements
    >>>> against, in order to pick only the first ocurrence in each group; then
    >>>> output the group header at that point; and only then go and process all
    >>>> the
    >>>> elements in the group to extract the detail from each of them.
    >>>>
    >>>> The syntax is tricky because it's very compact. It selects all
    >>>> registration
    >>>> elements, but subjects each of them to the test that [the number of
    >>>> nodes
    >>>> in
    >>>> the union of (the current node and the first node with the current
    >>>> company
    >>>> value returned by the lookup) is equal to 1] -- in effect meaning they
    >>>> are
    >>>> one and the same node, ie the first in their company name grouping.
    >>>> You'll
    >>>> probably need to read that 3 or 4 times -- it took me a week to grok
    >>>> it.
    >>>>
    >>>> <?xml version="1.0" encoding="iso-8859-1"?>
    >>>> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    >>>> version="1.0">
    >>>>
    >>>> <xsl:eek:utput method="html"/>
    >>>>
    >>>> <xsl:key name="entry" match="registration" use="company"/>
    >>>>
    >>>> <xsl:template match="/">
    >>>> <html>
    >>>> <head>
    >>>> <title>Registrations</title>
    >>>> </head>
    >>>> <body>
    >>>> <xsl:apply-templates/>
    >>>> </body>
    >>>> </html>
    >>>> </xsl:template>
    >>>>
    >>>> <xsl:template match="registrations">
    >>>> <table>
    >>>> <xsl:for-each select="registration[count(.|key('entry',company
    >>>> [1])=1]">
    >>>> <xsl:sort select="company"/>
    >>>> <tr>
    >>>> <th valign="top">
    >>>> <xsl:value-of select="company"/>
    >>>> </th>
    >>>> <td valign="top">
    >>>> <xsl:for-each select="key('entry',current()/company)">
    >>>> <xsl:sort select="last"/>
    >>>> <xsl:value-of select="first"/>
    >>>> <xsl:text> </xsl:text>
    >>>> <xsl:value-of select="last"/>
    >>>> <xsl:if test="position()!=last()">
    >>>> <br/>
    >>>> </xsl:if>
    >>>> </xsl:for-each>
    >>>> </td>
    >>>> </tr>
    >>>> </xsl:for-each>
    >>>> </table>
    >>>> </xsl:template>
    >>>>
    >>>> </xsl:stylesheet>
    >>>>
    >>>> ///Peter
    >>>>
    >>>
    >>>
    >>>

    >>
    >>

    >
    >
     
    Dimitre Novatchev, Aug 25, 2005
    #4
  5. Chris Kettenbach

    Peter Flynn Guest

    Dimitre Novatchev wrote:

    > Unbalanced left <--> right parenthenses


    Quite right, it looks like something chewed off the closing parenthesis.
    I pasted the code from the working file, so it may have been garbled in
    transmission. The line should read

    <xsl:for-each select="registration[count(.|key('entry',company)[1])=1]">

    (that too is cut'n'paste so if that gets screwed, I'm sorry).

    ///Peter

    >
    >
    > "Chris Kettenbach" <> wrote in message
    > news:...
    >> Hi Peter,
    >> I get error when processing the stylesheet. It errors here.
    >>
    >> <xsl:for-each select="registration[count(.|key('entry',company
    >> [1])=1]">
    >>
    >> specifically:
    >>
    >> Expression does not return a DOM node.
    >> registration[-->count(.|key('entry',company[1])=1]<--
    >>
    >> Ideas?
    >>
    >>
    >> Thanks,
    >> Chris
    >>
    >> "Peter Flynn" <> wrote in message
    >> news:...
    >>> Chris Kettenbach wrote:
    >>>
    >>>> Good Morning,
    >>>> Sorry for xposting. Just need a liitle help.
    >>>> I have an xml file that's generated from a database. How do I select
    >>>> distinct values from a field
    >>>
    >>> XML doesn't have fields -- the database did but this isn't a database
    >>> any more. In XML they're called elements (they've got a lot in common
    >>> with fields but they ain't the same).
    >>>
    >>>> in xslt and then loop through the records and
    >>>> produce output.
    >>>
    >>> It looks like you need to process the information grouped by company
    >>> name,
    >>> and there's a technique in XSLT 1.0 for doing this called Muenchian
    >>> grouping
    >>> (it won't be needed in XSLT 2 because that has a built-in
    >>> group-processing
    >>> command, but XSLT 2 is not a Recommendation yet).
    >>>
    >>> Check the XSLT FAQ for "Muenchian" to find examples.
    >>>
    >>> ///Peter
    >>>
    >>> [Group and followup corrected to comp.text.xml]
    >>>
    >>>> Example
    >>>>
    >>>> <registrations>
    >>>> <registration>
    >>>> <company>Awesome Printers</company>
    >>>> <first>John</first>
    >>>> <last>Smith</last>
    >>>> </registration>
    >>>> <registration>
    >>>> <company>Awesome Printers</company>
    >>>> <first>Bob</first>
    >>>> <last>Roberts</last>
    >>>> </registration>
    >>>> <registration>
    >>>> <company>Awesome Printers</company>
    >>>> <first>John</first>
    >>>> <last>Johnson</last>
    >>>> </registration>
    >>>> <registration>
    >>>> <company>Other Company</company>
    >>>> <first>Tom</first>
    >>>> <last>Thomas</last>
    >>>> </registration>
    >>>> <registration>
    >>>> <company>Other Company</company>
    >>>> <first>Dan</first>
    >>>> <last>Daniels</last>
    >>>> </registration>
    >>>> </registrations>
    >>>> ++++++++++++++++++++++++++++++++++++++++++++++++
    >>>> I want the out put to be something like this
    >>>>
    >>>> <table>
    >>>> <tr>
    >>>> <td>Company Name</td>
    >>>> <td>Employees</td>
    >>>> </tr>
    >>>> <tr>
    >>>> <td>Awesome Printers</td>
    >>>> <td>John Smith<br/>
    >>>> Bob Roberts<br/>
    >>>> John Johnson<br/></td>
    >>>> </tr>
    >>>> <tr>
    >>>> <td>Other Company</td>
    >>>> <td>Tom Thomas<br/>
    >>>> Dan Daniels<br/></td>
    >>>> </tr>
    >>>> </table>
    >>>>
    >>>> Effectively writing unique company names once and then putting only the
    >>>> employees from that company into the employee table cell.
    >>>
    >>> If you scrolled down this far then you've been rewarded :)
    >>>
    >>> The trick is to use lookup keys to test the selected group of elements
    >>> against, in order to pick only the first ocurrence in each group; then
    >>> output the group header at that point; and only then go and process all
    >>> the
    >>> elements in the group to extract the detail from each of them.
    >>>
    >>> The syntax is tricky because it's very compact. It selects all
    >>> registration
    >>> elements, but subjects each of them to the test that [the number of
    >>> nodes in
    >>> the union of (the current node and the first node with the current
    >>> company
    >>> value returned by the lookup) is equal to 1] -- in effect meaning they
    >>> are
    >>> one and the same node, ie the first in their company name grouping.
    >>> You'll
    >>> probably need to read that 3 or 4 times -- it took me a week to grok it.
    >>>
    >>> <?xml version="1.0" encoding="iso-8859-1"?>
    >>> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    >>> version="1.0">
    >>>
    >>> <xsl:eek:utput method="html"/>
    >>>
    >>> <xsl:key name="entry" match="registration" use="company"/>
    >>>
    >>> <xsl:template match="/">
    >>> <html>
    >>> <head>
    >>> <title>Registrations</title>
    >>> </head>
    >>> <body>
    >>> <xsl:apply-templates/>
    >>> </body>
    >>> </html>
    >>> </xsl:template>
    >>>
    >>> <xsl:template match="registrations">
    >>> <table>
    >>> <xsl:for-each select="registration[count(.|key('entry',company
    >>> [1])=1]">
    >>> <xsl:sort select="company"/>
    >>> <tr>
    >>> <th valign="top">
    >>> <xsl:value-of select="company"/>
    >>> </th>
    >>> <td valign="top">
    >>> <xsl:for-each select="key('entry',current()/company)">
    >>> <xsl:sort select="last"/>
    >>> <xsl:value-of select="first"/>
    >>> <xsl:text> </xsl:text>
    >>> <xsl:value-of select="last"/>
    >>> <xsl:if test="position()!=last()">
    >>> <br/>
    >>> </xsl:if>
    >>> </xsl:for-each>
    >>> </td>
    >>> </tr>
    >>> </xsl:for-each>
    >>> </table>
    >>> </xsl:template>
    >>>
    >>> </xsl:stylesheet>
    >>>
    >>> ///Peter
    >>>

    >>
    >>
    >>
     
    Peter Flynn, Aug 25, 2005
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Stylus Studio
    Replies:
    0
    Views:
    761
    Stylus Studio
    Aug 3, 2004
  2. Benjamin Hillsley
    Replies:
    3
    Views:
    1,744
    Dimitre Novatchev
    Sep 25, 2003
  3. ted
    Replies:
    1
    Views:
    651
    Laurens
    Jan 26, 2004
  4. Good Night Moon
    Replies:
    9
    Views:
    315
    Rick DeNatale
    Jul 25, 2007
  5. Mark Richards
    Replies:
    3
    Views:
    346
    Tad McClellan
    Nov 18, 2007
Loading...

Share This Page