Properties Table (Alphabetical)

VARIANT_TRUE—After aborting a transaction, the rowset remains active. That is, it is possible to fetch new rows, update, delete, and insert rows, and so on.

VARIANT_FALSE—After aborting a transaction, the only operations allowed on a rowset are to release row and accessor handles and to release the rowset.

The order in which columns must be accessed on the rowset.  One of the following values:

DBPROPVAL_AO_RANDOM—Columns can be accessed in any order.

DBPROPVAL_AO_SEQUENTIALSTORAGEOBJECTS—Columns bound as storage objects can only be accessed in sequential order as determined by the column ordinal. Further, storage objects from one row must be retrieved before calling GetData on any columns in any subsequent row. Calling GetData on a column bound as a storage object returns DBSTATUS_E_UNAVAILABLE for any columns bound as storage objects if any of the following are true:

• Columns beyond the column bound as a storage object are specified in the accessor.
  
  
• Columns beyond the column bound as a storage object have been accessed in a previous call to GetData for that row.
  
  
• GetData has been called for any columns on a row returned after the specified row.

Providers that never impose restrictions on column access ordering return DBPROPSTATUS_S_OK when this value is set. However, they upgrade the property to DBPROPVAL_AO_RANDOM such that calling GetProperty continues to return DBPROPVAL_AO_RANDOM for this property.

DBPROPVAL_AO_SEQUENTIAL—All columns must be accessed in sequential order determined by the column ordinal.  Further, all columns from one row must be retrieved before calling GetData on any columns in any subsequent row. Calling GetData returns DBSTATUS_E_UNAVAILABLE for any columns for which any of the following are true:

• The column is bound as a storage object and columns beyond it are specified in the accessor.
  
  
• Columns beyond the bound column have been accessed in a previous call to GetData for that row.
  
  
• GetData has been called for any columns on a row returned after the specified row.

Providers that never impose restrictions on column access ordering return DBPROPSTATUS_S_OK when this value is set. However, they upgrade the property to DBPROPVAL_AO_RANDOM such that calling GetProperty continues to return DBPROPVAL_AO_RANDOM for this property.

Providers may be able to optimize how data is retrieved if they know it will be read in column order. For instance, the provider may be able to read directly from a stream over the data if it knows the columns will be read in strictly sequential order, but may not be able to do so efficiently if the columns contain BLOBs that may be read in a random order.

The maximum number of sessions that can exist at the same time. If this property is set to zero, there is no limit on the number of sessions that can exist at one time.

A bitmask describing which portions of the DBCOLUMNDESC structure can be used in a call to IAlterTable::AlterColumn.

A combination of one or more of the following:

DBCOLUMNDESCFLAG_TYPENAME
DBCOLUMNDESCFLAG_ITYPEINFO
DBCOLUMNDESCFLAG_PROPERTIES
DBCOLUMNDESCFLAG_CLSID
DBCOLUMNDESCFLAG_COLSIZE
DBCOLUMNDESCFLAG_DBCID
DBCOLUMNDESCFLAG_WTYPE
DBCOLUMNDESCFLAG_PRECISION
DBCOLUMNDESCFLAG_SCALE

For more information about the mapping of these values to fields in the DBCOLUMNDESC structure, refer to the specification for IAlterTable::AlterColumn.

A rowset opened with this property set to VARIANT_TRUE will be initially empty. If the rowset was obtained by IOpenRowset::OpenRowset, this is equivalent to positioning the start of the rowset at the end of the table; if it was obtained by executing a command, it is equivalent to placing the start of the rowset at the end of the command's results. A rowset opened with DBPROP_APPENDONLY set to VARIANT_TRUE will be populated only by those rows inserted in it.

DBPROP_APPENDONLY set to VARIANT_TRUE implies:

• DBPROP_IRowsetChange is VARIANT_TRUE.
  
  
• DBPROP_OWNINSERT is VARIANT_TRUE.
  
  
• DBPROP_UPDATABILITY has the flag DBPROPVAL_UP_INSERT set.
  
  
• DBPROP_OTHERINSERT is VARIANT_FALSE.

Whether transactions can be aborted asynchronously.

Whether transactions can be committed asynchronously.

VARIANT_TRUE—The data source object or enumerator is allowed to cache sensitive authentication information such as a password in an internal cache.

VARIANT_FALSE—The data source object or enumerator is not allowed to cache sensitive authentication information.

VARIANT_TRUE—The consumer requires that the password be sent to the data source or enumerator in an encrypted form. This property specifies a stronger form of masking than DBPROP_AUTH_MASKPASSWORD; it uses cryptographic techniques.

VARIANT_FALSE—The password can be sent in an unencrypted form.

A string containing the name of the authentication service used by the server to identify the user using the identity provided by an authentication domain.  For example, for Microsoft^® NT^® Integrated Security, this is "SSPI" (for Security Support Provider Interface).  If the BSTR is a null pointer, the default authentication service should be used. When this property is used, no other DBPROP_AUTH* properties are needed and, if provided, their values are ignored.

VARIANT_TRUE—The consumer requires that the password be sent to the data source or enumerator in a masked form.

VARIANT_FALSE—The password can be sent in an unmasked form.

The password to be used when connecting to the data source or enumerator. When the value of this property is retrieved with IDBProperties::GetProperties, the provider might return a mask such as "******" or an empty string instead of the actual password. Note that the password is still set internally and is used when IDBInitialize::Initialize is called.

VARIANT_TRUE—The consumer requires that the data source object persist sensitive authentication information such as a password in encrypted form.

VARIANT_FALSE—The data source object can persist sensitive authentication information in unencrypted form.

VARIANT_TRUE—The data source object is allowed to persist sensitive authentication information such as a password along with other authentication information.

VARIANT_FALSE—The data source object cannot persist sensitive authentication information.

If DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO is set to VARIANT_FALSE at the time the data source is initialized, the data source object cannot persist sensitive authentication information. Furthermore, requesting properties that contain sensitive authentication information, such as password, returns some default value instead of the actual password. Once the data source has been uninitialized, sensitive information that was set when the data source was initialized with the DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO property set to VARIANT_FALSE still cannot be obtained through IDBProperties::GetProperties or by persisting the uninitialized data source, but new properties set after the data source has been uninitialized can be persisted or obtained as long as DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO is VARIANT_TRUE.

The user ID to be used when connecting to the data source or enumerator.

Whether storage objects might prevent use of other methods on the rowset.

VARIANT_TRUE—Instantiated storage objects might prevent the use of other methods on the rowset. That is, after a storage object is created and before it is released, methods other than those on the storage object might return E_UNEXPECTED.

VARIANT_FALSE—Instantiated storage objects do not prevent the use of other methods.

A bitmask specifying additional information about bookmarks over the rowset. A combination of zero or more of the following:

DBPROPVAL_BI_CROSSROWSET—If set, bookmark values returned by this rowset are valid across rowsets with the same metadata.  If not set, bookmark values are specific to this rowset and are not guaranteed to return the same values in other rowsets, even those resulting from the same specification.

Whether the rowset supports bookmarks. One of the following:

VARIANT_TRUE—The rowset supports bookmarks. Column 0 is the bookmark for the rows. Getting this column obtains a bookmark value, which can be used to reposition to the row.

VARIANT_FALSE—The rowset does not support bookmarks. The rowset is sequential and the values of the DBPROP_LITERALBOOKMARKS and DBPROP_ORDEREDBOOKMARKS properties are ignored.

The value of this property is automatically set to VARIANT_TRUE if the value of DBPROP_IRowsetLocate, DBPROP_LITERALBOOKMARKS, or DBPROP_ORDEREDBOOKMARKS is set to VARIANT_TRUE.

Whether the rowset allows IRowsetLocate::GetRowsAt, IRowsetScroll::GetApproximatePosition, or IRowsetFind::FindNextRow to continue if a bookmark row was deleted, is a row to which the consumer does not have access rights, or is no longer a member of the rowset. One of the following:

VARIANT_TRUE—GetRowsAt, GetApproximatePosition, or FindNextRow skips the bookmark row and continues with the next row.

VARIANT_FALSE—GetRowsAt, GetApproximatePosition, or FindNextRow returns DB_E_BADBOOKMARK.

The bookmark type supported by the rowset. One of the following:

DBPROPVAL_BMK_NUMERIC—The bookmark type is numeric. Numeric bookmarks are based upon a row property that is not dependent on the values of the row's columns. For instance, they can be based on the absolute position of the row within a rowset, or on a row ID that the storage engine assigned to a tuple at its creation. The validity of numeric bookmarks is not changed by modifying the row's columns.

DBPROPVAL_BMK_KEY—The bookmark type is key. Key bookmarks are based on the values of one or more of the row's columns; these values form a unique key for each row. A key bookmark may be left dangling if the key values of the corresponding row are changed.

