There is a new pane in the Data Builder for VistaDB 4.1.  The LINQ query pane is a very handy way to build and test LINQ queries against a simple Entity Framework model.  First understand that this pane is a work in progress.  It was designed to be an easy way to write LINQ queries (similar to LINQPad) for your VistaDB database.  The feature is of limited usefulness since the model cannot be customized at generation, or loaded from your own assembly.  But this is where we were with the feature when we had to ship, so here it is.  We have been using it a lot to help write LINQ queries, we hope you find it useful too.

The current implementation only supports C# (sorry VB guys, it was on the list).  You can right click on the Entity Model tree and Script the main query window with all your basic CRUD operations.

By default the dialog is grayed out until you generate a model.  The code shown will still be present once the model is generated.

Generate a Model

By default the dialog is grayed out until you generate a model.  The code shown will still be present once the model is generated.

Click the Generate Model button to have Data Builder call the EDMGEN tool and build a default model for the current database.  The default is to output one type per table.  This is the same as if you add a new model to your application and accept all the defaults.  If any errors occur during the generation of the model they will be output in the Log window at the bottom of the screen.

When to generate a model

Each time Data Builder loads you will have to regenerate a new model (they are not saved across application runs).  The models are kept loaded after the initial generation.  If you make schema or foreign key changes you should regenerate the model in order for the changes to be present in the model.

How to view the current model

The current model is displayed on the second tab (after a model has been generated).

 

Intellisense

Sorry, there is no intellisense in the current version for the LINQ queries.  It REALLY does help to have it, but there just was not time to get it implemented.  Use the Entity Model tab to see what the entity names look like.

Right Click for Scripting

Right clicking on an entity (the table name) will allow you to generate some default LINQ queries for the Query pane.

 

Each of the basic CRUD operations are demonstrated for the object.  Selecting them will put the script in the query window.

Putting queries into your code

Once you have a query working the way you want, you can copy and paste it into your code.  The only requirements are that you have a model that matches the default model, and that you have a data context of your model called context (or you can rename the internal context to be what your variable is named).

A best practice for this code might look something like this:

using( RealModel.ModelEntities context = new RealModel.ModelEntities(connection))
{
   var query = from i in context.OrderDetails select new { i.OrderID, i.Orders.OrderDate };
   // Your custom code to work with the LINQ results
}

Example LINQ Queries

The example script code will not all execute by default.  They are templates for you to edit.  For example the delete template doesn’t know what your criteria is for the delete.  It leaves a string in the place for you to change to your actual criteria.

The idea was to eventually give the user an interactive wizard type of experience to build up their LINQ queries against the model.  But what is there today is still useful.

Summary

The LINQ panel in Data Builder 4.1 is a very useful way to write LINQ queries against a default EF model quickly with VistaDB.  It is not feature complete, but is still useful enough for us to release it with this version.

We hope you find it useful for writing LINQ queries, and possibly to interest you enough to learn more about Entity Framework.

According to a report from econsultancy.com 34% of shoppers prefer to buy online.  As buying habits change and consumers move more towards online shopping, the need for a robust and scalable IT infrastructure becomes greater.  According to Internet Retailing, internet retail sales in the UK hit £49.8 billion, up 21% from 2008. Overall, up to [...]

Hey you fellow Germans out there! O’Reilly published a new book on CouchDB just for you! It is Mario Scheliga’s CouchDB Kurz & Gut — roughly translated to CouchDB Short and Good. The Kurz & Gut series consists of compact books with enough content to get you running and that are later useful as a quick reference in day to day work (Jan happily remembers having the LaTeX edition at hand a couple of years back).

From all of us at Couchio:

Mario, awesome job! Thanks a lot for help getting the good word out and providing such a great resource for the German CouchDB community. Rock on! (or relax, either is fine :)

This document provides an example of installing and upgrading TM1 9.5 including TM1 9.5 Server, TM1 9.5 Web, and TM1 9.5 Contributor. This example is performed on a Single Server running MS Windows XP 32-bit and using IIS and Apache Tomcat.

