borland Packages  Class Hierarchy  dx.dataset Package 

StorageDataSet component

java.lang.Object
   +----com.borland.dx.dataset.ReadRow
           +----com.borland.dx.dataset.ReadWriteRow
                   +----com.borland.dx.dataset.DataSet
                           +----com.borland.dx.dataset.StorageDataSet
                                   +----com.borland.dx.dataset.TableDataSet
                                   +----com.borland.dx.sql.dataset.ProcedureDataSet
                                   +----com.borland.dx.sql.dataset.QueryDataSet

About the StorageDataSet component

Constructors  Properties  Methods  Event Listeners

Implements AccessListener, ColumnDesigner, Designable, MasterNavigateListener, StatusListener, Serializable, EventListener

This is an abstract class of core functionality for StorageDataSet functionality. It cannot be used directly. See TableDataSet, QueryDataSet, ProcedureDataSet components instead.

StorageDataSet manages a 2-dimensional array of data. Column data types are specified through Column components. A StorageDataSet has a Column component for each data column that it contains. Column components contain type information for the data columns in a StorageDataSet.

The StorageDataSet component extends the basic cursor functionality provided by its superclass DataSet with the:

The StorageDataSet component is extended by QueryDataSet, ProcedureDataSet, and TableDataSet components. The QueryDataSet and ProcedureDataSet work with a Database component to obtain data from a remote server through the execution of a query or stored procedure. You can also load data stored in a text file into a TableDataSet object. Once data is loaded (provided) into a StorageDataSet object, you handle the data in a common way, regardless of how the data was obtained or which StorageDataSet extension you use.

When making structure changes to the StorageDataSet, such as setting the store property to use a DataStore, use the addColumn, changeColumn, dropColumn, and moveColumn methods as these methods allow for better before and after mapping. Otherwise, when the StorageDataSet is restructured, Column names are used for mapping, which may not always work as anticipated. The Column component's preferredOrdinal property is retained when calling these StorageDataSet methods.

If your application involves a master-detail relationship, the resolveOrder property indicates the order in which changes made to the DataSets are resolved back to the data source.


StorageDataSet constructors

StorageDataSet properties

*Read-only properties **Write-only properties

Properties implemented in this class

Properties implemented in com.borland.dx.dataset.DataSet

Properties implemented in com.borland.dx.dataset.ReadRow

Properties implemented in com.borland.dx.dataset.ReadWriteRow

Properties implemented in java.lang.Object

StorageDataSet methods

Methods implemented in this class

Methods implemented in com.borland.dx.dataset.DataSet

Methods implemented in com.borland.dx.dataset.ReadRow

Methods implemented in com.borland.dx.dataset.ReadWriteRow

Methods implemented in java.lang.Object

StorageDataSet event listeners


StorageDataSet constructors

StorageDataSet()

  public StorageDataSet()
Constructs a StorageDataSet component, generates a StatusEvent of StatusEvent.LOADING_DATA and sets the following properties:

StorageDataSet properties

allRowIds

 public final synchronized void setAllRowIds(boolean setting)
Sets all Column components as being unique row identifiers.

calcAggFieldsListener

 public final CalcAggFieldsListener getCalcAggFieldsListener()
Read-only property that returns the CalcAggFieldsListener of the StorageDataSet.

calcFieldsListener

 public final CalcFieldsListener getCalcFieldsListener()
Read-only property that returns the CalcFieldsListener of the StorageDataSet.

columns

 public synchronized void setColumns(Column[] columns)
Specifies the Column components in the StorageDataSet and sets the persist property to true for all specified columns. Any pre-existing columns are removed when this property is set.

dataFile

 public final DataFile getDataFile()
 public void setDataFile(DataFile dataFile)
Specifies the DataFile implementation used for file import and export operations. See TextDataFile for an implementation of DataFile.

deletedRowCount

 public final int getDeletedRowCount()
Read-only property that returns the number of deleted rows not visible to this StorageDataSet

duplicates

 public final StorageDataSet getDuplicates()

When a unique sort property is applied for the first time, rows that violate the unique constraint will be copied off to a separate duplicates DataSet. The duplicates DataSet can be retrieved by calling getDuplicates().

