Ben Nadel
On User Experience (UX) Design, JavaScript, ColdFusion, Node.js, Life, and Love.
I am the chief technical officer at InVision App, Inc - a prototyping and collaboration platform for designers, built by designers. I also rock out in JavaScript and ColdFusion 24x7.
Meanwhile on Twitter
Loading latest tweet...
Ben Nadel at CFUNITED 2010 (Landsdown, VA) with:

Working With Inconsistent XML Structures In ColdFusion

By Ben Nadel on
Tags: ColdFusion

After my recent post on moving XML data into a database, several people have asked me how to best go about working with XML documents in ColdFusion that do not have a consistent structure. While this might sound like an odd scenario, when dealing with 3rd party XML APIs, it's actually quite common. For example, when getting shipping information from UPS, often times their XML response structure will differ depending on what they have on file. As such, your processing code might need special logic to deal with things like a missing "company" node or "name" node.

I have several ways of doing this, but, before we can discuss the solutions, let's take a look at some sample XML. For this post, I'm going to assume we are working with an XML response that might contain this entire structure:

Full XML Response

  • <!---
  • Create our respone data template. This is the XML template
  • that uses all of the possible options.
  • --->
  • <cfxml variable="completeData">
  •  
  • <response>
  • <contact>
  • <name />
  • <email />
  • </contact>
  • <address type="business">
  • <street />
  • <street />
  • <company />
  • <city />
  • <state />
  • <zip />
  • </address>
  • </response>
  •  
  • </cfxml>

As you can see, this XML response data contains a contact and an address node, each with its own child nodes. In our XML processing logic, we are going to assume that the XML response that we actually receive may contain all or only some of the data defined by the full XML response. For demonstration purposes, we are going to use this as our given XML response:

Simulated XML Response

  • <!---
  • Create our response data using just some of the possible
  • data that is available.
  • --->
  • <cfxml variable="partialData">
  •  
  • <response>
  • <contact>
  • <name>Tricia</name>
  • </contact>
  • <address>
  • <zip>10016</zip>
  • </address>
  • </response>
  •  
  • </cfxml>

As you can see, our simulated XML response has both the contact and the address nodes, but it is missing almost all child elements as well as the "type" attribute of the address node.

Now that we have our ColdFusion XML documents, completeData and partialData, we can look at how to move the inconsistent XML data into the database. For the rest of this demo, please assume that I have a database table to contain each one of the leaf nodes in the complete XML document.

Brute Force Node Existence Checking