Last week we sat down with our good friends Richard Campbell and Greg Hughes of RunAs Radio and recorded an interview about how to learn effectively. It was incented by Paul's recent post as part of TSQL Tuesday: T-SQL Tuesday #008: Top ten mistakes to make when attending a class. Additionally, I've written some related posts on types of training here.

Here's the specific link to the show: Kim Tripp and Paul Randal Talk about Learning Effectively!

Enjoy!
kt

Here is a new release of the Eloquera DB. In the version 2.8 we have done some fixes and improvements – the list is on the download page.

Besides, now in the database creation scripts you can add types that you do not wish to have in the database, e.g., debug or runtime only objects. For example, you cannot restore Thread objects from the database, even though you can store them. The functionality can be used in a pretty simple way:

db.RegisterType(typeof(Book));
db.TypeRules.IgnoreType(typeof(DebugBook)).
                    IgnoreType(typeof(DebugAuthor)).
                    IgnoreType(typeof(InputServer));

That will add a rule to the database to ignore all objects, fields and properties of the specified types and of their descendant types.

Any newly created database has a list of types automatically added to the ignored type list:

System.Runtime.ConstrainedExecution.CriticalFinalizerObject

System.Type

System.Reflection.Assembly

System.AppDomain

System.ActivationContext

System.Exception

System.AppDomainManager

System.IAppDomainSetup

System.ApplicationId

System.ApplicationIdentity

System.Attribute

System.Threading.WaitHandle

System.Runtime.InteropServices._AssemblyName

System.Reflection.Binder

System.IntPtr

System.Signature

System.WeakReference

System.Threading.Timer

System.Threading.TimerBase

System.Threading.SynchronizationContext

System.Threading.Overlapped

System.IntPtr

System.Windows.Threading.Dispatcher

System.Windows.DependencyProperty

System.Threading.CompressedStack

System.Threading.Monitor

System.IO.Stream

System.Runtime.Serialization.SerializationInfo

MS.Utility.FrugalListBase<>

MS.Utility.FrugalObjectList<>

System.Windows.Media.UniqueEventHelper<>

System.Windows.Media.UniqueEventHelper

System.Windows.Media.ColorContext

We hope this feature will help avoiding problems with types that do not carry any useful information when persisted.

Happy programming!

The last week was a big one for CouchDB. Here is a brief recap, (inspired by Mark Phillips’s great blog post on the Riak Recaps). I can’t get everything in, cause there’s way too much. Leave a comment (or email jchris@couch.io) if I left anything out, or if you have ideas for what to mention next week.

1.0 Released

We’ve been working toward CouchDB 1.0 for five years, so geting that out the door was rather major. There was even a New York Times article that calls CouchDB the first production ready NoSQL database (I heartily concur, we’ve been production worthy since 0.8.0) Now that we are 1.0 there’s no reason not to use CouchDB in your banking, medical, air-traffic control, or other mission-critical applications.

As part of the 1.0 release we asked the community to write retrospective blog posts on how they came to CouchDB. Thanks to Klaus for a collection of links:

• Volker Mische: How I met CouchDB
• J Chris Anderson: Reflections on CouchDB 1.0
• Noah Slater: CouchDB retrospective
• Filipe Manana: My CouchDB retrospective
• Klaus Trainer: My Personal CouchDB 1.0 Retrospective
• Will Hartung: Couch 1.0 retrospect

We’re still hoping to find more of these, so if you’ve been involved in CouchDB for a while (or even a short time) and you write one, let me know.

Windows Support

Part of the 1.0 release is Windows support. Thanks to Aaron Miller for building a provisional installer kit. Some folks are having trouble with the installer, so we’re waiting on Mark Hammond to get home and build a proper one. Thanks Mark!

CouchCamp

Last year we had CouchHack which was the first time a few of the committers met each other. It was also when Damien, Jan, and Chris first decided to form a company behind CouchDB.

This year we are hosting CouchCamp which will be the biggest gathering of CouchDB supporters in the history of all time. Of all time. There will be scrumptious organic food (and maybe Damien will even make a McDonald’s run) and quality beer. All this and a cabin bed at Walker Creek Ranch in Marin County. Slots are filling up fast, and there are only a limited number of beds. Anyone who registers after we are out of beds will be welcome, but you’ll end up camping (for real) in the great outdoors. Registration for this two and a half day event is currently only $500, in celebration of CouchDB 1.0.

