by community-syndication | Jan 9, 2012 | BizTalk Community Blogs via Syndication
The documentation for BizTalk Server 200X is very clear, and has been since BizTalk Server 2006. See the 2010 versions of technet wiki and download. It states:
“Named instances of SQL Server 200X Analysis Services are not supported”
But why is that? I set out to investigate if I could find a reason for it still being true.
Examining the history
In the beginning, there was a limitation with SQL Server 2000 Analysis Services (SSAS). It was not instance or cluster aware (much like SSIS today). Some time later with the help of service packs (if I can recall and use my search engine correctly) SSAS became cluster aware, but only supported running on the default instance. Thus the requirements and the reason that was true with BizTalk Server 2006 is crystal – due to the support of the underlying technology, namely SQL Server 2000, named instance of Analysis Service was not supported.
Present
I later versions of SQL Server, and the latest of SQL Server 2008 R2 specifically, there is no such limitation. Analysis Services is both cluster and instance aware and can be installed in a named instance. So the underlying limitation just isn’t there. But what about BizTalk? Does it have some built in limitation to how it uses Analysis Services that doesn’t allow working against a named instance?
The scenario
Two BizTalk Server Group installations – connected to their respective database instance – side-by-side. Both SQL Server instances has the database, agent and analysis services services installed. In the default instance I have a BizTalk Server Group configured with BAM tracking and Analysis, and a deployed activity and view when we start our journey. For the named instance I wanted to configure the same thing to see that there were no issue with
- running Analysis Service in a named instance, and
- running it side by side with the default instance and its Analysis Services on the same SQL Server machine.
Configuring BizTalk Server against a named instance of SQL Server 2008 R2 Analysis Services
First configuring the feature using BizTalk Server Configuration.
Then applying the configuration and view the result.
No issues.
Deploy BAM activities and views
Using bm.exe to deploy my BAM activity and view to my named instance.
No issues.
Using Tracking Profile Editor to connect my activity to an orchestration.
No issues.
Running some data through the integration
BizTalk Server behaves as expected. After running some sample data through the integration I could open my BAMPrimaryImportDb and run a Select against it to view my data.
Running my BAM_AN_<View> SSIS package
This was one of my prime candidates beforehand of where it could possibly go wrong. However as I used Business Intelligence Development Studio to inspect the package I could see that it was configured with datasources for the databases that it worked with, including the Analysis Services database, and it clearly points to the correct configured instance.
Running it caused no incidents that I could detect. After having run the package and processed the cube I was ready to look at the data in the cube to see if it got there as expected.
Viewing the Live Workbook
The first thing to check was the live workbook (useless as I find this feature I wanted to see if it could read the data as expected).
It could. And again, if we view the data connection properties here it point to my named instance.
(sorry about the swedish locale here, but you get the point)
Viewing data in the BAM portal
Next up, what about the BAM portal – would it be able to understand the named instance of SSAS and retrieve my data?
Yes. Both the Activity Search and the Aggregations show the data expected.
Conclusion
I can find no reason why SQL Server 2008 R2 Analysis Service cannot be used on a named instance with BizTalk Server 2010. Granted, this was just a small test and I certainly haven’t investigated this through every aspect (as per the usual disclaimer), but it “Works on my Machine”.
Do you know a reason that this will not work? Are you running this configuration yourself and can confirm further that it does work? Let me know
HTH
/Johan
Blog Post by: Johan Hedberg
by community-syndication | Jan 6, 2012 | BizTalk Community Blogs via Syndication
One problem with email notifications is it usually sends too many emails. Errors frequently happen in series. For example, a temporarily issue with network can result in hundreds repetitive emails. In result an email notification designed as a “VIP” notification is downgraded to the “annoying” status.
This email flooding could be mitigated with this solution.
A Sample demonstrates using the emails for sending notification in case of failed messages.
It compounds several similar errors in one email notification.
Recently I’ve downloadedthis sample
BizTalk: Samples: ErrorHandling: Notification emails
to MSDN Gallery.
It has all solution artifacts and can be used in real-life projects.
by community-syndication | Jan 5, 2012 | BizTalk Community Blogs via Syndication
You will not run into your typical Hello World walkthrough with QuickLearn’s new SharePoint 2010 courseware. QuickLearn’s SharePoint 2010 curriculum are scenario-driven classes in which we set out to create real-life SharePoint solutions, dissect them and provide best practice solutions to real problems developers face. Our classes have greater focus on interesting issues such as:
- Developing solutions that can be easily migrated into different environments and packaged for automatic deployment
- Creating code in a secure fashion while working within the limitations of SharePoint’s sandbox solution model, writing client-side object model code that reduces external calls, batches operations, and attempts to reduce request size
- Accessing custom external data sources that aren’t readily accessible with out of the box tooling
Our courses cover each topic in a broader way by providing more in depth labs. Rather than dozens of 10-15 minute labs our 45-60 minute labs provide a more complete picture of each topic.
We show you how to exercise SharePoint’s strengths, as well as work through some of its more challenging areas. Our classes won’t give you a simplified sales pitch that leaves you wanting more, but instead will provide real guidance, for real solutions.
- SharePoint 2010 Developer Immersion
- Upcoming dates include: February 13-17 & April 16-20
- SharePoint 2010 Developer Deep Dive
- Upcoming dates include: March 19-23 & May 21-25
For 20% off register before January 20th with the promotion code: NEWSP.
by community-syndication | Jan 4, 2012 | BizTalk Community Blogs via Syndication
2012 is off to a great start for QuickLearn’s lead ALM instructor, Anthony Borton. Anthony has been awarded the Microsoft%u00ae MVP Award for Visual Studio ALM for the 6th consecutive year. This award is given to exceptional technical community leaders who actively share their high quality, real world expertise with others.
Anthony has developed our leading ALM curriculum that focuses on everything connected to Microsoft Team Foundation Server. He is a popular and highly regarded instructor and international presenter. If you’re eager to learn how to developer software better, please check out our upcoming TFS ALM courses starting again in February.
For those of you eagerly awaiting the upcoming BETA release of the next version of Visual Studio and TFS, make sure you keep an eye out for news of our upcoming early-adopter courses which Anthony is putting the finishing touches on right now. Why not follow us on Facebook or LinkedIn to make sure you don’t miss our announcement.
Happy New Year to all our readers and I hope you’re year has started with some great news as well.
by community-syndication | Jan 4, 2012 | BizTalk Community Blogs via Syndication
[Source: http://geekswithblogs.net/EltonStoneman]
This is one in a series of posts covering my generic mapping library on github: Sixeyed.Mapping.
1. Mapping and Auto-Mapping Objects
2. Mapping and Auto-Mapping Objects from IDataReader
3. Mapping and Auto-Mapping Objects from XML
4. Mapping and Auto-Mapping Objects from CSV
5. Comparing Sixeyed.Mapping to AutoMapper
The mapping library has support for IDataReader objects used as the source. Using data readers, AutoMap will try to populate the target by matching property names to column names. Alternatively a static map can be defined, manually specifying the mapping between column names and properties.
Auto-Mapping
Using a populated data reader as a source, you can auto-map a target object using the DataReaderAutoMap and the same syntax as for an object source:
IDataReader reader = GetReader(id);
User user = DataReaderAutoMap<User>.CreateTarget(reader);
The data reader must be open, and the map will populate from the current row so the data reader should be read to the desired start position before mapping. For a single row, call Read() once on the reader before passing it to the Create() call.
DataReaderAutoMap and AutoMap share the same base class, and the mapping logic is the same for all sources. Specification, caching strategy and naming strategy options still apply. To specify a property mapping, you need to provide the name of the source column:
var addressMap = new DataReaderAutoMap<Address>()
.Specify(“PostCode”, t => t.PostCode.Code);
//or:
var addressMap = new DataReaderAutoMap<Address>()
.Specify((s, t) => t.PostCode.Code = (string)s[“PostCode”]);
You can also use the conversion overloads for converting the source value during population:
var map = new DataReaderAutoMap<User>()
.Specify<DateTime, DateTime>(“JoinedDate”, t => t.JoinedDate, sd =>FromLegacyDate(sd));
Static Mapping
For static maps, extend the base DataReaderMap class. As we’re dealing with string constants for the column names, static maps may be the better option in caseswhere the source and target names can’t be matched by convention – they centralise the constant definition in one place:
public class FullUserFromDataReaderMap : DataReaderMap<User>
{
/// <summary>
/// Default constructor, initialises mapping
/// </summary>
public FullUserFromDataReaderMap()
{
this.AutoMapUnspecifiedTargets = false;
Specify(ColumnName.Id, t => t.Id);
Specify(ColumnName.FirstName, t => t.FirstName);
//etc.
}
private struct ColumnName
{
public const string Id = “UserId”;
public const string FirstName = “FirstName”;
//etc.
}
}
Nested Maps
Maps can include nested maps, populating an object graph from a flattened representation in a single data reader:
var addressMap = new DataReaderAutoMap<Address>()
.Specify(“PostCode”, t => t.PostCode.Code);
var map = newDataReaderAutoMap<User>()
.Specify(“UserId”, t => t.Id)
.Specify((s, t) => t.Address = addressMap.Create(s));
var user = map.Create(reader);
Nested maps can also populate objects from multiple readers – although this requires each reader to be associated with a separate connection:
var addressMap = new DataReaderAutoMap<Address>()
.Specify((s, t) => t.PostCode.Code = (string)s[“PostCode”]);
var map = new DataReaderAutoMap<User>()
.Specify(“UserId”, t => t.Id)
.Specify((s, t) => t.Address = addressMap.Create(addressReader));
var user = map.Create(userReader);
Limitations
Data reader maps can only operate in one direction – populating an object from a reader. They also rely on the column names being available in the IDataReader implementation through the GetOrdinal method. Not all data providers supply this, and if there are no column names available, mapping will fail for auto-maps and static maps, leaving the target object unpopulated.
Performance
Mapping from data readers uses the column names of the source, so only the target is reflected over. For small numbers of reads, there is less of a performance impact than with object-to-object mapping, and the benefits are greater as mapping also takes care of type conversion. Using a SqlServerCe database populated with 250,000 rows (80+Mb of data), the performance was bounded by the speed of the database connection and not the speed of mapping. Up to 1,000 are read and mapped in 0.4-0.6 seconds for all reads, with a small performance hit for the automap:
For larger reads, the performance impact is more significant, with DataReaderAutoMap and a static DataReaderMap taking almost twice as long as manually reading and mapping the data, when you reach 100K or 250K reads:
At 10K reads, performance is still comparable for auto-mapping and manual mapping, so whether you can use the DataReaderAutoMap would need to be looked at in context of your own data, mapping complexity and any upstream caching in your solution.
