Class JpaDaoAPI

java.lang.Object
com.jbstrap.core.dao.base.JpaDaoAPI

public final class JpaDaoAPI extends Object
  • Method Details

    • find

      public static List<Record> find(Class<?> type) throws FindException, DataAccessException
      Gets the records of the specified entity
      Parameters:
      type - The entity type, representing a database tables
      Returns:
      Every record of the entity, in a list If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type) throws FindException, DataAccessException
      Gets the records of the specified entity
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database tables
      Returns:
      Every record of the entity, in a list If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, Client client) throws FindException, DataAccessException
      Gets the records of the specified entity
      Parameters:
      type - The entity type, representing a database tables
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      Returns:
      Every record of the entity, in a list If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, Client client) throws FindException, DataAccessException
      Gets the records of the specified entity
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database tables
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      Returns:
      Every record of the entity, in a list If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters.
      Parameters:
      type - The entity type, representing a database tables
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The entity records, that met the criteria. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database tables
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The entity records, that met the criteria. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, Order... orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters.
      Parameters:
      type - The entity type, representing a database tables
      orders - The order objects
      Returns:
      The entity records, that met the criteria. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, Order... orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database tables
      orders - The order objects
      Returns:
      The entity records, that met the criteria. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, List<Order> orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters.
      Parameters:
      type - The entity type, representing a database tables
      orders - The order objects
      Returns:
      The entity records, that met the criteria. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, List<Order> orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database tables
      orders - The order objects
      Returns:
      The entity records, that met the criteria. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, Criteria criteria, Order... orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters.
      Parameters:
      type - The entity type, representing a database tables
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The entity records, that met the criteria. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, Criteria criteria, Order... orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database tables
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The entity records, that met the criteria. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, Criteria criteria, List<Order> orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters.
      Parameters:
      type - The entity type, representing a database tables
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The entity records, that met the criteria. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, Criteria criteria, List<Order> orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database tables
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The entity records, that met the criteria. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, Client client, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters.
      Parameters:
      type - The entity type, representing a database tables
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The entity records, that met the criteria. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, Client client, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database tables
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The entity records, that met the criteria. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, int startRow, int endRow, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      type - The entity type, representing a database tables
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The entity records, that met the criteria, from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, int startRow, int endRow, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database tables
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The entity records, that met the criteria, from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, Client client, int startRow, int endRow, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      type - The entity type, representing a database tables
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The entity records, that met the criteria, from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, Client client, int startRow, int endRow, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database tables
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The entity records, that met the criteria, from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, int startRow, int endRow, Criteria criteria, Order order) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      type - The entity type, representing a database tables
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      order - The order object
      Returns:
      The entity record, ordered from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, int startRow, int endRow, Criteria criteria, Order order) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database tables
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      order - The order object
      Returns:
      The entity record, ordered from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, Client client, int startRow, int endRow, Criteria criteria, Order order) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      type - The entity type, representing a database tables
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      order - The order objects
      Returns:
      The entity records, ordered from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, Client client, int startRow, int endRow, Criteria criteria, Order order) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database tables
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      order - The order objects
      Returns:
      The entity records, ordered from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, int startRow, int endRow, Criteria criteria, Order... orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      type - The entity type, representing a database table
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The entity records, ordered from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, int startRow, int endRow, Criteria criteria, Order... orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The entity records, ordered from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, Client client, int startRow, int endRow, Criteria criteria, Order... orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The entity records, ordered from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, Client client, int startRow, int endRow, Criteria criteria, Order... orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The entity records, ordered from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, int startRow, int endRow, Criteria criteria, List<Order> orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      type - The entity type, representing a database table
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The entity records, ordered from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, int startRow, int endRow, Criteria criteria, List<Order> orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The entity records, ordered from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(Class<?> type, Client client, int startRow, int endRow, Criteria criteria, List<Order> orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The entity records, ordered from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, Class<?> type, Client client, int startRow, int endRow, Criteria criteria, List<Order> orders) throws FindException, DataAccessException
      Gets the records of the specified entity, following the specified parameters, starting from the specified row, and ending at the specified row.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The entity records, ordered from the starting row to the end row. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the type is specified as null
      See Also:
    • find

      public static List<Record> find(JPADataDescriptor dataDescriptor) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      Returns:
      The records of the DataDescriptor in a list If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, JPADataDescriptor dataDescriptor) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      Returns:
      The records of the dataDescriptor in a list If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(JPADataDescriptor dataDescriptor, Client client) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      Returns:
      The records of the DataDescriptor in a list If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      Returns:
      The records of the DataDescriptor in a list If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(JPADataDescriptor dataDescriptor, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The DataDescriptor records (that meet the criteria) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The DataDescriptor records (that meet the criteria) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(JPADataDescriptor dataDescriptor, Client client, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The DataDescriptor records (that meet the criteria) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The DataDescriptor records (that meet the criteria) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(JPADataDescriptor dataDescriptor, int startRow, int endRow, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows.
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, JPADataDescriptor dataDescriptor, int startRow, int endRow, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows.
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(JPADataDescriptor dataDescriptor, Client client, int startRow, int endRow, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows.
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, int startRow, int endRow, Criteria criteria) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows.
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(JPADataDescriptor dataDescriptor, int startRow, int endRow, Criteria criteria, Order order) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows (ordered).
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      order - The order object
      Returns:
      The ordered DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, JPADataDescriptor dataDescriptor, int startRow, int endRow, Criteria criteria, Order order) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows (ordered).
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      order - The order object
      Returns:
      The ordered DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(JPADataDescriptor dataDescriptor, Client client, int startRow, int endRow, Criteria criteria, Order order) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows (ordered).
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      order - The order object
      Returns:
      The ordered DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, int startRow, int endRow, Criteria criteria, Order order) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows (ordered).
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      order - The order object
      Returns:
      The ordered DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(JPADataDescriptor dataDescriptor, int startRow, int endRow, Criteria criteria, Order... orders) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows (ordered).
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The ordered DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, JPADataDescriptor dataDescriptor, int startRow, int endRow, Criteria criteria, Order... orders) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows (ordered).
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The ordered DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(JPADataDescriptor dataDescriptor, Client client, int startRow, int endRow, Criteria criteria, Order... orders) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows (ordered).
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The ordered DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, int startRow, int endRow, Criteria criteria, Order... orders) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows (ordered).
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The ordered DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(JPADataDescriptor dataDescriptor, int startRow, int endRow, Criteria criteria, List<Order> orders) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows (ordered).
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The ordered DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, JPADataDescriptor dataDescriptor, int startRow, int endRow, Criteria criteria, List<Order> orders) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows (ordered).
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The ordered DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(JPADataDescriptor dataDescriptor, Client client, int startRow, int endRow, Criteria criteria, List<Order> orders) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows (ordered).
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The ordered DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • find

      public static List<Record> find(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, int startRow, int endRow, Criteria criteria, List<Order> orders) throws FindException, DataAccessException
      Gets the records of the specified entity based DataDescriptor, that meet the specified criteria, between the specified starting and ending rows (ordered).
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      startRow - Specifies the starting row of the query. Can be 0, or a positive integer.
      endRow - Specifies the ending row of the query. If less than the startRow parameter, the value will be the Integer.MAX_VALUE parameter value
      criteria - Database criteria object (can be complex or simple)
      orders - The order objects
      Returns:
      The ordered DataDescriptor records (that meet the criteria, between the specified rows) in a list. If not found, returns with an empty list.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • findById

      public static Record findById(Class<?> type, Object id) throws FindException, DataAccessException
      Gets the entity specified in the parameter by its primary key (ID)
      Parameters:
      type - The entity type, representing a database table
      id - The primary key of the record, that is queried.
      Returns:
      The entity record, that has the same primary key, as the specified primary key. If not found, returns with null.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • findById

      public static Record findById(SQLTransaction transaction, Class<?> type, Object id) throws FindException, DataAccessException
      Gets the entity specified in the parameter by its primary key (ID)
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      id - The primary key of the record, that is queried.
      Returns:
      The entity record, that has the same primary key, as the specified primary key. If not found, returns with null.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • findById

      public static Record findById(Class<?> type, Client client, Object id) throws FindException, DataAccessException
      Gets the entity specified in the parameter by its primary key (ID)
      Parameters:
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      id - The primary key of the record, that is queried.
      Returns:
      The entity record, that has the same primary key, as the specified primary key. If not found, returns with null.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • findById

      public static Record findById(SQLTransaction transaction, Class<?> type, Client client, Object id) throws FindException, DataAccessException
      Gets the entity specified in the parameter by its primary key (ID)
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      id - The primary key of the record, that is queried.
      Returns:
      The entity record, that has the same primary key, as the specified primary key. If not found, returns with null.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • findById

      public static Record findById(JPADataDescriptor dataDescriptor, Object id) throws FindException, DataAccessException
      Gets the entity based DataDescriptor specified in the parameter by its primary key (ID)
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      id - The primary key of the record, that is queried.
      Returns:
      The DataDescriptor record, that has the same primary key, as the one specified in the parameter. If not found returns null.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • findById

      public static Record findById(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Object id) throws FindException, DataAccessException
      Gets the entity based DataDescriptor specified in the parameter by its primary key (ID)
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      id - The primary key of the record, that is queried.
      Returns:
      The DataDescriptor record, that has the same primary key, as the one specified in the parameter. If not found returns null.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • findById

      public static Record findById(JPADataDescriptor dataDescriptor, Client client, Object id) throws FindException, DataAccessException
      Gets the entity based DataDescriptor specified in the parameter by its primary key (ID)
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      id - The primary key of the record, that is queried.
      Returns:
      The DataDescriptor record, that has the same primary key, as the one specified in the parameter. If not found returns null.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • findById

      public static Record findById(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, Object id) throws FindException, DataAccessException
      Gets the entity based DataDescriptor specified in the parameter by its primary key (ID)
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      id - The primary key of the record, that is queried.
      Returns:
      The DataDescriptor record, that has the same primary key, as the one specified in the parameter. If not found returns null.
      Throws:
      FindException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - Occurs if the DataDescriptor in the parameter is null
      See Also:
    • getRowCount

      public static long getRowCount(Class<?> type) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified record
      Parameters:
      type - The entity type, representing a database table
      Returns:
      The number of entity record rows. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
    • getRowCount

      public static long getRowCount(SQLTransaction transaction, Class<?> type) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified record
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      Returns:
      The number of entity record rows. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
    • getRowCount

      public static long getRowCount(Class<?> type, Client client) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified record
      Parameters:
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      Returns:
      The number of entity record rows. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
      See Also:
    • getRowCount

      public static long getRowCount(SQLTransaction transaction, Class<?> type, Client client) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified record
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      Returns:
      The number of entity record rows. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
      See Also:
    • getRowCount

      public static long getRowCount(Class<?> type, Criteria criteria) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified record, that meet the criteria
      Parameters:
      type - The entity type, representing a database table
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The number of entity record rows, that met the criteria. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data. If not found, null
      IllegalArgumentException - If the entity type is specified as null
      See Also:
    • getRowCount

      public static long getRowCount(SQLTransaction transaction, Class<?> type, Criteria criteria) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified record, that meet the criteria
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The number of entity record rows, that met the criteria. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data. If not found, null
      IllegalArgumentException - If the entity type is specified as null
      See Also:
    • getRowCount

      public static long getRowCount(Class<?> type, Client client, Criteria criteria) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified entity record, that meet the criteria
      Parameters:
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The number of entity record rows, that met the criteria. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
      See Also:
    • getRowCount

      public static long getRowCount(SQLTransaction transaction, Class<?> type, Client client, Criteria criteria) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified entity record, that meet the criteria
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The number of entity record rows, that met the criteria. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
      See Also:
    • getRowCount

      public static long getRowCount(JPADataDescriptor dataDescriptor) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified entity based DataDescriptor record.
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      Returns:
      The number of DataDescriptor record rows. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
    • getRowCount

      public static long getRowCount(SQLTransaction transaction, JPADataDescriptor dataDescriptor) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified entity based DataDescriptor record.
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      Returns:
      The number of DataDescriptor record rows. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
    • getRowCount

      public static long getRowCount(JPADataDescriptor dataDescriptor, Client client) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified entity based DataDescriptor record.
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      Returns:
      The number of DataDescriptor record rows. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
      See Also:
    • getRowCount

      public static long getRowCount(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified entity based DataDescriptor record.
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      Returns:
      The number of DataDescriptor record rows. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
      See Also:
    • getRowCount

      public static long getRowCount(JPADataDescriptor dataDescriptor, Criteria criteria) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified entity based DataDescriptor record, that meet the criteria.
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The number of DataDescriptor record rows, that met the criteria. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
      See Also:
    • getRowCount

      public static long getRowCount(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Criteria criteria) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified entity based DataDescriptor record, that meet the criteria.
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The number of DataDescriptor record rows, that met the criteria. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
      See Also:
    • getRowCount

      public static long getRowCount(JPADataDescriptor dataDescriptor, Client client, Criteria criteria) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified entity based DataDescriptor record, that meet the criteria.
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The number of DataDescriptor record rows, that met the criteria. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
      See Also:
    • getRowCount

      public static long getRowCount(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, Criteria criteria) throws RowCountException, DataAccessException
      Counts and returns the rows of the specified entity based DataDescriptor record, that meet the criteria.
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      criteria - Database criteria object (can be complex or simple)
      Returns:
      The number of DataDescriptor record rows, that met the criteria. If not found, null
      Throws:
      RowCountException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to read the data
      IllegalArgumentException - If the entity type is specified as null
      See Also:
    • save

      public static List<Record> save(Class<?> type, Record record) throws SaveException, DataAccessException
      Saves the record to the specified entity. The record field names must match the entity field names.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      Parameters:
      type - The entity type, representing a database table
      record - The record to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the data
      See Also:
    • save

      public static List<Record> save(SQLTransaction transaction, Class<?> type, Record record) throws SaveException, DataAccessException
      Saves the record to the specified entity. The record field names must match the entity field names.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      record - The record to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the data
      See Also:
    • save

      public static List<Record> save(Class<?> type, Client client, Record record) throws SaveException, DataAccessException
      Saves the record to the specified entity. The record field names must match the entity field names.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      Parameters:
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      record - The record to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(SQLTransaction transaction, Class<?> type, Client client, Record record) throws SaveException, DataAccessException
      Saves the record to the specified entity. The record field names must match the entity field names.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      record - The record to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(Class<?> type, Record... records) throws SaveException, DataAccessException
      Saves the records to the specified entity. The field names in the record must be the same as in the entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too. In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      type - The entity type, representing a database table
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(SQLTransaction transaction, Class<?> type, Record... records) throws SaveException, DataAccessException
      Saves the records to the specified entity. The field names in the record must be the same as in the entity
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too. In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(Class<?> type, Client client, Record... records) throws SaveException, DataAccessException
      Saves the records to the specified entity. The field names in the record must be the same as in the entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The saved records, that include every value, that are set during the saving operation.
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(SQLTransaction transaction, Class<?> type, Client client, Record... records) throws SaveException, DataAccessException
      Saves the records to the specified entity. The field names in the record must be the same as in the entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The saved records, that include every value, that are set during the saving operation.
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(Class<?> type, List<Record> records) throws SaveException, DataAccessException
      Saves the records to the specified entity. The field names in the record must be the same as in the entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too. In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      type - The entity type, representing a database table
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(SQLTransaction transaction, Class<?> type, List<Record> records) throws SaveException, DataAccessException
      Saves the records to the specified entity. The field names in the record must be the same as in the entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too. In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(Class<?> type, Client client, List<Record> records) throws SaveException, DataAccessException
      Saves the records to the specified entity. The field names in the record must be the same as in the entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(SQLTransaction transaction, Class<?> type, Client client, List<Record> records) throws SaveException, DataAccessException
      Saves the records to the specified entity. The field names in the record must be the same as in the entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(JPADataDescriptor dataDescriptor, Record record) throws SaveException, DataAccessException
      Saves the record to the specified entity, that is defined by a DataDescriptor. The field names in the record must be the same as the field names in the DataDescriptor defined entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the fields marked with the (ForeignKey) annotation will be set. The SCD (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) annotations, view mapping (ViewEntity, MappedField and the history HistoryCustomizer annotations will be processed as well.
      Files are saved, (FileHandler) and so do the mutli-value fields (JBMultiValue).
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      record - The record that will be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Record record) throws SaveException, DataAccessException
      Saves the record to the specified entity, that is defined by a DataDescriptor. The field names in the record must be the same as the field names in the DataDescriptor defined entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the fields marked with the (ForeignKey) annotation will be set. The SCD (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) annotations, view mapping (ViewEntity, MappedField and the history HistoryCustomizer annotations will be processed as well.
      Files are saved, (FileHandler) and so do the mutli-value fields (JBMultiValue).
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      record - The record that will be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(JPADataDescriptor dataDescriptor, Client client, Record record) throws SaveException, DataAccessException
      Saves the record to the specified entity, that is defined by a DataDescriptor. The field names in the record must be the same as the field names in the DataDescriptor defined entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      record - The record that will be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, Record record) throws SaveException, DataAccessException
      Saves the record to the specified entity, that is defined by a DataDescriptor. The field names in the record must be the same as the field names in the DataDescriptor defined entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      record - The record that will be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(JPADataDescriptor dataDescriptor, Record... records) throws SaveException, DataAccessException
      Saves the records to the specified entity, that is defined by a DataDescriptor. The field names in the record must be the same as the field names in the DataDescriptor defined entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too. In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Record... records) throws SaveException, DataAccessException
      Saves the records to the specified entity, that is defined by a DataDescriptor. The field names in the record must be the same as the field names in the DataDescriptor defined entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too. In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(JPADataDescriptor dataDescriptor, Client client, Record... records) throws SaveException, DataAccessException
      Saves the records to the specified entity, that is defined by a DataDescriptor. The field names in the record must be the same as the field names in the DataDescriptor defined entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, Record... records) throws SaveException, DataAccessException
      Saves the records to the specified entity, that is defined by a DataDescriptor. The field names in the record must be the same as the field names in the DataDescriptor defined entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(JPADataDescriptor dataDescriptor, List<Record> records) throws SaveException, DataAccessException
      Saves the records to the specified entity, that is defined by a DataDescriptor. The field names in the record must be the same as the field names in the DataDescriptor defined entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too. In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(SQLTransaction transaction, JPADataDescriptor dataDescriptor, List<Record> records) throws SaveException, DataAccessException
      Saves the records to the specified entity, that is defined by a DataDescriptor. The field names in the record must be the same as the field names in the DataDescriptor defined entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too. In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(JPADataDescriptor dataDescriptor, Client client, List<Record> records) throws SaveException, DataAccessException
      Saves the records to the specified entity, that is defined by a DataDescriptor. The field names in the record must be the same as the field names in the DataDescriptor defined entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • save

      public static List<Record> save(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, List<Record> records) throws SaveException, DataAccessException
      Saves the records to the specified entity, that is defined by a DataDescriptor. The field names in the record must be the same as the field names in the DataDescriptor defined entity.
      If the entity's primary key is set, and the database table representing the entity already has such value, then a modification will be executed, otherwise a new record will be inserted into the database table.
      During saving, the audit fields (Creator, Modifier, CreatorTimestamp, ModifierTimestamp) and the field that has the ForeignKey annotation will be filled The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      the files are also saved (FileHandler) and the fields with multiple values (JBMultiValue) are saved too.
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be saved
      Returns:
      The saved records, that include every value, that are set during the saving operation.
      Throws:
      SaveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(Class<?> type, Record record) throws RemoveException, DataAccessException
      Removes the records from the specified entity. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      Parameters:
      type - The entity type, representing a database table
      record - The record to be removed
      Returns:
      The removed record
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(SQLTransaction transaction, Class<?> type, Record record) throws RemoveException, DataAccessException
      Removes the records from the specified entity. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      record - The record to be removed
      Returns:
      The removed record
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(Class<?> type, Client client, Record record) throws RemoveException, DataAccessException
      Removes the records from the specified entity. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      Parameters:
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      record - The record to be removed
      Returns:
      The removed record
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(SQLTransaction transaction, Class<?> type, Client client, Record record) throws RemoveException, DataAccessException
      Removes the records from the specified entity. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      record - The record to be removed
      Returns:
      The removed record
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(Class<?> type, Record... records) throws RemoveException, DataAccessException
      Removes the records from the specified entity. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      type - The entity type, representing a database table
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(SQLTransaction transaction, Class<?> type, Record... records) throws RemoveException, DataAccessException
      Removes the records from the specified entity. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(Class<?> type, Client client, Record... records) throws RemoveException, DataAccessException
      Removes the records from the specified entity. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(SQLTransaction transaction, Class<?> type, Client client, Record... records) throws RemoveException, DataAccessException
      Removes the records from the specified entity. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(Class<?> type, List<Record> records) throws RemoveException, DataAccessException
      Removes the records from the specified entity. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      type - The entity type, representing a database table
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(SQLTransaction transaction, Class<?> type, List<Record> records) throws RemoveException, DataAccessException
      Removes the records from the specified entity. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(Class<?> type, Client client, List<Record> records) throws RemoveException, DataAccessException
      Removes the records from the specified entity. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(SQLTransaction transaction, Class<?> type, Client client, List<Record> records) throws RemoveException, DataAccessException
      Removes the records from the specified entity. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      type - The entity type, representing a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(JPADataDescriptor dataDescriptor, Record record) throws RemoveException, DataAccessException
      Removes the record from the specified entity, that is defined by a DataDescriptor. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      record - The record to be removed
      Returns:
      The removed record
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Record record) throws RemoveException, DataAccessException
      Removes the record from the specified entity, that is defined by a DataDescriptor. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      record - The record to be removed
      Returns:
      The removed record
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(JPADataDescriptor dataDescriptor, Client client, Record record) throws RemoveException, DataAccessException
      Removes the record from the specified entity, that is defined by a DataDescriptor. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      record - The record to be removed
      Returns:
      The removed record
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, Record record) throws RemoveException, DataAccessException
      Removes the record from the specified entity, that is defined by a DataDescriptor. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      record - The record to be removed
      Returns:
      The removed record
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(JPADataDescriptor dataDescriptor, Record... records) throws RemoveException, DataAccessException
      Removes the records from the specified entity, that is defined by a DataDescriptor. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Record... records) throws RemoveException, DataAccessException
      Removes the records from the specified entity, that is defined by a DataDescriptor. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(JPADataDescriptor dataDescriptor, Client client, Record... records) throws RemoveException, DataAccessException
      Removes the records from the specified entity, that is defined by a DataDescriptor. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, Record... records) throws RemoveException, DataAccessException
      Removes the records from the specified entity, that is defined by a DataDescriptor. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(JPADataDescriptor dataDescriptor, List<Record> records) throws RemoveException, DataAccessException
      Removes the records from the specified entity, that is defined by a DataDescriptor. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(SQLTransaction transaction, JPADataDescriptor dataDescriptor, List<Record> records) throws RemoveException, DataAccessException
      Removes the records from the specified entity, that is defined by a DataDescriptor. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(JPADataDescriptor dataDescriptor, Client client, List<Record> records) throws RemoveException, DataAccessException
      Removes the records from the specified entity, that is defined by a DataDescriptor. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • remove

      public static List<Record> remove(SQLTransaction transaction, JPADataDescriptor dataDescriptor, Client client, List<Record> records) throws RemoveException, DataAccessException
      Removes the records from the specified entity, that is defined by a DataDescriptor. The removal is done based on the primary key. The record's primary key field name must be the same, as the entity's primary key field name.
      The SCD annotation (SCD, ActiveFlag, EntityId, ValidFrom, ValidTo) fields, view creation ViewEntity, MappedField) and history annotations (HistoryCustomizer) are also processed.
      The files are removed, (FileHandler), along with the database records with multi value fields (JBMultiValue)
      In the case of multiple records, the saving is done in a transaction. If any errors are encountered, the transaction will be withdrawn
      Parameters:
      transaction - The SQL transaction instance
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      client - The client object, that is necessary for the FileHandler, it is also needed for the read access verification.
      records - The records to be removed
      Returns:
      The removed records.
      Throws:
      RemoveException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
      DataAccessException - If the user has no access to write the entity
      See Also:
    • getJDBCConnection

      public static Connection getJDBCConnection()
      Gets a generic Connection from the persistence unit, that was specified in the persistence xml file.
      Returns:
      A connection from the Persistence unit
      Throws:
      javax.persistence.PersistenceException - If the JPA implementation (that is served by the persistence layer) doesn't support the Connection query
    • getSeqNextVal

      public static Object getSeqNextVal(Class<?> type)
      Gets the next sequence value from an entity.
      Parameters:
      type - The entity, that contains the sequence.
      Returns:
      The next sequence value
      Throws:
      IllegalArgumentException - Occurs if the entity is null
    • getSeqNextVal

      public static Object getSeqNextVal(JPADataDescriptor dataDescriptor)
      Gets the next sequence value from the specified DataDescriptor based entity.
      Parameters:
      dataDescriptor - A DataDescriptor, that is based on an entity, that represents a database table
      Returns:
      The next sequence value
      Throws:
      IllegalArgumentException - Occurs if the entity and the DataDescriptor is null
    • startTransaction

      public static SQLTransaction startTransaction()
      Starts a new transaction from the persistence layer. With the help of the transaction, multiple operations can be done in a session. The user can use the commit and rollBack operations. If any error is encountered, an automatic rollBack will be executed.
      Returns:
      A database transaction
      See Also:
    • runNativeSelect

      public static List<Record> runNativeSelect(String sql) throws NativeStatementException
      Runs a native sql query with no parameters By default, field names in returned records are in uppercase. To return database-specific field names, use the following method: runNativeSelect(String, boolean)
      Parameters:
      sql - The Sql query in text
      Returns:
      The queried result records. The record query field names can only be in all caps.
      Throws:
      NativeStatementException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
    • runNativeSelect

      public static List<Record> runNativeSelect(SQLTransaction transaction, String sql) throws NativeStatementException
      Runs a native sql query with no parameters By default, field names in returned records are in uppercase. To return database-specific field names, use the following method: runNativeSelect(String, boolean)
      Parameters:
      transaction - The SQL transaction instance
      sql - The Sql query in text
      Returns:
      The queried result records. The record query field names can only be in all caps.
      Throws:
      NativeStatementException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
    • runNativeSelect

      public static List<Record> runNativeSelect(String sql, Object... params) throws NativeStatementException
      Runs a native sql query with the specified parameters. The parameters will be bounded to the query, thus they will be placed in the sql instruction with the correct type. By default, field names in returned records are in uppercase. To return database-specific field names, use the following method: runNativeSelect(String, boolean, Object...) or
      Parameters:
      sql - The sql query in text
      params - The query parameters (with correct types)
      Returns:
      The queried records. The field names in the records are in all caps.
      Throws:
      NativeStatementException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
    • runNativeSelect

      public static List<Record> runNativeSelect(SQLTransaction transaction, String sql, Object... params) throws NativeStatementException
      Runs a native sql query with the specified parameters. The parameters will be bounded to the query, thus they will be placed in the sql instruction with the correct type. By default, field names in returned records are in uppercase. To return database-specific field names, use the following method: runNativeSelect(String, boolean, Object...) or
      Parameters:
      transaction - The SQL transaction instance
      sql - The sql query in text
      params - The query parameters (with correct types)
      Returns:
      The queried records. The field names in the records are in all caps.
      Throws:
      NativeStatementException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
    • runNativeSelect

      public static List<Record> runNativeSelect(String sql, boolean upperCase) throws NativeStatementException
      Runs a native sql query with no parameters
      Parameters:
      sql - The Sql query in text
      upperCase - Use it to determine whether field names in result records should be returned in uppercase or in a database-specific way
      Returns:
      The queried result records. The record query field names can only be in all caps.
      Throws:
      NativeStatementException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
    • runNativeSelect

      public static List<Record> runNativeSelect(SQLTransaction transaction, String sql, boolean upperCase) throws NativeStatementException
      Runs a native sql query with no parameters
      Parameters:
      transaction - The SQL transaction instance
      sql - The Sql query in text
      upperCase - Use it to determine whether field names in result records should be returned in uppercase or in a database-specific way
      Returns:
      The queried result records. The record query field names can only be in all caps.
      Throws:
      NativeStatementException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
    • runNativeSelect

      public static List<Record> runNativeSelect(String sql, boolean upperCase, Object... params) throws NativeStatementException
      Runs a native sql query with the specified parameters. The parameters will be bounded to the query, thus they will be placed in the sql instruction with the correct type.
      Parameters:
      sql - The sql query in tex
      upperCase - Use it to determine whether field names in result records should be returned in uppercase or in a database-specific way
      params - The query parameters (with correct types)
      Returns:
      The queried records. The field names in the records are in all caps.
      Throws:
      NativeStatementException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
    • runNativeSelect

      public static List<Record> runNativeSelect(SQLTransaction transaction, String sql, boolean upperCase, Object... params) throws NativeStatementException
      Runs a native sql query with the specified parameters. The parameters will be bounded to the query, thus they will be placed in the sql instruction with the correct type.
      Parameters:
      transaction - The SQL transaction instance
      sql - The sql query in tex
      upperCase - Use it to determine whether field names in result records should be returned in uppercase or in a database-specific way
      params - The query parameters (with correct types)
      Returns:
      The queried records. The field names in the records are in all caps.
      Throws:
      NativeStatementException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
    • runNativeStatement

      public static void runNativeStatement(String sql) throws NativeStatementException
      Runs a native sql statement with no parameters
      Parameters:
      sql - The Sql statement in text
      Throws:
      NativeStatementException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
    • runNativeStatement

      public static void runNativeStatement(SQLTransaction transaction, String sql) throws NativeStatementException
      Runs a native sql statement with no parameters
      Parameters:
      transaction - The SQL transaction instance
      sql - The Sql statement in text
      Throws:
      NativeStatementException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
    • runNativeStatement

      public static void runNativeStatement(String sql, Object... params) throws NativeStatementException
      Runs a native sql statement with the specified parameters. The parameters will be bounded to the statement, thus they will be placed in the sql statement with the correct type.
      Parameters:
      sql - The sql statement in text
      params - The to be applied parameters (with correct types)
      Throws:
      NativeStatementException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
    • runNativeStatement

      public static void runNativeStatement(SQLTransaction transaction, String sql, Object... params) throws NativeStatementException
      Runs a native sql statement with the specified parameters. The parameters will be bounded to the statement, thus they will be placed in the sql statement with the correct type.
      Parameters:
      transaction - The SQL transaction instance
      sql - The sql statement in text
      params - The to be applied parameters (with correct types)
      Throws:
      NativeStatementException - Occurs if an error is encountered in the persistence layer. (The database or persistence layer is not found)
    • getPrimaryKey

      public static Object getPrimaryKey(Record record)
      Gets the value of the primary key from the specified record.
      Parameters:
      record - The record, whose primary key value is requested
      Returns:
      The primary key of the entity, that was created from the record. Can be a composite key.