Re: XML within XML - includes, transcludes, whatever

Ah!  I'm not familiar with the intimate details of the current parsers (parse
and validate in one API call) but it may very well be that this breaks down
into a pass through the instance to get the parse and a pass through the
post-parse form (say a DOM) to do the validation.  Two passes (though only one
through the instance) are made anyway.  If so, what diff if we defer the
validation step until later?  Then I can see that there's no performance
concern.  In fact, defering validation might speed things along by shortening
the elapsed time of the initial parse.  On the other hand, if a single pass is
currently enough to get to wellformed and valid, then the deferral of the
validation steps would make the process less efficient.

Continuing to play devil's advocate:

Assuming...

 - a single physical instance with independently validating routing,
processing and content sections, and
 - all the sections are XML

...then does the approach require a parse of all sections of the original
instance at once?  If it does, this seems analogous to having the mail room
open and read completely through all incoming mail before routing it to the
recipient within the enterprise.   Not very efficient.  In such a
circumstance, I think I'd lobby for the routing section to be other than XML
(MIME seems to work well) with the rest of the payload attached thereto.  IOW,
there ought not to be a requirement to read the application content just to
route the message to the correct queue or inbound process.

I'm thinking here that the routing section would tell me the type of
transaction this is and the identity of the sender.  That would allow my
inbound engine to identify the DTD/Schema to use in validating the apps
content section.  I'd want to be able to get at that info before I read any of
the other sections.

Corrections if I've again gone astray, please.

--Mike


Gavin Thomas Nicol wrote:

> > Wouldn't this idea require two passes through the XML instance to get to
> > wellformed *and* valid?  If so, this seems clearly unacceptable
> > performance-wise.  Or am I misunderstanding the idea?
>
> One pass is enough: you validate the post-parse form in the
> naive (brute-force approach) case, and with a more
> intelligent processor, validate as you parse.
>