insertedRowCount

 public final int getInsertedRowCount()
Read-only property that returns the number of inserted rows visible to this StorageDataSet

locale

 public Locale getLocale()
 public synchronized void setLocale(Locale locale)
Used for formatting the data stored in the StorageDataSet. Locale contains country or area-specific formatting specifications such as date format (MM/DD/YY, DD/MM/YY, YY/MM/DD), currency symbol, and so on.

When set at the StorageDataSet level, this property is the default locale for all Column components in the StorageDataSet. If the StorageDataSet's locale property is null, and the store property is set to a DataStore component, the locale property of the DataStore will be used if set. If not set any level, it defaults to the locale of the Java environment.

maxDesignRows

 public final int getMaxDesignRows()
 public final void setMaxDesignRows(int maxDesignRows)
Limits the number of rows that can be initially loaded into a DataSet in JBuilder's UI Designer. The default is to load 50 rows. If the limit is reached, only that number of rows is displayed; no message is displayed nor is any Exception thrown.

maxResolveErrors

 public final int getMaxResolveErrors()
 public final void setMaxResolveErrors(int maxResolveErrors)
The maximum number of errors that can be logged in an error DataSet before the ResolutionManager is called.

If this property is set to 0, no errors will be logged. If set to -1, all errors will be logged.

See also: ResolveError

maxRows

 public final int getMaxRows()
 public final void setMaxRows(int maxRows)
Limits the number of rows that can initially be loaded into the DataSet when running the application or applet. Also called a governor. The setMaxRows() method has no effect on rows added after the initial loading of data, for example, from a query or import specification.

This property defaults to -1 which indicates that there is no limit to the number of rows that can be initially loaded into a DataSet. No message is displayed nor is any Exception thrown when the limit is reached, however, only that number of rows is included in the DataSet when it is loaded with data. With long running queries that can possibly return large result sets, it is advisable to set the maxRows property since the maximum number of rows defaults to unlimited.

See also: Load.AS_NEEDED

metaDataUpdate

 public final int getMetaDataUpdate()
 public final synchronized void setMetaDataUpdate(int metaDataUpdate)
Determines what kind of metadata discovery is performed when executing a query or a stored procedure against a SQL server database. Valid values for this property are defined in the MetaDataUpdate interface.

To prevent the addition of row ID columns and various metadata related properties on DataSet and Column components, set this property to MetaDataUpdate.NONE.

needsRestructure

 public final boolean getNeedsRestructure()
Returns true for StorageDataSet components when structural changes have occurred (add, drop, move, change column) and the store being used requires a restructure. To cause the restructure to happen, call the restructure() method. After a successful restructure, getNeedsRestructure() returns false.

A StorageDataSet that uses a MemoryStore always returns false. Currently, this method is meaningful only with DataStore use.

A StorageDataSet with pending structural changes can still be used. Moved columns can be read and written to. Deleted columns are not visible, inserted columns can be read, but not written, changed data type columns can be read but not written to.

provider

 public Provider getProvider()
 public void setProvider(Provider provider)
Specifies the Provider component that controls how the data is fetched from the database when the StorageDataSet is opened. JDataStore includes these provider components:

readOnly

 public final boolean isReadOnly()
 public final void setReadOnly(boolean readOnly)
Specifies whether edits to the DataSet are permitted. If true, edits to the DataSet are not allowed, otherwise the DataSet can be updated.

A StorageDataSet can be internally marked readOnly in some situations. These automatic readOnly settings cannot be cleared by calling setReadOnly(false). The return value of DataSetException.getMessage() explains why a StorageDataSet is readOnly.

A common reason for a StorageDataSet to be automatically marked readOnly is that a Provider, such as QueryProvider or ProcedureProvider, could not determine which Columns should have their rowId property set to true. This readOnly state can be cleared by calling Column.setRowId(), StorageDataSet.setRowId(), or StorageDataSet.setAllRowIds().

If a QueryProvider or ProcedureProvider cannot determine the tableName property setting, the changes in the StorageDataSet cannot be saved back. To save changes back, the StorageDataSet.setTableName property must be explicitly set. If the query was the result of a join operation, and you would like to resolve the changes back, the Column.tableName property will have to be set for each column. If this was not successfully accomplished by the Provider, this property will have to be set for each Column that is to have its values saved (resolved) back.