For more information, see "Bookmark Types" in Chapter 4.

Whether the provider supports the DBACCESSOR_PASSBYREF flag in IAccessor::CreateAccessor. This applies to both row and parameter accessors.

VARIANT_TRUE—The provider caches the value of a deferred column when the consumer first gets a value from that column. When the consumer later gets a value from the column, the provider returns the value in the cache. The contents of the cache can be overwritten by IRowsetChange::SetData or IRowsetRefresh::RefreshVisibleData. The cached value is released when the row is released.

Consumers should set the value of this property to VARIANT_TRUE rather sparingly, because it might require substantial memory use in the provider. Such use might limit the number of rows that can be held at one time. Setting the value of this property to VARIANT_TRUE automatically sets the value of the DBPROP_DEFERRED property to VARIANT_TRUE.

VARIANT_FALSE—The provider does not cache the value of a deferred column, and multiple calls to IRowset::GetData for the column can return different values.

Whether the rowset can fetch backward.

VARIANT_TRUE—cRows in IRowset::GetNextRows, IRowsetLocate::GetRowsAt, and IRowsetScroll::GetRowsAtRatio can be negative. When it is negative, these methods fetch rows backward from the specified row.

VARIANT_FALSE—cRows must be non-negative.

VARIANT_TRUE—The rowset allows the consumer to retrieve more rows or change the next fetch position while holding previously fetched rows with pending changes.

VARIANT_FALSE—The rowset requires pending changes to be transmitted to the data source and all rows to be released before fetching additional rows, inserting new rows, or changing the next fetch position.

Whether the rowset can scroll backward.

VARIANT_TRUE—lRowsOffset in IRowset::GetNextRows or IRowsetLocate::GetRowsAt can be negative.

VARIANT_FALSE—lRowsOffset must be non-negative.

If the rowset supports IRowsetLocate, then the value of this property is VARIANT_TRUE, because this method supports backward scrolling by definition.

The position of the catalog name in a qualified table name in a text command. One of the following:

DBPROPVAL_CL_START—The catalog name is at the start of the fully qualified name. For example, a dBASE^® provider returns DBPROPVAL_CL_START because the directory (catalog name) is at the start of the table name, as in \EMPDATA\EMP.DBF.

DBPROPVAL_CL_END—The catalog name is at the end of the fully qualified name. For example, an ORACLE server provider returns DBPROPVAL_CL_END because the catalog name is at the end of the table name, as in ADMIN.EMP@EMPDATA.

The name the data source uses for a catalog; for example, "catalog", "database", or "directory". This is used for building user interfaces.

A bitmask specifying how catalog names can be used in text commands. A combination of zero or more of the following:

DBPROPVAL_CU_DML_STATEMENTS—Catalog names are supported in all Data Manipulation Language statements.

DBPROPVAL_CU_TABLE_DEFINITION—Catalog names are supported in all table definition statements.

DBPROPVAL_CU_INDEX_DEFINITION—Catalog names are supported in all index definition statements.

DBPROPVAL_CU_PRIVILEGE_DEFINITION—Catalog names are supported in all privilege definition statements.

VARIANT_TRUE—The consumer can call IRowsetChange::DeleteRows or IRowsetChange::SetData for newly inserted rows.

VARIANT_FALSE—If the consumer calls DeleteRows or SetData for newly inserted rows, DeleteRows returns a status of DBROWSTATUS_E_NEWLYINSERTED for the row and SetData returns DB_E_NEWLYINSERTED.

A newly inserted row is defined to be a row for which the insertion has been transmitted to the data source, as opposed to a pending insert row. For some providers this property may imply other properties.

Whether the values of the column are autoincrementing. One of the following:

VARIANT_TRUE—The values of the column are autoincrementing.

VARIANT_FALSE—The values of the column are not autoincrementing.

If this property is read-only, then whether or not a column is autoincrementing is a property of the datatype. If this property is read/write, then DBPROP_COL_AUTOINCREMENT can be specified for the column provided the AUTO_UNIQUE_VALUE property of the underlying datatype is VARIANT_TRUE in the PROVIDER_TYPES schema rowset.

A VARIANT specifying the default value for an object—typically a domain or column. If the default value is a string, the string must be quoted so it can be distinguished from an object of the same name. For example, 'Salary' is a string, but Salary is an object, such as a column.

A string specifying a human-readable description of the specified column.

Whether a column is fixed- or variable-length.

If the value of this property is VARIANT_TRUE, the column is fixed length and ulColumnSize in the DBCOLUMNDESC structure contains the fixed-length value. If the value of this property is VARIANT_FALSE or is not specified, the column is variable length and ulColumnSize represents the maximum size of the column. For information about the DBCOLUMNDESC structure, see ITableDefinition::CreateTable.

Whether a column can contain a NULL value. One of the following:

VARIANT_TRUE—The column can contain NULL values.

VARIANT_FALSE—The column cannot contain NULL values.

Whether the column is part of the primary key. One of the following:

VARIANT_TRUE—The column is part of the primary key of the table.

VARIANT_FALSE—The column is not part of the primary key of the table.

Whether values of the column must be unique in the table. One of the following:

VARIANT_TRUE—The values of the column must be unique within the table.

VARIANT_FALSE—The values of the column can be repeated within the table.

A bitmask defining the valid clauses for the definition of a column. A combination of zero or more of the following:

DBPROPVAL_CD_NOTNULL—Columns can be created non-nullable.

The locale ID of the column.

VARIANT_TRUE—Access rights are restricted on a column-by-column basis. If the rowset exposes IRowsetChange, IRowsetChange::SetData cannot be called for at least one column. A provider must not execute a query that would specify a column for which the consumer has no read access rights.

VARIANT_FALSE—Access rights are not restricted on a column-by-column basis. If the rowset exposes IRowsetChange, SetData can be called for any column in the rowset.

If access is restricted both by row and by column, then individual columns of particular rows might have their own stricter access rights: the consumer might not even be permitted to read such columns. The column values will be NULL. If a NULL value is contrary to schema rules (NULLs not permitted) then the rowset should not count or return any rows that would have this condition. For more information, see DBPROP_ROWRESTRICT.

The number of seconds before a command times out. A value of 0 indicates an infinite timeout.

VARIANT_TRUE—After committing a transaction, the rowset remains active. That is, it is possible to fetch new rows, update, delete, and insert rows, and so on.

VARIANT_FALSE—After committing a transaction, the only operations allowed on a rowset are to release row and accessor handles and to release the rowset.

How the data source handles the concatenation of NULL-valued character data type columns with non–NULL-valued character data type columns. One of the following:

DBPROPVAL_CB_NULL—The result is NULL valued.

DBPROPVAL_CB_NON_NULL—The result is the concatenation of the non–NULL-valued column or columns.

The status of the current connection. One of the following:

DBPROPVAL_CS_UNINITIALIZED—The DSO is in an uninitialized state.

DBPROPVAL_CS_INITIALIZED—The DSO is in an initialized state and able to communicate with the data store.

DBPROPVAL_CS_COMMUNICATIONFAILURE—The DSO is unable to communicate with the data store.

Some providers may have to silently spawn multiple connections to the database in order to support multiple concurrent Commands, Sessions, and Rowsets, according to DBPROP_MULTIPLECONNECTIONS. For such providers, DBPROP_CONNECTIONSTATUS refers to the status of the primary connection, which was created when the user called Initialize.

The name of the current catalog. The consumer can use the CATALOGS schema rowset to enumerate catalogs.

The name of the data source. This might be used during the connection process.

VARIANT_TRUE—The data source is read-only.

VARIANT_FALSE—The data source is updatable.

The name of the product accessed by the provider. For example, "ORACLE Server" or, for Microsoft^® Excel^®, "Excel".

The version of the product accessed by the provider. The version is of the form ##.##.####, where the first two digits are the major version, the next two digits are the minor version, and the last four digits are the release version. The provider must render the product version in this form but can also append the product-specific version. For example, "04.01.0000 Rdb 4.1".

VARIANT_TRUE—The data in the column is not fetched until an accessor is used on the column.

VARIANT_FALSE—The data in the column is fetched when the row containing it is fetched.

The value of this property is automatically set to VARIANT_TRUE if the value of the DBPROP_CACHEDEFERRED property is set to VARIANT_TRUE.

In delayed update mode, if the value of this property is VARIANT_TRUE then storage objects are also used in delayed update mode. In particular:

• Changes to the object are not transmitted to the data source until IRowsetUpdate::Update is called,
  
  
• IRowsetUpdate::Undo undoes any pending changes, and
  
  
• IRowsetUpdate::GetOriginalData retrieves the original value of the object; that is, the object's value when the row was last fetched or updated and excluding any changes made since then.

In delayed update mode, if the value of this property is VARIANT_FALSE, then storage objects are used in immediate update mode. In particular:

• Changes to the object are immediately transmitted to the data source.
  
  
• Update has no effect on the object.
  
  
• Undo does not undo changes made to the object since the row was last fetched or updated.
  
  
• GetOriginalData retrieves the current value of the object, including changes made since the row was last fetched or updated.
  
  
• In immediate update mode, this property has no effect on storage objects.

A bitmask specifying the threading models supported by the data source object. A combination of one or more of the following:

DBPROPVAL_RT_FREETHREAD
DBPROPVAL_RT_APTMTTHREAD
DBPROPVAL_RT_SINGLETHREAD

Note that the threading model returned in this property may be stricter than the thread model registered under the provider's CLSID in the case where additional threading limitations are imposed by underlying components.

A bitmask describing the comparison operations supported by IViewFilter for a particular column. If no column is specified, this is the full set of comparison operators that may be supported:

DBPROPVAL_CO_EQUALITY — Provider supports the following comparison operators:
DBCOMPAREOPS_LT
DBCOMPAREOPS_LE
DBCOMPAREOPS_EQ
DBCOMPAREOPS_GE
DBCOMPAREOPS_GT
DBCOMPAREOPS_NE

DBPROPVAL_CO_STRING — Provider supports the following comparison operator:
DBCOMPAREOPS_BEGINSWITH

DBPROPVAL_CO_CONTAINS—Provider supports the following comparison operators:
DBCOMPAREOPS_CONTAINS
DBCOMPAREOPS_NOTCONTAINS

DBPROPVAL_CO_BEGINSWITH—Provider supports the following comparison operators:
DBCOMPAREOPS_BEGINSWITH
DBCOMPAREOPS_NOTBEGINSWITH

DBPROPVAL_CO_CASESENSITIVE — Provider supports the DBCOMPAREOPS_CASESENSITIVE modifier.

DBPROPVAL_CO_CASEINSENSITIVE — Provider supports the DBCOMPAREOPS_CASEINSENSITIVE modifier.

• Providers may support one, or the other, or both of DBPROPVAL_CO_CASESENSITIVE and DBPROPVAL_CO_CASEINSENSITIVE.

A bitmask describing the comparison operations supported by IRowsetFind for a particular column. If no column is specified, this is the full set of comparison operators that may be supported:

DBPROPVAL_CO_EQUALITY — Provider supports the following comparison operators:
DBCOMPAREOPS_LT
DBCOMPAREOPS_LE
DBCOMPAREOPS_EQ
DBCOMPAREOPS_GE
DBCOMPAREOPS_GT
DBCOMPAREOPS_NE

DBPROPVAL_CO_STRING — Provider supports the following comparison operators:
DBCOMPAREOPS_BEGINSWITH

DBPROPVAL_CO_CONTAINS—Provider supports the following comparison operators:
DBCOMPAREOPS_CONTAINS
DBCOMPAREOPS_NOTCONTAINS

DBPROPVAL_CO_BEGINSWITH—Provider supports the following comparison operators:
DBCOMPAREOPS_BEGINSWITH
DBCOMPAREOPS_NOTBEGINSWITH

DBPROPVAL_CO_CASESENSITIVE — Provider supports the DBCOMPAREOPS_CASESENSITIVE modifier.

DBPROPVAL_CO_CASEINSENSITIVE — Provider supports the DBCOMPAREOPS_CASEINSENSITIVE modifier.

All providers that support IRowsetFind must support DBPROPVAL_CO_EQUALITY and DBPROPVAL_CO_STRING.

Providers may support one, or the other, or both of DBPROPVAL_CO_CASESENSITIVE and DBPROPVAL_CO_CASEINSENSITIVE.

The relationship between the columns in a GROUP BY clause and the nonaggregated columns in the select list. One of the following:

DBPROPVAL_GB_EQUALS_SELECT—The GROUP BY clause must contain all nonaggregated columns in the select list. It cannot contain any other columns. For example, SELECT DEPT, MAX(SALARY) FROM EMPLOYEE GROUP BY DEPT.

DBPROPVAL_GB_COLLATE—A COLLATE clause can be specified at the end of each grouping column.

DBPROPVAL_GB_CONTAINS_SELECT—The GROUP BY clause must contain all nonaggregated columns in the select list. It can contain columns that are not in the select list. For example, SELECT DEPT, MAX(SALARY) FROM EMPLOYEE GROUP BY DEPT, AGE.

DBPROPVAL_GB_NO_RELATION—The columns in the GROUP BY clause and the select list are not related. The meaning of nongrouped, nonaggregated columns in the select list is data source–dependent. For example, SELECT DEPT, SALARY FROM EMPLOYEE GROUP BY DEPT, AGE.

A bitmask specifying whether the provider can join tables from different catalogs or providers. A combination of zero or more of the following:

DBPROPVAL_HT_DIFFERENT_CATALOGS
DBPROPVAL_HT_DIFFERENT_PROVIDERS

If the value of any of these properties is set to VARIANT_TRUE, the rowset supports the specified interface. Providers that support an interface must support the property associated with that interface with a value of VARIANT_TRUE. These properties are primarily used to request interfaces through ICommandProperties::SetProperties.

The values of the DBPROP_IRowset, DBPROP_IAccessor, DBPROP_IColumnsInfo, DBPROP_IConvertType, and DBPROP_IRowsetInfo properties are read-only and are always VARIANT_TRUE. They cannot be set to VARIANT_FALSE. If the consumer does not set the value of any of these properties to true, the resulting rowset supports IRowset, IAccessor, IColumnsInfo, IConvertType, and IRowsetInfo.

Setting DBPROP_IRowsetLocate to VARIANT_TRUE implicitly causes the created rowset to support bookmarks and IRowsetInfo::GetProperties will return VARIANT_TRUE for the property DBPROP_BOOKMARKS. Setting DBPROP_IRowsetUpdate to VARIANT_TRUE automatically sets DBPROP_IRowsetChange to VARIANT_TRUE.

How identifiers treat case. One of the following:

DBPROPVAL_IC_UPPER—Identifiers in SQL are case insensitive and are stored in uppercase in system catalog.

DBPROPVAL_IC_LOWER—Identifiers in SQL are case insensitive and are stored in lowercase in system catalog.

DBPROPVAL_IC_SENSITIVE—Identifiers in SQL are case sensitive and are stored in mixed case in system catalog.

DBPROPVAL_IC_MIXED—Identifiers in SQL are case insensitive and are stored in mixed case in system catalog.

If the value of this property is set to VARIANT_TRUE, then the rowset is capable of manipulating the contents of columns as a storage object supporting the specified interface. The provider reports its ability to enable this property on a per-column basis by setting the flag DBPROPFLAGS_COLUMNOK. A provider that does not have the ability to turn the property on/off on a per-column basis, does not set DBPROPFLAGS_COLUMNOK. Regardless of whether the property is supported in the rowset as a whole or on a per-column basis, the ability to manipulate a column value as a storage object depends on whether the provider supports the coercion from the column's native type (BLOB or non-BLOB) to the particular storage interface.

VARIANT_TRUE—The rowset will not reorder inserted or updated rows. For IRowsetChange::InsertRow, rows will appear at the end of the rowset.

VARIANT_FALSE—If the rowset is ordered, then inserted rows and updated rows (where one or more of the columns in the ordering criteria are updated) obey the ordering criteria of the rowset. If the rowset is not ordered, then inserted rows are not guaranteed to appear in a determinate position, and the position of updated rows is not changed.

This property is meaningful only if DBPROP_OWNINSERT is VARIANT_TRUE.

Whether the index is maintained automatically when changes are made to the corresponding base table. One of the following:

VARIANT_TRUE—The index is automatically maintained.

VARIANT_FALSE—The index must be maintained by the consumer through explicit calls to IRowsetChange.

Ensuring consistency of the index as a result of updates to the associated base table is the responsibility of the consumer.

VARIANT_TRUE is always returned when using integrated indexes.

Whether an index is clustered.

VARIANT_TRUE—The leaf nodes of the index contain full rows, not bookmarks. This is a way to represent a table clustered by key value.

VARIANT_FALSE—The leaf nodes of the index contain bookmarks of the base table rows whose key value matches the key value of the index entry.

For a B+-tree index, this property represents the storage utilization factor of page nodes during the creation of the index. The value is an integer from 1 to 100 representing the percentage of use of an index node. For a linear hash index, this property represents the storage utilization of the entire hash structure (the ratio of the used area to the total allocated area) before a file structure expansion occurs.

The total number of bytes allocated to this structure at creation time.

How NULLs are collated in the index. One of the following:

DBPROPVAL_NC_END—NULLs are collated at the end of the list, regardless of the collation order.

DBPROPVAL_NC_START—NULLs are collated at the start of the list, regardless of the collation order.

DBPROPVAL_NC_HIGH—NULLs are collated at the high end of the list.

