Ole db consumer templates

A comprehensive and practical guide, OLE DB ConsumerTemplates is an essential resource for all database programmers working with Microsoft technologies. The book is filled with examples that show you how to harness the power of OLE DB using consumer templates to create efficient, scalable, and manageable database applications.

OLE DB Consumer Templates presents an overview of DNA, COM, universal data access, and how OLE DB fits in with Microsoft's component and data access strategies-it explains the differences between OLE DB and ADO architectures. The author provides detailed and practical information on using OLE DB consumer templates to develop all the major elements and functions of database applications, including:

• OLE DB wizard
• OLE DB errors
• OLE DB properties
• Data sources and sessions
• Tables, commands, rowsets, and accessors
• Exchanging data
• BLOBS
• Transactions
• Schema information

Contents

Preface

Acknowledgments

Chapter 1. Windows DNA and COM

DNA

The best of Windows

The best of the Internet

Compatibility

Separation of the different layers

Windows DNA architecture

Description of the different tiers

Description of the presentation tier

Description of the business logic tier

Description of the data tier

Microsoft universal data access

XML

DNA summary

DNA scenarios

Client server architecture

Web scenarios

COM

Reuse

Challenges

The COM solution

Interfaces

IUnknown

COM Classes

COM Instances

GUIDs

COM+ and attributes

Benefits

Performance

Upgrade

Computer language independence

Location transparency

Reuse components

Aggregation

Using COM object with ATL

COM component encapsulation

Where are we?

Chapter 2. Universal data access

Universal data server and universal data access

Universal data server

Benefits and drawbacks

Universal data access

Benefits and drawbacks

UDA components

ODBC

ODBC and the history of data access under Windows

ODBC architecture

ODBC shortcomings

OLEDB

What is OLEDB?

OLEDB supports numerous OLEDB provider types

Tabular providers

Multi dimensional providers

Hierarchical providers

OLEDB types

OLEDB is based on COM

Performance

Flexibilities with multiple interfaces

OLEDB is based on a new architecture

Service components and service providers

Service components

Data shaping service

OLEDB providers

ODBC versus OLEDB

OLEDB versions

ADO

ADO architecture

When use ADO?

OLEDB templates

Using raw OLEDB

Using OLEDB consumer templates

OLEDB template extensions

Where are we?

Chapter 3. Using the OLEDB wizard

Is the wizard a good thing?

Using the wizard

Creating an ATL project

Invoking the OLEDB wizard

Selecting the data source

Selecting the table

Generated code

Global actions

Opening a table

Opening a command

Adding support for changes

Using stored procedures

Improvements

MFC wizard

OLEDB consumer templates classes overview

Table command rowset accessor architecture

What?

How many?

What navigation?

What binding?

Putting classes together

CAccessorRowset

Closing a CAccessorRowset

Where are we?

Chapter 4. Errors

Error codes and exceptions

HRESULT

Interpreting HRESULT

HRESULT in the practice

Error info

Tracing errors

Error info and error records

Error info

Error records

Using OLEDB classes

Getting the basic error information

Getting a custom error object

Tracing custom information

Error info support

Putting things together

Where are we?

Chapter 5. OLEDB properties

Notion of property

Properties and property sets

Property set GUIDs

Property groups

Property operations

Setting properties

DBPROPSET

DBPROP

Using the raw structures

CDBPropSet

Setting one property

Required and optional properties

Column identifiers

Custom property classes

Checking the property status

Tracing properties

Getting properties

DBPROPIDSET

CDBPropIDSet

Memory management

Getting one property

Enumeration properties

Enumerating errors

Getting property information

DBPROPINFOSET

DBPROPINFO

Property description

Property type

Property flags

Read / write properties

Other flags

Possible values

CDBPropertyInfoSet

Where are we?

Chapter 6. Data sources and session

Where is the data?

A little bit of history

Proprietary database

ODBC

Opening a data source

ProgID and CLSID

Opening a data source with user name and password

Try it yourself

Opening a data source from a set of properties

Opening the data source with incomplete information

Security

Authentication

Protection and Encryption

Data links and initialization string

Try it yourself

Where should you store the connection string?

Opening a data source interactively

Data link dialog

Organize data links dialog

Try in yourself

Service components and resource pooling

Resource pooling

Closing a data source

Enumerators

Root enumerator

Enumerator navigation

Data sources and enumerators

Provider enumerator

Try it yourself.

Data source extensions

Saving the connection string to file

Editing a data source

Try it yourself:

Getting the CLSID

Sessions

Where are we?

Chapter 7. Tables and commands

Table or command?

Using tables

Opening a table

Using commands

CCommand

Opening a command

First Open method

Where does the command text come from?

Command dialects

Second Open method

Closing a command

Releasing the command object

Opening and closing: summary

Preparing a command

Command with parameters

Command with multiple results

Using multiple results

Inside multiple results

Command extensions

Command with multiple parameter accessor

Command with multiple parameter sets

Where are we?

Chapter 8. Rowsets

Why a rowset object?

Rowset classes

Rowsets and rows

Row management

Row count and position

Cursor movement

Row identity

Bookmarks

Bookmark types

Numeric bookmarks

Key value bookmarks

Bookmark comparison

Bookmark position