To prevent edits to the DataSet through data-aware controls only (permitting programmatic edits), set the editable property.

See also: editable property of the DataSet class, resolvable property of this class

resolvable

 public final boolean isResolvable()
 public final void setResolvable(boolean resolvable)
Specifies whether to allow changes made to this DataSet to be saved back to its data source (true) or not (false).

resolvable is a user property that indicates an intent to resolve edits to the StorageDataSet. If set to false, inserts, updates, and deletes are not tracked. This will save space and improve performance for StorageDataSets that are wired to a DataStore when you have no intention of resolving.

See also: editable property of the DataSet class, readOnly property of this class

resolveOrder

 public final String[]getResolveOrder()
 public final void setResolveOrder(String[]resolveOrder)
A String array that specifies the resolution order for multi-table resolution. Inserts and updates use the order of the String array while deletes use the reverse order. The default order of the tables in the String array is the order by which they appear in the query statement. The table names should include any necessary schema names. If a table is removed from the list, then the columns from that table will not be resolved. If your application involves a master-detail relationship, the resolveOrder property indicates the order in which changes made to the DataSets are resolved back to the data source.

resolver

 public Resolver getResolver()
 public void setResolver(Resolver resolver)
Specifies the Resolver object to use that defines resolver logic when saving data changes back to the data source.

schemaName

 public final String getSchemaName()
 public synchronized void setSchemaName(String schemaName)
Write-only property for the table name of the data source for the Column components of this StorageDataSet. If a DataSet has any updateable Column components, this property must reflect the table name of the data source.

store

 public final Store getStore()
 public final void setStore(Store store)
Sets the storage for the DataSet. Valid values for this property are MemoryStore or DataStore. The default is MemoryStore.

With MemoryStore, DataSet data is stored in memory and released when an application closes. With DataStore, storage is persistent and file-based so that when an application closes, it can be restarted in the same state as when it was closed.

storeClassFactory

 public final StoreClassFactory getStoreClassFactory()
 public final void setStoreClassFactory(StoreClassFactory factory)
Allows a DataStore table to be accessed only by a specific StorageDataSet class or StorageDataSet class extension. This allows an application to make sure that property and event settings are always activated when a DataStore table is accessed.

Currently, this property is only meaningful when the StorageDataSet.store property is set to a DataStoreConnection or DataStore component.

See also: StoreClassFactory

storeName

 public final String getStoreName()
 public synchronized void setStoreName(String name)
If the store property component supports naming of a DataSet components in the Store, this can be set. The default store is MemoryStore, which does not support naming of DataSet components. This property is meaningful to and used only by DataStore.

When specified for a DataStore component, the storeName property must be unique. The value specified for storeName is case insensitive, though it is stored internally in upper case. To force a storeName to be case insensitive, enclose it in quotes, for example:

 "\"name\""

tableName

 public final String getTableName()
 public synchronized void setTableName(String tableName)
Stores the name of the table from which the DataSet obtains its data. If a DataSet has any updateable columns, the name of the table for these columns is stored as tableName.

The table name is normally retrieved automatically from the data source. Some stored procedures and queries however will not return the table name. If it doesn't, use setTableName() to specify the table name so that changes made to the DataSet can be resolved back to the data source, then set the rowId and metadataupdate properties (if not already set). The table name is also useful as a String identifier of the data source.

updatedRowCount

 public final int getUpdatedRowCount()
Read-only property that returns the number of updated rows visible to this StorageDataSet

StorageDataSet methods

addColumn(java.lang.String, int)

  public final int addColumn(String columnName, int datatype)
Adds a Column to a DataSet where columnName indicates the String name of the Column and dataType is the data type of the Column. The Column is added at the end of all existing columns. The return value int indicates the ordinal position of the newly-added Column. Use the enableDataSetEvents method to propagate changes to a control that is bound to this DataSet.

To achieve similar results as when calling StorageDataSet.setColumns(...) method, call the addColumn(...) method followed by Column.setPersist(true).

If the store property is set, StorageDataSet.restructure() must be called before this column can be edited.

On error, this method throws a DataSetException.