CouchRest

In other news, the CouchRest Ruby library for CouchDB has a new set of active maintainers. For help with patching CouchRest, talk to Marcos Tapajós, Sam Lown, and Will Leinweber. Thanks Rubyists!

GeoCouch

GeoCouch is taking the world by storm. There was a meetup in Augsburg. PDXAPI continues to kick ass, and has begun to spawn related applications like Food Cart Pages and mobile clients.. Thanks Volker Mische, Max Ogden, Don Park and others.

This just in: PDXAPI has won an award (and $1,000) from the Mayor of Portland!

Faster JavaScript Views

A few months ago, the Riak team (great hackers) released some code to make communication between Erlang and JavaScript way more efficient. After that Paul Davis integrated it with CouchDB, as a proof of concept. Since then, he’s started to refactor it for easier builds. We are looking forward to integrating this with CouchDB trunk in a near-future release.

Mr. Rogers on Sesame Street

Just kidding about the PBS reference (as a kid I was always fascinated by cameos). But Cloudant’s Mike, Alan, and Dave stopped by the Couchio offices and we talked about collaboration and strategy, and how to help get the CouchDB story to the millions of developers who haven’t heard a word of it yet.

One thing that came out of the meeting, we plan to host some CouchDB trainings. If you want one in your town, email hello@couch.io and we’ll get it together.

Monthly webinars

O’Reilly has been sponsoring monthly Webcasts in association with the CouchDB book. Here’s the list so far.

CouchApp Evently Guided Hack. Learn how to make CouchApps the JChris way.

Intro to Apache CouchDB

What’s new in CouchDB 1.0. A round up of the features and improvements that CouchDB’s seen in the last few months.

Flexible Scaling with CouchDB Replication (video not yet available.)

Next month (on the 25th) we’ll be doing one on how to make crash-only applications using the _changes feed. Signup link to follow.

New Committers

The Apache CouchDB project is very lucky to have two new committers joining us: Filipe Manana and Robert Newson. Filipe has been hard at work on updating the replicator to be more robust and performant. Robert is the force behind CouchDB-Lucene.

The IBM Data Server .NET Provider supports application development for IBM Informix. It is available for download as part of the Informix Client Software Development Kit (SDK). This article describes the two .NET providers that support .NET application development for Informix, and highlights the benefits of using the Data Server .NET Provider. The article also provides examples to help you quickly get started using the IBM Data Server .NET Provider.

The concept of shell sharing between Eclipse-based products means that you can share the core Eclipse components so that they are not duplicated between each Eclipse-based product. Shell sharing can save disk space, eliminate duplication of components, and enable products to interact with each other, making each product stronger than if it were run stand-alone. This article explains the process of sharing Eclipse shells between many different IBM products by showing an example of this using InfoSphere Data Architect (IDA), Optim Development Studio (ODS) and Optim Database Administrator (ODA).

Get an introduction to the various editions of IBM Informix, and compare features, benefits, and licensing considerations in a side-by-side table. Regardless of which edition you choose, Informix brings you legendary ease-of-use, reliability, stability, and access to extensibility features.

Going to OSCON?  SETI needs your help! 

Cloudant is teaming up with the SETI Institute to help engage citizen-scientists in the search for intelligent life elswhere in the universe.  With some help from Amazon, we've built a 'croudsourced data analytics platform' where ordinary citizens can search and analyze data from the Allen telescope array.  Are you a citizen-scientist?  Do you know about signal processing?  Are  you interested in helping in the search?  Come find out how!

Thursday, July 22nd at OSCON, our own Dr. Dave Hardtke will be demonstrating SETICloud.  He'll be describing the Cloudant platform and how we're bringing the wisdom of the crowds to SETI's search.

Time: 12:20 - 1:20 pm

Place: Room E143/144

SETI is hacking on CouchDB!  Come find out how you can help.

And don't miss Dr. Jill Tarter's keynote talk on "Open SEITQuest" Thursday morning at OSCON:

http://www.oscon.com/oscon2010/public/schedule/detail/13425

Permalink | Leave a comment  »

