Rowset Properties

Typical R/W: R Only

Description: Preserve on Abort

Specifies values as either of:

• VARIANT_TRUE, which indicates that, after an abort that preserves, the rowset remains active. Therefore, it is possible to manipulate rows.
  
  
• VARIANT_FALSE, which indicates that, after an abort, or an abort that preserves, the only operations allowed on a rowset are to release row and accessor handles and to release the rowset.

Typical R/W: R/W

Description: Append-Only Rowset

If the value is VARIANT_TRUE, when a rowset is opened it will initially be 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 the rowset was obtained by executing a command, this is equivalent to placing the start of the rowset at the end of the command’s results. A rowset opened with 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_TRUE.

Typical R/W: R Only

Description: Blocking Storage Objects

Specifies whether storage objects might prevent use of other methods on the rowset, that is:

• VARIANT_TRUE, which indicates that, after creating an instance of a storage object, use of other methods on the rowset might be prevented. That is, after a storage object is created and before it is released, methods other than those on the storage objects might return E_UNEXPECTED.
  
  
• VARIANT_FALSE, which indicates that creating instances of storage objects does not prevent the use of other methods.

Typical R/W: R/W

Description: Use Bookmarks

Specifies whether the rowset supports bookmarks, that is:

• VARIANT_TRUE, which indicates that 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, which indicates that 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

Typical R/W: R Only

Description: Skip Deleted Bookmarks

Specifies whether the rowset allows IRowsetLocate::GetRowsAt 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.

Specifies values as either of:

• VARIANT_TRUE, which indicates that GetRowsAt or FindNextRow skips the bookmark row and continues with the next row.
  
  
• VARIANT_FALSE, which indicates that GetRowsAt or FindNextRow returns DB_E_BADBOOKMARK

Typical R/W: R Only

Description: BookMark Type

Specifies the bookmark type supported by the rowset, that is:

• DBPROPVAL_BMK_NUMERIC, which indicates that the bookmark type is numeric. Numeric bookmarks are based on a row's properties that are not dependent on the values of the row’s columns. For instance, a numeric bookmark can be based on the absolute position of the row within rowset, or on a row ID that the storage engine assigned to a tuple when it was created. The validity of numeric bookmarks is not changed by modifying the row’s columns.
  
  
• DBPROPVAL_BMK_KEY, which indicates that 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.

Typical R/W: R Only

Description: Cache Deferred Columns

Specifies values as either of:

• VARIANT_TRUE, which indicates that the provider caches the value of a deferred column when the consumer first gets a value from this column. When the consumer later gets values from this column, the provider returns the value in the cache. The contents of the cache can be overwritten by IRowsetChange::SetData or IRowsetResynch::ResynchRows. The cached value is released when the row is released. Consumers should set the value of this property to VARIANT_TRUE  only when this is absolutely necessary, as this might require a large amount of memory in the provider. This could limit the number of rows that can be held at one time. Setting the values of this property to VARIANT_TRUE automatically sets the DBPROP_DEFERRED property to VARIANT_TRUE.
  
  
• VARIANT_FALSE, which indicates that the provider does not cache the value of a deferred column and multiple calls to IRowset::GetData as the column can return different values.

Typical R/W: R/W

Description: Fetch Backwards

Specifies whether the rowset can fetch backwards, that is:

• VARIANT_TRUE, which indicates that cRows in IRowset::GetNextRows, IRowsetLocate::GetRowsAt, and IRowsetScroll::GetRowsAtRatio can be negative. When it is negative, these methods fetch rows backwards from the specified row.
  
  
• VARIANT_FALSE, which indicates that cRows must be non-negative.

Typical R/W: R/W

Description: Hold Rows

Specifies values as either of:

• VARIANT_TRUE, which indicates that 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, which indicates that 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.

Typical R/W: R/W

Description: Scroll Backwards

Specifies whether the rowset can scroll backward, that is:

• VARIANT_TRUE, which indicates that IRowsOffset in IRowset::GetNextRows or IRowsetLocate::GetRowsAt can be negative.
  
  
• VARIANT_FALSE, which indicates that IRowsOffset must be non-negative.

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

Typical R/W: R/W

Description: Change Inserted Rows

Specifies values as either of:

• VARIANT_TRUE, which indicates that the consumer can call IRowsetChange::DeleteRows or IRowsetChange::SetData for newly inserted rows.
  
  
• VARIANT_FALSE, which indicates whether 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 as a row for which the insertion has been transmitted to the data source, as opposed to a pending insert row.

Typical R/W: R Only

Description: Column Privileges

Specifies values as either of:

• VARIANT_TRUE, which indicats that 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, which indicates that 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, individual columns of particular rows might have their own stricter access rights, and the consumer may not 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.

Typical R/W: Not Supported

Description: Command Time-out

Specifies the number of seconds before a command times out. A value of 0 indicates an infinite time-out.

Typical R/W: R Only

Description: Preserve On Commit

Specifies values as either of:

• VARIANT_TRUE, which indicates that after a commit that preserves, the rowset remains active. That is, it is possible to fetch new rows, update, delete, and insert rows, and so on.
  
  
• VARIANT_FALSE, which indicates that after a commit or a commit that preserves, the only operations allowed on a rowset are to release row and accessor handles and to release the rowset.

Typical R/W: R Only

Description: Defer Column

Specifies values as either of:

• VARIANT_TRUE, which indicates that the data in the column is not fetched until an accessor is used on the column.
  
  
• VARIANT_FALSE, which indicates that 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.

Typical R/W: R Only

Description: Delay Storage Object Updates

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, and 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.

DBPROP_ICOLUMNSINFO

DBPROP_ICOLUMNSROWSET

DBPROP_ICONNECTIONPOINTCONTAINER

DBPROP_ICONVERTTYPE

DBPROP_IROWSET

DBPROP_IROWSETCHANGE

DBPROP_IROWSETIDENTITY

DBPROP_IROWSETINFO

DBPROP_IROWSETLOCATE

DBPROP_IROWSETRESYNCH

DBPROP_IROWSETSCROLL

DBPROP_IROWSETUPDATE

DBPROP_ISUPPORTERRORINFO

Typical R/W: R/W, except as noted below.

Description: IAccessor

                        IColumnsInfo

                        IColumnsRowset

                        IConnectionPointContainer

                        IConvertType

                        IRowset

                        IRowsetChange

                        IRowsetIdentity

                        IRowsetInfo

                        IRowsetLocate

                        IRowsetResynch

                        IRowsetScroll

                        IRowsetUpdate

                        ISupportErrorInfo

If the value of any of these properties is set to VARIANT_TRUE, the rowset supports the specified interface. These properties are primarily used to request interfaces through ICommandProperties::SetProperties.

The values of the DBPROP_IROWSET, DBPROP_IACCESSOR, 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 automatically sets DBPROP_BOOKMARKS to VARIANT_TRUE. Setting DBPROP_IROWSETUPDATE to VARIANT_TRUE automatically sets DBPROP_IROWSETCHANGE to VARIANT_TRUE.

DBPROP_ISEQUENTIALSTREAM

DBPROP_ISTORAGE

DBPROP_ISTREAM

Typical R/W: R/W

Description: ILockBytes

                        ISequentialStream

                        IStorage

                        IStream

If the value of this property is set to VARIANT_TRUE, the specified column is treated as storage object that exposes the specified interface.

If this property is set on all columns, the provider must be capable of exposing all columns of the rowset as storage objects.

Typical R/W: R Only

Description: Immobile Rows

Specifies values as either of:

• VARIANT_TRUE, which specifies that the rowset will not reorder inserted or updated rows. For IRowsetChange::InsertRow, rows will appear at the end of the rowset.
  
  
• VARIANT_FALSE, which indicates that 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.

Typical R/W: R Only