Parameters:

columnName
The String name of the Column component to add to the StorageDataSet.
datatype
The data type of the data in the Column. Valid values for this parameter are defined in com.borland.dx.dataset.Variant variables.

addColumn(java.lang.String, java.lang.String, int)

  public final int addColumn(String columnName, String caption, int dataType)
Adds a Column to the end of existing columns in a DataSet. Row values for the added Column are set to null. The return value int indicates the ordinal position of the newly-added Column. On error, this method throws a DataSetException.

If the store property is set, StorageDataSet.restructure() must be called before this column can be edited.

Parameters:

columnName
The String name of the Column by which you refer to it most of the time.
colLabel
The name of the (displayed) label for the Column in a data-aware control. You may want to use a more descriptive name than columnName.
dataType
The data type of the field to be added. Valid values for this parameter are described in com.borland.dx.dataset.Variant variables.

addLoadRowListener(listener)

  public void addLoadRowListener(LoadRowListener listener)
Adds the specified LoadRowListener object.

addUniqueColumn(com.borland.dx.dataset.Column)

  public final int addUniqueColumn(Column column)
Adds a Column to the DataSet only if it does not already exist. The specified column is cloned before being added to the DataSet. The return value int indicates the ordinal position of the newly-added Column. On error, this method throws a DataSetException of COLUMN_TYPE_CONFLICT.

Parameters:

column
The Column component to add to this StorageDataSet.

cancelLoading()

  public final void cancelLoading()
Cancels any long running load operations currently active on this DataSet. For this have an effect, the long running loading operation must be executing on a different thread than the thread that calls this method.

Overrides: com.borland.dx.dataset.DataSet.cancelLoading()

cancelOperation()

  public final void cancelOperation()
Cancels any long running operation currently active on this DataSet. This includes loading a query result, restructure operations, and index building operations. For this have an effect, the long running operation must be executing on a different thread than the thread that calls this method.

Overrides: com.borland.dx.dataset.DataSet.cancelOperation()

changesPending()

  public boolean changesPending()
Returns true if there are any inserted, deleted, or updated rows to be resolved back to the data source. If true, one or more of the following methods getUpdatedRowCount(), getDeletedCount(), or getInsertedCount() return a value greater than 0.

cloneColumns()

  public Column[] cloneColumns()
Creates a copy of all Columns in the StorageDataSet.

cloneDataSetStructure()

  public final synchronized StorageDataSet cloneDataSetStructure()
Creates a new empty StorageDataSet object with the identical structure as the current StorageDataSet.

closeProvider(boolean)

  public void closeProvider(boolean loadRemainingRows)

This method can be used to terminate a provider that is currently still loading rows into the StorageDataSet. If a load option such as Load.AS_NEEDED or Load.ASYNCHRONOUS is being used by a QueryProvider or ProcedureProvider, and closeProvider() is called with loadRemainingRows set to true, the remaining rows will be retrieved before the provider is closed. If loadRemainingRows is false, the provide operation will be terminated and the remaining rows will not be retrieved.

deleteDuplicates()

  public final void deleteDuplicates()

When a unique sort property is applied for the first time, rows that violate the unique constraint will be copied off to a separate duplicates DataSet. The duplicates DataSet can be retrieved by calling getDuplicates(). Opening a DataSet with a new sort property setting that has a unique constraint will not succeed if a duplicates StorageDataSet already exists. This restriction protects an application from accidentally losing valuable data in duplicate rows.

Call deleteDuplicates() to delete the old set of duplicates.

dropAllIndexes()

  public final void dropAllIndexes()
Drops all indexes used by this StorageDataSet. For MemoryStore, this can be used to save memory after viewing the data in different sort orders. For DataStore, this frees up maintained secondary indexes, releasing disk storage. In both MemoryStore and DataStore, this can improve update performance.

dropColumn(com.borland.dx.dataset.Column)

  public final synchronized void dropColumn(Column column)
Deletes the specified Column object (and all the data it contains) from the DataSet. If the Column cannot be dropped, this method throws a DataSetException. dropColumn does not affect the relative order of columns but does cause a recalculation of column ordinal values.

If the store property is set, StorageDataSet.restructure() must be called before this column can be edited.