Standard bookmarks

Using standard bookmarks

Rowset properties

Setting properties at creation time

Getting properties

Bulk rowsets

Rowset arrays

Client cursor service component

Finding a value

What is the "find" mechanism?

An example of find

Using the find feature

Where are we?

Chapter 9. Accessors

Overview of accessors

What is an accessor?

Column and parameter accessors

Input and output accessors

Binding

Data parts

Accessors

Accessor classes

CAccessorBase

Accessor classes

CNoAccessor

Using CAccessor

Column bindings

Macro internals

Binding length and status

Precision and scale macros

Column type and size

Auto accessors

Multiple accessors

Binding by reference

Provider owned memory

Client owned memory

Using BSTR

Summary

Parameter binding

Dynamic accessors

Using dynamic accessors

Number of columns

Type, names and flags

Getting and setting data parts

Getting values

Setting a value

Using CDynamicParameterAccessor

Extending dynamic accessors

Where are we?

Chapter 10. Exchanging data

Getting data

Auto accessors

GetDataHere

From the consumer to the data store

Deleting a row

Setting data

Inserting a row

Rowset method versus SQL

Deferred updates

Deferred updates benefits

Setting deferred changes

How deferred updates work

Pending status

Pending rows: navigating the cache

Transmitting the changes

Updating all changes

Undoing changes

Undoing all changes

Original and last visible data

Deferred changes and transactions

Notifications

Rowset listeners

Event reasons

Event phase

Notification example

Where are we?

Chapter 11. BLOBs

The different types of BLOBs

BLOB content

Access methods

Long and short BLOBs

Fixed size and variable size

Summary

BLOBs as in-memory data

BLOB as in-memory data by reference

BLOB as storage object

Storage interfaces

Retrieving BLOB data with a storage object

Storing BLOB data with a storage object

Storing BLOBs by writing on a storage object

Storing BLOBs with a consumer provided storage object

BLOB properties

Handling several BLOBs

Converting interfaces, memory and files

IStream

ILockBytes

IStorage

Accessing persistent COM objects

Where are we?

Chapter 12. Transactions

The need for transaction

The Transaction approach

Transaction properties

Atomicity

Consistency

Isolation

Durability

Using transactions

Simple transaction

Transaction retention

Rowset preservation

Setting preservation properties

Try it yourself

Isolation levels

Isolation phenomena

Dirty read

Non repeatable read

Phantom

Isolation levels

Read Uncommitted isolation level

Read Committed isolation level

Repeatable Read isolation level

Serializable isolation level (also called Isolated)

Transaction isolation demo

Program A

Program B

Read uncommitted transaction

Read committed transaction

Repeatable read transactions

Serializable transactions

Isolation level and locks

Choosing an isolation level

Supported isolation levels

Sessions with no transaction

Asynchronous transactions

Using transaction outcome

Define your Transaction outcome events COM class

Advise the transaction you want to get the events from

Nested transactions

Using nested transactions

Distributed transaction

Microsoft Distributed Transaction Coordinator

Checking that Microsoft distributed transaction coordinator is running

Using Microsoft distributed transaction coordinator

Transactional components

Components and transactions

Component granularity

Microsoft Transaction Server and COM+ components

Object context

Transaction attributes

Transaction enlistment

Where are we?

Chapter 13. Indexes, Chapters and Views

Indexes

Index type

Using indexes

Opening an index

Seeking a row

Restricting the range

Chapters

Using a

Chapter

CRowsetEx

Hierarchical rowsets

Example description

Traditional approach

Approach with chapters

Data Shaping Service

Navigating hierarchical rowsets

Separate parent and child

Child as part of the parent

Views

When to use views?

Opening the view

View type

Sorting a view

Filtering a view

View chapters

Stacking views

Where are we?

Chapter 14. Schema, definitions and synchronization

Querying and navigating the schema

Restrictions and schema rowsets

Restrictions

CRestrictions

Catalog and schema

Catalogs

Tables

Columns

Views

Procedures

Indexes

Keys

Privileges

Provider types

Modifying the schema

Using CTableDefinition

Table operations

Column operations

Using CIndexDefinition

Synchronizing the schema

Checking binding at compile time

Binding by name

Creating tables from the code

Where are we?

Chapter 15. OLAP

From tabular to multi-dimensional

Multi dimensional sessions and commands

Datasets

The dataset object

CDataset

Working with datasets

Metadata: axis information

Axis navigation

Hierarchies Using an axis rowset

Axis with multiple dimensions

Axis information with multiple dimension

Using CAxisAccessor with multiple dimensions

Cells

Cell identification

Cell accessors

Getting cell data

Cell ranges

Range of cells

Range rowsets

Getting cell ranges

Using multi-dimensional data with rowset

OLAP schema

Where are we?

Chapter 16. Hierarchical data

Object overview

Direct binding

How direct binding works

Row object

Opening a row

Creating a row

Getting and setting column values

Scoped operations

Copying a row

Moving a row

Deleting a row

Document model

Row folder object

Opening and creating a row folder

Enumerating children

Streams

Opening a stream

Reading and writing in the stream

Where are we?

Appendix Advanced C++ Techniques

Inheriting from a template parameter

Default template parameters

Type definition overloading