A quick one here. Wasn’t getting any results when running XPath queries on the following Xml:

<root xmlns="http://www.tempuri.org/xml/export-0.3/">
  <page>...</page>
  <page>...</page>
  <page>...</page>
</root>
Query: "/root/page" or "//page"

As this xml contains a namespace definition you’ll need to pass an instance of the XmlNamespaceManager like so…

XmlDocument xdDoc = new XmlDocument();
xdDoc.Load("Source.xml");

XmlNamespaceManager xnManager =
 new XmlNamespaceManager(xdDoc.NameTable);
xnManager.AddNamespace("tu",
 "http://www.tempuri.org/xml/export-0.3/");

XmlNode xnRoot = xdDoc.DocumentElement;
XmlNodeList xnlPages = xnRoot.SelectNodes("/root/page", xnManager);

XmlNode xnRoot = xdProfiles.DocumentElement;
XmlNodeList xnlPages = xnRoot.SelectNodes("/root/page", xnManager);
// Assert(xnlPages.Count == 3);

This is part zero of a multi-part series. Jump to The Poor Developer’s Object DataStore: Iteration 001 for the first code drop.

What is an object datastore? For an object-oriented developer it’s as easy to use as a typed collection. No need to build and maintain a complex relational model to simulate the native object functionality. Just create your object, modify it, store it, query for it and delete it. All the complicated work is handled by the object database engine. But let’s consider a situation where you may want to “roll your own” light-weight object datastore. And depending on your situation, it might make sense. CAVEAT: Rule #1 of Software Engineering: If You Can Use A Proven Product Don’t Write Your Own. They Did It First And They Did It Better. But for the sake of exercise and trying something new let’s just ignore that rule and keep on going.

Consider the following scenario. You’re a .NET developer and you’ve been tasked with creating an archiving system. The system needs to take a snapshot of the data and store it to be queried against and reported on later.

How would you implement this? Would you copy the data structure you’re looking to archive and pull the data state into there? How do you manage foreign keys? Do you squish the data into a single table? Do you recreate all the tables with annotations to identify the archived records? Now, it’s a few months later and the original data structure has changed. How do you handle that change in your archiving?

Do you really want to recreate that complex data structure and try to wrangle the data into it and manage it over time? No, neither did I and I think there is a better way. Let’s consider a new way: an object datastore.

Let’s get this out of the way. Object databases aren’t just for ninjas although they are often wielded by ninjas. An object database is exactly what it sounds like, a database for your objects. No sql, no tables, no object-relational impedance. Just objects persisted similar to how a relational database allows you to store and persist tabular information offline without all the grief of mapping your object-oriented structure onto a relational model. Instead you create your objects and using the database’s API you can save and query for your data without worrying about sql or any of that mess. My personal favorite OODBMS (object-oriented database management system) is db4o. I recommend downloading and playing around with it to get a feel for how simple it is to use. (If you want to learn more about various types of *DBMS check out the great presentation by Ben Scoffield at WindyCityRails 2009 – “Comics” is Hard.)

There’s one catch to using db4o in a closed source or proprietary project. You can either pay to license the product. It’s not too expensive for bringing into a medium sized project. Or you can release your project under GPL. For the project I was working on, neither option was palatable for our client. Also, I didn’t want to introduce yet another external dependency that our client would have to manage. Instead I created the simplest possible implementation of an object datastore I could using only native .NET and Microsoft Sql Server functionality.

Continued in The Poor Developer’s Object DataStore: Iteration 001.

Parent page: Service Functions – XML (QTP, VBScript) 

What is XSL? The Extensible Stylesheet Language.
An XSL script is a set of transformation instructions used by an engine (often, web browser, but could be any other processing program as well) to produce a new document based on XML input document. The original document remains unchanged.
The output document format can be another XML, HTML, or plane text.

How XSL could be used in test automation?

XML files verification

Manual verification of XML file contents and structure is a very tedious job, and only small-sized files could be  tested that way. Implementation of XML parsing script requires time and does remove the need to manually go over comparison logs. Each XML structure to compare will require creation of a separate script.

Having displayed XML-based data records as a structured and color coded tables on a web-page tester can go through a hundreds of records in just a few minutes.

Example. XML verification example