Parameters:

column
The Column component to drop from this StorageDataSet.

dropIndex(com.borland.dx.dataset.SortDescriptor, com.borland.dx.dataset.RowFilterListener)

  public final boolean dropIndex(SortDescriptor descriptor, RowFilterListener listener)
This method can be used to drop unneeded indexes used to maintain a sorted and filtered view of a DataSet. Dropping an index can save space and improve the performance of insert/add/delete operations.

Parameters:

descriptor
Sort settings that describe the index.
listener
RowFilterListener used for filtering. Pass null if not a filtered index.

empty()

  public final void empty()
Empties all rows of the DataSet and resets the DataSet to contain no rows. All change state information (inserted, deleted, changed) is lost and therefore, nothing remains in the DataSet to be resolved back to the original data source. On error, this method generates a DataSetException.

endLoading()

  public final synchronized void endLoading()
Stops the loading of data into the StorageDataSet.

See also: startLoading(com.borland.dx.dataset.LoadCancel, int, boolean), loadRow()

getDeletedRows(com.borland.dx.dataset.DataSetView)

  public final synchronized void getDeletedRows(DataSetView deleteDataSet)
Initializes deleteDataSet to display only the deleted rows in the current DataSet. On error, this method generates a DataSetException.

Parameters:

deleteDataSet
The DataSetView initialized by this method to includes only deleted rows.

getInsertedRows(com.borland.dx.dataset.DataSetView)

  public final synchronized void getInsertedRows(DataSetView insertDataSet)
Initializes the DataSetView to display only the inserted (new) rows in the current DataSet. On error, this method generates a DataSetException.

Parameters:

insertDataSet
The DataSetView initialized by this method to include only inserted rows.

getOriginalRow(com.borland.dx.dataset.DataSet, com.borland.dx.dataset.ReadWriteRow)

  public final void getOriginalRow(DataSet updateDataSet, ReadWriteRow originalRow)
Given a DataSet with a changed record, this method initializes a dataRow with the original values.

getUpdatedRows(com.borland.dx.dataset.DataSetView)

  public final synchronized void getUpdatedRows(DataSetView updateDataSet)
Initializes a DataSetView object to display only the updated rows in the current DataSet. On error, this method generates a DataSetException.

Parameters:

updateDataSet
The DataSetView that is initialized by this method to contain only updated rows.

hasRowIds()

  public final synchronized boolean hasRowIds()
Returns whether the DataSet has any unique row identifiers. If at least one exists, this method returns true.

indexExists(com.borland.dx.dataset.SortDescriptor, com.borland.dx.dataset.RowFilterListener)

  public final boolean indexExists(SortDescriptor descriptor, RowFilterListener listener)

Returns true if a maintained index already exists for the given descriptor and listener.

Parameters:

descriptor
Sort settings that describe the index.
listener
RowFilterListener used for filtering. Pass null if not a filtered index.

loadRow()

  public final void loadRow()
This method allows for faster loading of a StorageDataSet. It calls loadRow(loadStatus), where loadStatus is the value of loadStatus passed to startLoading().

See also: startLoading(com.borland.dx.dataset.LoadCancel, int, boolean), endLoading()

loadRow(int)

  public final long loadRow(int status)

Allows for faster loading of a StorageDataSet. You can also use this method to load rows as updated or deleted.

To load a row as deleted, set the variant values returned from startLoading() and call loadRow(RowStatus.DELETED).

To load a row as updated, set the variant values returned from startLoading() to the original row values and call loadRow(RowStatus.ORIGINAL). Then set the variant values returned form startLoading to the updated row values and call loadRow(RowStatus.UPDATED).

Parameters:

status
Status of the row, typically RowStatus.INSERTED or RowStatus.LOADED.

moveColumn(int, int)

  public final synchronized void moveColumn(int oldOrdinal, int newOrdinal)
Moves a Column at the specified ordinal position to a new ordinal position. If either parameter is invalid, a DataSetException of type INVALID_COLUMN_POSITION is thrown.

If the store property is set, StorageDataSet.restructure() must be called before this column can be edited.

Parameters:

oldOrdinal
The ordinal position of the Column component to move.
newOrdinal
The ordinal position where the Column should be moved to.

