Hi,

I am fairly new into BizTalk and I would like some advise into how to design
complex mapping.
More requirements being added with time made that I had to review my
mapping. It was originally just one btm file. I encountered many problems
while trying to do things especially with cumulative functoids.

After mixing together too many functoids, at some point I cannot have the
result I want, some result becoming kind of unexpected.
For example when i link the output of 2 functoids (let's call them functoind
A and B) to the destination schema i can read result but if I use these
outputs into another functoid (let's call it functoid Z) to do some
computation then some data disappear (I can see it actually disappear by
simulation i replace my actual functoid Z by a concatenation functoid and i
see that only the output of functoid A is there).

To solve this kind of problem i splitted my mapping into 3 maps and use a
intermediate schema. While this is ok for now, I am afraid that more
requirement and more complexities will make me have to split the mapping
into more maps. I don't think it's a good idea to have the number of maps
and thus the number of transform shape grow too much it starts to lose
sense.

Also another issue is that DB functoids are called for every node
calculation and sometimes this cause a lot of redundant SQL calls to the DB.

While btm maps seem the way to go to do simple mapping I am not sure if it
is good for more complex mappings where lot of calculation and database
acitvity needs to be done... is there any kind of guideline or
rule-of-thumbs or even examples? I have a BizTalk book but all it says it is
that we could use .Net assemblies or XSLT instead of map but nothign more...
No design guideline, no explanation, nothing... just plain and simple
exemples on every kind of functoids shipped with the product...

Anyone who could help me here? Explain me or point me to a source of
information about different mapping technologies and in what case to use
them?

Best regards,

Francois Malgreve.

Hi Francois,

Can you give a more specific example of your data disappearing?

Gary

"Francois Malgreve" wrote:
[..]

An isolated example is to sum the value inside a node that repeats itself
and multiply the result with another value stored somewhere else in a
schema.
i.e.:
....
<currency>USD</currency>
....
<details>
<amount>100</amount>
<amount>140</amount>
<amount>120</amount>
</details>
....
In my example i would sum <amount> and then use a db functoid to get an
exchange rate for USD. After that I divide the output of the cumulative
functoid by the output of the DB functoid. It does not work and if I replace
the division functoid by the Concatanation functoid, only the output of the
cumulative functoid is shownm the output of the DB functoid is empty... (but
if, as a test, I link the output of the DB functoid to a random node in the
output schema then i can see its value)

This is not the main point of my post in the newsgroup even if of course I
would also appreciate your opinion on this particular issue as well. My main
concern is what kind of best practices and guidelines exist around complex
mapping scenarios. Especially with a lot of DB access and cumulative
functoids. If you have any expereince with complex scenarios then pls share
it with me.

Thanks,

Francois Malgreve.

"Gary" <Gary> wrote in message
news:db89
[..]

Hi Francois,

I could not replicate your problem with the example you gave, it seems to
work okay for me, maybe I misunderstood your approach.

Unfortunately I can't really give a best practice answer for things such as
complex mapping, it will be interesting to see if anybody does. These type of
things cross my mind quite often. There seem to be that many ways to do the
same thing, I'm never certain which is best.

I guess it boils down to each individual circumstance, i.e. do you use
orchestrations, is sql on different boxes etc. How is the performance when
you use xpath sum function in an expression shape if orchestrations are used
etc etc? The way I normally do it is to try as many different options that I
can think of and see which seems to be best, this however, can sometimes fall
down if not tested in a production style set up.

Hopefully somebody with a bit more experience can help you with this.

Gary

"Francois Malgreve" wrote:
[..]

It is a interesting topic to participate.

Based on my experiences working on complex mappings I would like to
suggest the following.

Development:

=> Validate the inbound schema data before proceeding with the actual
mapping. Use two maps, one to validate and log errors(outbound
Exception schema) and another to do actual mapping. This eliminates
input data errors and database related data errors.

=> Make use of Logical Existance, IsNull, Equal, Logical Not, Value
Mapping etc., to validate each node and data in it before proceeding
with actual mapping.

Debug:

=> Verify the functoid parameters sequence, most of the errors occur
due to this reason and BizTalk does not throw any error if you
mis-match your parameter sequence.

=> Verify the xslt generated by BizTalk map validation, this helps
understand the logic built by BizTalk for the map you built. This xslt
seems too complex but it really helps debug complex runtime errors.

Testing:

=> Choose a test driven development approach. Create positive and
negetive test cases for each map that should cover all functoids in the
map including the newly added functoids.

=> Implement Unit, Integration & Regression testing steps executing all
the test cases for every change. Make use of BizUnit and other
available tools in automating your test process.

I would like to hear more from other BizTalkers.

Thanks,
Kiran Pabba


Thanks

Gary wrote:
[..]

Let me add some my practice to this fine list: