ActiveTable (sormula)

java.lang.Object
- org.sormula.active.ActiveTable<R>

Type Parameters:
R - record type
```
public class ActiveTable<R extends ActiveRecord<R>>
extends java.lang.Object
```
Performs all database operations for ActiveRecord objects. This class is used by ActiveRecord to perform single record operations. This class may also be created explicity to invoke collection methods like, saveAll(Collection), insertAll(Collection), updateAll(Collection), deleteAll(Collection), and select methods.

Since:

1.7 and 2.1

Author:

Jeff Miller

Constructor Summary

Constructors
Constructor and Description
`ActiveTable(ActiveDatabase activeDatabase, java.lang.Class<R> recordClass)` Constructs for a database and record type.
`ActiveTable(java.lang.Class<R> recordClass)` Constructs for default active database and a record type.

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`delete(R record)` Deletes by primary key.
`int`	`deleteAll()` Deletes all records in table.
`int`	`deleteAll(java.util.Collection<R> records)` Deletes many records by primary key.
`int`	`deleteAllBatch(java.util.Collection<R> records)` Deletes many records by primary key in batch mode.
`ActiveDatabase`	`getActiveDatabase()` Gets the active database.
`java.lang.Class<R>`	`getRecordClass()` Gets the record class.
`int`	`insert(R record)` Inserts one record into table.
`int`	`insertAll(java.util.Collection<R> records)` Inserts collection of records.
`int`	`insertAllBatch(java.util.Collection<R> records)` Inserts collection of records in batch mode.
`R`	`newActiveRecord()` Creates a new active record of type R using zero-arg constructor.
`int`	`save(R record)` Updates an existing record or insert record if it is not already in database.
`int`	`saveAll(java.util.Collection<R> records)` Updates an existing records or insert records if they are not already in database.
`R`	`select(java.lang.Object... primaryKeys)` Selects one record in table using primary key.
`java.util.List<R>`	`selectAll()` Selects all records in table.
`java.util.List<R>`	`selectAllCustom(java.lang.String customSql, java.lang.Object... parameters)` Select list of records using custom sql.
`java.util.List<R>`	`selectAllWhere(java.lang.String whereConditionName, java.lang.Object... parameters)` Selects list of records for where condition and parameters.
`java.util.List<R>`	`selectAllWhereOrdered(java.lang.String whereConditionName, java.lang.String orderByName, java.lang.Object... parameters)` Selects list of records for where condition and parameters.
`<T> T`	`selectAvg(java.lang.String expression)` Selects average value.
`<T> T`	`selectAvg(java.lang.String expression, java.lang.String whereConditionName, java.lang.Object... parameters)` Selects average value.
`<T> T`	`selectCount()` Selects count of records using "select count(*) from ...".
`<T> T`	`selectCount(java.lang.String expression)` Selects count of records.
`<T> T`	`selectCount(java.lang.String expression, java.lang.String whereConditionName, java.lang.Object... parameters)` Selects count of records.
`R`	`selectCustom(java.lang.String customSql, java.lang.Object... parameters)` Select list of records using custom sql.
`<T> T`	`selectMax(java.lang.String expression)` Selects maximum value.
`<T> T`	`selectMax(java.lang.String expression, java.lang.String whereConditionName, java.lang.Object... parameters)` Selects maximum value.
`<T> T`	`selectMin(java.lang.String expression)` Selects minimum value.
`<T> T`	`selectMin(java.lang.String expression, java.lang.String whereConditionName, java.lang.Object... parameters)` Selects minimum value.
`<T> T`	`selectSum(java.lang.String expression)` Selects sum.
`<T> T`	`selectSum(java.lang.String expression, java.lang.String whereConditionName, java.lang.Object... parameters)` Selects sum.
`R`	`selectWhere(java.lang.String whereConditionName, java.lang.Object... parameters)` Selects one record for where condition and parameters.
`int`	`update(R record)` Updates one record in table by primary key.
`int`	`updateAll(java.util.Collection<R> records)` Updates collection of records using primary key.
`int`	`updateAllBatch(java.util.Collection<R> records)` Updates collection of records using primary key in batch mode.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ActiveTable
```
public ActiveTable(java.lang.Class<R> recordClass)
            throws ActiveException
```
    Constructs for default active database and a record type. Uses the default active database that is configured with ActiveDatabase.setDefault(ActiveDatabase). The default active database must be configured prior to first database access by this table.
    
    Parameters:
    recordClass - Java class of record
    
    Throws:
    
    ActiveException - if error
  - ActiveTable
```
public ActiveTable(ActiveDatabase activeDatabase,
           java.lang.Class<R> recordClass)
            throws ActiveException
```
    Constructs for a database and record type.
    
    Parameters:
    activeDatabase - active database that defines data source for records
    recordClass - Java class of record
    
    Throws:
    
    ActiveException - if activeDatabase is null
- Method Detail
  - getActiveDatabase
```
public ActiveDatabase getActiveDatabase()
```
    Gets the active database.
    
    Returns:
    active database that was supplied in constructor
  - getRecordClass
```
public java.lang.Class<R> getRecordClass()
```
    Gets the record class.
    
    Returns:
    record class supplied in constructor
  - newActiveRecord
```
public R newActiveRecord()
                                          throws ActiveException
```
    Creates a new active record of type R using zero-arg constructor. New record is attached to this tables active database with ActiveRecord.attach(ActiveDatabase).
    
    Returns:
    new active record
    
    Throws:
    
    ActiveException - if error
  - select
```
public R select(java.lang.Object... primaryKeys)
                                 throws ActiveException
```
    Selects one record in table using primary key. Primary key must be defined by one or more Column.primaryKey() annotations. ActiveRecord.attach(ActiveDatabase) is invoked on selected record to attach it to the active database of this table.
    Example:
    ActiveDatabase activeDatabase = ... ActiveTable<Order> table = new ActiveTable<Order>(activeDatabase, Order.class); int orderNumber = 123456; // primary key Order order = table.select(orderNumber);
    Parameters:
    primaryKeys - primary key values to use for select (must be in same order as primary key columns appear with record class)
    
    Returns:
    record or null if none found
    
    Throws:
    
    ActiveException - if error
  - selectWhere
```
public R selectWhere(java.lang.String whereConditionName,
            java.lang.Object... parameters)
                                      throws ActiveException
```
    Selects one record for where condition and parameters. ActiveRecord.attach(ActiveDatabase) is invoked on selected record to attach it to the active database of this table.
    
    Parameters:
    whereConditionName - name of where condition to use; empty string to select arbitrary record in table
    parameters - parameter values for where condition
    
    Returns:
    record for where condition and parameters; null if none found
    
    Throws:
    
    ActiveException - if error
  - selectCustom
```
public R selectCustom(java.lang.String customSql,
             java.lang.Object... parameters)
                                       throws ActiveException
```
    Select list of records using custom sql. ActiveRecord.attach(ActiveDatabase) is invoked on selected record to attach it to the active database of this table.
    Example:
    ActiveDatabase activeDatabase = ... ActiveTable<Order> table = new ActiveTable<Order>(activeDatabase, Order.class); List<Order> orders = table.selectAllCustom("where orderdate >= '2011-01-01'");
    Parameters:
    customSql - custom sql to be appended to base sql (for example, "where somecolumn=?")
    parameters - parameter value to be set in customSql
    
    Returns:
    record or null if none found
    
    Throws:
    
    ActiveException - if error
  - selectAll
```
public java.util.List<R> selectAll()
                                                    throws ActiveException
```
    Selects all records in table. ActiveRecord.attach(ActiveDatabase) is invoked on selected records to attach them to the active database of this table.
    Example:
    ActiveDatabase activeDatabase = ... ActiveTable<Order> table = new ActiveTable<Order>(activeDatabase, Order.class); List<Order> orders = table.selectAll();
    Returns:
    list of all records; empty list if none found
    
    Throws:
    
    ActiveException - if error
  - selectAllWhere
```
public java.util.List<R> selectAllWhere(java.lang.String whereConditionName,
                               java.lang.Object... parameters)
                                                         throws ActiveException
```
    Selects list of records for where condition and parameters. ActiveRecord.attach(ActiveDatabase) is invoked on selected records to attach them to the active database of this table.
    
    Parameters:
    whereConditionName - name of where condition to use; empty string to select all records in table
    parameters - parameter values for where condition
    
    Returns:
    records for where condition and parameters; empty list if none found
    
    Throws:
    
    ActiveException - if error
  - selectAllWhereOrdered
```
public java.util.List<R> selectAllWhereOrdered(java.lang.String whereConditionName,
                                      java.lang.String orderByName,
                                      java.lang.Object... parameters)
                                                                throws ActiveException
```
    Selects list of records for where condition and parameters. ActiveRecord.attach(ActiveDatabase) is invoked on selected records to attach them to the active database of this table.
    
    Parameters:
    whereConditionName - name of where condition to use; empty string to select all records in table
    orderByName - name of order phrase to use as defined in OrderBy.name()
    parameters - parameter values for where condition
    
    Returns:
    records for where condition and parameters; empty list if none found
    
    Throws:
    
    ActiveException - if error
  - selectAllCustom
```
public java.util.List<R> selectAllCustom(java.lang.String customSql,
                                java.lang.Object... parameters)
                                                          throws ActiveException
```
    Select list of records using custom sql. ActiveRecord.attach(ActiveDatabase) is invoked on selected records to attach them to the active database of this table.
    Example:
    ActiveDatabase activeDatabase = ... ActiveTable<Order> table = new ActiveTable<Order>(activeDatabase, Order.class); List<Order> orders = table.selectAllCustom("where orderdate >= '2011-01-01'");
    Parameters:
    customSql - custom sql to be appended to base sql (for example, "where somecolumn=?")
    parameters - parameter value to be set in customSql
    
    Returns:
    list of records selected; empty list if none found
    
    Throws:
    
    ActiveException - if error
  - selectCount
```
public <T> T selectCount()
              throws ActiveException
```
    Selects count of records using "select count(*) from ...".
    The data type returned from database is the same type as the expression. The return type is database dependent since expression is "*".
    
    Type Parameters:
    T - aggregate result type
    
    Returns:
    count of records for expression
    
    Throws:
    
    ActiveException - if error
  - selectCount
```
public <T> T selectCount(java.lang.String expression)
              throws ActiveException
```
    Selects count of records.
    The data type returned from database is the same type as the expression. For example, if expression is a column, then the returned type is the same type as column. If expression is "*", then return types are database dependent.
    
    Type Parameters:
    T - aggregate result type
    Parameters:
    expression - expression to use as parameter to function; typically it is the name of a column
    
    Returns:
    count of records for expression
    
    Throws:
    
    ActiveException - if error
  - selectCount
```
public <T> T selectCount(java.lang.String expression,
                java.lang.String whereConditionName,
                java.lang.Object... parameters)
              throws ActiveException
```
    Selects count of records.
    The data type returned from database is the same type as the expression. For example, if expression is a column, then the returned type is the same type as column. If expression is "*", then return types are database dependent.
    
    Type Parameters:
    T - aggregate result type
    Parameters:
    expression - expression to use as parameter to function; typically it is the name of a column
    whereConditionName - name of where condition to use; empty string to count all records in table
    parameters - parameter values for where condition
    
    Returns:
    count of records for expression and where condition
    
    Throws:
    
    ActiveException - if error
  - selectMin
```
public <T> T selectMin(java.lang.String expression)
            throws ActiveException
```
    Selects minimum value.
    
    Type Parameters:
    T - aggregate result type
    Parameters:
    expression - expression to use as parameter to function; typically it is the name of a column
    
    Returns:
    minimum value for expression
    
    Throws:
    
    ActiveException - if error
  - selectMin
```
public <T> T selectMin(java.lang.String expression,
              java.lang.String whereConditionName,
              java.lang.Object... parameters)
            throws ActiveException
```
    Selects minimum value.
    
    Type Parameters:
    T - aggregate result type
    Parameters:
    expression - expression to use as parameter to function; typically it is the name of a column
    whereConditionName - name of where condition to use; empty string to count all records in table
    parameters - parameter values for where condition
    
    Returns:
    minimum value for expression and where condition
    
    Throws:
    
    ActiveException - if error
  - selectMax
```
public <T> T selectMax(java.lang.String expression)
            throws ActiveException
```
    Selects maximum value.
    
    Type Parameters:
    T - aggregate result type
    Parameters:
    expression - expression to use as parameter to function; typically it is the name of a column
    
    Returns:
    maximum value for expression
    
    Throws:
    
    ActiveException - if error
  - selectMax
```
public <T> T selectMax(java.lang.String expression,
              java.lang.String whereConditionName,
              java.lang.Object... parameters)
            throws ActiveException
```
    Selects maximum value.
    
    Type Parameters:
    T - aggregate result type
    Parameters:
    expression - expression to use as parameter to function; typically it is the name of a column
    whereConditionName - name of where condition to use; empty string to count all records in table
    parameters - parameter values for where condition
    
    Returns:
    maximum value for expression and where condition
    
    Throws:
    
    ActiveException - if error
  - selectSum
```
public <T> T selectSum(java.lang.String expression)
            throws ActiveException
```
    Selects sum.
    
    Type Parameters:
    T - aggregate result type
    Parameters:
    expression - expression to use as parameter to function; typically it is the name of a column
    
    Returns:
    sum for expression
    
    Throws:
    
    ActiveException - if error
  - selectSum
```
public <T> T selectSum(java.lang.String expression,
              java.lang.String whereConditionName,
              java.lang.Object... parameters)
```
    Selects sum.
    
    Type Parameters:
    T - aggregate result type
    Parameters:
    expression - expression to use as parameter to function; typically it is the name of a column
    whereConditionName - name of where condition to use; empty string to count all records in table
    parameters - parameter values for where condition
    
    Returns:
    sum for expression and where condition
    
    Throws:
    
    ActiveException - if error
  - selectAvg
```
public <T> T selectAvg(java.lang.String expression)
            throws ActiveException
```
    Selects average value.
    
    Type Parameters:
    T - aggregate result type
    Parameters:
    expression - expression to use as parameter to function; typically it is the name of a column
    
    Returns:
    average value for expression
    
    Throws:
    
    ActiveException - if error
  - selectAvg
```
public <T> T selectAvg(java.lang.String expression,
              java.lang.String whereConditionName,
              java.lang.Object... parameters)
            throws ActiveException
```
    Selects average value.
    
    Type Parameters:
    T - aggregate result type
    Parameters:
    expression - expression to use as parameter to function; typically it is the name of a column
    whereConditionName - name of where condition to use; empty string to count all records in table
    parameters - parameter values for where condition
    
    Returns:
    average value for expression and where condition
    
    Throws:
    
    ActiveException - if error
  - save
```
public int save(R record)
         throws ActiveException
```
    Updates an existing record or insert record if it is not already in database. ActiveRecord.attach(ActiveDatabase) is invoked on record to attach it to the active database of this table prior to save. Typically ActiveRecord.save() is used instead of this method.
    
    Parameters:
    record - record to save
    
    Returns:
    count of records affected
    
    Throws:
    
    ActiveException - if error
  - saveAll
```
public int saveAll(java.util.Collection<R> records)
            throws ActiveException
```
    Updates an existing records or insert records if they are not already in database. ActiveRecord.attach(ActiveDatabase) is invoked on records to attach them to the active database of this table prior to saving them.
    
    Parameters:
    records - collection of new and/or existing records to save (may be mixture of new and existing)
    
    Returns:
    count of records affected
    
    Throws:
    
    ActiveException - if error
  - insert
```
public int insert(R record)
           throws ActiveException
```
    Inserts one record into table. ActiveRecord.attach(ActiveDatabase) is invoked on record to attach it to the active database of this table prior to insert. Typically ActiveRecord.insert() is used instead of this method.
    Example:
    ActiveDatabase activeDatabase = ... ActiveTable<Student> table = new ActiveTable<Student>(activeDatabase, Student.class); Student s = new Student(); s.setId(1234); s.setFirstName("Jeff"); s.setLastName("Miller"); s.setGraduationDate(new Date(System.currentTimeMillis())); table.insert(s);
    Parameters:
    record - record to insert
    
    Returns:
    count of records affected
    
    Throws:
    
    ActiveException - if error
  - insertAll
```
public int insertAll(java.util.Collection<R> records)
              throws ActiveException
```
    Inserts collection of records. ActiveRecord.attach(ActiveDatabase) is invoked on records to attach them to the active database of this table prior to insert.
    Example:
    ActiveDatabase activeDatabase = ... ActiveTable<Student> table = new ActiveTable<Student>(activeDatabase, Student.class); ArrayList<Student> list = new ArrayList<Student>(); list.add(s1); list.add(s2); list.add(s3); table.insertAll(list);
    Parameters:
    records - records to insert
    
    Returns:
    count of records affected
    
    Throws:
    
    ActiveException - if error
  - insertAllBatch
```
public int insertAllBatch(java.util.Collection<R> records)
                   throws ActiveException
```
    Inserts collection of records in batch mode. ActiveRecord.attach(ActiveDatabase) is invoked on records to attach them to the active database of this table prior to insert. See limitations about batch inserts in ModifyOperation.setBatch(boolean).
    
    Parameters:
    records - records to insert
    
    Returns:
    count of records affected
    
    Throws:
    
    ActiveException - if error
    Since:
    
    1.9 and 2.3
  - update
```
public int update(R record)
           throws ActiveException
```
    Updates one record in table by primary key. Primary key must be defined by one or more Column.primaryKey() annotations. ActiveRecord.attach(ActiveDatabase) is invoked on record to attach it to the active database of this table prior to update. Typically ActiveRecord.update() is used instead of this method.
    Example:
    ActiveDatabase activeDatabase = ... ActiveTable<Student> table = new ActiveTable<Student>(activeDatabase, Student.class); Student s = table.select(id); s.setGraduationDate(...); table.update(s);
    Parameters:
    record - record to update
    
    Returns:
    count of records affected
    
    Throws:
    
    ActiveException - if error
  - updateAll
```
public int updateAll(java.util.Collection<R> records)
              throws ActiveException
```
    Updates collection of records using primary key. Primary key must be defined by one or more Column.primaryKey() annotations. ActiveRecord.attach(ActiveDatabase) is invoked on records to attach them to the active database of this table prior to update.
    Example:
    ActiveDatabase activeDatabase = ... ActiveTable<Student> table = new ActiveTable<Student>(activeDatabase, Student.class); List<Student> list = table.selectAll(); for (Student s: list) s.setGraduationDate(...); table.updateAll(list);
    Parameters:
    records - records to update
    
    Returns:
    count of records affected
    
    Throws:
    
    ActiveException - if error
  - updateAllBatch
```
public int updateAllBatch(java.util.Collection<R> records)
                   throws ActiveException
```
    Updates collection of records using primary key in batch mode. Primary key must be defined by one or more Column.primaryKey() annotations. ActiveRecord.attach(ActiveDatabase) is invoked on records to attach them to the active database of this table prior to update. See limitations about batch updates in ModifyOperation.setBatch(boolean).
    
    Parameters:
    records - records to update
    
    Returns:
    count of records affected
    
    Throws:
    
    ActiveException - if error
    Since:
    
    1.9 and 2.3
  - delete
```
public int delete(R record)
           throws ActiveException
```
    Deletes by primary key. Primary key must be defined by one or more Column.primaryKey() annotations. ActiveRecord.attach(ActiveDatabase) is invoked on record to attach it to the active database of this table prior to delete. Typically ActiveRecord.delete() is used instead of this method.
    Example:
    ActiveDatabase activeDatabase = ... ActiveTable<Student> table = new ActiveTable<Student>(activeDatabase, Student.class); // delete student with id of 1234 Student s = table.select(1234); table.delete(s);
    Parameters:
    record - get primary key values from this record
    
    Returns:
    count of records affected
    
    Throws:
    
    ActiveException - if error
  - deleteAll
```
public int deleteAll()
              throws ActiveException
```
    Deletes all records in table.
    Example:
    ActiveDatabase activeDatabase = ... ActiveTable<Student> table = new ActiveTable<Student>(activeDatabase, Student.class); table.deleteAll();
    Returns:
    count of records affected
    
    Throws:
    
    ActiveException - if error
  - deleteAll
```
public int deleteAll(java.util.Collection<R> records)
              throws ActiveException
```
    Deletes many records by primary key. Primary key must be defined by one or more Column.primaryKey() annotations. ActiveRecord.attach(ActiveDatabase) is invoked on records to attach them to the active database of this table prior to delete.
    Example:
    ActiveDatabase activeDatabase = ... ActiveTable<Student> table = new ActiveTable<Student>(activeDatabase, Student.class); List<Student> list = getSomeStudents(); table.deleteAll(list);
    Parameters:
    records - get primary key values from each record in this collection
    
    Returns:
    count of records affected
    
    Throws:
    
    ActiveException - if error
  - deleteAllBatch
```
public int deleteAllBatch(java.util.Collection<R> records)
                   throws ActiveException
```
    Deletes many records by primary key in batch mode. Primary key must be defined by one or more Column.primaryKey() annotations. ActiveRecord.attach(ActiveDatabase) is invoked on records to attach them to the active database of this table prior to delete.
    
    Parameters:
    records - get primary key values from each record in this collection
    
    Returns:
    count of records affected
    
    Throws:
    
    ActiveException - if error
    Since:
    
    1.9 and 2.3

Class ActiveTable<R extends ActiveRecord<R>>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ActiveTable

ActiveTable

Method Detail

getActiveDatabase

getRecordClass

newActiveRecord

select

selectWhere

selectCustom

selectAll

selectAllWhere

selectAllWhereOrdered

selectAllCustom

selectCount

selectCount

selectCount

selectMin

selectMin

selectMax

selectMax

selectSum

selectSum

selectAvg

selectAvg

save

saveAll

insert

insertAll

insertAllBatch

update

updateAll

updateAllBatch

delete

deleteAll

deleteAll

deleteAllBatch