postAllDataSets()

  public final void postAllDataSets()
Attempts to post any unposted rows in the DataSet and DataSetView components that share the same StorageDataSet property. On error, this method throws a DataSetException.

Overrides: com.borland.dx.dataset.DataSet.postAllDataSets()

provideMoreData()

  public boolean provideMoreData()

If a Provider, such as QueryProvider or ProcedureProvider, has a load property setting of Load.AS_NEEDED, calling this method retrieves the next batch of rows.

recalc()

  public final synchronized void recalc()
Forces a recalculation of any calculated columns in the StorageDataSet.

refresh()

  public void refresh()
Calls the Provider to refresh data from the data source of the StorageDataSet.

Overrides: com.borland.dx.dataset.DataSet.refresh()

refreshSupported()

  public boolean refreshSupported()
Returns true if the data source of the StorageDataSet supports refresh operations. Otherwise, this method returns false.

Overrides: com.borland.dx.dataset.DataSet.refreshSupported()

removeLoadRowListener(listener)

  public synchronized void removeLoadRowListener(LoadRowListener listener)
Removes the specified LoadRowListener object.

reset()

  public final void reset()
Resets the StorageDataSet with the original values it was loaded with. All insert, update, and delete operations performed by the application are backed out.

resetPendingStatus(boolean)

  public final void resetPendingStatus(boolean resolved)
Resets the status bits of the rows marked pending during resolution.

Parameters:

resolved
true if changes were resolved and the changed rows should now be treated as originals in a new resolution query.

false if changes were rolled back and the changed rows should still be treated as changed rows.

Overrides: com.borland.dx.dataset.DataSet.resetPendingStatus(boolean)

resetPendingStatus(long, boolean)

  public final void resetPendingStatus(long internalRow, boolean resolved)

Reset the status bits of a specific row.

Parameters:

internalRow
The row where the the status bits should be reset.
resolved
true if changes were resolved and the changed rows should now be treated as originals in a new resolution query.

false if changes were rolled back and the changed rows should still be treated as changed rows.

Overrides: com.borland.dx.dataset.DataSet.resetPendingStatus(long, boolean)

restructure()

  public final void restructure()
Restructures the StorageDataSet. Currently meaningful only for DataStore after a move, delete, add, or change column method call.

The needsRestructure property returns whether a restructure operation is pending. A StorageDataSet with pending structural changes can still be used, and moved columns can be read and written to. Deleted columns are not visible, inserted columns can be read but not written and changed data type columns can be read but not written to.

The restructure() method can also be used to repair or compact a StorageDataSet and its associated indexes even when there are no pending structural changes.

saveChanges(com.borland.dx.dataset.DataSet)

  public void saveChanges(DataSet dataSet)
Saves changes made to the data in the StorageDataSet back to its data source. If the resolver property is null, a DataSetException of CANNOT_SAVE_CHANGES is thrown.

Parameters:

dataSet
The DataSet containing the updated data.

saveChangesSupported()

  public boolean saveChangesSupported()
Returns true if the data source supports resolving changes made to the StorageDataSet, false if not. Typically, file-based data sources do not support data resolution.

Overrides: com.borland.dx.dataset.DataSet.saveChangesSupported()

setRowId(java.lang.String, boolean)

  public final synchronized void setRowId(String columnName, boolean setting)
Specifies that the named Column component either uniquely identifies a row in the server table where changes made to this StorageDataSet will be saved back to, or is one of a group of Column components that uniquely identifies a row. A false value indicates that the specified Column is not (part of) a unique row identifier.

Parameters:

columnName
The String name of the Column component.
setting
A boolean value indicating the participation of the columnName in the row identifier (true) or not (false).

startLoading(com.borland.dx.dataset.LoadCancel, int, boolean)

  public final Variant[] startLoading(LoadCancel loader, int loadStatus, boolean loadAsync)

This method calls startLoading(loader, loadStatus, loadAsync, false, false), where the last two parameters (loadRowByRow and loadValidate) are set to false. The following description is for the startLoading(loader, loadStatus, loadAsync, loadRowbyRow, loadValidate) method, which was added to late to make it into the documentation.