This the first delivery in a series of articles targeted at showing developers how db4o (an open source database that leverages today's object-oriented languages, systems, and mindset) is being used in several Android projects to avoid all the pitfalls and hassles of object-relational mapping while benefiting from an elegant and straight forward way to evolve a domain model which, in the end, translates into faster, easier upgrades for users.

More: http://java.dzone.com/articles/leverage-db4o-your-android

A new 8.0 development release is online. Below  is the list of changes since our last 8.0.146 release. We highly recommend all 8.0 users to upgrade to this build since we have fixed 2 serious issues ( bold ). Both issues were introduced with the new BTreeIdSystem in the 8.0 branch. Production and Stable builds are not affected. COR-2008 - [Android] ClassCastException trying to cast Db4oDatabase to GenericObject COR-2003 - [.Net] Investigate failing.Net 4.0 tests due to cecil update COR-2001 - With low custom max stack depth, PendingSet processing order expected by static field handling is not maintained COR-2000 - Defragmenting string field indexes is broken with btree id system COR-1998 - Introduce ID mapping sanity checking to be used in dedicated db4ounit fixture COR-1997 - Commit throw an UniqueFieldValueConstraintViolationException after defragment COR-1996 - java.lang.OutOfMemoryError in UnicodeStringIO.read COR-1992 - [Android] Review all ' ...

A new 7.12 production release is online. Here is the list of changes since our last 7.12.145 release: COR-2001 - With low custom max stack depth, PendingSet processing order expected by static field handling is not maintained COR-1978 - Transient field modifier is not being respected in C/S mode without classes in the server COR-1977 - Execution of sub queries descending into collection members only seem to use a single collection member as root COR-1950 - Respect transient modifier on static fields COR-1946 - Storage implementation to be able to call #saveAs() on an open database COR-1945 - Transaction.objectContainer() should always return an ObjectContainer with transactional behaviour, also in events. COR-1902 - System.Byte and System.SByte casting problem in Db4objects.Db4o.Internal.Handlers.ByteHandler COR-1822 - Committed callbacks should provide a means to discover if the committed event was raised by this clients commit or another one in C/S mode  Yo ...

Oracle's most popular technology newsletter: Database Insider Newsletter's July Edition is now available!

Includes:

• Exclusive interview with IOUG President Andy Flower
• Migrating from Sybase to Oracle Database
• Customer stories and podcasts
• Tips and techniques
• Upcoming Events not to miss
• much more

Available online.

var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));


try {
var pageTracker = _gat._getTracker("UA-13185312-1");
pageTracker._trackPageview();
} catch(err) {}

A little bit about Mark — He is an experienced voice, mobile and web application developer who has built civic applications for the District of Columbia, the Sunlight Foundation, the New York State Senate, and the cities of New York, San Francisco and Toronto. He writes about open government, programming, communication technologies and open source software on his blog at voiceingov.org.

Now for his guest blogpost…

Building Twitter Apps with CouchDB

CouchDB is a sexy beast.

There are so many things about it that make it attractive to Web 2.0 and mashup developers, and it seems like the more I use it the more cool features I find that make my life as a developer easier.

The dead simple HTTP API. Replication. URL rewriting. I could go on…

Several months ago, I started a project to develop an application that would let citizens who live in cities that have adopted the Open311 standard submit service requests using Twitter. There are some important reasons why I believe Twitter makes an ideal interface for submitting geographically specific service requests to municipalities. When I started to consider various alternatives for a platform for the TweetMy311 application, I looked very closely at CouchDB. This was right around the time CouchDB 0.11 was released. I soon discovered something else cool about my favorite NoSQL database — CouchDB absolutely rocks as a platform for Twitter applications.

Why CouchDB?

If you’ve had a play with the Twitter API and your thinking about building an application that uses it, you should take a close look at CouchDB. There are a number of reasons why it makes an ideal platform for Twitter applications:

• You interact with a CouchDB instance the same way that you interact with the Twitter API — by making HTTP calls. This can help keep the code for your application clean and simple, and provides lots of opportunities for code reuse within your application.
• The structure of documents in CouchDB are JSON, which is one of the formats returned from the Twitter API when searching for Tweets (or “status objects” in Twitter parlance).
• Documents in a CouchDB database are assigned a globally unique ID — it’s how documents are distinguished from one another. Twitter also uses unique identifiers for status objects, so using the ID of a Twitter status object as the ID for a document in CouchDB makes life pretty easy for a Twitter app developer.