XML log to Web-page report transformation

It’s very convenient to generate and store execution logs in XML format. That could be Test Execution Logs, File Comparison Logs, Data Processing Logs, anything. However, XML tree view is not screen or paper friendly. Producing logs directly in HTML format creates extra maintenance issues.

Using XSL scripts allows transforming XML log files into easily viewable, content-rich, navigation-enhanced, and printer-friendly web-pages. Same XML log could be displayed in a variety of forms (detailed, summary, fail reports, etc)  by quickly switching  to different XSL templates.

Example. Text File Compare Report example

Documentation and references.

XSLT Questions and Answers

XSL Transformations 

Converting XML to HTML using XSL

Reference Cards

In The Poor Developer’s Object DataStore : Iteration 000 we proposed a possible motivation for wanting to store complex objects in a database without resorting to creating a complicated relational model.

For our first iteration we need only to be able to create and read the object from the database. It’s not going to be necessary to update or delete the data at this point. Only store and read. So why bother recreating the original data structure? Why not just query for the data with your ORM of choice and then serialize that result to Xml and store that? If you’re already using Microsoft Sql Server 2005 or later you’re already in a very good position as MSSQL provides the Xml datatype which makes storing, querying and retrieving Xml data very
easy and efficient.

If you are using an ORM for your data-access (you *ARE* using an ORM aren’t you?) then you’re already halfway there. My original implementation utilized custom objects that implemented an IStorable interface. Basically, I used Linq to Sql to query the data I wanted to archive and mapped the query result to an object that implemented the interface. Using that I could save the object into the datastore in a similar manner to Active Record. This was very easy to do.

public interface IStorable<T>
{
  string ConnectionString { get; set; }
  string Serialize();
  T Deserialize(string xml);
  XmlSerializer CreateSerializer();
  int Save();
}

So I could load up my data into a custom object, set the connectionstring and then automatically save it into the database.

//a sample unit test demonstrating usage of the IStorable object.
public void TestStoreFoo()
{
  var foo = new Foo();
  foo.Id = 100;
  foo.Name = "Penelope";
  foo.ConnectionString = "__YourConnectionString__"
  var objectId = foo.Save();
  Assert.That(objectId == 1);
}

So here’s the implementation. If you wish to grab the source code don’t try to cut and paste it from here. All the source code for this blog post can be browsed and downloaded from GitHub.

Source Code for Iteration 001

First we must implement the IStorable interface. The interface must take the implementing type as it’s generic argument. This is because we’re providing functionality for the object to serialize and store itself.

public class Foo : IStorable<Foo>
{

The Foo.Id and Foo.Name are our data. They are not part of the IStorable implementation.

  public int Id { get; set; }
  public string Name { get; set; }

We need to provide the connectionstring to the database where the objects are going to be stored.

  public string ConnectionString { get; set; }

Now we’re getting to the fun part. We will use an in-memory stream to serialize this instance of the Foo object and then write it to a string.

  public string Serialize()
  {
    string output;
    using(var buffer = new MemoryStream())
    {
      new XmlSerializer(typeof(Foo)).Serialize(buffer, this);
      buffer.Position = 0;
      output = new StreamReader(buffer).ReadToEnd();
    }
    return output;
  }

The deserialize method takes the xml as a string from a previous serialization and will attempt to convert it back into a Foo instance.

  public Foo Deserialize(string xml)
  {
    return (Foo)new XmlSerializer(typeof(Foo)).Deserialize(new StringReader(xml));
  }

In order to serialize a type we must create a typed instance of a serializer object. Here we’re just creating a Foo serializer and setting the error event handlers to output it’s errors to standard output.

  public XmlSerializer CreateSerializer()
  {
    var serializer = new XmlSerializer(typeof(Foo));
    //simply output error messages for types that we don't know how to serialize.
    serializer.UnknownAttribute += ((sender, e)=>Console.Out.WriteLine(e));
    serializer.UnknownElement += ((sender, e)=>Console.Out.WriteLine(e));
    return serializer;
  }

The save method is where we will kick off the work. We take this current instance and apply the Serialize() method to itself which converts the instance to a xml string. We also capture the fully-qualified name of the object type, both the namespace and the type name. This will be important when we are ready to pull the object back out of the datastore.

Here I’m using a Linq to Sql context, you may use any ORM as long as it supports the Microsoft Sql Server Xml datatype.

