<< 1 >>
Rating: 
Summary: Sure Beats The Online Documentation
Review: After spending months struggling with the very confusing Microsoft provided online documentation this book was a welcome sight. As I am sure you have noticed there are very few books dedicated to the OLE DB ATL wrapper classes. Typically OLE DB coverage is the exclusive domain of a single chapter in an introductory COM book. This book provides a very good introduction to the ATL OLE DB wrappers. It assumes a working knowledge of COM and does not provide a detailed analysis of the guts of OLE DB, the Microsoft documentation is still the best place for this. The author appears to have plenty of real world experience under is belt to back up his text. The author also provides an interesting set of extensions to the default ATL wrappers available for download through a web site. You may not need all of the extensions but they do provide a very good base for other possible enhancements to the library as well as a good place to test your knowledge of the concepts discussed in the book. Well worth the cash, especially if you have had OLE DB thrust upon you and are in a "learn and burn" situation.
Rating: 
Summary: Almost ok - READ THIS
Review: As you can see, there are not many books on the subject. However, this book contains very few code lines and it is not organized well. The fact that a programming book does not have even 1 (!) full example can't be good. You will get a fair amount of information from this book; however, YOU WILL visit MSDN regularly. The author spend time on known subjects like performance again and again (although that C++ programmers are well aware to this subject) and less to the whole concept of the templates. He is breaking up all the objects very well, but failing terribly in providing the whole system. A "nice to have" book as a second or third reference. Don't buy it as first.
Rating: 
Summary: Not complete, not correct, not supported, not recommended
Review: I am by now several months into a project using the consumer templates. I have to say at this point that the decision to use them was the biggest mistake I have made on this project. They do not make the grade and it is too late to back out and user another interface.
The templates would be a good idea if carried to completion and fully supported. They are not. The template classes Nallet presents are not a full wrapper, but just a series of incomplete examples. They do not compile under newer versions of C++ and must be hacked just to build. Each hack in turn produces more problems. The publisher's web page no longer contains any reference to this book, nor to it's source code. The author's web page is "404", and the code exists on the Internet only in "pirate" sites. I have turned up references to the author through search engines but see no sign he is maintaining his code.
Microsoft is in the process of abandoning OLEDB in any case in favor of ADO.
In short and in other words: DON'T BOTHER!!
Rating:
Summary: Too many errors/typos; very sloppy in proofreading
Review: The book provides a detailed guide to developing OLE DB consumers using ATL. Unlike other books it goes much further than just showing you how to build a primitive consumer using ATL wizard. The author explains how to use OLE DB templates to develop real world applications, e.g. with various types of accessors, accessing not only regular tabular data sources but also OLAP and hierarchical data, etc. A very good on-line support for the book provides some useful template extensions as well other additional information. Unfortunately the book doesn't touch OLE DB providers but at least it's clearly stated in the title. Very recommended!
Rating:
Summary: This is a good Book handling some advanced OLE DB topics.
Review: The coverage for basic OLE DB is not good in this book. To get a decent coverage of this in my opinion you can do no better than: "Beginning Components for ASP" which not only explains basic OLE DB well, but also explains MTS and Writing components for ATL to work with ASP amongst other things.
Rating: 
Summary: OK book... very lacking in examples
Review: This book isn't exactly what I had hoped for. It seems that only about 30% of the book is actually devoted to "Consumer Templates" and the other 70% talks about raw OLE DB interfaces. However, since it is the only book that covers anything on consumer templates ... it is better than nothing.
Rating: 
Summary: The one and the only....
Review: This is perhaps the only book available that provides clear and fairly deep coverage of ATL Consumer Templates. Well written, compact sensible examples, right to the point. In addition to ATL Consumer Templates, the author presents a set of useful extensions and to his credit - he managed not to turn this book into a marketing brochure for his own extension library. After having read pretty much every book that current market has to offer on the subject of ATL Consumer Templates I got a lucky break with this one - it's just so much better than one page description of Consumer Templates in "Visual C++ Database Programming" by Wendy Sarrett and especially the terrible reprint of the on-line docs in "Learn OLE DB Development with VC++ 6.0" by Nathan Wallace. If I could only find a similar book on provider programming....
Rating:
Summary: Great book, lots of typos
Review: This is the best book on the market concerning the subject, but you should browse the online documentation first to orient yourself. The author clearly knows what he is talking about based on experience. The author's OLEDB extensions rectify many the shortcomings of ATL for OLEDB. If you are familiar with ATL, OLEDB is a much more powerful way to program data access than ADO. I find the object model is actually clearer and simpler to use than ADO's (this is not the case when you try coding OLEDB without ATL, unless you are a masochist). There are very few complete examples. In computer books, you have to find a balance between adding bulky printouts of code versus having insufficient working examples. The books errs on the latter side and is filled with tiny snippets of code that are sometimes hard to place in context. The book also suffers from lots of obvious typos. I am not sure why the editors didn't take more time since there is no real competitor to this book on the market. The book should have also included a bit on the relationship between OLEDB and ADO. For example, if you write an object that is called from a dispatch interface (ASP, say), you might want to perform most of the processing in OLEDB and then return the results as an ADO recordset rather than an OLEDB resultset. This translation isn't that hard to do, but it took me hours to find the correct functions / interfaces in the documentation.
Rating:
Summary: OK book... very lacking in examples
Review: With high hopes, I bought this book. But it has been a big disappointment. The book explains the concepts of OLE DB templates and the various macros, quite well. Lot of figures explaining the relationship between objects. But it is very much lacking on real usable examples. There is not a single complete example. Most examples are real simple. Inserts and Deletes get just one page each, hardly useful, and also the example used for these is with a CTable. How many people use a CTable for inserts and deletes? It is like saying "Delete/Update the first row in the database", which is hardly practical. There are about 30 OLE DB types, but no examples on how to use these. In summary, the book is better than the SDK documentation on OLE DB templates, but not much useful if you want to get into OLE DB programming quickly.
<< 1 >>
| 