These benefits become readily apparent when you begin interacting with the Twitter API and storing status object in CouchDB.

A Quick Example

Twitter actually has several different APIs that developers can interact with — the basic REST API, the Search API and the Streaming API. Since there are lots of resources on these different APIs, and tons of good tutorials for how to use them, I’ll focus in this post on the most basic way to use HTTP requests to get Twitter status updates — using statuses/show. (The same approach described below can be used to get multiple status updates using the Twitter REST or Search APIs and store them in a CouchDB database.)

Consider the following Tweet:

This is a status update I sent when I was walking around my neighborhood in Wilmington, Delaware thinking about how Twitter could be used to start a 311 service request. If I wanted to get this status update in JSON format from the Twitter API, I would use the statuses/show method with the id of the status update.

This URL will return the full JSON object for the status update. So now we can start to see how this JSON structure can be saved into a CouchDB database.

First, create a CouchDB database to use for our example:

curl -X PUT http://127.0.0.1:5984/twittertest
{"ok":true}

Consider the following sample script (written in PHP):

This is a very simplistic example of how you can interact with the Twitter API and store JSON formatted status updated to CouchDB. Do note, you’ll need to use PHP version 5.2.0 or greater to take advantage of PHP’s JSON functions. Not counting our constant declarations and basic cURL functions, it takes 3 lines of code to grab a status update and store it in CouchDB. When you run this script from the command line, you’ll see something like this:

curl http://127.0.0.1/twitter-example.php?status_id=7911766753
{"ok":true,"id":"7911766753","rev":"3-8855db513f6fc0d45bbbc66a6be02035"}

It may seem redundant to get the ID of the Twitter status update from the JSON object returned from the API (since we’re already using this ID to get the status update in the first place), but consider a scenario where you are interacting with the Twitter REST API, to get @mentions or to search for any status update the contains specific phrases. Those interactions could potentially return dozens or hundreds of Tweets at a time as a collection of JSON formatted objects. By wrapping our simple example logic in a foreach() statement, you can easily process large volumes of status requests without having the ID in advance.

Ch-ch-ch-ch-Changes

Now that you’ve got a handle on just how easy it is to grab Twitter status updates and store them in CouchDB, you’re probably wondering what to do next in building your Twitter app. Let’s say your Twitter app looks for @mentions on a specific account and then processes those status updates based on the content of the Tweet, or by looking at the location of the Tweet (this is, by the way, what TweetMy311 does).

You’ll probably need to go through a series of steps, processing a status update at each step and ultimately sending a response back to a user via the Twitter API. Get a Tweet — process it n number of times —  send back a response. The series of steps involved in processing a Tweet (one step to potentially many steps, depending on what your application does) is the heart of any Twitter application, and can cause lots of complexity if not approached properly.

Fortunately, CouchDB makes this aspect of building Twitter applications incredibly easy to do through the _changes API. The _changes API is a powerful, easy to use mechanism for receiving notices when a change has been made to your CouchDB database. Each time a new document is inserted into a CouchDB database, or an existing document is updated, the _changes API will provide notice. The book “CouchDB: The Definitive Guide” has an entire section on the _changes API to goes into great detail about all the ways it can be used.

For the purposes of this post, let’s focus on the continuous changes API. This API lets you set up a single, persistent HTTP connection to CouchDB and get notices each and every time a document is inserted or updated. You can access the continues changes API by simply running the following at the command line:

curl -X GET "http://127.0.0.1:5984/twittertest/_changes?feed=continuous"

If you run this command in a separate terminal window you’ll see the following:

{"seq":1,"id":"7911766753","changes":[{"rev":"1-daac85c534df91d607ea8a7aa8f46fb2"}]}

This is the first change (in sequence order) that has happened in the specified CouchDB database since it was created.

There are lots of options you can use to help you refine how the HTTP connection to the _changes API works, and which specific changes that your Twitter application acts on. If the HTTP client you’re using is picky about how long it will keep a connection open without getting a response, you can use the “heartbeat” parameter to tell CouchDB to send a newline character at specific intervals, to tell your HTTP client that the connection is still alive.