Description: Literal Bookmarks

Specifies values as either of:

• VARIANT_TRUE, which indicates that 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, which indicates that bookmarks can only be compared with IRowsetLocate::Compare.

Typical R/W: R Only

Description: Literal Row Identity

Specifies values as either of:

• VARIANT_TRUE, which indicates that the consumer can perform a binary comparison of two row handles to determine whether they point to the same row.
  
  
• VARIANT_FALSE, which indicates that 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.

Typical R/W: R Only

Description: Maximum Open Rows

Specifies 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.

Typical R/W: R only

Description: Maximum Pending Rows

Specifies the maximum number of rows that can have pending changes 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, this value is zero.

Typical R/W: R Only

Description: Maximum Rows

Specifies the maximum number of rows that can be returned in a rowset. If there is no limit, this value is zero.

Typical R/W: R Only

Description: Column Writable

Specifies whether a particular column is writable or not. Note that 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.

Typical R/W: R Only

Description: Memory Usage

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 1–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.

Typical R/W: R/W

Description: Notification Granularity

Specifies values as one of:

• DBPROPVAL_NT_SINGLEROW, which indicates that, for methods that operate on multiple rows and generate multiphased notifications, 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, which indicates that, for methods that operate on multiple rows and generate multiphased notifications, 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.

Typical R/W: R Only

Description: Notification Phases

Specifies a bitmask that indicates 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.

DBPROP_NOTIFYROWDELETE

DBPROP_NOTIFYROWFIRSTCHANGE

DBPROP_NOTIFYROWINSERT

DBPROP_NOTIFYROWRESYNCH

DBPROP_NOTIFYROWSETRELEASE

DBPROP_NOTIFYROWSETFETCHPOSITIONCHANGE

DBPROP_NOTIFYROWUNDOCHANGE

DBPROP_NOTIFYROWUNDODELETE

DBPROP_NOTIFYROWUNDOINSERT

DBPROP_NOTIFYROWUPDATE

Typical R/W: R Only

Description: Column Set Notification.

                        Row Delete Notification

                        Row First Change Notification

                        Row Insert Notification

                        Row Resynchronization Notification

                        Rowset Release Notification

                        Rowset Fetch Position Change Notification

                        Row Undo Change Notification

                        Row Undo Delete Notification

                        Row Undo Insert Notification

                        Row Update Notification

Specifies a bitmask that indicates whether the notification phase can be cancelled, that is zero or more of:

• DBPROPVAL_NP_OKTODO
  
  
• DBPROPVAL_NP_ABOUTTODO
  
  
• DBPROPVAL_NP_SYNCHAFTER

Typical R/W: R/W

Description: Bookmarks Ordered

Specifies values as either of:

• VARIANT_TRUE, which indicates that 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, which indicates that bookmarks can be compared only 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.

Typical R/W: R/W

Description: Other’s Inserts Visible

Specifies values as either of:

• VARIANT_TRUE, which indicates that 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. Note that 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, which indicates that the rowset cannot see rows inserted by others.

For programmers accustomed to the cursor model in ODBC, the DBPROP_OTHERUPDATEDDELETE 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.

Typical R/W: R/W

Description: Other’s Changes Visible

Specifies values as either of:

• VARIANT_TRUE, which indicates that 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. Note that this includes updates and deletes made by other parties in the same transaction, as well as updates and deletes by parties outside the transaction.

  The transaction isolation level does not affect the ability of the rowset to see updates or deletes 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 by parties outside the transaction.

• VARIANT_FALSE, which indicates that the rowset cannot see updates and deletes by others.

Typical R/W: R/W

Description: Own Inserts Visible

Specifies values as either of:

• VARIANT_TRUE, which indicates that 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, which indicates that the rowset cannot see rows inserted by consumers of the rowset unless the command is re-executed.

Typical R/W: R/W

Description: Own Changes Visible

Specifies values as either of:

• VARIANT_TRUE, which indicates that 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, which indicates that the rowset cannot see updates and deletes by consumers of the rowset unless the command is re-executed.

Typical R/W: R/W

Description: Quick Restart

Specifies values as either of:

• VARIANT_TRUE, which indicates that IRowset::RestartPosition is relatively quick to execute. In particular, it does not re-execute the command that created the rowset.
  
  
• VARIANT_FALSE, which indicates that RestartPosition is expensive to execute and requires re-executing 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.

Typical R/W: R Only

Description: Re-entrant events

Specifies values as either of:

• VARIANT_TRUE, which indicates that the provider supports re-entrancy during callbacks to the IRowsetNotify interface. The provider might not support re-entrancy on all rowset methods. These methods return DB_E_NOTREENTRANT.
  
  
• VARIANT_FALSE, which indicates that the provider does not support such re-entrancy. 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.

Typical R/W: R/W

Description: Remove Deleted Rows

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 DBRPOP_OWNUPDATEDELETE and DBPROP_OTHERUPDATEDELETE properties. Whether the rowset removes these rows is determined by this property.

Note that 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, this value of the 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.

Typical R/W: R Only

Description: Report Multiple Changes

Specifies values as either of:

• VARIANT_TRUE, which indicates that 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, which indicates that an update or delete always affects a single row or the provider cannot detect whether it affects multiple rows.

Typical R/W: R Only

Description: Return Pending Inserts

Specifies values as either of:

• VARIANT_TRUE, which indicates that 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, which indicates that the methods that fetch rows cannot return pending insert rows.

Typical R/W: R Only

Description: Row Privileges

Specifies values as either of:

• VARIANT_TRUE, which indicates that 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, which indicates that access rights are not restricted on a row-by-row basis. If the rowset supports IRowsetChange, SetData can be called for any row.

Typical R/W: R/W

Description: Asynchronous Rowset Processing

Specifies a bitmask that indicates the asynchronous processing performed on the rowset.

Specifies values as zero or more of:

• DBPROPVAL_ASYNCH_INITIALIZE, which indicates that 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_IDBStatusNotify connection point may fail and the full set of interfaces may not be available on the rowset until asynchronous initialization has completed.
  
  
• DBPROPVAL_ASYNCH_SEQUENTIALPOPULATION, which indicates that the rowset is randomly asynchronously populated. Requests for rows may return DB_E_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 DBPROPVALUE_ASYNCH_SEQUENTIALPOPULATION and DBPROPVALUE_ASYNCH_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_ASYNCH_RANDOM or DBPROPVAL_ASYNCH_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.

Typical R/W: R/W

Description: Row Threading Model

Specifies the threading model of the rowsets generated by the command, that is:

• DBPROPVAL_RT_FREETHREAD
  
  
• DBPROPVAL_RT_APTMTTHREAD
  
  
• DBPROPVAL_RT_SINGLETHREAD

Typical R/W: R/W

Description: Server Cursor

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 with 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.

Typical R/W: R Only

Description: Strong Row Identity

Specifies values as either of:

• VARIANT_TRUE, which indicates that the handles of newly inserted rows can be compared as specified by DBPROP_LITERALIDENTITY.
  
  
• VARIANT_FALSE, which indicates that 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 to be a  row for which an insertion has been transmitted to the data source, as opposed to a pending insert row.

Typical R/W: R/W

Description: Objects Transacted

Specifies values as either of:

• VARIANT_TRUE, which indicates that 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, which indicates that 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.

Typical R/W: R/W

Description: Updatability

Specifies a bitmask that indicates the supported methods on IRowsetChange, that is, zero or more of:

• DBPROPVAL_UP_CHANGE, which indicates that SetData is supported.
  
  
• DBPROPVAL_UP_DELETE, which indicates that DeleteRows is supported.
  
  
• DBPROPVAL_UP_INSERT, which indicates that InsertRow is supported.
  
  
• DBPROP_UPDATABILITY, which 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.