My first approach to working with inconsistent XML structures in ColdFusion is a brute-force approach in which we manually check for the existence of each target node before we extract its value. Because ColdFusion wraps up XML node sets in named collections that mimic structures, we can use things like StructKeyExists() and ArrayLen() to check for the desired nodes by name:

  • <!---
  • Create a container to hold our xml data. This container will
  • start off with all of the default data for the values. This
  • way, we only override the default values if the nodes are
  • found in the target xml document.
  • --->
  • <cfset data = {
  • name = "",
  • email = "",
  • street1 = "",
  • street2 = "",
  • company = "",
  • city = "",
  • state = "",
  • zip = ""
  • } />
  •  
  •  
  • <!---
  • Now that we have our default data structure, we can start
  • checking the XML response data for our target nodes. Remember,
  • we will only overrid the default data above if we find a node.
  • --->
  •  
  • <!--- Check to see if the contact nodes exists. --->
  • <cfif structKeyExists( partialData.xmlRoot, "contact" )>
  •  
  • <!---
  • Get a short hand reference to the contact node so that
  • our subsequent checks and retrievals are shorter and
  • easier to read.
  • --->
  • <cfset contactNode = partialData.xmlRoot.contact />
  •  
  • <!--- Check to see if the name node exists. --->
  • <cfif structKeyExists( contactNode, "name" )>
  •  
  • <!--- Get the name value. --->
  • <cfset data.name = contactNode.name.xmlText />
  •  
  • </cfif>
  •  
  • <!--- Check to see if the email node exists. --->
  • <cfif structKeyExists( contactNode, "email" )>
  •  
  • <!--- Get the email value. --->
  • <cfset data.email = contactNode.email.xmlText />
  •  
  • </cfif>
  •  
  • </cfif>
  •  
  • <!--- Check to see if the address node exists. --->
  • <cfif structKeyExists( partialData.xmlRoot, "address" )>
  •  
  • <!---
  • Get a short hand reference to the address node so that
  • our subsequent checks and retrievals are shorter and
  • easier to read.
  • --->
  • <cfset addressNode = partialData.xmlRoot.address />
  •  
  • <!--- Check to see if the first street node exists. --->
  • <cfif (
  • structKeyExists( addressNode, "street" ) &&
  • arrayLen( addressNode.street )
  • )>
  •  
  • <!--- Get the first street value. --->
  • <cfset data.street1 = addressNode.street[ 1 ].xmlText />
  •  
  • </cfif>
  •  
  • <!--- Check to see if the second street node exists. --->
  • <cfif (
  • structKeyExists( addressNode, "street" ) &&
  • (arrayLen( addressNode.street ) GTE 2)
  • )>
  •  
  • <!--- Get the second street value. --->
  • <cfset data.street2 = addressNode.street[ 2 ].xmlText />
  •  
  • </cfif>
  •  
  • <!--- Check to see if the company node exists. --->
  • <cfif structKeyExists( addressNode, "company" )>
  •  
  • <!--- Get the company value. --->
  • <cfset data.company = addressNode.company.xmlText />
  •  
  • </cfif>
  •  
  • <!--- Check to see if the city node exists. --->
  • <cfif structKeyExists( addressNode, "city" )>
  •  
  • <!--- Get the city value. --->
  • <cfset data.city = addressNode.city.xmlText />
  •  
  • </cfif>
  •  
  • <!--- Check to see if the state node exists. --->
  • <cfif structKeyExists( addressNode, "state" )>
  •  
  • <!--- Get the state value. --->
  • <cfset data.state = addressNode.state.xmlText />
  •  
  • </cfif>
  •  
  • <!--- Check to see if the zip node exists. --->
  • <cfif structKeyExists( addressNode, "zip" )>
  •  
  • <!--- Get the zip value. --->
  • <cfset data.zip = addressNode.zip.xmlText />
  •  
  • </cfif>
  •  
  • </cfif>
  •  
  •  
  • <!---
  • ASSERT: At this point, we have moved all possible target
  • nodes into our data structure.
  • --->
  •  
  •  
  • <!--- Insert the extracted XML data into our database. --->
  • <cfquery name="insertData" datasource="ben">
  • INSERT INTO partial_xml
  • (
  • name,
  • email,
  • street1,
  • street2,
  • company,
  • city,
  • state,
  • zip
  • ) VALUES (
  • <cfqueryparam value="#data.name#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.email#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.street1#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.street2#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.company#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.city#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.state#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.zip#" cfsqltype="cf_sql_varchar" />
  • );
  • </cfquery>

As you can see, we start off with a default collection of data points. I like to start off this way because I tend to give everything a default value if it doesn't exist. If you need to have conditional inserts into your database based on the XML response, you can always start off with an empty data collection and then populate it with only the existing XML node values. Once the XML is extracted from the partial XML document, we move the centralized data collection into the database with a simple INSERT.

Gathering XML Data Using XmlSearchWithParam()

The code in the brute force method above is very easy to follow, but it's long. Of course, it has to be long because we need it to check for the existence of our target XML nodes. But, what if we didn't have to worry about XML node existence? Then, our code could be much shorter. In the first example, the default values were created first which meant we had to search out potential override values; in this next approach, I am building the concept of default values right into the data collection.