You can also use the “since” parameter to specify the change sequence you want to act on. For example, if you the following example in your terminal, you won’t see anything (yet) because there has been only one change to the database:

curl -X GET "http://127.0.0.1:5984/twittertest/_changes?feed=continuous&since=2"

Even more powerful, you can specify filters and apply them to the _changes API to access only the changes that meet specific tests. Filters live inside design documents and can be applied by using the “filter” parameter. For example, consider a Twitter application that processes incoming @mentions stored in a CouchDB database through a series of steps.

Let’s say that there is something specific that needs to happen on the third step of processing Tweets your application (e.g., sending a response back to the user through the Twitter API). We want to use the _changes API to tease out any change that are at step 3. We can do this by looking at the revision number of in the _rev field of each document:

{
   "_id": "_design/process_tweet",
   "filters": {
       "step_3": "function(doc, req) { if(doc._rev.charAt(0) == '2') { 
		return true; 
	} else { 
		return false; 
    }}"
   }
}

When we define our filter like this, we can now access the _changes API to ensure we only access changes to status messages that have reached the third step in processing.

To test this filter, you can open up Futon and access the twittertest database. The Twitter status update we inserted earlier in this post should have a revision starting with a “1”. When you access that document in Futon and save it (thereby changing its revision to begin with a “2”) you will see it come through in the HTTP connection we have set up to the _changes API that uses our custom process_tweet filter. For example

curl -X GET "http://127.0.0.1:5984/twittertest/_changes?feed=continuous&filter=process_tweet/step_3"
{"seq":3,"id":"7911766753","changes":[{"rev":"2-0e701a74cb89c65853fc25dbff152364"}]}

Towards Easier Twitter Apps

As you can see, there are lots of reasons why CouchDB is ideal for building Twitter applications. It’s easy to use, incredibly powerful and has lots of cool built in features that can help Twitter application developers.

The primary challenge I faced in building TweetMy311 was time —  I was the only developer on the project and my time to get it up and running was very limited. I didn’t want this constraint to diminish what the application could do, and I also wanted to make my approach repeatable - so I can build more cool Twitter apps in the future. CouchDB was the perfect choice for my project, and I’m proud to use it on a project that will soon help lots of people make their communities better.

The life of a Twitter developer can be challenging on the best of days —  make it easier, with CouchDB.

By Clair Ross Following on from James Gill’s recent blog post about the Coupling Facility today I’m sharing with you our experiences of working with Insert Load & Replication in DB2 pureScale.  In order to test the load capacity of the IBM DB2 pureScale machine we needed some test data and lots of it!  Being somewhat familiar [...]

This document is intended as a guideline on how to use IBM Cognos 8 as a data source to build IBM Cognos 8 BI Transformer PowerCubes.

Microsoft has recently released a new Silverlight control called PivotViewer. This new control helps us to make better use of the growing amounts of information around us by visualizing thousands of things at once in a way that reveals the relationships which connect them. At the heart of the PivotViewer control are "Collections." They combine large groups of similar items, so we can begin viewing the relationships between individual pieces of information in a new way. By visualizing hidden patterns, PivotViewer enables users to discover and act on new insights.

The Business Intelligence engineering team have prototyped a new concept that couples the PivotViewer control with a utility that uses Reporting Services to automatically generate this type of collections. We showcased this concept at the BI conference in New Orleans with overwhelming support and interest from our community of BI enthusiasts and are making this demo available here to those that would like to evaluate it in their own sandbox environments. View the video here to find out more.

As you view and try this prototype, treat it like a "Concept Project". Although the Silverlight PivotViewer is now a final shipping product, the PivotViewer extension for SQL Server Reporting Services is just a preview, and isn’t a supported product or a feature of Microsoft Business Intelligence. As such, it may not work perfectly under all conditions. We look forward to your feedback and participation in this experiment and will continue working hard to bring cutting edge visualization technologies like PivotViewer to you as fast as possible. Enjoy!

Guest partner post by Shimon Shlevich, Product Manager at Panorama Software