DBPROPVAL_NC_LOW—NULLs are collated at the low end of the list.

Whether NULL keys are allowed. One of the following values:

DBPROPVAL_IN_DISALLOWNULL—The index does not allow entries where the key columns are NULL. If the consumer attempts to insert an index entry with a NULL key, then the provider returns an error.

DBPROPVAL_IN_IGNORENULL—The index does not insert entries containing NULL keys. If the consumer attempts to insert an index entry with a NULL key, then the provider ignores that entry and no error code is returned.

DBPROPVAL_IN_IGNOREANYNULL—The index does not insert entries where some column key has a NULL value. For an index having a multi-column search key, if the consumer inserts an index entry with NULL value in some column of the search key, then the provider ignores that entry and no error code is returned.

Whether the index represents the primary key on the table.

How the index treats repeated keys. One of the following:

VARIANT_TRUE—The index sorts repeated keys by bookmark.

VARIANT_FALSE—The index does not sort repeated keys by bookmark.

Whether the index is temporary. One of the following:

VARIANT_TRUE—The index is destroyed when the session is released.

VARIANT_FALSE—The index is created permanently.

The type of the index. One of the following:

DBPROPVAL_IT_BTREE—The index is a B+-tree.

DBPROPVAL_IT_HASH—The index is a hash file using linear or extensible hashing.

DBPROPVAL_IT_CONTENT—The index is a content index.

DBPROPVAL_IT_OTHER—The index is some other type of index.

Whether index keys must be unique.

VARIANT_TRUE: The index keys must be unique.

VARIANT_FALSE: Duplicate keys are allowed.

A bitmask specifying the asynchronous processing performed on the data source. A combination of zero or more of the following

DBPROPVAL_ASYNCH_INITIALIZE: IDBInitialize::Initialize returns immediately, but the actual initialization of the data source is done asynchronously. The data source behaves as an unititialized data source prior to completing the initialization process, except that any call to IDBInitialize returns E_UNEXPECTED.

If no bits are set (the default), IDBInitialize::Initialize does not return until the data source is completely initialized.

The name of the initial, or default, catalog to use when connecting to the data source. If the provider supports changing the catalog for an initialized data source, the consumer can specify a different catalog name through the DBPROP_CURRENCATALOG property in the DBPROPSET_DATASOURCE property set after initialization.

The name of the database or enumerator to connect to. DBPROP_INIT_DATASOURCE is used to identify the data source to connect to, for instance a relational database server or a local file.  If the provider uses two-part naming to identify the data source, then the data source name is qualified with the location specified in DBPROP_INIT_DATASOURCE.

The window handle to be used if the data source object or enumerator needs to prompt for additional information.

The level of impersonation that the server is allowed to use when impersonating the client. This property applies only to network connections other than Remote Procedure Call (RPC) connections; these impersonation levels are similar to those provided by RPC. The values of this property correspond directly to the levels of impersonation that can be specified for authenticated RPC connections, but can be applied to connections other than authenticated RPC. One of the following:

DB_IMP_LEVEL_ANONYMOUS—The client is anonymous to the server. The server process cannot obtain identification information about the client and cannot impersonate the client.

DB_IMP_LEVEL_IDENTIFY—The server can obtain the client's identity. The server can impersonate the client for ACL checking but cannot access system objects as the client.

DB_IMP_LEVEL_IMPERSONATE—The server process can impersonate the client's security context while acting on behalf of the client. This information is obtained when the connection is established, not on every call.

DB_IMP_LEVEL_DELEGATE—The process can impersonate the client's security context while acting on behalf of the client. The server process can also make outgoing calls to other servers while acting on behalf of the client.

The locale ID of preference for the consumer. Consumers specify the LCID at initialization. This provides a method for the server to determine the consumer's LCID of choice in cases where it can use this information. This property does not guarantee that all text returned to the consumer will be translated according to the LCID.

Providers may wish to set the dwOptions of the DBPROP structure for this property to DBPROPOPTIONS_OPTIONAL.

The location of the data source or enumerator to connect to. Typically, this will be a server name. DBPROP_INIT_LOCATION is used as the first part of a two-part name to qualify the data source specified in the DBPROP_INIT_DATASOURCE property. For example, if the data source is defined on a different machine, this might be the machine name on which to look for the data source definition. This is typically not used if the provider can identify the data source using a single name, such as the name of an RDBMS server, that the consumer can use to identify the data source directly.

A bitmask specifying access permissions. A combination of zero or more of the following:

DB_MODE_READ—Read-only.

DB_MODE_WRITE—Write-only.

DB_MODE_READWRITE—Read/write (DB_MODE_READ | DB_MODE_WRITE).

DB_MODE_SHARE_DENY_READ—Prevents others from opening in read mode.

DB_MODE_SHARE_DENY_WRITE—Prevents others from opening in write mode.

DB_MODE_SHARE_EXCLUSIVE—Prevents others from opening in read/write mode (DB_MODE_SHARE_DENY_READ | DB_MODE_SHARE_DENY_WRITE).

DB_MODE_SHARE_DENY_NONE—Neither read nor write access can be denied to others.

A bitmask specifying OLE DB services to enable. A combination of zero or more of the following:

DBPROPVAL_OS_RESOURCEPOOLING—Resources should be pooled.

DBPROPVAL_OS_TXNENLISTMENT—Sessions in an MTS environment should automatically be enlisted in a global transaction where required (implies DBPROPVAL_OS_RESOURCEPOOLING).

DBPROPVAL_OS_ENABLEALL (default)—All services should be invoked. By default, all services are enabled and invoked as requested. Individual services can be deselected by specifying the bitwise-OR of DBPROPVAL_OS_ENABLEALL along with the bitwise complement of any services to be deselected. For example, DBPROPVAL_OS_ENABLEALL | ~DBPROPVAL_OS_TXNENLISTMENT enables all services except automatic transaction enlistment in an MTS environment.

Whether to prompt the user during initialization. One of the following values:

DBPROMPT_PROMPT—Always prompt the user for initialization information.

DBPROMPT_COMPLETE—Prompt the user only if more information is needed.

DBPROMPT_COMPLETEREQUIRED—Prompt the user only if more information is needed. Do not allow the user to enter optional information.

DBPROMPT_NOPROMPT—Do not prompt the user.

Information obtained from the user during prompting is available following initialization by calling GetProperties for the appropriate initialization properties.

The level of protection of data sent between client and server. This property applies only to network connections other than RPC connections; these protection levels are similar to those provided by RPC. The values of this property correspond directly to the levels of protection that can be specified for authenticated RPC connections, but can be applied to connections other than authenticated RPC. One of the following:

DB_PROT_LEVEL_NONE—Performs no authentication of data sent to the server.

DB_PROT_LEVEL_CONNECT—Authenticates only when the client establishes the connection with the server.

DB_PROT_LEVEL_CALL—Authenticates the source of the data at the beginning of each request from the client to the server.

DB_PROT_LEVEL_PKT—Authenticates that all data received is from the client.

DB_PROT_LEVEL_PKT_INTEGRITY—Authenticates that all data received is from the client and that it has not been changed in transit.

DB_PROT_LEVEL_PKT_PRIVACY—Authenticates that all data received is from the client, that it has not been changed in transit, and protects the privacy of the data by encrypting it.

A string containing provider-specific, extended connection information. Use of this property implies that the consumer knows how this string will be interpreted and used by the provider. Consumers should use this property only for provider-specific connection information that cannot be explicitly described through the property mechanism.

The amount of time (in seconds) to wait for initialization to complete.

For maximum user concurrency and component interoperability, providers for whom initialization is a potentially lengthy operation, such as connection across a network, are strongly encouraged to support this property.

For all methods returning a Rowset or View object, in addition to Rowset properties, DBPROPSET_VIEW should be set before creating a view.

VARIANT_TRUE—Bookmarks can be compared literally. That is, they can be compared as a sequence of bytes. Furthermore, if the bookmarks are ordered (as specified by the DBPROP_ORDEREDBOOKMARKS property), the bytes are guaranteed to be ordered so that an arithmetic comparison as their scalar type yields the same result as a call to IRowsetLocate::Compare. Setting the value of this property to VARIANT_TRUE automatically sets the value of DBPROP_BOOKMARKS to VARIANT_TRUE.

VARIANT_FALSE—Bookmarks can only be compared with IRowsetLocate::Compare.

VARIANT_TRUE—The consumer can perform a binary comparison of two row handles to determine whether they point to the same row.

VARIANT_FALSE—The consumer must call IRowsetIdentity::IsSameRow to determine whether two row handles point to the same row.

Whether the handle of a newly inserted row can be successfully compared to another handle is specified by the DBPROP_STRONGIDENTITY property.

For more information about row identity, see "Uniqueness of Rows in the Rowset" in Chapter 4.