  public int Save()
  {
    using(var context = new Example001DataContext(this.ConnectionString))
    {
      var entity = new Example001ObjectDataStore {
        Serialized = XElement.Parse(this.Serialize()),
        FullyQualifiedTypeName = this.GetType().FullName
      };
      context.Example001ObjectDataStores.InsertOnSubmit(entity);
      context.SubmitChanges();
      return entity.Id;
    }
  }
}

The underlying data table is very simple. Only a single table with a field for storing the serialized xml data and a field for storing the fully qualified name of the object.

The Iteration 001 Object DataStore Table Definition

In this post we’ve got the ball rolling for storing objects into some some table. We can create an object that knows how to write itself into a database without requiring the creation of an elaborate data structure in order to just to simulate the object structure.

Next post we’ll cover how to retrieve the data from the table and convert it back into an instance of the persisted type. Next post we’ll look at how we can really test the functionality and behavior of the system. And begin to explore how to abstract the datastore to support arbitrary objects (with some minor restrictions.)

The source code for this project is hosted on GitHub and can be downloaded from here.

SCRIBEFIREol26UBNsSCRIBEFIRE

Parent page: Service Functions – XML (QTP, VBScript) 

Note. Although there could be no “reusable function” that would construct XPath for you, I store current post under “XML Service Functions” category, as it’s closely related to it. XPath is fairly simple to learn and very powerful in use. 
You can use free XPath Designer Tool to validate queries you constructed.

What is XPath? The each element in XML tree has its own unique address.
The XPath expressions provide the ability to navigate around the tree, selecting elements (groups of nodes, single nodes, attributes, text values, etc.) by a variety of conditions.

What does it mean? You can address any XML tree element without looping through the tree, i.e. as you use array[index] notation to get an element of the array, for XML you would use XML[XPath].

How basic XPath syntax looks like? You will see that it is very similar to a disk folder/file addressing, as it’s a tree structure too.
For example, filepath “c:\documents\personal\pictures\1.jpg”  in XML-XPath notation would look like “./documents/personal/pictures/picture[1]“.

What are the differences?
If we can address only one file with a single pathstring, in XML we can address a collection of elements with a single pathstring. If in any folder there could be no duplicated filenames, in XML it’s allowed: elements will be referred by index. 
If we can address an element of an array only by index value, in XML we can address elements by index value or by element value. If with arrays all indexing is absolute, in XML it could be relative.

Examples.
Get a collection of book items in a library XML structure. Xpath = “./library/book”.
Get first book in the collection. Xpath = “./library/book[1]“.
Get a collection of book items written by James Bach. Xpath = “descendant::book[author/@firstname='James' and author/@lastname='Bach']“.

Documentation and references.

W3C XML Path Language

W3Schools XPath Introduction

Using XML Queries and Transformations

During the last two months, I’ve been doing Selenium development. I’ve been somewhat mixed in feelings about the Selenium platform.

Prefer CSS3 selectors

In theory, Selenium makes it fast and easy to create new tests. With a Firefox plugin available, practically anyone can take a page and record a test for it.

In practice, however, there is catch. Most of the selectors of Selenium, when recorded using the Firefox plugin use Xpath to operate their magic. While using an Xpath is not a problem in itself, it is a technology with which fewer developers are familiar, then say, CSS. More aggravating to me is that the Xpath that is implemented is incomplete. I haven’t checked thoroughly on what the differences are between Selenium’s Xpath and the W3 specifications, but there are enough that I will often write a valid Xpath query with another Firefox plugin called Xpath Checker that fails with Selenium. The solution often is to rewrite the selector using CSS3, which seems to work better in most circumstances.  The thing that saves Xpath is its great flexibility when it comes to, say, selecting a tag based on a value somewhere else on the page.

Get GIGO with it

Not all the problems we’ve been having with Selenium come from it.

I’ve spent a week or two to get a meaningful, representative data set, from which to operate Selenium. The, of course crucially important in order to get non GIGO results.

The problem in our case is that it is not something that had been done since the project inception. While migrations help a great deal with the structure and fixtures help with seeding some values, our system is complex enough that it is not realistic to simply rely on fixtures.

