Some time ago i was reading an article about new MS DBMS technology. It's some kind of OLAP but on the fly. This technology can bind to data flows and then provide a real time aggregation. So the question is "what is it's name?". I need such a technology now but can't remember it's name... Or maybe there are some similar technologies?
Are you referring to PopFly? LINQ? Reactive LINQ?
What about this site:
(M Language): http://msdn.microsoft.com/en-us/data/ee460940.aspx
or this one:
(Quadrant): http://msdn.microsoft.com/en-us/data/ee477952.aspx
Regards.
I think you was reading about powerpivot
The problem is no more actual...
Related
I am trying to evaluate and use column db for my application.
I have evaluated InfiniDb and InfoBright. Can you suggest some other Column DB's
Your question might suggest that column-store database are NoSQL database.
Those are two different kind of database / way of representing datas that should not be confused.
I do personally use LucidDB that works like a charm. I use it for Business Intelligence use, and LucidDB is optimized for Business Intelligence. One of the activest member of the community Nicholas Goodman , someone really influent in the world of Open Source BI.
For this use, it is really well though and I would recommend it for this use.
There's a good list on wikipedia
Can you recommend good embedded databases with Visual C++/MFC?
I've looked at:
- SQLite
- HamsterDB
Any others?
Have a look around on codeproject.com for MFC-esque wrappers around sqlite. There are quite a number of good ones. The sqlite website has links to c++ wrappers, too.
I would use SQL Server Compact Edition plus ATL OLE DB Consumer Templates (you can use them with MFC).
This is an interesting link: http://www.codeproject.com/KB/windows/atl_ole_db_ppc.aspx
You have to use this OLE DB provider: http://msdn.microsoft.com/en-us/library/ms174142(SQL.100).aspx
i'm the author of hamsterdb.
To answer your question - it depends.
sqlite offers more functionality, but is slower.
hamsterdb (or tokyo cabinet, or berkeleydb) are faster but have less functionality.
if you give a better description of your use case then i can help better.
bye
Christoph
Windows has an embedded database enginge (no query engine, a low level API like HamsterDB).
Link
Salesforce’s secret sauce: It queries its databases with “The Multi-Tenant Optimizer" So exactly what could this practice be comprised of?
A whole lot of marketing.
Denormalizing the data so that every row has the "tenant id" in it which reduces the number of necessary joins that have to be done to find the owner of the data.
Just a guess.
Patent application is here
Broadly, separate stats for each tenant/user.
Here's a link to one of their webinars, where their chief architect talked about their database architecture.
Another option is to use "Sharding". Here is a link which has a fairly good description of this technique :
http://www.codefutures.com/database-sharding/
If you're using hibernate for Object-Relational Persistence, they have an additional library which adds support for sharding (and insulates the application many of the details) :
http://www.hibernate.org/subprojects/shards.html
I want to know that the distributed database system Bigtable is object oriented?
No. It is "a sparse, distributed multi-dimensional sorted map"
(source: http://en.wikipedia.org/wiki/BigTable)
No. It is a rather odd beast - see Wikipedia.
I recommend Google's own research paper on the subject. Good read.
Does anyone know of any design patterns for interfacing with relational databases? For instance, is it better to have SQL inline in your methods, or instantiate a SQL object where you pass data in and it builds the SQL statements? Do you have a static method to return the connection string and each method just gets that string and connects to the DB, performs its action, then disconnects as needed or do you have other structures that are in charge of connecting, executing, disconnecting, etc?
In otherwords, assuming the database already exists, what is the best way for OO applications to interact with it?
Thanks for any help.
I recommend the book Patterns of Enterprise Application Architecture by Martin Fowler for a thorough review of the most common answers to these questions.
There are a few patterns you can use:
Repository Pattern
Active Record Pattern
I personally would hate to work with a database without an ORM. NHibernate is preferable but iBatis is also an option for existing databases (not to say that NH can't handle existing databases).
In general, the best way for OO applications to interface with a relational database is through an ORM; while this isn't a design pattern per se, it's a type of tool that has a specific usage pattern, so it's similar enough. Object Relational Mapping (ORM) tools provide a mapping between a database and a set of objects in memory; usually, these tools provide means for managing things such as sessions, connections, and transactions. A good example of an ORM that works fantastically well would be Hibernate (NHibernate on .NET).
In my experience it is best to have no SQL statements at all (most ORMs will allow that), and it is best not to have any knowledge of connection details (connection string, etc). Even better if you can have the exact same piece of code working with any major db vendor.
POEAA has a wealth of knowledge on the issue if you intend to roll your own.
Everything you will identify by googling for DAL describes a design pattern. Seems like standing in the middle of the forest and asking to see a tree. There are dozens if not thousands.
Here's a quote from a book I'm reading to start with for looking for resources.
... it is impossible to discuss ORM without talking about patterns and best practices for building persistence layers. Then again, it is also impossible to discuss ORM patterns without calling out the gurus in the industry, namely Martin Fowler, Eric Evans, Jimmy Nilsson, Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, the last four of whom are known in the industry as the Gang of Four (GoF). The purposes of this chapter are to explain and expand some of the patterns created by these gurus and to provide concrete examples using language that every developer can understand.