The level of locking peformed by the rowset. One of the following:

DBPROPVAL_LM_NONE—The provider is not required to lock rows at any time to ensure successful updates. Updates may fail when sent to the server for reasons of concurrency (for example, if someone else has updated the row).

DBPROPVAL_LM_SINGLEROW—The provider uses the minimum level of locking necessary to ensure that changes successfully written to a single row returned by the most recent fetch will not fail due to a concurrency violation if Update is called before any additional rows are retrieved. Typically this means that the provider takes a lock on the row when SetData is first called on the row, but the provider may lock the row as early as when it is read in order to guarantee that calling Update will succeed.

Lock Mode and Isolation Level are closely related, but distinct. A consumer's isolation level specifies the isolation of that consumer from changes made by other users to the underlying data. Lock mode defines when underlying data is locked in order to ensure updates succeed. The provider may use locking in order to enforce higher levels of isolation, in which case a higher level of locking may occur than required to enforce the specified lock mode. Lock mode specifies the minimum level of locking.

The maximum number of bytes allowed in the combined columns of an index. If there is no specified limit or the limit is unknown, this value is set to zero.

The maximum number of of chapters that can be open at any time.

If a chapter must be released before a new chapter can be opened, this value is one; if the provider does not support chapters, this value is zero.

The maximum number of rows that can be active at the same time. This limit does not reflect resource limitations such as RAM, but does apply if the rowset implementation uses some strategy that results in a limit. If there is no limit, the value of this property is zero. The provider is free to support a greater number of active rows than the maximum specified by the consumer. In this case, the provider will return its actual maximum number of active rows instead of the value specified by the consumer.

The maximum number of disjunct conditions that can be supported in a view filter. Multiple conditions (rows) of a view filter are joined in a logical OR. Providers that do not support joining multiple conditions return a value of 1. Providers that do not support view filters return a value of 0.

This value applies only to the conditions that can be joined in a logical OR in a call to SetFilter; it does not imply the maximum number of OR conditions that may exist in a command.

The maximum number of rows that can have pending changes at the same time. This limit does not reflect resource limitations such as Random Access Memory (RAM), but does apply if the rowset implementation uses some strategy that results in a limit. If there is no limit, this value is zero. The provider is free to support a greater number of pending rows than the maximum specified by the consumer. In this case, the provider will return its actual maximum number of pending rows instead of the value specified by the consumer.

The maximum number of rows that can be returned in a rowset. If there is no limit, this value is zero. If the provider supports setting DBPROP_MAXROWS the provider must ensure that the rowset never contains more than the specified number of rows.

The maximum length of a single row in a table. If there is no specified limit or the limit is unknown, this value is set to zero.

VARIANT_TRUE—The maximum row size returned for the DBPROP_MAXROWSIZE property includes the length of all BLOB data.

VARIANT_FALSE—The maximum row size does not include the length of all BLOB data.

The maximum number of columns that can be supported in a View Sort. If there is no specified limit or the limit is unknown, this value is set to zero.

This value applies only to the number of sort columns that can be specified in a call to SetSortOrder; it does not imply the maximum number of columns that can be used to sort in a command.

The maximum number of tables allowed in the FROM clause of a SELECT statement. If there is no specified limit or the limit is unknown, this value is set to zero.

Whether a particular column is writable or not. This property can be set implicitly through the command used to create the rowset. For example, if the rowset is created by the SQL statement SELECT A, B FROM MyTable FOR UPDATE OF A, then this property is VARIANT_TRUE for column A and VARIANT_FALSE for column B.

This property estimates the amount of memory that can be used by the rowset. If it is 0, the rowset can use unlimited memory. If it is between 1 and 99 inclusive, the rowset can use the specified percentage of total available virtual memory (physical and page file). If it is greater than or equal to 100, the rowset can use up to the specified number of kilobytes of memory.

Some providers may have to spawn multiple connections to the database in order to support multiple concurrent Commands, Sessions, and Rowsets. Such providers may expose DBPROP_MULTIPLECONNECTIONS in order to let the consumer disable making additional connections under the covers. Providers that can support multiple concurrent Commands, Sessions, and Rowsets without spawning multiple connections do not support this property.

VARIANT_TRUE (default)—The provider silently creates additional connections as required in order to support concurrent Command, Session, and Rowset objects.

VARIANT_FALSE—The provider returns DB_E_OBJECTOPEN if a method would require spawning an additional connection to the database.

VARIANT_TRUE—The provider supports multiple parameter sets.

VARIANT_FALSE—The provider supports only a single set of parameters per execution.

All providers that support parameters must support this property. Providers that do not support parameters must not support this property.

A bitmask specifying whether the provider supports multiple results objects and what restrictions it places on these objects. A combination of zero or more of the following:

DBPROPVAL_MR_SUPPORTED—The provider supports multiple results objects.

DBPROPVAL_MR_CONCURRENT—More than one rowset created by the same multiple results object can exist concurrently. If this bit is not set, the consumer must release the current rowset before calling IMultipleResults::GetResult to get the next result.

If multiple results objects are not supported, DBPROPVAL_MR_NOTSUPPORTED is returned. For more information about multiple results, see "Multiple Results" in Chapter 3.

VARIANT_TRUE—The provider supports multiple, open storage objects at the same time.

VARIANT_FALSE—The provider supports only one open storage object at a time. Any method that attempts to open a second storage object returns a status of DBSTATUS_E_CANTCREATE for the column on which it attempted to open the second storage object, regardless of whether the objects are constructed over the same column, different columns in the same row, or different rows.

VARIANT_TRUE—The provider can update rowsets derived from multiple tables.

VARIANT_FALSE—The provider cannot update rowsets derived from multiple tables.

DBPROPVAL_NT_SINGLEROW—For methods that operate on multiple rows, the provider calls IRowsetNotify::OnRowChange separately for each phase for each row. A cancellation affects a single row; it does not affect the other rows, and notifications are still sent for these rows.

DBPROPVAL_NT_MULTIPLEROWS—For methods that operate on multiple rows, then for each phase, the provider calls OnRowChange once for all rows that succeed and once for all rows that fail. This separation can occur at each phase where a change can fail. For example, if IRowsetChange::DeleteRows deletes some rows and fails to delete others during the Preliminary Work phase, it calls OnRowChange twice: once with DBEVENTPHASE_SYNCHAFTER and the array of handles of rows that it deleted, and once with DBEVENTPHASE_FAILEDTODO and the array of handles of rows it failed to delete. A cancellation affects all rows with handles that were passed to OnRowChange.

DBPROP_NOTIFICATIONGRANULARITY does not affect how providers return notifications about events that affect columns or the entire rowset.

A bitmask specifying the notification phases supported by the provider. A combination of two or more of the following:

DBPROPVAL_NP_OKTODO
DBPROPVAL_NP_ABOUTTODO
DBPROPVAL_NP_SYNCHAFTER
DBPROPVAL_NP_FAILEDTODO
DBPROPVAL_NP_DIDEVENT

The DBPROPVAL_NP_FAILEDTODO and DBPROPVAL_NP_DIDEVENT bits must be returned by all providers that support notifications.

A bitmask specifying whether the notification phase is cancelable. A combination of zero or more of the following:

DBPROPVAL_NP_OKTODO
DBPROPVAL_NP_ABOUTTODO
DBPROPVAL_NP_SYNCHAFTER

Where NULLs are sorted in a list. One of the following:

DBPROPVAL_NC_END—NULLs are sorted at the end of the list, regardless of the sort order.

DBPROPVAL_NC_HIGH—NULLs are sorted at the high end of the list.

DBPROPVAL_NC_LOW—NULLs are sorted at the low end of the list.

DBPROPVAL_NC_START—NULLs are sorted at the start of the list, regardless of the sort order.

A bitmask specifying the ways in which the provider supports access to BLOBs and OLE objects stored in columns. A combination of zero or more of the following:

DBPROPVAL_OO_BLOB—The provider supports access to BLOBs as structured storage objects. A consumer determines what interfaces are supported through DBPROP_STRUCTUREDSTORAGE.

DBPROPVAL_OO_IPERSIST—The provider supports access to OLE objects through IPersistStream, IPersistStreamInit, or IPersistStorage.

VARIANT_TRUE—Columns in an ORDER BY clause must be in the select list.

VARIANT_FALSE—Columns in an ORDER BY clause are not required to be in the select list.

VARIANT_TRUE—Bookmarks can be compared to determine the relative position of their associated rows in the rowset. Setting the value of this property to VARIANT_TRUE automatically sets the value of DBPROP_BOOKMARKS to VARIANT_TRUE.

VARIANT_FALSE—Bookmarks can only be compared for equality.

Whether bookmarks can be compared byte-by-byte or must be compared with IRowsetLocate::Compare depends on the value of the DBPROP_LITERALBOOKMARKS property.

