How To Use A DataDescriptor

Fetch

You can query data from the database using two different methods. A synchronous query means source code execution will wait until the queried data is loaded. An asynchronous query, on the other hand, means program execution will not be interrupted due to data loading and a callback method is used to handle data or exceptions.

Synchronous query using a DataDescriptor :

  Getting all records in the DataDescriptor without user access control:  
        
List<DataRecord> result = dataDescriptor.find();

  Getting all records from the DataDescriptor with user access control:  
        
List<DataRecord> result = dataDescriptor.find(client);

  Getting records from the DataDescriptor corresponding a given Criteria without user access control (getting all records where the valid column has a Y value):  
        
List<DataRecord> result = dataDescriptor.find(new Criteria("valid", OperatorType.EQUALS, "Y"));

  Getting all records from the DataDescriptor where the valid column has a Y, without user access control:  
        
List<DataRecord> result = dataDescriptor.find(client, new Criteria("valid", OperatorType.EQUALS, "Y"));

  Getting the first 50 records where the valid column has a Y, without user access control:  
        
List<DataRecord> result = dataDescriptor.find(0, 50, new Criteria("valid", OperatorType.EQUALS, "Y"));

  Getting the first 50 records where the valid column has a Y, with user access control:  
        
List<DataRecord> result = dataDescriptor.find(client, 0, 50, new Criteria("valid", OperatorType.EQUALS, "Y"));

  Getting the first 50 records where the valid column has a Y, without user access control and in ascending order by column1 values:  
        