As Microsoft PowerPivot is gaining more popularity and exposure, BI professionals ask more and more questions about PowerPivot’s role in the organization in trying to understand what value the new in-memory BI solution from Microsoft brings, along with the benefits and the limitations of it. Is PowerPivot going to replace SQL Server Analysis Services? If so, how soon? What should be done with the existing BI solution? Or maybe both can coexist and serve different needs?

In order to answer these questions and understand both short and long term impacts of the new products on your BI solution we need to understand what motivated Microsoft to release this new creature and where do they position it. Microsoft are trying to achieve two main goals – introduce a new in-memory engine for data processing and promote the self-service BI concept extending the usage of BI systems to a wider audience.

The new in-memory engine is called “Vertipaq”. Vertipaq is claimed to perform much better than classic SSAS engine doing the aggregations and calculations as well as temporary data storage in a computer’s RAM eliminating the slow disk lookup overhead. The first version of this engine is currently released as a part of both Microsoft Office Excel 2010 and the SQL Server 2008 R2 enabling SSAS to work either in classic or the new in-memory mode. The in-memory mode for SSAS is currently only available for PowerPivot created cubes and not for all your classic cubes, however, eventually the new engine will make it to a major SSAS release and will become the new default engine of the SSAS.

Meanwhile, classic SSAS is more functional than PowerPivot in terms of analytics and administration. SSAS has more semantics such as hierarchies, and more administration support such as robust data security functionality. SSAS is probably the richest multidimensional engine on the market today, scalable to support large data amounts and completely enterprise ready. The downside of these capabilities is that SSAS project requires design and planning of the BI solution, implementation, deployment, testing and additional phases. A team of BI developers, IT support, long development cycle and not that frequent updates result with a highly customized, less flexible solution which is good for years and relies on enterprise data which structure does not change that often.

Analysis Services is the corner stone of any corporate infrastructure and it enables users to analyze data that has already been pre-modeled for them by IT. So users can create standard reports, dashboards and KPI’s based on the data there, in a sense, answering ‘known’ questions. PowerPivot, on the other hand, enables users to connect to any data and instantly start modeling and analyzing it “on-the-fly” (without IT defining the cubes and modeling it in advance). PowerPivot essentially enables users to answer those ‘unknown’ questions that can often exist.

How often have you had data was missing from the cube? Or a business user come to ask for a missing metric and you postponed its creation for the next data warehouse update which was postponed and never actually happened? This is where we need self-service BI and this is where PowerPivot comes to help both the business user and the IT team. PowerPivot authoring environment is the same beloved Microsoft Office Excel that everybody has and knows how to use. The simplicity and the familiarity of this desktop tool eliminates the need for additional training and increases the adoption rate. Give them a tool they are not afraid to use and they’ll know how to work with the metrics. Business users are able to just go through any data on their flat spreadsheet and produce a cube from it in a pivot table with only a single mouse click. There are certain limitations there, but the value is still huge – self service BI with zero training required and remarkable engine performance providing instant business value.

That’s why we say SSAS answers your “known” questions and PowerPivot solves the “unknown” ones. Panorama NovaView 6.2 supports both systems and supplies our customers with the same interface and same tools for both SSAS and PowerPivot. NovaView’s unified security layer secures both data sources at the same time and with the same security definitions making administrators’ life easier and making PowerPivot ready for a large enterprise deployment. NovaView BI Server resides in the center of the BI solution and implements the business logic, additional data semantics, and security applied on both SSAS and PowerPivot. It also delivers the data insights over both data sources via the entire suite of NovaView front end tools such as Flash Analytics, Dashboard, Smart Report, Spotlight and more.

By adopting the Microsoft roadmap of self-service BI, Panorama offers intuitive and easy to learn tools which allow business users to connect to either SSAS or PowerPivot cube within seconds. Following the initial connection NovaView users can manipulate the data, build extra calculations, exceptions, charts, KPIs and more. Users can save their work and share it with colleagues by making it publically available, sending by email or via a SharePoint portal. Specifically for PowerPivot, Panorama’s data security layer and rich analytical and dashboarding abilities extend PowerPivot cubes and create an enterprise ready, self-service, in-memory driven BI solution.

Learn more about Panorama for PowerPivot >>