This method is used for high-speed loading of data into a StorageDataSet. It returns an array of Variant objects for all columns in a DataSet. You set the values in the array and call loadRow() or loadRow(int). When the load operation is complete, you must call endLoading. Only one load operation may be active at one time.

This method may generate a DataSetException of LOADING_NOT_STARTED.

Parameters:

loader
A call back interface that requests the load operation to be canceled. Cannot be null.
loadStatus
Boolean that determines the status of the load process. Can be RowStatus.INSERTED or RowStatus.LOADED. Normally RowStatus.LOADED is used to indicate that the row was not inserted or updated.
loadAsync
Whether the loading should be done in a separate thread. Set this parameter to true if the intention is to load the StorageDataSet using a separate thread. This will cause periodic update notifications to be sent to any data aware controls and StatusListeners.
loadRowByRow
Boolean that indicates how to load rows. True means to load one row at a time. Use this with QueryProviders and ProcedureProviders that use the Load.UNCACHED option.
loadValidate
Boolean that indicates whether to have rows validated by calling DataRow.validate() for each row before it is loaded.

See also: loadRow(),endLoading()

startLoading(com.borland.dx.dataset.LoadCancel, int, boolean, boolean)

  public final synchronized Variant[] startLoading(LoadCancel loader, int loadStatus, boolean loadAsync, boolean loadUncached)
Calls startLoading(loader, loadStatus, loadAsync, loadRowByRow, false). The last parameter, loadValidate, is set to false.

startLoading(com.borland.dx.dataset.LoadCancel, int, boolean, boolean, boolean)

  public final synchronized Variant[] startLoading(LoadCancel loader, int loadStatus, boolean loadAsync, boolean loadUncached, boolean loadValidate)
Used for high speed loading of data into a StorageDataSet.
loader
A call back interface that requests the load operation to be canceled. Cannot be null.
loadStatus
Boolean that determines the status of the load process. Can be RowStatus.INSERTED or RowStatus.LOADED. Normally RowStatus.LOADED is used to indicate that the row was not inserted or loaded.
loadAsync
Whether the loading should be done in a separate thread. Set this parameter to true if the intention is to load the StorageDataSet using a separate thread. This will cause periodic update notifications to be sent to any data aware controls and StatusListeners.
loadRowByRow
Boolean that indicates how to load rows. True means to load one row at a time. Use this with QueryProviders and ProcedureProviders that use the Load.UNCACHED option.
loadValidate
Boolean that indicates whether to have rows validated by calling DataRow.validate() for each row before it is loaded.

StorageDataSet event listeners

This component is a source for the following event sets.

access

 public final void addAccessListener(AccessListener listener)
 public final void removeAccessListener(AccessListener listener)

calcAggFields

 public synchronized void addCalcAggFieldsListener(CalcAggFieldsListener listener)
 public synchronized void removeCalcAggFieldsListener(CalcAggFieldsListener listener)

calcFields

 public synchronized void addCalcFieldsListener(CalcFieldsListener listener)
 public synchronized void removeCalcFieldsListener(CalcFieldsListener listener)

columnChange

 public void addColumnChangeListener(ColumnChangeListener listener)
 public synchronized void removeColumnChangeListener(ColumnChangeListener listener)

dataChange

 public final void addDataChangeListener(DataChangeListener listener)
 public final void removeDataChangeListener(DataChangeListener listener)

edit

 public void addEditListener(EditListener listener)
 public synchronized void removeEditListener(EditListener listener)

load

 public final synchronized void addLoadListener(LoadListener listener)
 public final synchronized void removeLoadListener(LoadListener listener)

masterNavigate

 public final void addMasterNavigateListener(MasterNavigateListener listener)
 public final void removeMasterNavigateListener(MasterNavigateListener listener)

navigation

 public final void addNavigationListener(NavigationListener listener)
 public final void removeNavigationListener(NavigationListener listener)

open

 public final void addOpenListener(OpenListener listener)
 public final void removeOpenListener(OpenListener listener)

rowFilter

 public final void addRowFilterListener(RowFilterListener listener)
 public final void removeRowFilterListener(RowFilterListener listener)

status

 public final void addStatusListener(StatusListener listener)
 public final void removeStatusListener(StatusListener listener)