This solution uses a ColdFusion user defined function, XmlSearchWithParam(), which mimics the functionality of ColdFusion's XmlSearch() function, with the caveat that if no results are found, the method will populate the results array with a given default node value (or set of values). By using this function, rather than XmlSearch() directly, we know that our results array will always contain the type of target data we are seeking, even if it's not the actual data coming from the XML document:

  • <cffunction
  • name="xmlSearchWithParam"
  • access="public"
  • returntype="array"
  • output="false"
  • hint="I perform an XmlSearch() with the option to param the results with the given structure.">
  •  
  • <!--- Define arguments. --->
  • <cfargument
  • name="xmlDocument"
  • type="any"
  • required="true"
  • hint="I am the Xml document being searched."
  • />
  •  
  • <cfargument
  • name="xpath"
  • type="string"
  • required="true"
  • hint="I am the XPath query to search with."
  • />
  •  
  • <cfargument
  • name="defaultNode"
  • type="struct"
  • required="false"
  • default="#structNew()#"
  • hint="I am the default node to put in the xmlSearch() results if no target node is found."
  • />
  •  
  • <cfargument
  • name="defaultCount"
  • type="numeric"
  • required="false"
  • default="1"
  • hint="I am the number of default nodes to be added to the results if no valid results are found (or not enough valid results are found)."
  • />
  •  
  • <!--- Define the local scope. --->
  • <cfset local = {} />
  •  
  • <!--- Perform the xmlSearch() query. --->
  • <cfset local.nodes = xmlSearch(
  • arguments.xmlDocument,
  • arguments.xpath
  • ) />
  •  
  • <!---
  • Check to see if we came up empty handed from the search
  • AND if there is a default node to use in place of any
  • valid search results.
  • --->
  • <cfif (
  • structCount( arguments.defaultNode ) &&
  • (
  • !arrayLen( local.nodes ) ||
  • (arrayLen( local.nodes ) lt arguments.defaultCount)
  • ))>
  •  
  • <!---
  • Add as many default nodes to the array as requested
  • by the user. Be sure to duplicate the struct so we
  • don't create reference issues.
  • --->
  • <cfloop
  • index="local.defaultNodeIndex"
  • from="#(arrayLen( local.nodes ) + 1)#"
  • to="#arguments.defaultCount#"
  • step="1">
  •  
  • <!--- Use the default node as the only result. --->
  • <cfset arrayAppend(
  • local.nodes,
  • duplicate( arguments.defaultNode )
  • ) />
  •  
  • </cfloop>
  •  
  • </cfif>
  •  
  • <!--- Return the collected nodes. --->
  • <cfreturn local.nodes />
  • </cffunction>
  •  
  •  
  •  
  • <!---
  • Create a structure that contains only one key - XmlValue.
  • When we search for our text nodes, this is a sub-set of
  • the structure that will be returned. We can use this to
  • param the results of our XmlSearch() call.
  • --->
  • <cfset defaultNode = {
  • xmlValue = ""
  • } />
  •  
  • <!---
  • Now that we have our default value, let's search for the
  • nodes in our partial XML document. I'm going to search for
  • each leaf node individually.
  • --->
  •  
  • <!--- Should return one match. --->
  • <cfset nameNodes = xmlSearchWithParam(
  • partialData,
  • "//contact/name/text()",
  • defaultNode
  • ) />
  •  
  • <!--- Should return one match. --->
  • <cfset emailNodes = xmlSearchWithParam(
  • partialData,
  • "//contact/email/text()",
  • defaultNode
  • ) />
  •  
  • <!--- Should return TWO matches. --->
  • <cfset streetNodes = xmlSearchWithParam(
  • partialData,
  • "//address/street/text()",
  • defaultNode,
  • 2
  • ) />
  •  
  • <!--- Should return one match. --->
  • <cfset companyNodes = xmlSearchWithParam(
  • partialData,
  • "//address/company/text()",
  • defaultNode
  • ) />
  •  
  • <!--- Should return one match. --->
  • <cfset cityNodes = xmlSearchWithParam(
  • partialData,
  • "//address/city/text()",
  • defaultNode
  • ) />
  •  
  • <!--- Should return one match. --->
  • <cfset stateNodes = xmlSearchWithParam(
  • partialData,
  • "//address/state/text()",
  • defaultNode
  • ) />
  •  
  • <!--- Should return one match. --->
  • <cfset zipNodes = xmlSearchWithParam(
  • partialData,
  • "//address/zip/text()",
  • defaultNode
  • ) />
  •  
  •  
  • <!---
  • Now that we have our search results, we can store the values
  • of the collected nodes into our data collection.
  • --->
  • <cfset data = {
  • name = nameNodes[ 1 ].xmlValue,
  • email = emailNodes[ 1 ].xmlValue,
  • street1 = streetNodes[ 1 ].xmlValue,
  • street2 = streetNodes[ 2 ].xmlValue,
  • company = companyNodes[ 1 ].xmlValue,
  • city = cityNodes[ 1 ].xmlValue,
  • state = stateNodes[ 1 ].xmlValue,
  • zip = zipNodes[ 1 ].xmlValue
  • } />
  •  
  •  
  • <!---
  • ASSERT: At this point, we have moved all possible target
  • nodes into our data structure.
  • --->
  •  
  •  
  • <!--- Insert the extracted XML data into our database. --->
  • <cfquery name="insertData" datasource="ben">
  • INSERT INTO partial_xml
  • (
  • name,
  • email,
  • street1,
  • street2,
  • company,
  • city,
  • state,
  • zip
  • ) VALUES (
  • <cfqueryparam value="#data.name#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.email#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.street1#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.street2#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.company#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.city#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.state#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.zip#" cfsqltype="cf_sql_varchar" />
  • );
  • </cfquery>

