JPA DAO - Learn JBStrap

Fetch

This functionality is used most often by JPA DAO API to fetch data from the database. This can be done by fetching all data from an entity, or you can use a filter criteria as well as look for something specific using its unique entity ID. The returned data can be further organized. You can specify if you want the full data set or just a part of it.

You can start a fetch based on an entity or DataDescriptor. If a Client object is passed to the fetch method, you can perform this while taking user access rights into account. This means that if the current user has no read rights to the data, the fetch will be unsuccessful, and it will return with an error.

General fetches (through an entity):

  Fetching every data through an entity:  
        
List<DataRecord> result = JpaDaoAPI.find(Entity.class);

  Fetching every data through an entity, while checking for access rights:  
        
List<DataRecord> result = JpaDaoAPI.find(Entity.class, client);

  Fetching the data records, that meet the specified filters, through an entity (fetching every valid DataRecord):  
        
List<DataRecord> result = JpaDaoAPI.find(Entity.class, new Criteria("valid", OperatorType.EQUALS, "Y"));

  Fetching every data record, that meets the specified filters, through an entity while checking for access rights:  
        
List<DataRecord> result = JpaDaoAPI.find(Entity.class, client, new Criteria("valid", OperatorType.EQUALS, "Y"));

  Fetching the first 50 data records through an entity that meets the specified filters (Every record that has the column1 value of 100. If there are more than 50, only the first 50 will be fetched):  
        