VARIANT_TRUE—The rowset can see rows inserted by someone other than a consumer of the rowset. That is, if someone other than a consumer of the rowset inserts a row, any consumer of the rowset can see that row the next time it fetches a set of rows containing it. This includes rows inserted by other parties in the same transaction, as well as rows inserted by parties outside the transaction.

The transaction isolation level does not affect the ability of the rowset to see rows inserted by other parties in the same transaction, such as other rowsets in the same session. However, it does restrict the ability of the rowset to see rows inserted by parties outside the transaction.

VARIANT_FALSE—The rowset cannot see rows inserted by others.

For programmers accustomed to the cursor model in ODBC, the DBPROP_OTHERUPDATEDELETE and DBPROP_OTHERINSERT properties correspond to ODBC cursors as follows:

Static cursor:
DBPROP_OTHERINSERT = VARIANT_FALSE
DBPROP_OTHERUPDATEDELETE =
VARIANT_FALSE

Keyset-driven cursor:
DBPROP_OTHERINSERT = VARIANT_FALSE
DBPROP_OTHERUPDATEDELETE =
VARIANT_TRUE

Dynamic cursor:
DBPROP_OTHERINSERT = VARIANT_TRUE
DBPROP_OTHERUPDATEDELETE =
VARIANT_TRUE

Furthermore, the DBPROP_OWNUPDATEDELETE and DBPROP_OWNINSERT properties correspond to the values returned by the SQL_STATIC_SENSITIVITY information type in SQLGetInfo in ODBC.

For a description of how these properties relate to transaction isolation level, see "Visibility of Other Changes" in Chapter 5.

VARIANT_TRUE—The rowset can see updates and deletes made by someone other than a consumer of the rowset. That is, suppose someone other than a consumer of the rowset updates the data underlying a row or deletes the row. If the row is released completely, any consumer of the rowset will see that change the next time it fetches the row. This includes updates and deletes made by other parties in the same transaction, as well as updates and deletes made by parties outside the transaction.

The transaction isolation level does not affect the ability of the rowset to see updates or deletes made by other parties in the same transaction, such as other rowsets in the same session. However, it does restrict the ability of the rowset to see updates or deletes made by parties outside the transaction.

VARIANT_FALSE—The rowset cannot see updates and deletes made by others.

For information about how this relates to the cursor types in ODBC, see the DBPROP_OTHERINSERT property.

The time at which output parameter values become available. One of the following:

DBPROPVAL_OA_NOTSUPPORTED—Output parameters are not supported.

DBPROPVAL_OA_ATEXECUTE—Output parameter data is available immediately after ICommand::Execute returns.

DBPROPVAL_OA_ATROWRELEASE—If a command returns a single result that is a rowset, output parameter data is available at the time the rowset is completely released. If a command returns multiple results, output parameter data is available when IMultipleResults::GetResult returns DB_S_NORESULT or the multiple results object is completely released, whichever occurs first. Before the output parameter data is available, the consumer's bound memory is in an indeterminate state. For more information about multiple results, see "Multiple Results" in Chapter 3.

VARIANT_TRUE—The rowset can see its own inserts. That is, if a consumer of a rowset inserts a row, any consumer of the rowset can see that row the next time it fetches a set of rows containing it.

This ability is independent of the transaction isolation level, because all consumers of the rowset share the same transaction.

VARIANT_FALSE—The rowset cannot see rows inserted by consumers of the rowset unless the command is re-executed.

For information about how this relates to the SQL_STATIC_SENSITIVITY information type in ODBC, see the DBPROP_OTHERINSERT property.

VARIANT_TRUE—The rowset can see its own updates and deletes. That is, suppose a consumer of the rowset updates or deletes a row. If the row is released completely, any consumer of the rowset will see the update or delete the next time it fetches that row.

This ability is independent of the transaction isolation level because all consumers of the rowset share the same transaction.

VARIANT_FALSE—The rowset cannot see updates and deletes made by consumers of the rowset unless the command is re-executed.

For information about how this relates to the SQL_STATIC_SENSITIVITY information type in ODBC, see the DBPROP_OTHERINSERT property.

An integer specifying the type of DBID that the provider uses when persisting DBIDs for tables, indexes, and columns. This is generally the type of DBID that the provider considers to be the most permanent under schema changes and physical data reorganizations. One of the following:

DBPROPVAL_PT_NAME
DBPROPVAL_PT_PROPID
DBPROPVAL_PT_GUID
DBPROPVAL_PT_GUID_NAME
DBPROPVAL_PT_GUID_PROPID
DBPROPVAL_PT_PGUID_NAME
DBPROPVAL_PT_PGUID_PROPID

How aborting a transaction affects prepared commands. One of the following:

DBPROPVAL_CB_DELETE—Aborting a transaction deletes prepared commands. The application must reprepare commands before executing them.

DBPROPAL_CB_PRESERVE—Aborting a transaction preserves prepared commands. The application can re-execute commands without repreparing them.

How committing a transaction affects prepared commands. One of the following:

DBPROPVAL_CB_DELETE—Committing a transaction deletes prepared commands. The application must reprepare commands before executing them.

DBPROPAL_CB_PRESERVE—Committing a transaction preserves prepared commands. The application can re-execute commands without repreparing them.

A character string with the data source vendor's name for a procedure; for example, "database procedure", "stored procedure", or "procedure". This is used for building user interfaces.

The friendly name of the provider, for example "Microsoft OLE DB Provider for ODBC Drivers".

The filename of the provider; for example, "MYPRVDR.DLL".

The version of OLE DB supported by the provider. The version is of the form ##.##, where the first two digits are the major version and the next two digits are the minor version. For example, OLE DB providers conforming to the 1.5 specification would return "01.50".

The version of the provider. The version is of the form ##.##.####, where the first two digits are the major version, the next two digits are the minor version, and the last four digits are the release version. The provider can append a description of the provider.

This is the same as DBPROP_DBMSVER if the DBMS is the same as the provider; that is, if the DBMS supports OLE DB interfaces directly. It is different if the provider is separate from the DBMS, such as when the provider accesses the DBMS through ODBC.

VARIANT_TRUE—IRowset::RestartPosition is relatively quick to execute. In particular, it does not reexecute the command that created the rowset.

VARIANT_FALSE—RestartPosition is expensive to execute and requires reexecuting the command that created the rowset.

Although the value of this property can be set to VARIANT_TRUE, the provider is not required to honor it. The reason for this is that the provider does not know what the command is at the time the property is set; in particular, the consumer can set this property and then change the command text. However, the provider can fail this property if it is never able to quickly restart the next fetch position. Thus, if a consumer successfully sets this property, it must still check this flag on the rowset to determine if the next fetch position can be quickly set.

How quoted identifiers treat case. One of the following:

DBPROPVAL_IC_UPPER—Quoted identifiers in SQL are case insensitive and are stored in uppercase in system catalog.

DBPROPVAL_IC_LOWER—Quoted identifiers in SQL are case insensitive and are stored in lowercase in system catalog.

DBPROPVAL_IC_SENSITIVE—Quoted identifiers in SQL are case sensitive and are stored in mixed case in system catalog.

DBPROPVAL_IC_MIXED—Quoted identifiers in SQL are case insensitive and are stored in mixed case in system catalog.

VARIANT_TRUE—The provider supports reentrancy during callbacks to the IRowsetNotify interface. The provider might not support reentrancy on all rowset methods. These methods return DB_E_NOTREENTRANT.

VARIANT_FALSE—The provider does not support such reentrancy. The provider returns DB_E_NOTREENTRANT on methods called during the notification.

Regardless of this flag, all providers must support IRowset::GetData and IRowset::ReleaseRows calls during notifications, so long as the columns being accessed do not include deferred columns.

If the value of this property is VARIANT_TRUE, the provider removes rows it detects as having been deleted from the rowset. That is, fetching a block of rows that formerly included a deleted row does not return a handle to that row.

Which rows the rowset detects as having been deleted is determined by the DBPROP_OWNUPDATEDELETE and DBPROP_OTHERUPDATEDELETE properties; whether the rowset removes these rows is determined by this property.

This property is independent of the transaction isolation level. While the transaction isolation level in some cases determines whether the rowset can detect a row as having been deleted, it has no effect on whether or not the rowset removes that row.

For programmers accustomed to the cursor model in ODBC, the value of this property is always VARIANT_TRUE for rowsets implemented through dynamic cursors; that is, dynamic cursors always remove deleted rows. Whether static and keyset-driven cursors remove deleted rows depends on the value of this property.

VARIANT_TRUE—An update or delete can affect multiple rows and the provider can detect that multiple rows have been updated or deleted. This happens when a provider cannot uniquely identify a row. For example, the provider might use the values of all the columns in the row to identify the row; if these columns do not include a unique key, an update or delete might affect more than one row.