As you can see, by ensuring that an XmlSearchWithParam() method call always returns a result set with the appropriate number of target nodes, when it comes time to moving the node values into our data collection, we don't have to do any node validation.

Paraming An Entire XML Document With XmlParam()

The above approach is a bit better; but, even excluding the XmlSearchWithParam() user defined function, which would be stored in some UDF library, the code is not that much shorter than our brute force method. And, on top of that, we are now forcing the programmer to use XPath, which is certainly an advanced level topic. Ideally, we want to use ColdFusion's named-node collections, which are much more intuitive than using XmlSearch(); but, we also don't want to have to worry about checking for node existence. In this last and final approach, I am using another ColdFusion user defined function, XmlParam(), to literally param our entire partial XML document.

If we know the structure of a complete XML document, we can use that structure to fill in the gaps in our partial XML response with default values. And, once we do that, we can then use the named-node collection notation to easily populate our data collection:

  • <cffunction
  • name="xmlParam"
  • access="public"
  • returntype="any"
  • output="false"
  • hint="I take a partial XML document and param it based on a complete XML document.">
  •  
  • <!--- Define arguments. --->
  • <cfargument
  • name="partialXmlDoc"
  • type="any"
  • required="true"
  • hint="I am the partial XML document that we are paraming."
  • />
  •  
  • <cfargument
  • name="completeXmlDoc"
  • type="any"
  • required="true"
  • hint="I am the complete XML document against which the the partial XML document is being paramed."
  • />
  •  
  • <!---
  • NOTE: Following arguments are optional if you want
  • to param an entire XML document. Use the following two
  • arguments if you only want to param part of an XML
  • document (specifically, the given node).
  • --->
  •  
  • <cfargument
  • name="partialXmlNode"
  • type="any"
  • required="false"
  • hint="I am the partial node being compared. Exclude this argument if you want to param the entire document."
  • />
  •  
  • <cfargument
  • name="completeXmlNode"
  • type="any"
  • required="false"
  • hint="I am the complete node being compared. Exclude this argument if you want to param the entire document."
  • />
  •  
  • <!--- Define the local scope. --->
  • <cfset var local = {} />
  •  
  • <!---
  • Make sure that we have XML nodes. If we don't then get
  • the root node of the given documents. If we do, then
  • either the user sent them in or we are in the middle of
  • a recursive comparison.
  • --->
  • <cfif !structKeyExists( arguments, "partialXmlNode" )>
  •  
  • <!---
  • Get Root nodes for both the partial XML document
  • and the completeXml document.
  • --->
  • <cfset arguments.partialXmlNode = arguments.partialXmlDoc.xmlRoot />
  • <cfset arguments.completeXmlNode = arguments.completeXmlDoc.xmlRoot />
  •  
  • </cfif>
  •  
  •  
  • <!---
  • Param the node attributes. Loop over the complete XML
  • node to move any non-existent attributes over to the
  • partial XML document.
  • --->
  • <cfloop
  • item="local.attribute"
  • collection="#arguments.completeXmlNode.xmlAttributes#">
  •  
  • <!---
  • Param the value in the partial document. Since we
  • are using CFParam, it will only be copied over if
  • it doesn't already exist.
  • --->
  • <cfparam
  • name="arguments.partialXmlNode.xmlAttributes[ '#local.attribute#' ]"
  • type="any"
  • default="#arguments.completeXmlNode.xmlAttributes[ local.attribute ]#"
  • />
  •  
  • </cfloop>
  •  
  •  
  • <!---
  • Now, let's loop over the children to see if they match
  • up. This is a bit trickier since XML documents can be
  • so flexible. This is ONLY going to work with CERTAIN
  • types of XML documents (specifically those that have a
  • rigid structure and not so much for those that can
  • contain 1..N of a particular type of node - for that,
  • you have to param sub-documents).
  • --->
  • <cfloop
  • index="local.nodeIndex"
  • from="1"
  • to="#arrayLen( arguments.completeXmlNode.xmlChildren )#"
  • step="1">
  •  
  • <!--- Get a reference to the complete child node. --->
  • <cfset local.completeChildNode = arguments.completeXmlNode.xmlChildren[ local.nodeIndex ] />
  •  
  • <!---
  • Check to see if the partial XML document has enough
  • children to even check this against the complete
  • version of the node.
  • --->
  • <cfif (arrayLen( arguments.partialXmlNode.xmlChildren ) lt local.nodeIndex)>
  •  
  • <!---
  • The partial XML document doesn't even have a node
  • at this position. As such, we have to just copy
  • over the node from the complete Xml document.
  • --->
  • <cfset arrayAppend(
  • arguments.partialXmlNode.xmlChildren,
  • xmlElemNew(
  • arguments.partialXmlDoc,
  • local.completeChildNode.xmlName
  • )
  • ) />
  •  
  • <!---
  • Now that we have appended the new child node,
  • get a short-hand reference to it.
  • --->
  • <cfset local.partialChildNode = arguments.partialXmlNode.xmlChildren[ local.nodeIndex ] />
  •  
  • <!--- Copy over the default text value. --->
  • <cfset local.partialChildNode.xmlText = local.completeChildNode.xmlText />
  •  
  • <!---
  • With the new node in place in the partial
  • document, we can now recursively move over the
  • rest of the complete sub-tree recursively.
  • --->
  • <cfset xmlParam(
  • arguments.partialXmlDoc,
  • arguments.completeXmlDoc,
  • local.partialChildNode,
  • local.completeChildNode
  • ) />
  •  
  • <cfelse>
  •  
  • <!---
  • A node exists at this index in the partial XML
  • document. Now, we have to see if is the right
  • node to be at this index, or if we need to
  • create a new node.
  • --->
  •  
  • <!--- Get a refernce to the partial XML node. --->
  • <cfset local.partialChildNode = arguments.partialXmlNode.xmlChildren[ local.nodeIndex ] />
  •  
  • <!---
  • Check to see if this partial node is the same name
  • as the complete node. If they are, then we can
  • simply compare them. If they are not, however,
  • then we have to insert a new node.
  • --->
  • <cfif (local.partialChildNode.xmlName eq local.completeChildNode.xmlName)>
  •  
  • <!---
  • The node names are the same. Therefore, we can
  • simply compare them recursively.
  • --->
  • <cfset xmlParam(
  • arguments.partialXmlDoc,
  • arguments.completeXmlDoc,
  • local.partialChildNode,
  • local.completeChildNode
  • ) />
  •  
  • <cfelse>
  •  
  • <!---
  • The node names are NOT the same. This means
  • that the given node is missing from the
  • partial xml document. We now have to create it
  • and then insert it.
  • --->
  • <cfset local.partialChildNode = xmlElemNew(
  • arguments.partialXmlDoc,
  • local.completeChildNode.xmlName
  • ) />
  •  
  • <!--- Copy over the default text value. --->
  • <cfset local.partialChildNode.xmlText = local.completeChildNode.xmlText />
  •  
  • <!--- Insert the node at the given position. --->
  • <cfset arrayInsertAt(
  • arguments.partialXmlNode.xmlChildren,
  • local.nodeIndex,
  • local.partialChildNode
  • ) />
  •  
  • <!---
  • Now that we have inserted the new node,
  • compare it to the target complete node.
  • NOTE: Because XML elements are inserted by
  • VALUE, we have to get the reference to our
  • taret child node again otherwise the changes
  • will not hold.
  • --->
  • <cfset xmlParam(
  • arguments.partialXmlDoc,
  • arguments.completeXmlDoc,
  • arguments.partialXmlNode.xmlChildren[ local.nodeIndex ],
  • local.completeChildNode
  • ) />
  •  
  • </cfif>
  •  
  • </cfif>
  •  
  • </cfloop>
  •  
  •  
  • <!--- Return the updated partial XML document. --->
  • <cfreturn arguments.partialXmlDoc />
  • </cffunction>
  •  
  •  
  •  
  • <!---
  • Param the partial data response using the structure of our
  • known complete data XML repsonse.
  • --->
  • <cfset xmlParam( partialData, completeData ) />
  •  
  • <!---
  • ASSERT: At this point, our partial XML document structure is
  • the same as our complete XML document structure.
  • --->
  •  
  • <!---
  • Now that we have paramed our partial xml document to mimic our
  • complete xml document, we can use named-node collection
  • notation to store the node values into our data collection.
  • --->
  • <cfset data = {
  • name = partialData.xmlRoot.contact.name.xmlText,
  • email = partialData.xmlRoot.contact.email.xmlText,
  • street1 = partialData.xmlRoot.address.street[ 1 ].xmlText,
  • street2 = partialData.xmlRoot.address.street[ 2 ].xmlText,
  • company = partialData.xmlRoot.address.company.xmlText,
  • city = partialData.xmlRoot.address.city.xmlText,
  • state = partialData.xmlRoot.address.state.xmlText,
  • zip = partialData.xmlRoot.address.zip.xmlText
  • } />
  •  
  •  
  • <!---
  • ASSERT: At this point, we have moved all possible target
  • nodes into our data structure.
  • --->
  •  
  •  
  • <!--- Insert the extracted XML data into our database. --->
  • <cfquery name="insertData" datasource="ben">
  • INSERT INTO partial_xml
  • (
  • name,
  • email,
  • street1,
  • street2,
  • company,
  • city,
  • state,
  • zip
  • ) VALUES (
  • <cfqueryparam value="#data.name#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.email#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.street1#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.street2#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.company#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.city#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.state#" cfsqltype="cf_sql_varchar" />,
  • <cfqueryparam value="#data.zip#" cfsqltype="cf_sql_varchar" />
  • );
  • </cfquery>