The first approach was to take an existing data dump from a live system. While this was quite workable, it was also hard to maintain the test data, the Selenium tests and the application up to date and sufficiently seperate from one another.

The second approach we took was to include fixtures on top of the dump. While this was convenient to quickly resolve issues with a particular test, we rapidly found out that this caused unit and functional test which already relied on certain value to fail.

The third approach was to start from scratch and completely rebuild the database, in order to have a perfect blank, or master from which to evolve. In practice, the system’s data was complex enough that when there was missing data, it was often difficult and time consuming to isolate the origin of the error and correct it.

The current approach I feel is the best one so far. It is simply to take the previous, start-from-scratch approach and automate it entirely, thereby introducing better traceability into the test data process and shortening the time required to fix initial data errors.

The lessons I take from this are:

• Since you’ll be agile and testing, plan your data creation strategy from the beginning.
• Make sure that the data creation process is as automated as possible, so that when large changes to the application come about, it is possible to quickly make Selenium follow along
• Involve domain experts. Often, creating a blank slate of the application can be daunting, especially in a large system that has evolved without such a system. Domain experts are your best bet into what need to be included in the creation of initial data.
• Maintain the strategy. While it would be nice to have tests on the data that the strategy creates, this is a bit of a chicken and the egg problem. So, instead of testing directly the data creation strategy, reexamine it in thought when one of its dependent test fails.

You’ll probably want to have your strategy using Rake or Raven depending on your platform and preferences. Even using Rake on DotNet and learning a new tool is better then relying on manual efforts to create that valuable data.

Parent page: Service Functions – XML (QTP, VBScript)

Description

Uses .AddChildElementByName method to create a child XML node, then returns reference to the newly created object. If Parent XML node is not defined returns “Nothing”.

Public Function CreateChildElementByName(ByRef objXMLParent, ByVal sTagName, ByVal sInnerText)
 Dim objColl

 If objXMLParent is Nothing Then
  Set CreateChildElementByName = Nothing
  Exit Function
 End If

 objXMLParent.AddChildElementByName sTagName, sInnerText

 Set objColl = objXMLParent.ChildElementsByPath(“./”&sTagName)
 If objColl.Count >0 Then
  Set CreateChildElementByName = objColl.Item(objColl.Count)
 Else
  Set CreateChildElementByName = Nothing
 End If
 
End Function

In the previous post i commented an approach to perform queries with dynamic xpath. It was useful initially to determine the result in a stand alone sql sentence (e.g. exec spXpah @xml, @xpath, @result output), but if we need to use for example in a where clause we’ll need a function. Since the previous approach uses sp_executesql it not suites well to Sql Server.

So i decided to use SqlClr to create the function:

To create the assembly just add a new SqlClr C# Project, add a user defined function and paste this code:

using System;

using System.Data;

using System.Data.SqlClient;

using System.Data.SqlTypes;

using Microsoft.SqlServer.Server;

using System.Xml;

using System.Xml.XPath;

using System.IO;

using System.Text;

public partial class UserDefinedFunctions

{

[Microsoft.SqlServer.Server.SqlFunction]

public static SqlString XPath(SqlXml message, string xpath)

{

if (message.IsNull || string.IsNullOrEmpty(xpath))

return string.Empty;

XPathDocument doc = new XPathDocument(new StringReader(message.Value));

XPathNavigator nav = doc.CreateNavigator();

XPathExpression expr = nav.Compile(xpath);

string result = string.Empty;

switch (expr.ReturnType)

{

case XPathResultType.Boolean:

case XPathResultType.Number:

case XPathResultType.String:

result = nav.Evaluate(expr).ToString();

break;

case XPathResultType.NodeSet:

XPathNodeIterator iterator = (XPathNodeIterator)nav.Evaluate(expr);

XmlDocument xmldoc = new XmlDocument();

xmldoc.LoadXml(message.Value);

XmlNodeList nodes = xmldoc.SelectNodes(xpath);

foreach (XmlNode node in nodes)

result += node.OuterXml;

break;

case XPathResultType.Error:

throw new ArgumentException(“Invalid XPath query.”);

}

return new SqlString(result);

}

};

Hope this helps