VARIANT_FALSE—An update or delete always affects a single row or the provider cannot detect whether it affects multiple rows.

A bitmask specifying the data source state to be reset.  A combination of zero or more of the following:

DBPROPVAL_RD_RESETALL—The provider should reset all states associated with the data source, such that the DSO appears as if it were newly initialized, with the exception that any open object is not released.

DBPROP_RESETDATASOURCE is generally used by a consumer in order to reuse an existing data source object without paying the cost of uninitializing and reinitializing the DSO.

VARIANT_TRUE—The methods that fetch rows, such as IRowset::GetNextRows, can return pending insert rows; that is, rows that have been inserted in delayed update mode but for which IRowsetUpdate::Update has not yet been called.

VARIANT_FALSE—The methods that fetch rows cannot return pending insert rows.

A bitmask describing optimizations that a provider may take for updates to the rowset. These optimizations are usually used for things like bulk loading of a table. The following values can be specified, and are usually set as OPTIONAL properties because they are hints to the provider. Additional bits may be defined in the future; providers should be prepared to handle new bits in this bitmask by ignoring them if the property is set as optional, or returning an error if the property is set as required.

DBPROPVAL_BO_NOLOG—The provider is not required to log inserts or changes to the rowset.

DBPROPVAL_BO_NOINDEXUPDATE—The provider is not required to update indexes based on inserts or changes to the rowset. Any indexes need to be re-created following changes made through the rowset.

DBPROPVAL_BO_REFINTEGRITY—Referential Integrity constraints do not need to be checked or enforced for changes made through the rowset.

VARIANT_TRUE—Access rights are restricted on a row-by-row basis. If the rowset supports IRowsetChange, IRowsetChange::SetData can be called for some but not all rows. A rowset must never count or return a handle for a row for which the consumer does not have read access rights.

VARIANT_FALSE—Access rights are not restricted on a row-by-row basis. If the rowset supports IRowsetChange, SetData can be called for any row.

For more information, see DBPROP_COLUMNRESTRICT.

A bitmask specifying the asynchronous processing performed on the rowset. A combination of zero or more of the following:

DBPROPVAL_ASNYCH_INITIALIZE: The rowset is initialized asynchronously. The method requesting the rowset returns immediately, but attempting to call any interface other than IConnectionPointContainer to obtain the IID_IDBAsynchNotify connection point may fail and the full set of interfaces may not be available on the rowset until asynchronous initialization has completed.

DBPROPVAL_ASNYCH_SEQUENTIALPOPULATION: The rowset is sequentially asynchronously populated; requests for rows may return DB_S_ENDOFROWSET before the end of the rowset is actually reached. Asynchronously populated rows are always added to the end of the rowset.

DBPROPVAL_ASNYCH_RANDOMPOPULATION: The rowset is randomly asynchronously populated; requests for rows may return DB_S_ENDOFROWSET before the end of the rowset is actually reached. Asynchronously populated rows may be inserted anywhere in the rowset.

The consumer may set both DBPROPVAL_ASNYCH_SEQUENTIALPOPULATION and DBPROPVAL_ASNYCH_RANDOMPOPULATION bits to request that the rowset be asynchronously populated either sequentially or randomly. The consumer is prepared for asynchronous notifications in OnRowChange as well as from IDBAsynchStatus. Only one property is returned by the rowset; if the rowset is asynchronously populated it returns either DBPROPVAL_ASNYCH_RANDOM or DBPROPVAL_ASNYCH_SEQUENTIAL.

If no bits are set (the default) the rowset is initialized and populated synchronously. All requested interfaces are available when the method requesting the rowset returns and requesting rows block until the requested number of hRows are obtained or the end of the rowset is reached.

DBPROPVAL_ASYNCH_BACKGROUNDPOPULATION: The rowset is to be populated asynchronously in the background. The rowset supports IDBAsynchStatus in order to get information about the population of the rowset or abort background population, and may support the connection point for IDBAsynchNotify to give status of the background population. DBPROPVAL_ASYNCH_BACKGROUNDPOPULATION is implied by DBPROPVAL_ASYNCH_SEQUENTIALPOPLUATION and DBPROPVAL_ASYNCH_RANDOMPOPULATION, however, if DBPROPVAL_ASYNCH_SEQUENTIALPOPLUATION or DBPROPVAL_ASYNCH_RANDOMPOPLUATION are not also set, the rowset appears to the consumer as if it were being populated synchronously in that requesting rows will always block until the requested number of hRows are obtained or the end of the rowset is reached.

DBPROPVAL_ASYNCH_PREPOPULATE: The consumer prefers to optimize for retrieving all data when the rowset is materialized. This is a hint to the provider to fetch all of the data up-front. DBPROPVAL_ASYNCH_PREPOPULATE is only a hint to the provider, the provider should never fail opening the rowset based on the setting of this flag, and need not return it to the consumer, even if the rowset is prepopulated.

DBPROPVAL_ASYNCH_POPULATEONDEMAND: The consumer prefers to optimize for getting each individual request for data returned as quickly as possible. This is a hint to the provider to populate the rowset as the data is fetched. DBPROPVAL_ASYNCH_POPULATEONDEMAND is only a hint to the provider, the provider should never fail opening the rowset based on the setting of this flag, and need not return it to the consumer, even if the rowset is populated on demand.

Since DBPROPVAL_ASYNCH_PREPOPULATE and DBPROPVAL_ANSYCH_POPULATEONDEMAND are just hints to the provider, if the consumer sets one or both of these properties in addition to the asychronous population properties DBPROPVAL_ASYNCH_SEQUENTIALPOPULATION or DBPROPVAL_ASYNCH_RANDOMPOPULATION, then the provider should attempt to populate asynchronously according to DBPROPVAL_ASYNCH_SEQUENTIALPOPULATION and DBPROPVAL_ASYNCH_RANDOMPOPULATION. If the asynchronous population specified by DBPROPVAL_ASYNCH_SEQUENTIALPOPULATION or DBPROPVAL_ASYNCH_RANDOMPOPULATION can not be supported, the provider should fail if DBPROPOPTIONS_REQUIRED was specified for the property, or attempt to populate synchronously according to DBPROPVAL_ASYNCH_PREPOPULATE or DBPROPVAL_ASYNCH_POPULATEONDEMAND if the property was set with DBPROPOPTIONS_OPTIONAL.

VARIANT_TRUE—Callers to IConvertType::CanConvert can inquire on a command about conversions supported on rowsets generated by the command.

VARIANT_FALSE—Callers can inquire on a command only about conversions supported by the command.

A bitmask specifying the threading models supported by the rowset. A combination of one or more of the following:

DBPROPVAL_RT_FREETHREAD
DBPROPVAL_RT_APTMTTHREAD
DBPROPVAL_RT_SINGLETHREAD

The name the data source uses for a schema; for example, "schema" or "owner". This is used for building user interfaces.

A bitmask specifying how schema names can be used in text commands. A combination of zero or more of the following:

DBPROPVAL_SU_DML_STATEMENTS—Schema names are supported in all Data Manipulation Language statements.

DBPROPVAL_SU_TABLE_DEFINITION—Schema names are supported in all table definition statements.

DBPROPVAL_SU_INDEX_DEFINITION—Schema names are supported in all index definition statements.

DBPROPVAL_SU_PRIVILEGE_DEFINITION—Schema names are supported in all privilege definition statements.

If the value of this property is set to VARIANT_TRUE with ICommandProperties::SetProperties, the cursor underlying the rowset (if any) must be materialized on the server.

If the value of this property is not set to VARIANT_TRUE with ICommandProperties::SetProperties, it is up to the provider to decide where to materialize the cursor.

The consumer can determine where the cursor was materialized by checking the value of this property on the rowset.

VARIANT_TRUE—At the time an insert is transmitted to the server (when InsertRow is called in immediate mode, or when Update is called for an inserted row in deferred update mode), the provider retrieves data from the server to update the local row cache.

VARIANT_FALSE—The provider does not retrieve server values for newly inserted rows.  The consumer can only retrieve data values explicitly set in the call to InsertRow, or by calls to SetData for the hRow returned by InsertRow.

Consumers should be aware that setting DBPROP_SERVERDATAONINSERT is potentially expensive, and may not be supported for certain types of rowsets.

The name of the server. This may be the same as the DBPROP_INIT_DATASOURCE property if the server name is used to define the data source that the user specifies when connecting, or may be the actual name of the server if the provider connects through "friendly" data source names.

A bitmask specifying the transaction isolation level while in auto-commit mode. The values that can be set in this bitmask are the same as those that can be set for DBPROP_SUPPORTEDTXNISOLEVELS.

VARIANT_TRUE: The provider supports SetSortOrder only for columns contained in an index.