List<DataRecord> result = JpaDaoAPI.find(Entity.class, 0, 50, new Criteria("column1", OperatorType.EQUALS, 100);

  Getting the next 50 data records (51-100), while checking for access rights:  
        
List<DataRecord> result = JpaDaoAPI.find(Entity.class, client, 51, 100, new Criteria("column1", OperatorType.EQUALS, 100);

  Getting the first 50 data records that meet the specified criteria, and ordering it descending order by column2:  
        
List<DataRecord> result = JpaDaoAPI.find(Entity.class, 0, 50, new Criteria("column1", OperatorType.EQUALS, 100), new Order("column2", OrderType.DESCENDING));

  Fetching the same data record, while checking for access rights, and ordering it, descending by column2 and ascending by column3:  
        
List<DataRecord> result = JpaDaoAPI.find(Entity.class, client, 0, 50, new Criteria("column1", OperatorType.EQUALS, 100), new Order("column2", OrderType.DESCENDING), new Order("column3", OrderType.ASCENDING));

General fetches (through a DataDescriptor ):

  Fetching every data through a DataDescriptor:  
        
List<DataRecord> result = JpaDaoAPI.find(dataDescriptor);

  Fetching every data record through a DataDescriptor, while checking for access rights:  
        
List<DataRecord> result = JpaDaoAPI.find(dataDescriptor, client);

  Fetching every data record that meets the specified Criteria, through a DataSource (fetching every valid Record):  
        
List<DataRecord> result = JpaDaoAPI.find(dataDescriptor, new Criteria("valid", OperatorType.EQUALS, "Y"));

  Fetching every valid data record, while checking for access rights, through a DataSource:  
        
List<DataRecord> result = JpaDaoAPI.find(dataDescriptor, client, new Criteria("valid", OperatorType.EQUALS, "Y"));

  Fetching the first 50 data records through a DataDescriptor that meets the specified filters (Every record that has the column1 value of 100. If there are more than 50, only the first 50 will be fetched):  
        
List<DataRecord> result = JpaDaoAPI.find(dataDescriptor, 0, 50, new Criteria("column1", OperatorType.EQUALS, 100);

  Getting the next 50 data records (51-100), while checking for access rights:  
        
List<DataRecord> result = JpaDaoAPI.find(dataDescriptor, client, 51, 100, new Criteria("column1", OperatorType.EQUALS, 100);

  Getting the first 50 data records that meet the specified criteria, and ordering it descending order by column2:  
        
List<DataRecord> result = JpaDaoAPI.find(dataDescriptor, 0, 50, new Criteria("column1", OperatorType.EQUALS, 100), new Order("column2", OrderType.DESCENDING));

  Fetching the same data record, while checking for access rights, and ordering it, descending by column2 and ascending by column3:  
        
List<DataRecord> result = JpaDaoAPI.find(dataDescriptor, client, 0, 50, new Criteria("column1", OperatorType.EQUALS, 100), new Order("column2", OrderType.DESCENDING), new Order("column3", OrderType.ASCENDING));

Fetching using the unique ID:

  Fetching the data record that corresponds to ID 23, from an entity:  
        
DataRecord result = JpaDaoAPI.findById(Entity.class, 23);

  Fetching the data record that corresponds to ID 23, from an entity, while checking for access rights:  
        
DataRecord result = JpaDaoAPI.findById(Entity.class, client, 23);

  Fetching the data record that corresponds to ID 23, from a DataDescriptor:  
        
DataRecord result = JpaDaoAPI.findById(DataDescriptor, 23);

  Fetching the data record that corresponds to ID 23, from a DataDescriptor, while checking for access rights:  
        
DataRecord result = JpaDaoAPI.findById(dataDescriptor, client, 23);

Counting rows in a data source:

  Counting the data record rows in an entity:  
        
long count = JpaDaoAPI.getRowCount(Entity.class);

  Counting the data record rows in an entity, while checking for access rights:  
        
long count = JpaDaoAPI.getRowCount(Entity.class, client);

  Counting the data record rows in an entity that meet the specified criteria (has the column1 value of 100):  
        
long count = JpaDaoAPI.getRowCount(Entity.class, new Criteria("column1", OperatorType.EQUALS, 100));

  Counting the data record rows in an entity that meet the specified criteria while checking for access rights:  
        
long count = JpaDaoAPI.getRowCount(Entity.class, client, new Criteria("column1", OperatorType.EQUALS, 100));

  Counting the data record rows in a DataDescriptor:  
        
long count = JpaDaoAPI.getRowCount(DataDescriptor);

  Counting the rows in a DataDescriptor, while checking for access rights:  
        
long count = JpaDaoAPI.getRowCount(DataDescriptor, client);

  Counting the rows in a DataDescriptor that meet the specified criteria (has the column1 value of 100):  
        
long count = JpaDaoAPI.getRowCount(DataDescriptor, new Criteria("column1", OperatorType.EQUALS, 100));

  Counting the rows in a DataDescriptor that meet the specified criteria while checking for access rights:  
        
long count = JpaDaoAPI.getRowCount(DataDescriptor, client, new Criteria("column1", OperatorType.EQUALS, 100));

Save

A DataRecord in the memory can be saved to the database by using the JPA DAO API layer. If the primary key is present in the DataRecord and a DataRecord exists also in the database, the existing one will be overwritten with the one being saved. If no primary key value exists in the data record to be saved or the specified value does not exist in the database, a new value will be committed to the database.

If the save operation results in an error, data in the database will be left unchanged and an error message appears. You can also implement access control for a save operation. If a user has no access rights to write the data, the save operation will return with an error and data will be left unchanged.

  Saving a data record to an entity:  
        
JpaDaoAPI.save(Entity.class, dataRecord);

  Saving a data record to an entity with access control:  
        
JpaDaoAPI.save(Entity.class, client, dataRecord);

  Saving multiple data records to an entity at the same time:  
        
JpaDaoAPI.save(Entity.class, dataRecord1, dataRecord2, dataRecord3);

  Saving multiple data records to an entity at the same time, using access control:  
        
JpaDaoAPI.save(Entity.class, client, dataRecord1, dataRecord2, dataRecord3);

  Saving a data record to a data source:  
        
JpaDaoAPI.save(dataDescriptor, dataRecord);

  Saving a record to a data descriptor with access control:  
        
JpaDaoAPI.save(dataDescriptor, client, dataRecord);

  Saving multiple data records to a data descriptor with access control:  
        
JpaDaoAPI.save(dataDescriptor, dataRecord1, dataRecord2, dataRecord3);

  Saving multiple data records to a data descriptor with access control:  
        
JpaDaoAPI.save(dataDescriptor, client, dataRecord1, dataRecord2, dataRecord3);

Remove

JPA DAO API allows you to delete a record from a database. The prerequisite for this is that the data record must have a unique ID. Except for the unique ID, the API does not use any other values from the data record. Therefore, it is sufficient to use the unique ID to reference the record.

You can even use the API to delete a record. If an exception is thrown during the delete operation, the record will not be deleted. It remains unchanged in the database and an error message appears.

  Deleting a record from an entity:  
        
JpaDaoAPI.remove(Entity.class, dataRecord);

  Deleting multiple records from an entity at the same time:  
        
JpaDaoAPI.remove(Entity.class, dataRecord1, dataRecord2, dataRecord3);

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

  Deleting multiple records from a DataDescriptor:  
        
JpaDaoAPI.remove(dataDescriptor, dataRecord1, dataRecord2, dataRecord3);

JBStrap JPA DAO

Fetch

Save

Remove

Related pages