Hi, today I was working with in SQL trying to execute a query against a variable of Xml type. Something likes this:

declare @xml xml, @xpath varchar(512)

set @xml = ‘<Hello>world</Hello>’

select @xml.value(@xpath,’varchar(255)’)

The error trying to run this was

The argument 1 of the XML data type method “value” must be a string literal.

Taking a look about how to solve this I found this thread on MSND:

http://social.msdn.microsoft.com/Forums/en-US/sqlxml/thread/b93d0790-e239-459e-a4e3-7511475f548b

Continuing with the idea provided by Christian, I created a stored procedure that calls to sp_executes

ql using output parameters and wrapped the logic in a new stored procedure.

So basically, now you can run something like this

EXECUTE [MyDB].[dbo].[Xpath] @xml,@xpath, @result output

Here is the code to create the stored procedure:

CREATE PROCEDURE Xpath

(

@xml xml,

@xpath varchar(1024),

@result varchar(255) OUTPUT

)

AS

BEGIN

DECLARE

@EncodedXPath nvarchar(200),

@Sql nvarchar(max),

@SeqValue varchar(512),

@paramDefinition nvarchar(255)

SET @EncodedXPath = REPLACE(@xpath, ””, ”””)

SET @Sql = N’SET @SeqValueOUT = @xmlVar.value(”’ + @EncodedXPath + N”’, ”varchar(25)”)’

SET @paramDefinition  = ‘@xmlVar xml, @SeqValueOUT varchar(25) OUTPUT’

EXEC sp_executesql      @Sql, @paramDefinition, @xmlVar = @xml, @SeqValueOUT = @SeqValue OUTPUT

SELECT @result = @SeqValue

END

GO

And, here is a sample to use it:

DECLARE  @xml xml,  @xpath nvarchar(200)

SET @xml=’<Root><Device><Inspection><Status>OK</Status></Inspection></Device></Root>’

SET @xpath = ‘/Root[1]/Device[1]/Inspection[1]/Status[1]‘

DECLARE @result varchar(255)

EXECUTE [MyDb].[dbo].[Xpath] @xml,@xpath, @result output

select @result

Thanks again to Christian, the idea is based on his post.

Solução para: Os métodos de ligação de dados como Eval(), XPath() e Bind() só podem ser usados no contexto de um controle limitado por dados.

Ae pessoal! Encontrei a solução para o erro: Os métodos de ligação de dados como Eval(), XPath() e Bind() só podem ser usados no contexto de um controle limitado por dados.

Segue abaixo a solução:
Crie uma nova classe (Ela será o seu componente DropDownList) e coloque o código abaixo…

using System;
using System.Collections;
using System.ComponentModel;
using System.Security.Permissions;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

}
}


O projeto onde ela se encontra deve ter referência para System.Web.

Se ela não aparecer sozinha na ToolBox, crie uma nova aba na sua toolbox e adicione a dll do projeto dela… No meu caso eu criei um novo projeto dentro da solution e coloquei ela lá… E meu projeto se chama TIAGO.Componentes.

Ai você utiliza a nossa DataBoundDropDownlist em vez da DropDownList do framework!

Esta é a solução mais rápida!

Espero ter ajudado!

Since the first version of the .NET framework an XML DOM has been available for manipulating and searching XML documents. This has been in the System.Xml namespace and used classes like XmlDocument and XmlElement. These xml classes support XPath queries. XPath allows any xml node or list of nodes to be queried using an XPath expression.

// <Document>
//  <Item>Item 1</Item>
//  <Item>Item 2</Item>
// </Document>