VARIANT_FALSE: The provider does not require columns to be indexed in order to be specified in SetSortOrder, or the provider does not support SetSortOrder.

This value applies only to the ability to specify a column in SetSortOrder; it does not imply whether or not nonindexed columns can be used in the order clause of a command.

A bitmask specifying the level of support for SQL. A combination of zero or more of the following:

DBPROPVAL_SQL_NONE—SQL is not supported.

DBPROPVAL_SQL_ODBC_MINIMUM
DBPROPVAL_SQL_ODBC_CORE
DBPROPVAL_SQL_ODBC_EXTENDED—These levels correspond to the levels of SQL conformance defined in ODBC version 2.5. These levels are cumulative. That is, if the provider supports one level, it also sets the bits for all lower levels. For example, if the provider sets the DBPROPVAL_SQL_ODBC_CORE bit, it also sets the DBPROPVAL_SQL_ODBC_MINIMUM bit.

DBPROPVAL_SQL_ESCAPECLAUSES—The provider supports the ODBC escape clause syntax.

DBPROPVAL_SQL_ANSI92_ENTRY
DBPROPVAL_SQL_FIPS_TRANSITIONAL
DBPROPVAL_SQL_ANSI92_INTERMEDIATE
DBPROPVAL_SQL_ANSI92_FULL—These levels correspond to the levels in ANSI SQL92. These levels are cumulative. That is, if the provider supports one level, it also sets the bits for all lower levels.

DBPROPVAL_SQL_ANSI89_IEF—The provider supports the ANSI89 Integrity Enhancement Facility.

DBPROPVAL_SQL_SUBMINIMUM—The provider supports the DBGUID_SQL dialect and parses the command text according to SQL rules, but does not support either the minimum ODBC level nor the ANSI SQL92 Entry level. This level is not accumulative; providers that support at least the minimal ODBC Level or ANSI SQL92 Entry Level do not set this bit. OLE DB consumers can determine whether or not the provider supports the DBGUID_SQL dialect by verifying that the DBPROPVAL_SQL_NONE bit is not set.

VARIANT_TRUE—The handles of newly inserted rows can be compared as specified by DBPROP_LITERALIDENTITY.

VARIANT_FALSE—There is no guarantee that the handles of newly inserted rows can be compared successfully. In this case, IRowsetIdentity::IsSameRow might return DB_E_NEWLYINSERTED.

A newly inserted row is defined as a row for which an insertion has been transmitted to the data source, as opposed to a pending insert row. For more information, see "Uniqueness of Rows in the Rowset" in Chapter 4.

A bitmask specifying what interfaces the rowset supports on storage objects. If a provider can support any of these interfaces it is also required to support ISequentialStream. A combination of zero or more of the following:

DBPROPVAL_SS_ISEQUENTIALSTREAM
DBPROPVAL_SS_ISTREAM
DBPROPVAL_SS_ISTORAGE
DBPROPVAL_SS_ILOCKBYTES

A bitmask specifying the predicates in text commands that support subqueries. A combination of zero or more of the following:

DBPROPVAL_SQ_CORRELATEDSUBQUERIES
DBPROPVAL_SQ_COMPARISON
DBPROPVAL_SQ_EXISTS
DBPROPVAL_SQ_IN
DBPROPVAL_SQ_QUANTIFIED

The DBPROPVAL_SQ_CORRELATEDSUBQUERIES bit indicates that all predicates that support subqueries support correlated subqueries.

Whether Data Definition Language (DDL) statements are supported in transactions. One of the following:

DBPROPVAL_TC_NONE—Transactions are not supported.

DBPROPVAL_TC_DML—Transactions can only contain Data Manipulation Language (DML) statements. DDL statements within a transaction cause an error.

DBPROPVAL_TC_DDL_COMMIT—Transactions can only contain DML statements. DDL statements within a transaction cause the transaction to be committed.

DBPROPVAL_TC_DDL_IGNORE—Transactions can only contain DML statements. DDL statements within a transaction are ignored.

DBPROPVAL_TC_ALL—Transactions can contain DDL and DML statements in any order.

A bitmask specifying the supported transaction isolation levels. A combination of zero or more of the following:

DBPROPVAL_TI_CHAOS
DBPROPVAL_TI_READUNCOMMITTED
DBPROPVAL_TI_BROWSE
DBPROPVAL_TI_CURSORSTABILITY
DBPROPVAL_TI_READCOMMITTED
DBPROPVAL_TI_REPEATABLEREAD
DBPROPVAL_TI_SERIALIZABLE
DBPROPVAL_TI_ISOLATED

For more information, see "Isolation Levels" in Chapter 12.

A bitmask specifying the supported transaction isolation retention levels. A combination of zero or more of the following:

DBPROPVAL_TR_COMMIT_DC—The transaction may either preserve or dispose of isolation context across a retaining commit.

DBPROPVAL_TR_COMMIT—The transaction preserves its isolation context (that is, it preserves its locks, if that is how isolation is implemented) across a retaining commit.

DBPROPVAL_TR_COMMIT_NO—The transaction is explicitly not to preserve isolation across a retaining commit.

DBPROPVAL_TR_ABORT_DC—The transaction may either preserve or dispose of isolation context across a retaining abort.

DBPROPVAL_TR_ABORT—The transaction preserves its isolation context across a retaining abort.

DBPROPVAL_TR_ABORT_NO—The transaction is explicitly not to preserve isolation across a retaining abort.

DBPROPVAL_TR_DONTCARE—The transaction may preserve or dispose of isolation context across a retaining commit or abort. This is the default.

DBPROPVAL_TR_BOTH—Isolation is preserved across both a retaining commit and a retaining abort.

DBPROPVAL_TR_NONE—Isolation is explicitly not to be retained across either a retaining commit or abort.

DBPROPVAL_TR_OPTIMISTIC—Optimistic concurrency control is to be used. If DBPROPVAL_TR_OPTIMISTIC is specified, then whatever isolation technology is in place (such as locking), it must be the case that other transactions' ability to make changes to the data and resources manipulated by this transaction is not in any way affected by the data read or updated by this transaction. That is, optimistic control is to be used for all data in the transaction.

For more information, see ITransactionLocal::StartTransaction.

The name the data source uses for a table; for example, "table" or "file". This is used for building user interfaces.

Whether the table is temporary. One of the following:

VARIANT_TRUE—The table is destroyed when the session is released.

VARIANT_FALSE—The table is created permanently.

VARIANT_TRUE—Any object created on the specified column is transacted. That is, data made visible to the data source through the object can be committed with ITransaction::Commit or aborted with ITransaction::Abort.

VARIANT_FALSE—Any object created on the specified column is not transacted. That is, all changes to the object are permanent once they are made visible to the data source.

If this property is set on a column that does not contain an object, it is ignored.

VARIANT_TRUE—Each row is uniquely identified by its column values.

VARIANT_FALSE—Rows in the rowset may or may not be uniquely identified by their column values.

If this property is set to VARIANT_TRUE when opening the rowset, the provider adds additional columns, if necessary, in order to ensure that each row is uniquely identified by its values. These additional columns appear at the end of the rowset, have a DBID of type DBKIND_GUID_PROPID, DBKIND_PGUID_PROPID, DBKIND_GUID_NAME, or DBKIND_PGUID_NAME, and the guid (or pguid) element is (or points to) DBCOL_SPECIALCOL.  These columns are typically not displayed to the user, but are used by components such as update services to uniquely identify a row.

The provider may, but is not required to, duplicate existing columns in the rowset in order to make sure key columns are included.

If this property is set to VARIANT_TRUE, and the provider supports the optional IColumnsRowset metadata column DBCOLUMN_KEYCOLUMN, then the set of columns which uniquely identify the row have a value of VARIANT_TRUE in the DBCOLUMN_KEYCOLUMN column returned by IColumnsRowset. This may be a subset of the columns in the row, or all of the columns if the provider cannot determine a proper subset that uniquely identifies the row. If this property is not VARIANT_TRUE, then DBCOLUMN_KEYCOLUMN may or may not be set to VARIANT_TRUE for key columns, but there is no guarantee that the set of columns that are flagged with this value are sufficient in order to uniquely identify the row.

A bitmask specifying the supported methods on IRowsetChange. A combination of zero or more of the following:

DBPROPVAL_UP_CHANGE—SetData is supported.

DBPROPVAL_UP_DELETE—DeleteRows is supported.

DBPROPVAL_UP_INSERT—InsertRow is supported.

DBPROP_UPDATABILITY should be used in conjunction with DBPROP_IRowsetChange. If DBPROP_IRowsetChange is VARIANT_TRUE and DBPROP_UPDATABILITY is not set, then it is provider-specific what methods are supported on IRowsetChange.

If DBPROP_UPDATABILITY is specified, then the provider must not support any methods whose bits are not set.

A character string with the name used in a particular database, which can be different than a login name.