List<DataRecord> result = dataDescriptor.find(0, 50, new Criteria("valid", OperatorType.EQUALS, "Y"), new Order("column1", OrderType.ASCENDING);

  Getting the first 50 records where the valid column has a Y, with user access control and in ascending order by column1 values:  
        
List<DataRecord> result = dataDescriptor.find(client, 0, 50, new Criteria("valid", OperatorType.EQUALS, "Y"), new Order("column1", OrderType.ASCENDING);

  Getting a record from the DataDescriptor using the record’s unique ID, without user access control:  
        
DataRecord dataRecord = dataDescriptor.findById(1);

  Getting a record from the DataDescriptor using the record’s unique ID, with user access control:  
        
DataRecord dataRecord = dataDescriptor.findById(client, 1);

If you use an asynchronous query to get data from the DataDescriptor , you always have to implement the DataDescriptorCallback interface. The interface requires the implementation of two methods: onSuccess() gets the query result in a parameter. The method is called upon successful query execution. The method onError() gets the exception encountered during query execution. The method is called only if an exception has been thrown during the query.

Asynchronous query using a DataDescriptor :

  Getting all records from a DataDescriptor using an asynchronous query:  
        
dataDescriptor.fetchData(null, client, new DataDescriptorCallBack() {
    @Override
    public void onSuccess(List<DataRecord> data) {
        // Processing data
    }
    @Override
    public void onError(Throwable e) {
        // Handle error
    }
});

Getting all records from a DataDescriptor using an asynchronous query where the valid column has a Y :

        datadescriptor.fetchData(new Criteria("valid", OperatorType.EQUALS, "Y"), client, new DataDescriptorCallBack() {    
	@Override
    public void onSuccess(List<DataRecord> data) {
        // Processing data
    }
    @Override
    public void onError(Throwable e) {
        // Handle error
    });
       

  Getting all records from a DataDescriptor using an asynchronous query where the valid column has a Y in ascending order by column1 values:  
        
dataDescriptor.fetchData(new Criteria("valid", OperatorType.EQUALS, "Y"), new Order("column1", OrderType.ASCENDING), client, new DataDescriptorCallBack() {
    @Override
    public void onSuccess(List<DataRecord> data) {
        // Processing data
    }
    @Override
    public void onError(Throwable e) {
        // Handle error
    }
});

  Getting the first 50 records from a DataDescriptor using an asynchronous query where the valid column has a Y, in ascending order by column1 values:  
        
dataDescriptor.fetchData(0, 50, new Criteria("valid", OperatorType.EQUALS, "Y"), new Order("column1", OrderType.ASCENDING), client, new DataDescriptorCallBack() {
    @Override
    public void onSuccess(List<DataRecord> data) {
        // Processing data
    }
    @Override
    public void onError(Throwable e) {
        // Handle error
    }
});

Save

Not only can DataDescriptors query data, but records can be saved to a DataDescriptor . The save process can also be performed synchronously and asynchronously. Multiple records can be saved to a DataDescriptor at the same time and DataDescriptors support transaction management.

  Saving a record to a DataDescriptor synchronously:  
        
List<DataRecord> savedRecords = dataDescriptor.save(dataRecord, client);

  Saving multiple records synchronously to a DataDescriptor:  
        
List<DataRecord> savedRecords = dataDescriptor.save(dataRecords, client);

  Saving a record to a DataDescriptor synchronously in a previously initiated transaction:  
        
List<DataRecord> savedRecords = dataDescriptor.save(dataRecord, client, transaction);

  Saving multiple records synchronously to a DataDescriptor in a previously initiated transaction:  
        
List<DataRecord> savedRecords = dataDescriptor.save(dataRecords, client, transaction);

If the save is done asynchronously, saved records will be retrieved by the onSuccess() backend if the backup is successful. If an error occurs during save, the onError() method will be called to handle the error.

  Saving a record to a DataDescriptor asynchronously:  
        
dataDescriptor.save(dataRecord, client, new DataDescriptorCallback() {
    @Override
    public void onSuccess(List<DataRecord> data) {
        // Processing saved data
    }
    @Override
    public void onError(Throwable e) {
        // Handle error
    }
});

  Saving multiple records asynchronously to a DataDescriptor:  
        
dataDescriptor.save(dataRecords, client, new DataDescriptorCallback() {
    @Override
    public void onSuccess(List<DataRecord> data) {
        // Processing saved data
    }
    @Override
    public void onError(Throwable e) {
        // Handle error
    }
});

  Saving a record to a DataDescriptor in a previously initiated asynchronous transaction:  
        
@Override
    public void onSuccess(List<DataRecord> data) {
        // Processing saved data
    }
    @Override
    public void onError(Throwable e) {
        // Handle error
    }
}, transaction);

  Saving multiple records to a DataDescriptor in a previously initiated asynchronous transaction:  
        
dataDescriptor.save(dataRecords, client, new DataDescriptorCallback() {
    @Override
    public void onSuccess(List<DataRecord> data) {
        // Processing saved data
    }
    @Override
    public void onError(Throwable e) {
        // Handle error
    }
}, transaction);

Remove

You can also delete records from a DataDescriptor , which can also be done synchronously and asynchronously. It is also possible to delete multiple records from a DataDescriptor at the same time, and DataDescriptors can handle transactions even if they are deleted.

  Deleting a record from a DataDescriptor synchronously:  
        
dataDescriptor.remove(dataRecord, client);

  Synchronously deleting multiple records at a time from a DataDescriptor:  
        
dataDescriptor.remove(dataRecords, client);

  Deleting a record from a DataDescriptor synchronously in a previously initiated transaction:  
        
dataDescriptor.remove(dataRecord, client, transaction);

  Deleting multiple records synchronously from a DataDescriptor in a previously initiated transaction:  
        
dataDescriptor.remove(dataRecords, client, transaction);

If deletion is performed asynchronously, the deleted records will be retrieved by the onSuccess() method in case of a successful deletion. If an error occurs during deletion, the onError() method will be called to handle the error.

  Deleting a record from a DataDescriptor asynchronously:  
        
dataDescriptor.remove(dataRecord, client, new DataDescriptorCallback() {
    @Override
    public void onSuccess(List<DataRecord> data) {
        // Processing saved data
    }
    @Override
    public void onError(Throwable e) {
        // Handle error
    }
});

  Deleting multiple records at a time from a DataDescriptor asynchronously:  
        
dataDescriptor.remove(dataRecords, client, new DataDescriptorCallback() {    
	@Override
    public void onSuccess(List<DataRecord> data) {
        // Processing saved data
    }
    @Override
    public void onError(Throwable e) {
        // Handle error
    }
});

  Deleting a record from a DataDescriptor in an asynchronously initiated transaction:  
        
dataDescriptor.remove(dataRecord, client, new DataDescriptorCallback() {
    @Override
    public void onSuccess(List<DataRecord> data) {
        // Processing saved data
    }
    @Override
    public void onError(Throwable e) {
        // Handle error
    }
}, transaction);

  Deleting multiple records simultaneously from a DataDescriptor in an asynchronously initiated transaction:  
        
dataDescriptor.remove(dataRecords, client, new DataDescriptorCallback() {
    @Override
    public void onSuccess(List<DataRecord> data) {
        // Processing saved data
    }
    @Override
    public void onError(Throwable e) {
        // Handle error
    }
}, transaction);