var xmlDoc = new XmlDocument();
xmlDoc.Load( "Documents.xml" );
XmlNodeList nodeList = xmlDoc.SelectNodes( "/Document );
XmlNode node = xmlDoc.SelectSingleNode( "/Document );

This code create an XML document in memory does two XPath queries, the first returns all the XML <Items> under <Document>, the seconds returns just the first <Item>

In .NET framework 3.5 the System.Xml.Linq namespace was added with which provides the LINQ to XML classes, see from more details on LINQ. The LINQ to XML also provides an in-memory XML DOM which allows manipulation and searching of XML documents.

XDocument xDoc = XDocument.Load( "Documents.xml" );
var query = from x in xDoc.Root.Elements( "Item" ) select x;
XElement item = doc.Root.Element( "Document" ).Element( "Item" );

This code is basically the same as the above, the first query returns an enumerator of all the <Item> elements, the second queries the elements directly to get the first <Item>

Initially I used Xml* classes (which was all that was available at the time) with XPath queries to retrieve xml nodes, I found the XPath query syntax hard use, although with some patients and research complex queries can be made. The programmatic manipulation of the Xml* classes was also a bit painful, XmlElements had to be created by the XmlDocument that would own then, copying elements between different documents required elements to be imported into the target document.

When 3.5 can along I started using the LINQ to XML classes which are XDocument, XElement, etc. These classes felt more light weight and easier to use. There is an extension method that allows XPath queries on XNode objects, XPathSelectElements or XPathEvaluate

What I also found is that XPath queries did not seem that fast and I was interested in comparing the performance of some simple XPath queries to the LINQ to XML equivalents.

// <Document>
//    <Body>
//       <Section>
//          <Item>
//             <Name></Name>
//          <Item>
//            ...
//       </Section>
//    </Body>
// </Document>

The test XML document has a very basic structure, with the <Item> tag repeated about 100 times. In all the testing I did not time the creation of the XML document in memory only the time taken to query the XML. In the case where many items where returned from the query I would iterate over all the items to ensure the items where available.

XmlNodeList nodeList = xmlDoc.SelectNodes( "//Item" );
var query = from x in doc.Descendants( "Item" ) select x;

This test is returning all <Item> elements in the document, in this case the LINQ to XML query was about 3 times faster than the XPATH query.

string xPath = "/Document/Body/Section/Item";
XmlNodeList nodeList = xmlDoc.SelectNodes( xPath );

XElement section = doc.Root.Element( "Body" ).Element( "Section" );
var query = from x in section.Elements( "Item" ) select x;

In this case we are returning all the <Item> elements from a specific part of the XML document. The LINQ to XML query is about 4 times faster than the XPATH query.

In general using the LINQ to XML Element(“name 1”).Element(“name 2”) notation to find an element is very fast, although if the element does not exists a null check should be done.

Author:Salvatore Incandela

Summary: The number of people in the U.S. diagnosed with diabetes is now reaching 24 million. Diabetes requires monitoring. In this article, get an introduction to the concept of continuing care, particularly in the home. This article describes how diabetes monitoring can be improved through collaborative technologies. See how software from MyCareTeam, IBM, and other organizations are used in an example in support of diabetes monitoring. Understand information and Web-based technologies, such as XML storage and services (for example, through IBM® DB2® pureXML™) in the context of continuing care, as well as related initiatives, such as the Continua Health Alliance’s role in selecting appropriate standards. This article summarizes the impact of these technologies on the building of agile and collaborative systems for healthcare, and highlights the significant benefits of collaborative continuing care that include cost reduction and increased quality of healthcare.

This article introduced some results concerning continuing care for diabetes. In particular, studies have shown that increased patient Health Care Practitioner interaction, especially more personalized interactions, increases patient frequency of blood glucose monitoring. Providing software that encourages personalized interactions improves diabetes monitoring. The contribution of Web-based technologies and associated initiatives, such as the MyCareTeam software, to share data is significant. In addition, the diabetes monitoring demonstration described in this article used standard specifications in the area of healthcare from HL7, IHE, and Continua, and in the area of XML from the W3C, such as XQuery. An XML store, DB2 pureXML, accessed through Universal Services, was used to easily store and manipulate monitoring information. The demonstration illustrated the first steps towards building a Web-based infrastructure for continuing care in the home.

Resources

Learn

• MyCareTeam: Learn more about MyCareTeam, disease management software for diabetes patients.
• Continua Health Alliance: Learn more about Continua Health Alliance, a non-profit, open industry coalition of healthcare and technology companies.
• DB2 pureXML: Get more information about, a hybrid XML and relational store from IBM.
• “Universal Services for pureXML using Data Web Services” (developerWorks, August 2008): Enable DB2 pureXML columns to be accessed through Web service operations.
• “IBM Lotus Sametime and DB2 pureXML supporting healthcare collaboration” (developerWorks, Feb 2009): Follow a healthcare scenario based on an end-to-end XML architecture.
• IBM Lotus Mobile Portal Accelerator: Learn more about this content adaption product that helps enterprises and service providers deliver portal content to a broad range of mobile devices.
• IBM WebSphere Sensor Events: Learn more about this product that delivers services supporting sensor integration.
• developerWorks Information Management zone: Learn more about Information Management. Find technical documentation, how-to articles, education, downloads, product information, and more.
• Stay current with developerWorks technical events and webcasts.

Get products and technologies

• DB2 Express-C 9.7: Download DB2 Express-C 9.7, a no-charge version of DB2 Express database server for the community that includes pureXML.
• DB2 9.7 for Linux, UNIX, and Windows: Download a free trial version of DB2 LUW.
• Build your next development project with IBM trial software, available for download directly from developerWorks.

Discuss

• Participate in the discussion forum.
• Participate in developerWorks blogs and get involved in the My developerWorks community; with your personal profile and custom home page, you can tailor developerWorks to your interests and interact with other developerWorks users.

Using collaborative technologies for healthcare in the home.

Some of my xml elements are optional.  The customer need not populate them or even include them in the file.  BPEL does not like when I try to retrieve the value like this:

bpws:getVariableData(‘var_IncomingFile’,'ORDERS’,'/ns2:ORDERS/ns2:ORDER[bpws:getVariableData("var_LoopIterator")]/ns2:OPTIONAL_FIELD/text()’)

It spits out this error and throws a selectionFailure:

Error in evaluate <from> expression at line “347″. The result is empty for the XPath expression : “bpws:getVariableData(‘var_IncomingFile’,'ORDERS’,'/ns2:ORDERS/ns2:ORDER[bpws:getVariableData("var_LoopIterator")]/ns2:OPTIONAL_FIELD/text()’)”.

To get it to work I had to do this:

concat(bpws:getVariableData(‘var_IncomingFile’,'ORDERS’,'/ns2:ORDERS/ns2:ORDER[bpws:getVariableData("var_LoopIterator")]/ns2:OPTIONAL_FIELD/text()’),”)

Is there a more elegant way?

The Fundamentals tutorial series provides an introduction to SQL (Structured Query Language) and covers how DB2® 9 is packaged and installed, how to create databases and database objects, and the basics of database security and transaction isolation. These tutorials provide a solid base for each section of the exam. However, you should not rely on these tutorials as your only preparation for the exam.

After a quick registration, you can begin a tutorial. Each tutorial should take about an hour to complete. You can take the tutorials online, or download a PDF or zip file.

• DB2 9 Fundamentals exam 730 prep, Part 1: Planning
  This tutorial introduces the basics of the DB2 products and tools, along with the concepts of data warehousing and OLAP.
• DB2 9 Fundamentals exam 730 prep, Part 2: Security
  This tutorial introduces you to DB2 security. Learn about DB2 authentication, authorization, and privileges.
• DB2 9 Fundamentals exam 730 prep, Part 3: Accessing DB2 data
  This tutorial gives you an introduction to the objects that make up a DB2 database, and the different factors which affect how the database is created. After a brief introduction to DB2 objects, learn about the tools available to create, access, and manipulate DB2 objects.
• DB2 9 Fundamentals exam 730 prep, Part 4: Working with DB2 data
  This tutorial introduces you to Structured Query Language (SQL), and gives you the basics of how DB2 9 uses SQL to manipulate data in a relational database.
• DB2 9 Fundamentals exam 730 prep, Part 5: Working with DB2 objects
  This tutorial discusses data types, tables, views, and indexes as defined by DB2 9. It explains the features of these objects, how to create and manipulate them using Structured Query Language (SQL), and how they can be used in an application.
• DB2 9 Fundamentals exam 730 prep, Part 6: Data concurrency
  This tutorial introduces you to the concept of data consistency and to the various mechanisms that are used by DB2 9 to maintain database consistency in both single and multi-user environments.
• DB2 9 Fundamentals exam 730 prep, Part 7: Introducing Xquery
  DB2 9 features significant new support for storing, managing, and querying XML data. Learn how to query data stored in XML columns using XQuery.

Once you have the fundamentals mastered, you may be interested in learning more about DB2 database administration tasks. If so, check out the DB2 DBA exam 731 prep tutorials.

IBM developerWorks : DB2 9 Fundamentals certification 730 prep series.

If you need to read, write, navigate, create or modify XML documents, take a look at dom4j. Browsing the dom4j cookbook and quick start guide, it seems trivial to extract content from an XML document using XPATH. Consider the following XML document:

<?xml version="1.0" encoding="UTF-8"?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
	<title/>
</head>
<body>
	<div>
		<p>Paragraph 1</p>
	</div>
	<div>
		<p>Paragraph 2</p>
	</div>
	<div>
		<p>Paragraph 3</p>
	</div>
</body>
</html>

Listing 1: Sample XML

You would think the XPATH to extract the contents of each paragraph would be

String xpathExpr = "//div/p";

If you try it out, you will see there are no matches. The gotcha is the namespace

xmlns="http://www.w3.org/1999/xhtml"

If that namspace was not specified, then the above XPATH expression would work. The solution is to use an alternate set of API calls than what is shown in the standard XPATH examples in the dom4j documentation.

package com.hrycan.blog.xml;

import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Node;
import org.dom4j.XPath;

public class XPATHProcessor {

	private Map<String, String>  namespaceURIMap;

	public List<Node> extract(String content, String xpathExpr) throws DocumentException {
		Document document = DocumentHelper.parseText(content);
		XPath path = DocumentHelper.createXPath(xpathExpr);
		path.setNamespaceURIs(namespaceURIMap);

		List<Node> list = path.selectNodes(document.getRootElement());
		return list;
	}

	public void setNamespaceURIMap(Map<String, String> namespaceURIMap) {
		this.namespaceURIMap = namespaceURIMap;
	}
}

Here we use the DocumentHelper object to create an XPath object and then set it’s namespace URIs map instead of using the boilerplate document.selectNodes(xpathExpr) call.

Here is the JUnit test showing how it would be used with the content of Listing1 and the corresponding XPATH expression using the namespace.

package com.hrycan.blog.xml;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.dom4j.DocumentException;
import org.dom4j.Node;
import org.junit.Test;
import static org.junit.Assert.assertTrue;

public class XPATHProcessorTest {
	private XPATHProcessor xpathProcessor;

	@Test
	public void testExtract() throws DocumentException {
		xpathProcessor = new XPATHProcessor();
		Map<String, String>  namespaceURIMap = new HashMap<String, String> ();
		namespaceURIMap.put("html", "http://www.w3.org/1999/xhtml");
		xpathProcessor.setNamespaceURIMap(namespaceURIMap);

		String content = //content of Listing1 shown above
		String xpathExpr = "//html:div/html:p";

		List<Node> list = xpathProcessor.extract(content, xpathExpr);
		assertTrue(list.size() == 3);
	}
}

In the code examples I present I often refer to routine functions.

In my framework I have specialized libraries to call from.  In my blog I have been providing them along with the posts but now I see that better to keep all in one place and “call” with the link.

Using built-in QTP-XML Objects and Functions

Returns reference of XML Element

Returns text value of XML Element

Returns reference of XML Attribute

Returns text value of XML Attribute

Returns text value of a comment in XML Element

Create a child element and return its reference

Using Microsoft.XMLDOM Objects

Add processing instruction

XML queries: XPath

XPath introduction and references

XML transformation: XSL

XSL introduction and references

XML verification example (XSL, HTML)

Text File Compare Report example (XML, XSL, HTML)

http://stackoverflow.com/questions/226405/find-position-of-a-node-using-xpath

<a>
    <b>zyx</b>
    <b>wvu</b>
    <b>tsr</b>
    <b>qpo</b>
</a>

count(a/b[.='tsr']/preceding-sibling::*)+1

or in an InfoPath expression

count(current()/preceding-sibling::*) + 1

count(../preceding-sibling::*) + 1

http://www.biglist.com/lists/xsl-list/archives/200109/msg00583.html

To find the position of a particular node within the source tree, use
count(). For example, count(ancestor::parentMenu/preceding-sibling::*)+1

http://www.novell.com/communities/node/6276/using-xpath-get-position-node-node-set

http://support.microsoft.com/kb/827008