Ok, now granted that the code for XmlParam() is rather long - it's a complicated function. But, once we get past that function, which would be stored in a UDF library, the code for extracting the XML data is extremely small! Because we are ensuring that the partial XML document mimics the structure of the complete XML document, we can use our named-node collection without having to worry about any node existence checking. This is truly the best of all possible worlds.

The XmlParam() method is quite beasty and by no means easy to understand. As such, I want to run a small example just to show you how it alters the given XML document:

  • <!--- Dump out the partial document before we param it. --->
  • <cfdump
  • var="#partialData#"
  • label="Before XmlParam()"
  • />
  •  
  • <!--- Param the document. --->
  • <cfset xmlParam( partialData, completeData ) />
  • <br />
  •  
  • <!--- Dump out the partial document after we param it. --->
  • <cfdump
  • var="#partialData#"
  • label="After XmlParam()"
  • />

As you can see here, we are outputting the partial document, then paraming it with the complete document, and then outputting it again. Here is what we get:

 
 
 
 
 
 
XmlParam() Allows Us To Param An Entire XML Document Based On The Structure Or Sub-Structure Of Another One. 
 
 
 

By passing the partial XML document to the XmlParam() method, we leave all the existing values in the partial document untouched; however, for every value in the complete XML document that does not also exist in the partial XML document, we copy it over. This way, we can move forward with the partial XML document assuming it has a complete structure.

These three methods are just some of the methods used for dealing with inconsistentt XML data in ColdFusion. Furthermore, they are designed to work only within certain boundaries; specifically, in situations where the XML data structure does not hugely alter the processing logic and in situations were default values can be easily assigned when target nodes are absent. That said, the above boundaries cover the majority of XML use cases that I have had to deal with. I hope this helps in some way. If you want to see any additional demo for a given use case, just let me know.




Reader Comments

Ben, your blog is always a great place to answer an that I have when I hit a dead end. Thank you for your contributions to use developers.

I used to think XPath had very little power and I have now been reformed; and I am better for it.