Loading ...
Sorry, an error occurred while loading the content.
 

Find Root in DTD

Expand Messages
  • Tai Tran
    Hi, Given an DTD file, how can I create a program to parse the DTD find and find the root element? I ve seen some parsers using hastable, but I don t know how
    Message 1 of 23 , Sep 5, 2001
      Hi,

      Given an DTD file, how can I create a program to parse
      the DTD find and find the root element?

      I've seen some parsers using hastable, but I don't
      know how the whole process work. It would be great if
      you could explain how to do this?

      Best Regards,
      Kevin

      __________________________________________________
      Do You Yahoo!?
      Get email alerts & NEW webcam video instant messaging with Yahoo! Messenger
      http://im.yahoo.com
    • Ronald Bourret
      DTD files do not say which elements are root elements. Any element declared in the DTD can be a root element. The root element type for a particular XML
      Message 2 of 23 , Sep 6, 2001
        DTD files do not say which elements are root elements. Any element
        declared in the DTD can be a root element. The root element type for a
        particular XML document is declared in that document. For example:

        <?xml version="1.0"?>

        root element type declaration
        |
        v
        <!DOCTYPE "foo" [
        ... rest of DTD ...
        ]>
        <foo>
        ... elements, attributes, and text...
        </foo>

        If you want to parse a DTD, you can use the DTD parser shipped with
        XML-DBMS (de.tudarmstadt.ito.schemas.converters.SubsetToDTD). This
        builds a set of DTD objects that you can explore. You can also download
        the DTD parser separately from:

        http://www.rpbourret.com/schemas/index.htm

        For a list of other free DTD parsers in various languages, see:

        http://www.garshol.priv.no/download/xmltools/cat_ix.html#SC_DTDParser

        -- Ron

        Tai Tran wrote:
        >
        > Hi,
        >
        > Given an DTD file, how can I create a program to parse
        > the DTD find and find the root element?
        >
        > I've seen some parsers using hastable, but I don't
        > know how the whole process work. It would be great if
        > you could explain how to do this?
        >
        > Best Regards,
        > Kevin
        >
        > __________________________________________________
        > Do You Yahoo!?
        > Get email alerts & NEW webcam video instant messaging with Yahoo! Messenger
        > http://im.yahoo.com
        >
        >
        > To post a message, send it to: xml-dbms@yahoogroups.com
        > To unsubscribe, send a blank message to: xml-dbms-unsubscribe@yahoogroups.com
        > Or join the newsgroup at: news://news.barkto.com/homeless.xml.xml-dbms
        >
        > Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/

        --
        Ronald Bourret
        XML, Databases, and Schemas
        http://www.rpbourret.com
        Speaker, Geek Cruises' XML Excursion '02
      • Tai Tran
        Can your DTD parser (SubsetToDTD) find the root element? If yes, could you please tell me what is the function name and what data structure you used? Thanks
        Message 3 of 23 , Sep 6, 2001
          Can your DTD parser (SubsetToDTD) find the root
          element? If yes, could you please tell me what is the
          function name and what data structure you used?

          Thanks
          Kevin

          --- Ronald Bourret <rpbourret@...> wrote:
          > DTD files do not say which elements are root
          > elements. Any element
          > declared in the DTD can be a root element. The root
          > element type for a
          > particular XML document is declared in that
          > document. For example:
          >
          > <?xml version="1.0"?>
          >
          > root element type declaration
          > |
          > v
          > <!DOCTYPE "foo" [
          > ... rest of DTD ...
          > ]>
          > <foo>
          > ... elements, attributes, and text...
          > </foo>
          >
          > If you want to parse a DTD, you can use the DTD
          > parser shipped with
          > XML-DBMS
          > (de.tudarmstadt.ito.schemas.converters.SubsetToDTD).
          > This
          > builds a set of DTD objects that you can explore.
          > You can also download
          > the DTD parser separately from:
          >
          > http://www.rpbourret.com/schemas/index.htm
          >
          > For a list of other free DTD parsers in various
          > languages, see:
          >
          >
          >
          http://www.garshol.priv.no/download/xmltools/cat_ix.html#SC_DTDParser
          >
          > -- Ron
          >
          > Tai Tran wrote:
          > >
          > > Hi,
          > >
          > > Given an DTD file, how can I create a program to
          > parse
          > > the DTD find and find the root element?
          > >
          > > I've seen some parsers using hastable, but I don't
          > > know how the whole process work. It would be great
          > if
          > > you could explain how to do this?
          > >
          > > Best Regards,
          > > Kevin
          > >
          > > __________________________________________________
          > > Do You Yahoo!?
          > > Get email alerts & NEW webcam video instant
          > messaging with Yahoo! Messenger
          > > http://im.yahoo.com
          > >
          > >
          > > To post a message, send it to:
          > xml-dbms@yahoogroups.com
          > > To unsubscribe, send a blank message to:
          > xml-dbms-unsubscribe@yahoogroups.com
          > > Or join the newsgroup at:
          > news://news.barkto.com/homeless.xml.xml-dbms
          > >
          > > Your use of Yahoo! Groups is subject to
          > http://docs.yahoo.com/info/terms/
          >
          > --
          > Ronald Bourret
          > XML, Databases, and Schemas
          > http://www.rpbourret.com
          > Speaker, Geek Cruises' XML Excursion '02
          >


          __________________________________________________
          Do You Yahoo!?
          Get email alerts & NEW webcam video instant messaging with Yahoo! Messenger
          http://im.yahoo.com
        • Ronald Bourret
          ... No. It can t do this because the DTD doesn t tell you what the root element is. Any element can be the root element. This is kind of confusing. Since each
          Message 4 of 23 , Sep 6, 2001
            Tai Tran wrote:
            >
            > Can your DTD parser (SubsetToDTD) find the root
            > element?

            No. It can't do this because the DTD doesn't tell you what the root
            element is. Any element can be the root element.

            This is kind of confusing. Since each XML document must have a single
            root element, it is tempting to think that the DTD tells us what that
            root element is. This is not the case. Instead, the instance document
            tells us what the root element is.

            One consequence of this is that two XML documents with different root
            elements can be validated successfully with the same DTD. For example,
            suppose we have a DTD:

            example.dtd
            -----------
            <!ELEMENT A (B)>
            <!ELEMENT B (#PCDATA)>

            Now here are two valid XML documents with different root elements that
            both use this DTD:

            a.xml
            -----
            <!DOCTYPE A SYSTEM "example.dtd">
            <A>
            <B>bbbb</B>
            </A>

            b.xml
            -----
            <!DOCTYPE B SYSTEM "example.dtd">
            <B>bbbb</B>

            As you can see, you can't figure out what the root element is from
            looking at the DTD. (In theoretical terms, a DTD forms a directed graph
            of definitions. Where you enter the graph is the root element type. You
            can enter the graph at any node.)

            --
            Ronald Bourret
            XML, Databases, and Schemas
            http://www.rpbourret.com
            Speaker, Geek Cruises' XML Excursion '02
          • Tai Tran
            Hi, This is a bit out off topic, I was wondering what Enumeration does with the Hashtable? Assume the DTD has only one root element, is it possible to create a
            Message 5 of 23 , Sep 6, 2001
              Hi,

              This is a bit out off topic, I was wondering what
              Enumeration does with the Hashtable?

              Assume the DTD has only one root element, is it
              possible to create a parser to get the root element?
              Well, when I look at the DTD, I can identify which
              element is root and which is not. How come it is so
              hard to create a parser to get the root element? There
              must be a way to do this but I don't know how to do it
              at this point of time.

              Regards,
              Tai

              --- Ronald Bourret <rpbourret@...> wrote:
              > Tai Tran wrote:
              > >
              > > Can your DTD parser (SubsetToDTD) find the root
              > > element?
              >
              > No. It can't do this because the DTD doesn't tell
              > you what the root
              > element is. Any element can be the root element.
              >
              > This is kind of confusing. Since each XML document
              > must have a single
              > root element, it is tempting to think that the DTD
              > tells us what that
              > root element is. This is not the case. Instead, the
              > instance document
              > tells us what the root element is.
              >
              > One consequence of this is that two XML documents
              > with different root
              > elements can be validated successfully with the same
              > DTD. For example,
              > suppose we have a DTD:
              >
              > example.dtd
              > -----------
              > <!ELEMENT A (B)>
              > <!ELEMENT B (#PCDATA)>
              >
              > Now here are two valid XML documents with different
              > root elements that
              > both use this DTD:
              >
              > a.xml
              > -----
              > <!DOCTYPE A SYSTEM "example.dtd">
              > <A>
              > <B>bbbb</B>
              > </A>
              >
              > b.xml
              > -----
              > <!DOCTYPE B SYSTEM "example.dtd">
              > <B>bbbb</B>
              >
              > As you can see, you can't figure out what the root
              > element is from
              > looking at the DTD. (In theoretical terms, a DTD
              > forms a directed graph
              > of definitions. Where you enter the graph is the
              > root element type. You
              > can enter the graph at any node.)
              >
              > --
              > Ronald Bourret
              > XML, Databases, and Schemas
              > http://www.rpbourret.com
              > Speaker, Geek Cruises' XML Excursion '02
              >


              __________________________________________________
              Do You Yahoo!?
              Get email alerts & NEW webcam video instant messaging with Yahoo! Messenger
              http://im.yahoo.com
            • Ronald Bourret
              ... I m not sure I understand the question. It is possible to get Enumerations of the keys and values stored in a Hashtable, if that s what you are asking. (To
              Message 6 of 23 , Sep 6, 2001
                Tai Tran wrote:

                > This is a bit out off topic, I was wondering what
                > Enumeration does with the Hashtable?

                I'm not sure I understand the question. It is possible to get
                Enumerations of the keys and values stored in a Hashtable, if that's
                what you are asking. (To do this, use the Hashtable.elements() and
                .keys() methods.)

                > Assume the DTD has only one root element, is it
                > possible to create a parser to get the root element?
                > Well, when I look at the DTD, I can identify which
                > element is root and which is not.

                I think part of the confusion here might be terminology. The DOCTYPE
                statement is called a "document type declaration". DOCTYPE statements
                occur in instance documents and declare the root element type.
                Furthermore, to quote the XML spec, the document type declaration,
                "contains or points to markup declarations that provide a grammar for a
                class of documents. This grammar is known as a document type definition,
                or DTD."

                Note that there are two phrases here -- document type declaration and
                document type definition -- that have the same initial letters. Only the
                second one is a DTD, but people frequently confuse them. For example:

                <!DOCTYPE A [ <=== document type declaration

                <!ELEMENT A (B?, C?)> --
                <!ELEMENT B (A?, C?)> <==| document type definition (DTD)
                <!ELEMENT C (A?, B?)> --

                ]>

                <A>...</A> <=== rest of instance document

                Your original question was, "Given an DTD file, how can I create a
                program to parse the DTD find and find the root element?" In the example
                above, a "DTD file" would only contain the ELEMENT statements, not the
                DOCTYPE statement. Thus, it is not possible to determine the root
                element type from a DTD. You can only determine the root element type
                from an instance document.

                > How come it is so
                > hard to create a parser to get the root element? There
                > must be a way to do this but I don't know how to do it
                > at this point of time.

                You can create a parser to get the root element. All XML parsers do
                this. However, these parsers parse entire XML documents, not just DTDs.

                --
                Ronald Bourret
                XML, Databases, and Schemas
                http://www.rpbourret.com
                Speaker, Geek Cruises' XML Excursion '02
              • Tod Harter
                Perl has some good modules to do this. Check out XML::DOM::Parser, it includes the capability to parse DTDs into a DOM-Like structure.
                Message 7 of 23 , Sep 7, 2001
                  Perl has some good modules to do this. Check out XML::DOM::Parser, it
                  includes the capability to parse DTDs into a DOM-Like structure.

                  On Wednesday 05 September 2001 23:52, you wrote:
                  > Hi,
                  >
                  > Given an DTD file, how can I create a program to parse
                  > the DTD find and find the root element?
                  >
                  > I've seen some parsers using hastable, but I don't
                  > know how the whole process work. It would be great if
                  > you could explain how to do this?
                  >
                  > Best Regards,
                  > Kevin
                  >
                  > __________________________________________________
                  > Do You Yahoo!?
                  > Get email alerts & NEW webcam video instant messaging with Yahoo! Messenger
                  > http://im.yahoo.com
                  >
                  >
                  > To post a message, send it to: xml-dbms@yahoogroups.com
                  > To unsubscribe, send a blank message to:
                  > xml-dbms-unsubscribe@yahoogroups.com Or join the newsgroup at:
                  > news://news.barkto.com/homeless.xml.xml-dbms
                  >
                  > Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/
                • Tod Harter
                  In a case where you would need to validate the structure of a document in this way, IE verify that the root element was in Ron s example, you would
                  Message 8 of 23 , Sep 7, 2001
                    In a case where you would need to validate the structure of a document in
                    this way, IE verify that the root element was "<A>" in Ron's example, you
                    would probably want to use an XML Schema. Schemas provide a much more
                    powerfull validation mechanism than a DTD. There are also a variety of other
                    similar technologies (there must be at least 10 proposals/'standards" for XML
                    meta data aimed at doing this). Schematron is an interesting one, it uses an
                    XSLT stylesheet to validate a document, meaning that in theory any XSLT
                    conformant processor can act as a validation system. There are numerous books
                    on the subject, Wrox's "Professional XML" has a pretty good overview, it
                    covers 5 or 6 of these technologies in enough detail to evaluate their
                    potential utility for a given project.

                    On Thursday 06 September 2001 15:27, you wrote:
                    > Tai Tran wrote:
                    > > Can your DTD parser (SubsetToDTD) find the root
                    > > element?
                    >
                    > No. It can't do this because the DTD doesn't tell you what the root
                    > element is. Any element can be the root element.
                    >
                    > This is kind of confusing. Since each XML document must have a single
                    > root element, it is tempting to think that the DTD tells us what that
                    > root element is. This is not the case. Instead, the instance document
                    > tells us what the root element is.
                    >
                    > One consequence of this is that two XML documents with different root
                    > elements can be validated successfully with the same DTD. For example,
                    > suppose we have a DTD:
                    >
                    > example.dtd
                    > -----------
                    > <!ELEMENT A (B)>
                    > <!ELEMENT B (#PCDATA)>
                    >
                    > Now here are two valid XML documents with different root elements that
                    > both use this DTD:
                    >
                    > a.xml
                    > -----
                    > <!DOCTYPE A SYSTEM "example.dtd">
                    > <A>
                    > <B>bbbb</B>
                    > </A>
                    >
                    > b.xml
                    > -----
                    > <!DOCTYPE B SYSTEM "example.dtd">
                    > <B>bbbb</B>
                    >
                    > As you can see, you can't figure out what the root element is from
                    > looking at the DTD. (In theoretical terms, a DTD forms a directed graph
                    > of definitions. Where you enter the graph is the root element type. You
                    > can enter the graph at any node.)
                  • Tai Tran
                    Thanks for the info. What exactly I wanted to do is this. I ve been given a DTD file and a database account (Interbase). The DTD file is conform the database
                    Message 9 of 23 , Sep 8, 2001
                      Thanks for the info.

                      What exactly I wanted to do is this.

                      I've been given a DTD file and a database account
                      (Interbase). The DTD file is conform the database
                      schema.

                      What I have to do for the project specification is
                      that I have to parse the DTD file, get all the
                      elements, attributes, occurrences, etc... Put these
                      data into a data structure. From here, I have to
                      create an XML file by querying the data structure, not
                      directly to the database server.

                      So yeah, this is my problem.


                      --- Tod Harter <tharter@...> wrote:
                      > In a case where you would need to validate the
                      > structure of a document in
                      > this way, IE verify that the root element was "<A>"
                      > in Ron's example, you
                      > would probably want to use an XML Schema. Schemas
                      > provide a much more
                      > powerfull validation mechanism than a DTD. There are
                      > also a variety of other
                      > similar technologies (there must be at least 10
                      > proposals/'standards" for XML
                      > meta data aimed at doing this). Schematron is an
                      > interesting one, it uses an
                      > XSLT stylesheet to validate a document, meaning that
                      > in theory any XSLT
                      > conformant processor can act as a validation system.
                      > There are numerous books
                      > on the subject, Wrox's "Professional XML" has a
                      > pretty good overview, it
                      > covers 5 or 6 of these technologies in enough detail
                      > to evaluate their
                      > potential utility for a given project.
                      >
                      > On Thursday 06 September 2001 15:27, you wrote:
                      > > Tai Tran wrote:
                      > > > Can your DTD parser (SubsetToDTD) find the root
                      > > > element?
                      > >
                      > > No. It can't do this because the DTD doesn't tell
                      > you what the root
                      > > element is. Any element can be the root element.
                      > >
                      > > This is kind of confusing. Since each XML document
                      > must have a single
                      > > root element, it is tempting to think that the DTD
                      > tells us what that
                      > > root element is. This is not the case. Instead,
                      > the instance document
                      > > tells us what the root element is.
                      > >
                      > > One consequence of this is that two XML documents
                      > with different root
                      > > elements can be validated successfully with the
                      > same DTD. For example,
                      > > suppose we have a DTD:
                      > >
                      > > example.dtd
                      > > -----------
                      > > <!ELEMENT A (B)>
                      > > <!ELEMENT B (#PCDATA)>
                      > >
                      > > Now here are two valid XML documents with
                      > different root elements that
                      > > both use this DTD:
                      > >
                      > > a.xml
                      > > -----
                      > > <!DOCTYPE A SYSTEM "example.dtd">
                      > > <A>
                      > > <B>bbbb</B>
                      > > </A>
                      > >
                      > > b.xml
                      > > -----
                      > > <!DOCTYPE B SYSTEM "example.dtd">
                      > > <B>bbbb</B>
                      > >
                      > > As you can see, you can't figure out what the root
                      > element is from
                      > > looking at the DTD. (In theoretical terms, a DTD
                      > forms a directed graph
                      > > of definitions. Where you enter the graph is the
                      > root element type. You
                      > > can enter the graph at any node.)
                      >


                      __________________________________________________
                      Do You Yahoo!?
                      Get email alerts & NEW webcam video instant messaging with Yahoo! Messenger
                      http://im.yahoo.com
                    • Tod Harter
                      I m not 100% certain I follow you. What do you mean query the data structure ? Take a look at Castor, it might be very handy for what you want to do. Its a
                      Message 10 of 23 , Sep 10, 2001
                        I'm not 100% certain I follow you. What do you mean "query the data
                        structure"? Take a look at Castor, it might be very handy for what you want
                        to do. Its a free open source data binding engine for Java. Basically you can
                        give it an XML Schema and it can construct an appropriate data structure
                        (Java class) for you and help with generating the code required to extract
                        information from the database into your structure (and vice versa). In
                        essence it allows you to autogenerate logic to marshal and unmarshal data
                        between XML and Java classes. I believe the home page is part of the Apache
                        Software Foundation site (www.apache.org).

                        Unfortunately tasks of this nature are very difficult to manage using a DTD.
                        DTDs lack any real way to specify the data types of elements, and only very
                        limited typing for attributes. One way to get around this might be to find a
                        tool that will convert a DTD to an XML Schema. Then you could tweak the
                        schema and use Castor to create the binding logic. Its a little beyond my
                        experience at this point, but from what I've seen people doing on some other
                        projects it should work. I think MS and Oracle (no doubt IBM as well) have
                        proprietary tools that can accomplish similar tasks.

                        On Saturday 08 September 2001 10:16, you wrote:
                        > Thanks for the info.
                        >
                        > What exactly I wanted to do is this.
                        >
                        > I've been given a DTD file and a database account
                        > (Interbase). The DTD file is conform the database
                        > schema.
                        >
                        > What I have to do for the project specification is
                        > that I have to parse the DTD file, get all the
                        > elements, attributes, occurrences, etc... Put these
                        > data into a data structure. From here, I have to
                        > create an XML file by querying the data structure, not
                        > directly to the database server.
                        >
                        > So yeah, this is my problem.
                        >
                        > --- Tod Harter <tharter@...> wrote:
                        > > In a case where you would need to validate the
                        > > structure of a document in
                        > > this way, IE verify that the root element was "<A>"
                        > > in Ron's example, you
                        > > would probably want to use an XML Schema. Schemas
                        > > provide a much more
                        > > powerfull validation mechanism than a DTD. There are
                        > > also a variety of other
                        > > similar technologies (there must be at least 10
                        > > proposals/'standards" for XML
                        > > meta data aimed at doing this). Schematron is an
                        > > interesting one, it uses an
                        > > XSLT stylesheet to validate a document, meaning that
                        > > in theory any XSLT
                        > > conformant processor can act as a validation system.
                        > > There are numerous books
                        > > on the subject, Wrox's "Professional XML" has a
                        > > pretty good overview, it
                        > > covers 5 or 6 of these technologies in enough detail
                        > > to evaluate their
                        > > potential utility for a given project.
                        > >
                        > > On Thursday 06 September 2001 15:27, you wrote:
                        > > > Tai Tran wrote:
                        > > > > Can your DTD parser (SubsetToDTD) find the root
                        > > > > element?
                        > > >
                        > > > No. It can't do this because the DTD doesn't tell
                        > >
                        > > you what the root
                        > >
                        > > > element is. Any element can be the root element.
                        > > >
                        > > > This is kind of confusing. Since each XML document
                        > >
                        > > must have a single
                        > >
                        > > > root element, it is tempting to think that the DTD
                        > >
                        > > tells us what that
                        > >
                        > > > root element is. This is not the case. Instead,
                        > >
                        > > the instance document
                        > >
                        > > > tells us what the root element is.
                        > > >
                        > > > One consequence of this is that two XML documents
                        > >
                        > > with different root
                        > >
                        > > > elements can be validated successfully with the
                        > >
                        > > same DTD. For example,
                        > >
                        > > > suppose we have a DTD:
                        > > >
                        > > > example.dtd
                        > > > -----------
                        > > > <!ELEMENT A (B)>
                        > > > <!ELEMENT B (#PCDATA)>
                        > > >
                        > > > Now here are two valid XML documents with
                        > >
                        > > different root elements that
                        > >
                        > > > both use this DTD:
                        > > >
                        > > > a.xml
                        > > > -----
                        > > > <!DOCTYPE A SYSTEM "example.dtd">
                        > > > <A>
                        > > > <B>bbbb</B>
                        > > > </A>
                        > > >
                        > > > b.xml
                        > > > -----
                        > > > <!DOCTYPE B SYSTEM "example.dtd">
                        > > > <B>bbbb</B>
                        > > >
                        > > > As you can see, you can't figure out what the root
                        > >
                        > > element is from
                        > >
                        > > > looking at the DTD. (In theoretical terms, a DTD
                        > >
                        > > forms a directed graph
                        > >
                        > > > of definitions. Where you enter the graph is the
                        > >
                        > > root element type. You
                        > >
                        > > > can enter the graph at any node.)
                        >
                        > __________________________________________________
                        > Do You Yahoo!?
                        > Get email alerts & NEW webcam video instant messaging with Yahoo! Messenger
                        > http://im.yahoo.com
                        >
                        >
                        > To post a message, send it to: xml-dbms@yahoogroups.com
                        > To unsubscribe, send a blank message to:
                        > xml-dbms-unsubscribe@yahoogroups.com Or join the newsgroup at:
                        > news://news.barkto.com/homeless.xml.xml-dbms
                        >
                        > Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/
                      • Tai Tran
                        My project is similar to Castor but instead of XML Schema, I have to use DTD. Is it easier to parse the XML Schema than the DTD? Can you use DOM to parse the
                        Message 11 of 23 , Sep 10, 2001
                          My project is similar to Castor but instead of XML
                          Schema, I have to use DTD.

                          Is it easier to parse the XML Schema than the DTD? Can
                          you use DOM to parse the XML Schema?

                          Regards
                          --- Tod Harter <tharter@...> wrote:
                          > I'm not 100% certain I follow you. What do you mean
                          > "query the data
                          > structure"? Take a look at Castor, it might be very
                          > handy for what you want
                          > to do. Its a free open source data binding engine
                          > for Java. Basically you can
                          > give it an XML Schema and it can construct an
                          > appropriate data structure
                          > (Java class) for you and help with generating the
                          > code required to extract
                          > information from the database into your structure
                          > (and vice versa). In
                          > essence it allows you to autogenerate logic to
                          > marshal and unmarshal data
                          > between XML and Java classes. I believe the home
                          > page is part of the Apache
                          > Software Foundation site (www.apache.org).
                          >
                          > Unfortunately tasks of this nature are very
                          > difficult to manage using a DTD.
                          > DTDs lack any real way to specify the data types of
                          > elements, and only very
                          > limited typing for attributes. One way to get around
                          > this might be to find a
                          > tool that will convert a DTD to an XML Schema. Then
                          > you could tweak the
                          > schema and use Castor to create the binding logic.
                          > Its a little beyond my
                          > experience at this point, but from what I've seen
                          > people doing on some other
                          > projects it should work. I think MS and Oracle (no
                          > doubt IBM as well) have
                          > proprietary tools that can accomplish similar tasks.
                          >
                          >
                          > On Saturday 08 September 2001 10:16, you wrote:
                          > > Thanks for the info.
                          > >
                          > > What exactly I wanted to do is this.
                          > >
                          > > I've been given a DTD file and a database account
                          > > (Interbase). The DTD file is conform the database
                          > > schema.
                          > >
                          > > What I have to do for the project specification is
                          > > that I have to parse the DTD file, get all the
                          > > elements, attributes, occurrences, etc... Put
                          > these
                          > > data into a data structure. From here, I have to
                          > > create an XML file by querying the data structure,
                          > not
                          > > directly to the database server.
                          > >
                          > > So yeah, this is my problem.
                          > >
                          > > --- Tod Harter <tharter@...> wrote:
                          > > > In a case where you would need to validate the
                          > > > structure of a document in
                          > > > this way, IE verify that the root element was
                          > "<A>"
                          > > > in Ron's example, you
                          > > > would probably want to use an XML Schema.
                          > Schemas
                          > > > provide a much more
                          > > > powerfull validation mechanism than a DTD. There
                          > are
                          > > > also a variety of other
                          > > > similar technologies (there must be at least 10
                          > > > proposals/'standards" for XML
                          > > > meta data aimed at doing this). Schematron is an
                          > > > interesting one, it uses an
                          > > > XSLT stylesheet to validate a document, meaning
                          > that
                          > > > in theory any XSLT
                          > > > conformant processor can act as a validation
                          > system.
                          > > > There are numerous books
                          > > > on the subject, Wrox's "Professional XML" has a
                          > > > pretty good overview, it
                          > > > covers 5 or 6 of these technologies in enough
                          > detail
                          > > > to evaluate their
                          > > > potential utility for a given project.
                          > > >
                          > > > On Thursday 06 September 2001 15:27, you wrote:
                          > > > > Tai Tran wrote:
                          > > > > > Can your DTD parser (SubsetToDTD) find the
                          > root
                          > > > > > element?
                          > > > >
                          > > > > No. It can't do this because the DTD doesn't
                          > tell
                          > > >
                          > > > you what the root
                          > > >
                          > > > > element is. Any element can be the root
                          > element.
                          > > > >
                          > > > > This is kind of confusing. Since each XML
                          > document
                          > > >
                          > > > must have a single
                          > > >
                          > > > > root element, it is tempting to think that the
                          > DTD
                          > > >
                          > > > tells us what that
                          > > >
                          > > > > root element is. This is not the case.
                          > Instead,
                          > > >
                          > > > the instance document
                          > > >
                          > > > > tells us what the root element is.
                          > > > >
                          > > > > One consequence of this is that two XML
                          > documents
                          > > >
                          > > > with different root
                          > > >
                          > > > > elements can be validated successfully with
                          > the
                          > > >
                          > > > same DTD. For example,
                          > > >
                          > > > > suppose we have a DTD:
                          > > > >
                          > > > > example.dtd
                          > > > > -----------
                          > > > > <!ELEMENT A (B)>
                          > > > > <!ELEMENT B (#PCDATA)>
                          > > > >
                          > > > > Now here are two valid XML documents with
                          > > >
                          > > > different root elements that
                          > > >
                          > > > > both use this DTD:
                          > > > >
                          > > > > a.xml
                          > > > > -----
                          > > > > <!DOCTYPE A SYSTEM "example.dtd">
                          > > > > <A>
                          > > > > <B>bbbb</B>
                          > > > > </A>
                          > > > >
                          > > > > b.xml
                          > > > > -----
                          > > > > <!DOCTYPE B SYSTEM "example.dtd">
                          > > > > <B>bbbb</B>
                          > > > >
                          > > > > As you can see, you can't figure out what the
                          > root
                          > > >
                          > > > element is from
                          > > >
                          > > > > looking at the DTD. (In theoretical terms, a
                          > DTD
                          > > >
                          > > > forms a directed graph
                          > > >
                          > > > > of definitions. Where you enter the graph is
                          > the
                          > > >
                          > > > root element type. You
                          > > >
                          > > > > can enter the graph at any node.)
                          > >
                          > > __________________________________________________
                          > > Do You Yahoo!?
                          > > Get email alerts & NEW webcam video instant
                          > messaging with Yahoo! Messenger
                          > > http://im.yahoo.com
                          > >
                          > >
                          > > To post a message, send it to:
                          > xml-dbms@yahoogroups.com
                          > > To unsubscribe, send a blank message to:
                          > > xml-dbms-unsubscribe@yahoogroups.com Or join the
                          > newsgroup at:
                          > > news://news.barkto.com/homeless.xml.xml-dbms
                          > >
                          > > Your use of Yahoo! Groups is subject to
                          > http://docs.yahoo.com/info/terms/
                          >


                          __________________________________________________
                          Do You Yahoo!?
                          Get email alerts & NEW webcam video instant messaging with Yahoo! Messenger
                          http://im.yahoo.com
                        • Ronald Bourret
                          ... There are a number of products that can create Java classes from DTDs, including Breeze Factor, Delphi, JAXB, Oracle XML Class Generator, and Zeus. JAXB
                          Message 12 of 23 , Sep 10, 2001
                            Tai Tran wrote:
                            >
                            > My project is similar to Castor but instead of XML
                            > Schema, I have to use DTD.

                            There are a number of products that can create Java classes from DTDs,
                            including Breeze Factor, Delphi, JAXB, Oracle XML Class Generator, and
                            Zeus. JAXB and Zeus might not be available yet, but are both free (Zeus
                            is Open Source). Oracle XML Class Generator is free, but I don't know
                            what the license is.

                            For more information, see:

                            http://www.rpbourret.com/xml/XMLDataBinding.htm

                            > Is it easier to parse the XML Schema than the DTD? Can
                            > you use DOM to parse the XML Schema?

                            Yes. The reason is that XML Schemas are written in XML and can be parsed
                            with any XML parser.

                            DTDs must be parsed with a special parser and the result is usually a
                            proprietary set of objects that models a DTD. Thus, you can't change
                            parsers easily and you must learn a new set of objects. For a list of
                            free DTD parsers, see:

                            http://www.garshol.priv.no/download/xmltools/cat_ix.html#SC_DTDParser

                            --
                            Ronald Bourret
                            XML, Databases, and Schemas
                            http://www.rpbourret.com
                            Speaker, Geek Cruises' XML Excursion '02
                          • Tod Harter
                            XML Schema IS XML, so yes you can parse a schema using any existing XML tools. I suppose you could perform XSLT transforms etc on a schema, though I fail to
                            Message 13 of 23 , Sep 11, 2001
                              XML Schema IS XML, so yes you can parse a schema using any existing XML
                              tools. I suppose you could perform XSLT transforms etc on a schema, though I
                              fail to imagine a lot of utility in that... Perhaps some sort of automated
                              Schema maintenance tool might utilize those sorts of techniques.

                              On Monday 10 September 2001 20:19, you wrote:
                              > My project is similar to Castor but instead of XML
                              > Schema, I have to use DTD.
                              >
                              > Is it easier to parse the XML Schema than the DTD? Can
                              > you use DOM to parse the XML Schema?
                              >
                              > Regards
                              >
                              > --- Tod Harter <tharter@...> wrote:
                              > > I'm not 100% certain I follow you. What do you mean
                              > > "query the data
                              > > structure"? Take a look at Castor, it might be very
                              > > handy for what you want
                              > > to do. Its a free open source data binding engine
                              > > for Java. Basically you can
                              > > give it an XML Schema and it can construct an
                              > > appropriate data structure
                              > > (Java class) for you and help with generating the
                              > > code required to extract
                              > > information from the database into your structure
                              > > (and vice versa). In
                              > > essence it allows you to autogenerate logic to
                              > > marshal and unmarshal data
                              > > between XML and Java classes. I believe the home
                              > > page is part of the Apache
                              > > Software Foundation site (www.apache.org).
                              > >
                              > > Unfortunately tasks of this nature are very
                              > > difficult to manage using a DTD.
                              > > DTDs lack any real way to specify the data types of
                              > > elements, and only very
                              > > limited typing for attributes. One way to get around
                              > > this might be to find a
                              > > tool that will convert a DTD to an XML Schema. Then
                              > > you could tweak the
                              > > schema and use Castor to create the binding logic.
                              > > Its a little beyond my
                              > > experience at this point, but from what I've seen
                              > > people doing on some other
                              > > projects it should work. I think MS and Oracle (no
                              > > doubt IBM as well) have
                              > > proprietary tools that can accomplish similar tasks.
                              > >
                              > > On Saturday 08 September 2001 10:16, you wrote:
                              > > > Thanks for the info.
                              > > >
                              > > > What exactly I wanted to do is this.
                              > > >
                              > > > I've been given a DTD file and a database account
                              > > > (Interbase). The DTD file is conform the database
                              > > > schema.
                              > > >
                              > > > What I have to do for the project specification is
                              > > > that I have to parse the DTD file, get all the
                              > > > elements, attributes, occurrences, etc... Put
                              > >
                              > > these
                              > >
                              > > > data into a data structure. From here, I have to
                              > > > create an XML file by querying the data structure,
                              > >
                              > > not
                              > >
                              > > > directly to the database server.
                              > > >
                              > > > So yeah, this is my problem.
                              > > >
                              > > > --- Tod Harter <tharter@...> wrote:
                              > > > > In a case where you would need to validate the
                              > > > > structure of a document in
                              > > > > this way, IE verify that the root element was
                              > >
                              > > "<A>"
                              > >
                              > > > > in Ron's example, you
                              > > > > would probably want to use an XML Schema.
                              > >
                              > > Schemas
                              > >
                              > > > > provide a much more
                              > > > > powerfull validation mechanism than a DTD. There
                              > >
                              > > are
                              > >
                              > > > > also a variety of other
                              > > > > similar technologies (there must be at least 10
                              > > > > proposals/'standards" for XML
                              > > > > meta data aimed at doing this). Schematron is an
                              > > > > interesting one, it uses an
                              > > > > XSLT stylesheet to validate a document, meaning
                              > >
                              > > that
                              > >
                              > > > > in theory any XSLT
                              > > > > conformant processor can act as a validation
                              > >
                              > > system.
                              > >
                              > > > > There are numerous books
                              > > > > on the subject, Wrox's "Professional XML" has a
                              > > > > pretty good overview, it
                              > > > > covers 5 or 6 of these technologies in enough
                              > >
                              > > detail
                              > >
                              > > > > to evaluate their
                              > > > > potential utility for a given project.
                              > > > >
                              > > > > On Thursday 06 September 2001 15:27, you wrote:
                              > > > > > Tai Tran wrote:
                              > > > > > > Can your DTD parser (SubsetToDTD) find the
                              > >
                              > > root
                              > >
                              > > > > > > element?
                              > > > > >
                              > > > > > No. It can't do this because the DTD doesn't
                              > >
                              > > tell
                              > >
                              > > > > you what the root
                              > > > >
                              > > > > > element is. Any element can be the root
                              > >
                              > > element.
                              > >
                              > > > > > This is kind of confusing. Since each XML
                              > >
                              > > document
                              > >
                              > > > > must have a single
                              > > > >
                              > > > > > root element, it is tempting to think that the
                              > >
                              > > DTD
                              > >
                              > > > > tells us what that
                              > > > >
                              > > > > > root element is. This is not the case.
                              > >
                              > > Instead,
                              > >
                              > > > > the instance document
                              > > > >
                              > > > > > tells us what the root element is.
                              > > > > >
                              > > > > > One consequence of this is that two XML
                              > >
                              > > documents
                              > >
                              > > > > with different root
                              > > > >
                              > > > > > elements can be validated successfully with
                              > >
                              > > the
                              > >
                              > > > > same DTD. For example,
                              > > > >
                              > > > > > suppose we have a DTD:
                              > > > > >
                              > > > > > example.dtd
                              > > > > > -----------
                              > > > > > <!ELEMENT A (B)>
                              > > > > > <!ELEMENT B (#PCDATA)>
                              > > > > >
                              > > > > > Now here are two valid XML documents with
                              > > > >
                              > > > > different root elements that
                              > > > >
                              > > > > > both use this DTD:
                              > > > > >
                              > > > > > a.xml
                              > > > > > -----
                              > > > > > <!DOCTYPE A SYSTEM "example.dtd">
                              > > > > > <A>
                              > > > > > <B>bbbb</B>
                              > > > > > </A>
                              > > > > >
                              > > > > > b.xml
                              > > > > > -----
                              > > > > > <!DOCTYPE B SYSTEM "example.dtd">
                              > > > > > <B>bbbb</B>
                              > > > > >
                              > > > > > As you can see, you can't figure out what the
                              > >
                              > > root
                              > >
                              > > > > element is from
                              > > > >
                              > > > > > looking at the DTD. (In theoretical terms, a
                              > >
                              > > DTD
                              > >
                              > > > > forms a directed graph
                              > > > >
                              > > > > > of definitions. Where you enter the graph is
                              > >
                              > > the
                              > >
                              > > > > root element type. You
                              > > > >
                              > > > > > can enter the graph at any node.)
                              > > >
                              > > > __________________________________________________
                              > > > Do You Yahoo!?
                              > > > Get email alerts & NEW webcam video instant
                              > >
                              > > messaging with Yahoo! Messenger
                              > >
                              > > > http://im.yahoo.com
                              > > >
                              > > >
                              > > > To post a message, send it to:
                              > >
                              > > xml-dbms@yahoogroups.com
                              > >
                              > > > To unsubscribe, send a blank message to:
                              > > > xml-dbms-unsubscribe@yahoogroups.com Or join the
                              > >
                              > > newsgroup at:
                              > > > news://news.barkto.com/homeless.xml.xml-dbms
                              > > >
                              > > > Your use of Yahoo! Groups is subject to
                              > >
                              > > http://docs.yahoo.com/info/terms/
                              >
                              > __________________________________________________
                              > Do You Yahoo!?
                              > Get email alerts & NEW webcam video instant messaging with Yahoo! Messenger
                              > http://im.yahoo.com
                              >
                              >
                              > To post a message, send it to: xml-dbms@yahoogroups.com
                              > To unsubscribe, send a blank message to:
                              > xml-dbms-unsubscribe@yahoogroups.com Or join the newsgroup at:
                              > news://news.barkto.com/homeless.xml.xml-dbms
                              >
                              > Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/
                            • Richard Lee
                              Ron, I have two questions: 1. I know that it is impossible to find the root element in DTD, so is it possible to find the root element in xml-schema by SAX
                              Message 14 of 23 , Sep 26, 2001
                                Ron,

                                I have two questions:

                                1. I know that it is impossible to find the root
                                element in DTD, so is it possible to find the root
                                element in xml-schema by SAX Parser? DOM Parser might
                                be possible, as it build a tree from the schema, which
                                is also an xml doucment, so is it possible for SAX
                                parser?

                                2. I read the MapFactory_DTD (and
                                MapFactory_W3CSchema) code. It seems that the codes
                                create maps in this way: for EACH element defined in
                                the DTD/schema, it calls the method -
                                processElementTypes(ElementType) and build class/table
                                maps from it, in this algorithm the same element could
                                be mapped several times (could be mapped many times to
                                relatedClassMap depending on how many different
                                parents it has, and one time for classMap). I am a bit
                                confusing about it, as some elements can only be
                                appeared as subelement, i.e, never as a top-level
                                element, for this kind of elements, it can only be
                                mapped to relatedClassMap, and never classMap. This is
                                more apparent in the local-defined elements in
                                xml-schema. Only top-level elements could be mapped to
                                classMap, and other elements are mapped to
                                relatedClassMap, am I right??

                                Please give me some instructions on it. Thanks.


                                Richard




                                __________________________________________________
                                Do You Yahoo!?
                                Get email alerts & NEW webcam video instant messaging with Yahoo! Messenger. http://im.yahoo.com
                              • Ronald Bourret
                                ... If you mean the root element of the schema document itself, then yes. In a DOM tree, this is the first element in the tree. In a SAX application, this is
                                Message 15 of 23 , Sep 27, 2001
                                  Richard Lee wrote:

                                  > 1. I know that it is impossible to find the root
                                  > element in DTD, so is it possible to find the root
                                  > element in xml-schema by SAX Parser? DOM Parser might
                                  > be possible, as it build a tree from the schema, which
                                  > is also an xml doucment, so is it possible for SAX
                                  > parser?

                                  If you mean the root element of the schema document itself, then yes. In
                                  a DOM tree, this is the first element in the tree. In a SAX application,
                                  this is the first element for which a startElement event is sent.
                                  However, since this is always <schema>, I don't think this is what you
                                  mean.

                                  If you mean the root element of the schema defined by the schema
                                  document, then the answer is no. This is because XML Schemas, like DTDs,
                                  don't explicitly declare root element types.

                                  For more information, see the following message and answers to it:

                                  http://groups.yahoo.com/group/xml-dbms/message/1408

                                  > 2. I read the MapFactory_DTD (and
                                  > MapFactory_W3CSchema) code. It seems that the codes
                                  > create maps in this way: for EACH element defined in
                                  > the DTD/schema, it calls the method -
                                  > processElementTypes(ElementType) and build class/table
                                  > maps from it, in this algorithm the same element could
                                  > be mapped several times (could be mapped many times to
                                  > relatedClassMap depending on how many different
                                  > parents it has, and one time for classMap). I am a bit
                                  > confusing about it, as some elements can only be
                                  > appeared as subelement, i.e, never as a top-level
                                  > element,

                                  Any element type that is declared globally -- that is, any element type
                                  that is declared in a DTD and any non-local element type declared in an
                                  XML Schema -- can be the top-level (root) element. If an application
                                  only allows certain elements to be root elements, it must enforce this
                                  itself. There is nothing in the DTD or XML Schema that declares root
                                  element types.

                                  > for this kind of elements, it can only be
                                  > mapped to relatedClassMap, and never classMap.

                                  This is not true. A RelatedClassMap points to a ClassMap, so you must
                                  declare the ClassMap. Another way to think about this is that a ClassMap
                                  maps an element type to a class table. This is true whether the element
                                  type is the root element type or only appears as a child element in your
                                  documents.

                                  For example, look at the sales order example. The Part element is mapped
                                  to a class table, even though it is not a root element in the
                                  sales_in.xml document. Therefore, it is mapped with a ClassMap.

                                  A RelatedClassMap provides the information necessary to link the parent
                                  and child tables. Therefore, all element types that occur as children
                                  have RelatedClassMaps in addition to ClassMaps. If an element type never
                                  appears as a child element (as is often the case with element types used
                                  as roots), then it never appears in a RelatedClassMap.

                                  For example, in the sales order example, the SalesOrder element is
                                  mapped only with a ClassMap. The Part element is mapped with a ClassMap,
                                  but also has a RelatedClassMap in the ClassMap for Line.

                                  > This is
                                  > more apparent in the local-defined elements in
                                  > xml-schema.

                                  It is correct that local element types can never be the root element
                                  type. However, they still are mapped with ClassMaps and
                                  RelatedClassMaps. See above for details.

                                  > Only top-level elements could be mapped to
                                  > classMap, and other elements are mapped to
                                  > relatedClassMap, am I right??

                                  No. All element types that are treated as classes are mapped with
                                  ClassMaps. All element types-as-classes that occur in the content models
                                  of other element types are also mapped with RelatedClassMaps.

                                  (One nice feature of this is that you can use a single map document for
                                  many different document types. That is, you can use it to map any
                                  document that starts with an element type mapped with a ClassMap. In
                                  practice, most applications only use a single root element type, but
                                  this is not required.)

                                  -- Ron
                                • adam flinton
                                  Richard, Sorry for not getting back to re Updates but apart from the file in the news group binary section........ I have a suspicion that I was mailed it &
                                  Message 16 of 23 , Sep 27, 2001
                                    Richard,

                                    Sorry for not getting back to re Updates but apart from the file in the news
                                    group binary section........

                                    I have a suspicion that I was mailed it & following a bunch of mails from
                                    the mail admin re the size of my mail box on the server I did some drastic
                                    pruning.....


                                    Adam


                                    [Non-text portions of this message have been removed]
                                  • Richard Lee
                                    Ron: Now, I undertand the classMap and relatedClassMap, thank you very much. ... Based on the above explanation, so there could be another algorithm for
                                    Message 17 of 23 , Sep 28, 2001
                                      Ron:

                                      Now, I undertand the classMap and relatedClassMap,
                                      thank you very much.

                                      > Any element type that is declared globally -- that
                                      > is, any element type that is declared in a DTD and
                                      > any non-local element type declared in an XML Schema
                                      > -- can be the top-level (root) element. If an
                                      > application only allows certain elements to be root
                                      > elements, it must enforce this itself. There is
                                      > nothing in the DTD or XML Schema that declares root
                                      > element types.

                                      Based on the above explanation, so there could be
                                      another algorithm for MapFactory_DTD (Schema):

                                      //-- for all TOP-LEVEL(no parent) element declarations
                                      while (e.hasMoreElements()) {
                                      Element element = e.nextElement();
                                      processElementType(element);
                                      addRootClassMap(element); // all top-level element
                                      could be root element
                                      }


                                      //- no modification, remain the same as original
                                      //- just repeat it here for code continuation
                                      processElementType(ElementType elementType)
                                      {
                                      ....
                                      switch (elementType.contentType)
                                      {
                                      ....
                                      case:ElementType.CONTENT_ELEMENT:
                                      processElementContent(classMap,
                                      elementType.content,
                                      elementType.children);

                                      break;
                                      ....
                                      }
                                      }


                                      processElementContent(TempClassMap classMap,
                                      Group content,
                                      Hashtable children)
                                      {
                                      setRepeatInfo();
                                      e = children.elements();
                                      while (e.hasMoreElements())
                                      {
                                      child = (ElementType)e.nextElement();
                                      if (isClass(child))
                                      {
                                      processElementType(child) //- ADD: recursively
                                      for child element
                                      addRelatedClass(classMap, child);
                                      }
                                      else
                                      {
                                      repeatable = repeatInfo.get(
                                      child.name.qualified)).booleanValue();

                                      addElementTypePropertyMap(
                                      classMap, child, repeatable);
                                      }
                                      }
                                      }

                                      In this way, all the child's classMap is available
                                      before adding the RelateClassMap. Is it ok?

                                      Thanks,

                                      Richard

                                      __________________________________________________
                                      Do You Yahoo!?
                                      Listen to your Yahoo! Mail messages from any phone.
                                      http://phone.yahoo.com
                                    • Ronald Bourret
                                      ... Is this the code for processElementTypes? If so, the enumeration e is for all element types, not just those with no parent. I suspect what you want is
                                      Message 18 of 23 , Sep 28, 2001
                                        Richard Lee wrote:
                                        > Based on the above explanation, so there could be
                                        > another algorithm for MapFactory_DTD (Schema):
                                        >
                                        > //-- for all TOP-LEVEL(no parent) element declarations
                                        > while (e.hasMoreElements()) {
                                        > Element element = e.nextElement();
                                        > processElementType(element);
                                        > addRootClassMap(element); // all top-level element
                                        > could be root element
                                        > }

                                        Is this the code for processElementTypes? If so, the enumeration e is
                                        for all element types, not just those with no parent. I suspect what you
                                        want is something like the code found in addRootClassMaps:

                                        if (elementType.parents.isEmpty() && isClass(elementType))
                                        {
                                        processElementType(element);
                                        addRootClassMap(elementType);
                                        }

                                        Note also that RootClassMaps are going away in version 2.0. They caused
                                        nothing but trouble in version 1.0. (One of the most commonly
                                        encountered problems in 1.0 is people calling DBMSToDOM.retrieveDocument
                                        and passing in the name of a table that wasn't declared in a
                                        RootClassMap or PseudoRoot element.)

                                        > processElementContent(TempClassMap classMap,
                                        > Group content,
                                        > Hashtable children)
                                        > {
                                        > setRepeatInfo();
                                        > e = children.elements();
                                        > while (e.hasMoreElements())
                                        > {
                                        > child = (ElementType)e.nextElement();
                                        > if (isClass(child))
                                        > {
                                        > processElementType(child) //- ADD: recursively
                                        > for child element
                                        > addRelatedClass(classMap, child);
                                        > }
                                        > else
                                        > {
                                        > repeatable = repeatInfo.get(
                                        > child.name.qualified)).booleanValue();
                                        >
                                        > addElementTypePropertyMap(
                                        > classMap, child, repeatable);
                                        > }
                                        > }
                                        > }

                                        If you do this, you'll need to add code to processElementType to make
                                        sure the element type hasn't already been processed. Otherwise, a
                                        content model like the following will give you an infinite loop:

                                        <!ELEMENT A (A*)>

                                        (In general, any DTD graph that includes a cycle will cause an infinite
                                        loop. The current code avoids this by processing each element type
                                        exactly once.)

                                        > In this way, all the child's classMap is available
                                        > before adding the RelateClassMap. Is it ok?

                                        I haven't thought through all of the cases, but I think this does what
                                        you want. What I don't understand is why you need to make the change.
                                        I'm pretty sure that the generated map is exactly the same as the map
                                        generated by the current code.

                                        -- Ron
                                      • Richard Lee
                                        Ron, ... Exactly, becasue I assumed that all the top-level elements are available and Enumeration e is all top-level elements that are mapped to class. ... I
                                        Message 19 of 23 , Sep 28, 2001
                                          Ron,

                                          --- Ronald Bourret wrote:
                                          > Is this the code for processElementTypes? If so, the
                                          > enumeration e is
                                          > for all element types, not just those with no
                                          > parent. I suspect what you
                                          > want is something like the code found in
                                          > addRootClassMaps:
                                          >
                                          > if (elementType.parents.isEmpty() &&
                                          > isClass(elementType))
                                          > {
                                          > processElementType(element);
                                          > addRootClassMap(elementType);
                                          > }

                                          Exactly, becasue I assumed that all the top-level
                                          elements are available and Enumeration e is all
                                          top-level elements that are mapped to class.

                                          >
                                          > Note also that RootClassMaps are going away in
                                          > version 2.0. They caused
                                          > nothing but trouble in version 1.0.

                                          I know. So any element could be a possible root when
                                          retrieve data from database, even local elements? If
                                          so, we need to consider the possible name conflict due
                                          to not only the same name defined in different
                                          namespace but also the same name defined in different
                                          symbol space if xml document is validated by xml
                                          schema (DTD requires all names be unique). Same name
                                          could be defined in different symbol space in xml
                                          schema, for example, top-level element and local
                                          element that defined in a top-level complex type could
                                          have same name. In this case, more name conflict is
                                          possible. Is it correct?

                                          MapFactory_DTD does not solve the possible name
                                          confilt right now, I don't know whether it will be
                                          solved in version 2. Well, if considering
                                          Mapfactory_DTD is a design time option to generate
                                          Map, DBNameChecker could do some help, and modify the
                                          conflicts by hand. Any plan for some other *Auto*
                                          name-conflict-solvers included in version 2.0?


                                          >
                                          > If you do this, you'll need to add code to
                                          > processElementType to make
                                          > sure the element type hasn't already been processed.
                                          > Otherwise, a
                                          > content model like the following will give you an
                                          > infinite loop:
                                          >
                                          > <!ELEMENT A (A*)>
                                          >

                                          Right. But a hashtable should solve this.


                                          >
                                          > What I don't understand is why you need to
                                          > make the change.
                                          > I'm pretty sure that the generated map is exactly
                                          > the same as the map
                                          > generated by the current code.

                                          Yes, the generated map will be the same as original
                                          one. My original intent is to try to see how to use
                                          SAX parser to generate map from xml schema, not using
                                          DOM parser. I am trying to make XML-DBMS only
                                          SAX-based.

                                          Thank you very much for your explanation.


                                          Richard

                                          __________________________________________________
                                          Do You Yahoo!?
                                          Listen to your Yahoo! Mail messages from any phone.
                                          http://phone.yahoo.com
                                        • Ronald Bourret
                                          ... Yes, as long as the local element type is mapped with a ClassMap. Note that the result probably won t validate against an XML Schema, but I haven t read
                                          Message 20 of 23 , Sep 28, 2001
                                            Richard Lee wrote:
                                            > > Note also that RootClassMaps are going away in
                                            > > version 2.0. They caused
                                            > > nothing but trouble in version 1.0.
                                            >
                                            > I know. So any element could be a possible root when
                                            > retrieve data from database, even local elements?

                                            Yes, as long as the local element type is mapped with a ClassMap. Note
                                            that the result probably won't validate against an XML Schema, but I
                                            haven't read the schema spec closely enough to be sure. However, that
                                            won't stop XML-DBMS from returning it since, at the data transfer level,
                                            XML-DBMS deals in well-formed documents.

                                            > If
                                            > so, we need to consider the possible name conflict due
                                            > to not only the same name defined in different
                                            > namespace but also the same name defined in different
                                            > symbol space if xml document is validated by xml
                                            > schema (DTD requires all names be unique). Same name
                                            > could be defined in different symbol space in xml
                                            > schema, for example, top-level element and local
                                            > element that defined in a top-level complex type could
                                            > have same name. In this case, more name conflict is
                                            > possible. Is it correct?

                                            This is true. Your earlier email got me thinking about local element
                                            type names. I thought the 2.0 DTD supported these, but a little bit of
                                            investigation showed it didn't. As a solution, I'm considering storing
                                            local element types with their own name, but hashing them under a path
                                            name.

                                            The path name constructed as follows:

                                            1) Start with the universal name of the global element type in which the
                                            local element type is defined.

                                            2) Append the universal names of any intermediate (local) element types.

                                            3) Append the universal name of the local element type.

                                            For example, suppose the global element type G1 contains a local element
                                            type L1 which in turn contains a local element type L2. The path name
                                            is:

                                            G1^^L1^^L2

                                            If namespaces are used, local element type names are qualified, and all
                                            the names reside in the http://www.foo.org namespace, then the path name
                                            is:

                                            http://www.foo.org^G1^^http://www.foo.org^L1^^http://www.foo.org^L2

                                            If local element type names are not qualified, then the path name is:

                                            http://www.foo.org^G1^^L1^^L2

                                            When storing data, the code searches first on the universal name of the
                                            element type, since this is the most common case. If it doesn't find it,
                                            it then searches on the path name stretching back to the last global
                                            element type name that was found. Note that it is invalid (according to
                                            XML Schemas) for a local element type name and a global element type
                                            name with the same parent to share the same universal name, so at most
                                            one of these searches will return a map.

                                            When retrieving data, the code simply uses the element type name stored
                                            in the map.

                                            I haven't completely thought this through yet, but it appears to work.

                                            > MapFactory_DTD does not solve the possible name
                                            > confilt right now, I don't know whether it will be
                                            > solved in version 2.

                                            With DTDs there is no conflict, since local element type names are not
                                            supported. The problem only occurs when XML Schemas are used. (Note that
                                            the "problem" here is the need to have multiple maps for a single
                                            element type name.)

                                            > Well, if considering
                                            > Mapfactory_DTD is a design time option to generate
                                            > Map, DBNameChecker could do some help, and modify the
                                            > conflicts by hand. Any plan for some other *Auto*
                                            > name-conflict-solvers included in version 2.0?

                                            The code for an XMLNameChecker is included in MapFactory_Database, but
                                            it's pretty ugly. It needs to be split out and the interface thought
                                            through more carefully.

                                            > Yes, the generated map will be the same as original
                                            > one. My original intent is to try to see how to use
                                            > SAX parser to generate map from xml schema, not using
                                            > DOM parser. I am trying to make XML-DBMS only
                                            > SAX-based.

                                            Oh, OK.

                                            -- Ron
                                          • Richard Lee
                                            Ronald Bourret wrote: I understand the path name construction. Thanks. ... I am not clear about storing and retreating data. Can you give me a simple example
                                            Message 21 of 23 , Sep 29, 2001
                                              Ronald Bourret wrote:

                                              I understand the path name construction. Thanks.

                                              >
                                              > When storing data, the code searches first on the
                                              > universal name of the
                                              > element type, since this is the most common case. If
                                              > it doesn't find it,
                                              > it then searches on the path name stretching back to
                                              > the last global
                                              > element type name that was found. Note that it is
                                              > invalid (according to
                                              > XML Schemas) for a local element type name and a
                                              > global element type
                                              > name with the same parent to share the same
                                              > universal name, so at most
                                              > one of these searches will return a map.
                                              >
                                              > When retrieving data, the code simply uses the
                                              > element type name stored
                                              > in the map.
                                              >

                                              I am not clear about storing and retreating data. Can
                                              you give me a simple example or two? - like:
                                              G1^^L1^^G1, where case 1) those two <G1>s elements are
                                              from different namespace. Case 2) those two <G1>s are
                                              of different types (from different symbol space).

                                              The main reason of confusion is that the same element
                                              type name might have more than one map(ClassMap, or
                                              PropertyMap if element is multiValued. To make things
                                              more complicated, multivalued attribute might have
                                              same name as element and also map to propertyMap).
                                              Given an element to store, it must find a
                                              corresponding map and then store to the right table;
                                              also, to retrieve data from DB, a correct map also
                                              needs to be located so as to reconstruct the xml
                                              document correctly. Do you have any idea how this is
                                              done?


                                              Thanks,

                                              Richard

                                              __________________________________________________
                                              Do You Yahoo!?
                                              Listen to your Yahoo! Mail messages from any phone.
                                              http://phone.yahoo.com
                                            • Ronald Bourret
                                              ... Assume you have two global element types with the same local name. (Local name here means the non-URI part of the name -- it does not mean that the element
                                              Message 22 of 23 , Sep 29, 2001
                                                Richard Lee wrote:
                                                > I am not clear about storing and retreating data. Can
                                                > you give me a simple example or two? - like:
                                                > G1^^L1^^G1, where case 1) those two <G1>s elements are
                                                > from different namespace.

                                                Assume you have two global element types with the same local name.
                                                (Local name here means the non-URI part of the name -- it does not mean
                                                that the element type is defined locally.) For example:

                                                {http://www.foo.org}g1
                                                {http://www.bar.org}g1

                                                The maps for these would look something like:

                                                <XMLToDBMS Version="1.0">
                                                <Options>
                                                <Namespace Prefix="foo" URI="http://www.foo.org" />
                                                <Namespace Prefix="bar" URI="http://www.bar.org" />
                                                </Options>
                                                ...
                                                <Maps>
                                                <ClassMap>
                                                <ElementType Name="foo:g1" />
                                                ...
                                                </ClassMap>
                                                <ClassMap>
                                                <ElementType Name="bar:g1" />
                                                ...
                                                </ClassMap>
                                                </Maps>
                                                </XMLToDBMS>

                                                When the map factory is compiling the map, it constructs names of the
                                                form:

                                                "uri^local_name"

                                                A caret (^) is used because it is not legal in URIs or XML names. Thus,
                                                this would result in two different names:

                                                "http://www.foo.org^g1"
                                                "http://www.bar.org^g1"

                                                and the ClassMaps would be stored in a hash table under these names.
                                                When you encounter a g1 element in an instance document, it is therefore
                                                easy to retrieve the correct map, since the software constructs a name
                                                of the form used above and searches the hash table. This functionality
                                                is in 1.x.

                                                > Case 2) those two <G1>s are
                                                > of different types (from different symbol space).
                                                >
                                                > The main reason of confusion is that the same element
                                                > type name might have more than one map(ClassMap, or
                                                > PropertyMap if element is multiValued. To make things
                                                > more complicated, multivalued attribute might have
                                                > same name as element and also map to propertyMap).
                                                > Given an element to store, it must find a
                                                > corresponding map and then store to the right table;
                                                > also, to retrieve data from DB, a correct map also
                                                > needs to be located so as to reconstruct the xml
                                                > document correctly. Do you have any idea how this is
                                                > done?

                                                I got about halfway through the explanation for this and realized that
                                                the current DTD does work and that we don't need the paths I described
                                                in my last email.

                                                So, let's take a look at two different locally defined element types
                                                that have the same name (L1) but different content models. We'll also
                                                throw in a global element type with the same name. For example:

                                                <IgnoredRoot>
                                                <L1>
                                                <L1Child>This L1 is globally defined.</L1Child>
                                                </L1>
                                                <G1>
                                                <L1>
                                                <L2>def</L2>
                                                <L3>def</L3>
                                                </L1>
                                                </G1>
                                                <G2>
                                                <L1>
                                                <L4>def</L4>
                                                <L4>def</L4>
                                                </L1>
                                                </G2>
                                                </IgnoredRoot>

                                                When DOMToDBMS encounters an element, it takes the element type name and
                                                uses this to look up a map for the element type. For the root element,
                                                this means looking for a ClassMap for the element type in the hashtable
                                                of ClassMaps stored in the Map object. (If the root element is ignored,
                                                as in the above document, the "root" elements are the elements at the
                                                next level down -- L1, G1, and G2 in this case.)

                                                For child elements -- that is, all elements except the root element --
                                                it looks in the hashtable of element type maps in the ClassMap of the
                                                parent element type. Note that these may be RelatedClassMaps,
                                                PropertyMaps, or InlineClassMaps.

                                                Now let's look at what happens when processing the above document. When
                                                DOMToDBMS encounters the first L1 element (the globally defined one), it
                                                looks in the hashtable in the Map object using the name "L1". It then
                                                finds the ClassMap for L1 and processes the element.

                                                When DOMToDBMS encounters the second L1 element (which is locally
                                                defined in G1), it looks in the hashtable in the ClassMap object for G1.
                                                Since the hashtable contains a mixture of RelatedClassMap, PropertyMap,
                                                and InlineClassMap objects, so DOMToDBMS has to determine what type of
                                                object was returned using the instanceof operator. In this case, it is a
                                                RelatedClassMap object.

                                                Now, if you remember for several emails back, a RelatedClassMap object
                                                points to a ClassMap object. Normally, this would point to the ClassMap
                                                object for L1. However, that's a problem here, since we already have a
                                                ClassMap for the globally-defined L1 element type.

                                                This problem is solved by pointing to a ClassMap for an element type
                                                with a phony name, such as L1_In_G1. The map for this is as follows --
                                                notice the <UseClassMap> element in the <RelatedClass> element.

                                                <ClassMap>
                                                <ElementType Name="L1_In_G1" />
                                                ...
                                                </ClassMap>

                                                <ClassMap>
                                                <ElementType Name="G1" />
                                                ...
                                                <RelatedClass>
                                                <ElementType Name="L1" />
                                                <UseClassMap Name="L1_In_G1 />
                                                ...
                                                </RelatedClass>
                                                </ClassMap>

                                                The locally-defined L1 element type in G2 is handled in a similar
                                                fashion.

                                                At a theoretical level, you can think of the ClassMaps (and PropertyMaps
                                                and InlineClassMaps) as forming the nodes of a (possibly disconnected)
                                                directed graph with labeled edges. RelatedClassMaps correspond to the
                                                edges and the element type name in the RelatedClassMap is used to label
                                                the edge. When you search for a map for a child element, it is
                                                equivalent to looking at the names of all the edges pointing out from a
                                                ClassMap node.

                                                For the above document, the graph looks like this, where nodes are
                                                labeled by the name of the element type they map and edges are labeled
                                                by the name used for the lookup.

                                                L1 G1 G2
                                                | | |
                                                | L1Child | L1 | L1
                                                | | |
                                                L1Child L1_In_G1 L1_In_G2
                                                / \ |
                                                / L2 \ L3 | L4
                                                / \ |
                                                L2 L3 L4

                                                As you can see, the edge is normally labeled by the name of the element
                                                type that the pointed-to node maps. However, edges are allowed to have
                                                different names. This allows us to map the same element type name
                                                differently depending on its parent. If we didn't allow this (that is,
                                                we didn't have labeled edges), the L1 edge from G1 would point to the
                                                global L1 node, which is clearly incorrect.

                                                When we retrieve data from the database and construct a document, we
                                                create elements according to the edge labels, not the node labels. Thus,
                                                when we retrieve data from the L1_In_G1 table, we construct an <L1>
                                                element inside the <G1> element, not an L1_In_G1 element. (One
                                                consequence of this is that if the L1_In_G1 table is the root table, we
                                                can't correctly label the root element, since we don't have an edge
                                                pointing to it.)

                                                Other Random Notes:

                                                1) When we are processing the root element, we're not starting from a
                                                particular node, so we don't have any edge names to look at. Instead, we
                                                just do a lookup on the node names themselves.

                                                2) The following document is not schema valid and we don't have to worry
                                                about it. This is because a locally defined element and a globally
                                                defined element with the same name appear in the same content model:

                                                <G1>
                                                <L1>
                                                <L1Child>This L1 is globally defined.</L1Child>
                                                </L1>
                                                <L1>
                                                <L2>def</L2>
                                                <L3>def</L3>
                                                </L1>
                                                </G1>

                                                In graph terms, this means you can't have two edges leading out from the
                                                same node that both have the same label.

                                                3) Roughly the same mechanism is used to support complex types. That is,
                                                to map a complex type, you create a ClassMap for the complex type, then
                                                point to this ClassMap for any element types that use the complex type.
                                                For example:

                                                <ClassMap>
                                                <ElementType Name="AddressComplexType" />
                                                ...
                                                </ClassMap>

                                                <ClassMap>
                                                <ElementType Name="BillToAddress" />
                                                <UseClassMap Name="AddressComplexType" />
                                                </ClassMap>

                                                <ClassMap>
                                                <ElementType Name="ShipToAddress" />
                                                <UseClassMap Name="AddressComplexType" />
                                                </ClassMap>

                                                4) I could have created separate mapping elements for local element
                                                types (e.g. LocalClassMap), but this has two drawbacks. First, the code
                                                would be much more complex. Second, it would tie XML-DBMS much too
                                                closely to XML Schemas. While I want to support XML Schemas, I don't
                                                want to support them to the exclusion of everything else.

                                                I hope this explanation helps. It certainly helps me, since I realized I
                                                don't have to make any changes to support local element types -- just
                                                write better documentation in the DTD. Thanks!

                                                -- Ron
                                              • Tai Tran
                                                Hi, ... Problems still exists if you convert an DTD to an XML Schema. The Process is still the same as construct the structure of the DTD and map the structure
                                                Message 23 of 23 , Oct 2, 2001
                                                  Hi,

                                                  > One way to get around this might be to find a
                                                  > tool that will convert a DTD to an XML Schema. Then
                                                  > you could tweak the schema and use Castor to create
                                                  > the binding logic.

                                                  Problems still exists if you convert an DTD to an XML
                                                  Schema. The Process is still the same as construct the
                                                  structure of the DTD and map the structure to the
                                                  database schema. You still have to find the root
                                                  element in the DTD and so on.

                                                  I don't know much about XML Schema, please excuse me
                                                  if I say something wrong.

                                                  Best Regards,
                                                  Tai



                                                  --- Tod Harter <tharter@...> wrote:
                                                  > I'm not 100% certain I follow you. What do you mean
                                                  > "query the data
                                                  > structure"? Take a look at Castor, it might be very
                                                  > handy for what you want
                                                  > to do. Its a free open source data binding engine
                                                  > for Java. Basically you can
                                                  > give it an XML Schema and it can construct an
                                                  > appropriate data structure
                                                  > (Java class) for you and help with generating the
                                                  > code required to extract
                                                  > information from the database into your structure
                                                  > (and vice versa). In
                                                  > essence it allows you to autogenerate logic to
                                                  > marshal and unmarshal data
                                                  > between XML and Java classes. I believe the home
                                                  > page is part of the Apache
                                                  > Software Foundation site (www.apache.org).
                                                  >
                                                  > Unfortunately tasks of this nature are very
                                                  > difficult to manage using a DTD.
                                                  > DTDs lack any real way to specify the data types of
                                                  > elements, and only very
                                                  > limited typing for attributes. One way to get around
                                                  > this might be to find a
                                                  > tool that will convert a DTD to an XML Schema. Then
                                                  > you could tweak the
                                                  > schema and use Castor to create the binding logic.
                                                  > Its a little beyond my
                                                  > experience at this point, but from what I've seen
                                                  > people doing on some other
                                                  > projects it should work. I think MS and Oracle (no
                                                  > doubt IBM as well) have
                                                  > proprietary tools that can accomplish similar tasks.
                                                  >
                                                  >
                                                  > On Saturday 08 September 2001 10:16, you wrote:
                                                  > > Thanks for the info.
                                                  > >
                                                  > > What exactly I wanted to do is this.
                                                  > >
                                                  > > I've been given a DTD file and a database account
                                                  > > (Interbase). The DTD file is conform the database
                                                  > > schema.
                                                  > >
                                                  > > What I have to do for the project specification is
                                                  > > that I have to parse the DTD file, get all the
                                                  > > elements, attributes, occurrences, etc... Put
                                                  > these
                                                  > > data into a data structure. From here, I have to
                                                  > > create an XML file by querying the data structure,
                                                  > not
                                                  > > directly to the database server.
                                                  > >
                                                  > > So yeah, this is my problem.
                                                  > >
                                                  > > --- Tod Harter <tharter@...> wrote:
                                                  > > > In a case where you would need to validate the
                                                  > > > structure of a document in
                                                  > > > this way, IE verify that the root element was
                                                  > "<A>"
                                                  > > > in Ron's example, you
                                                  > > > would probably want to use an XML Schema.
                                                  > Schemas
                                                  > > > provide a much more
                                                  > > > powerfull validation mechanism than a DTD. There
                                                  > are
                                                  > > > also a variety of other
                                                  > > > similar technologies (there must be at least 10
                                                  > > > proposals/'standards" for XML
                                                  > > > meta data aimed at doing this). Schematron is an
                                                  > > > interesting one, it uses an
                                                  > > > XSLT stylesheet to validate a document, meaning
                                                  > that
                                                  > > > in theory any XSLT
                                                  > > > conformant processor can act as a validation
                                                  > system.
                                                  > > > There are numerous books
                                                  > > > on the subject, Wrox's "Professional XML" has a
                                                  > > > pretty good overview, it
                                                  > > > covers 5 or 6 of these technologies in enough
                                                  > detail
                                                  > > > to evaluate their
                                                  > > > potential utility for a given project.
                                                  > > >
                                                  > > > On Thursday 06 September 2001 15:27, you wrote:
                                                  > > > > Tai Tran wrote:
                                                  > > > > > Can your DTD parser (SubsetToDTD) find the
                                                  > root
                                                  > > > > > element?
                                                  > > > >
                                                  > > > > No. It can't do this because the DTD doesn't
                                                  > tell
                                                  > > >
                                                  > > > you what the root
                                                  > > >
                                                  > > > > element is. Any element can be the root
                                                  > element.
                                                  > > > >
                                                  > > > > This is kind of confusing. Since each XML
                                                  > document
                                                  > > >
                                                  > > > must have a single
                                                  > > >
                                                  > > > > root element, it is tempting to think that the
                                                  > DTD
                                                  > > >
                                                  > > > tells us what that
                                                  > > >
                                                  > > > > root element is. This is not the case.
                                                  > Instead,
                                                  > > >
                                                  > > > the instance document
                                                  > > >
                                                  > > > > tells us what the root element is.
                                                  > > > >
                                                  > > > > One consequence of this is that two XML
                                                  > documents
                                                  > > >
                                                  > > > with different root
                                                  > > >
                                                  > > > > elements can be validated successfully with
                                                  > the
                                                  > > >
                                                  > > > same DTD. For example,
                                                  > > >
                                                  > > > > suppose we have a DTD:
                                                  > > > >
                                                  > > > > example.dtd
                                                  > > > > -----------
                                                  > > > > <!ELEMENT A (B)>
                                                  > > > > <!ELEMENT B (#PCDATA)>
                                                  > > > >
                                                  > > > > Now here are two valid XML documents with
                                                  > > >
                                                  > > > different root elements that
                                                  > > >
                                                  > > > > both use this DTD:
                                                  > > > >
                                                  > > > > a.xml
                                                  > > > > -----
                                                  > > > > <!DOCTYPE A SYSTEM "example.dtd">
                                                  > > > > <A>
                                                  > > > > <B>bbbb</B>
                                                  > > > > </A>
                                                  > > > >
                                                  > > > > b.xml
                                                  > > > > -----
                                                  > > > > <!DOCTYPE B SYSTEM "example.dtd">
                                                  > > > > <B>bbbb</B>
                                                  > > > >
                                                  > > > > As you can see, you can't figure out what the
                                                  > root
                                                  > > >
                                                  > > > element is from
                                                  > > >
                                                  > > > > looking at the DTD. (In theoretical terms, a
                                                  > DTD
                                                  > > >
                                                  > > > forms a directed graph
                                                  > > >
                                                  > > > > of definitions. Where you enter the graph is
                                                  > the
                                                  > > >
                                                  > > > root element type. You
                                                  > > >
                                                  > > > > can enter the graph at any node.)
                                                  > >
                                                  > > __________________________________________________
                                                  > > Do You Yahoo!?
                                                  > > Get email alerts & NEW webcam video instant
                                                  > messaging with Yahoo! Messenger
                                                  > > http://im.yahoo.com
                                                  > >
                                                  > >
                                                  > > To post a message, send it to:
                                                  > xml-dbms@yahoogroups.com
                                                  > > To unsubscribe, send a blank message to:
                                                  > > xml-dbms-unsubscribe@yahoogroups.com Or join the
                                                  > newsgroup at:
                                                  > > news://news.barkto.com/homeless.xml.xml-dbms
                                                  > >
                                                  > > Your use of Yahoo! Groups is subject to
                                                  > http://docs.yahoo.com/info/terms/
                                                  >


                                                  __________________________________________________
                                                  Do You Yahoo!?
                                                  Listen to your Yahoo! Mail messages from any phone.
                                                  http://phone.yahoo.com
                                                Your message has been successfully submitted and would be delivered to recipients shortly.