KeylessDaoImpl (hrorm 0.10.0 API)

java.lang.Object
- org.hrorm.KeylessDaoImpl<ENTITY,PARENT,BUILDER,PARENTBUILDER>

Type Parameters:

ENTITY - The type whose persistence is managed by this Dao.

PARENT - The type of the parent (if any) of type ENTITY.

BUILDER - The type of object that can build an ENTITY instance.

PARENTBUILDER - The type of the object that can build a PARENT instance.

All Implemented Interfaces:

KeylessDao<ENTITY>, KeylessDaoDescriptor<ENTITY,BUILDER>

Direct Known Subclasses:

DaoImpl
```
public class KeylessDaoImpl<ENTITY,PARENT,BUILDER,PARENTBUILDER>
extends Object
implements KeylessDao<ENTITY>, KeylessDaoDescriptor<ENTITY,BUILDER>
```
The KeylessDao implementation.
There is no good reason to directly construct this class yourself. Use a IndirectKeylessDaoBuilder.

Field Summary

Fields
Modifier and Type Field and Description

protected Connection connection

protected KeylessSqlBuilder<ENTITY> keylessSqlBuilder

protected SqlRunner<ENTITY,BUILDER> sqlRunner

Fields
Modifier and Type	Field and Description
`protected Connection`	`connection`
`protected KeylessSqlBuilder<ENTITY>`	`keylessSqlBuilder`
`protected SqlRunner<ENTITY,BUILDER>`	`sqlRunner`

Constructor Summary

Constructors
Constructor and Description
`KeylessDaoImpl(Connection connection, DaoDescriptor<ENTITY,BUILDER> daoDescriptor)`
`KeylessDaoImpl(Connection connection, KeylessDaoDescriptor<ENTITY,BUILDER> daoDescriptor, List<ChildrenDescriptor<ENTITY,?,BUILDER,?>> childrenDescriptors)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Long`	`atomicInsert(ENTITY item)` Insert a record into the database within a transaction that is managed within the Dao.
`Function<BUILDER,ENTITY>`	`buildFunction()` The mechanism for building a new entity instance.
`<T> T`	`foldingSelect(T identity, BiFunction<T,ENTITY,T> accumulator, Where where)` Computes a result based on the entities found by a select statement without realizing the entire list of found entities in memory.
`static KeylessDaoImpl`	`forKeylessDescriptors(Connection connection, KeylessDaoDescriptor daoDescriptor)`
`static <A> A`	`fromSingletonList(List<A> items)`
`ColumnCollection<ENTITY,BUILDER>`	`getColumnCollection()`
`Long`	`insert(ENTITY item)` Insert a record into the database.
`protected List<ENTITY>`	`mapBuilders(List<BUILDER> bs)`
`protected Envelope<ENTITY>`	`newEnvelope(ENTITY item, long id)`
`BigDecimal`	`runBigDecimalFunction(SqlFunction function, String columnName, Where where)` Computes an aggregated BigDecimal value, based on the select criteria specified and the given SqlFunction and column name.
`Long`	`runLongFunction(SqlFunction function, String columnName, Where where)` Computes an aggregated Long value, based on the select criteria specified and the given SqlFunction and column name.
`List<ENTITY>`	`select(Where where)` Run a select in the data store for entities matching the given where predicates.
`List<ENTITY>`	`select(Where where, Order order)` Run a select in the data store for entities matching the given where predicates returned in the order specified.
`List<ENTITY>`	`selectAll()` Read all the records in the database of type ENTITY.
`List<ENTITY>`	`selectAll(Order order)` Read all the records in the database of type ENTITY in the required order.
`ENTITY`	`selectByColumns(ENTITY item, String... columnNames)` Select a single record from the database by some search criteria.
`List<ENTITY>`	`selectManyByColumns(ENTITY template, Order order, String... columnNames)` Select multiple records from the database by some search criteria in the required order.
`List<ENTITY>`	`selectManyByColumns(ENTITY item, String... columnNames)` Select multiple records from the database by some search criteria.
`Supplier<BUILDER>`	`supplier()` The mechanism to use to instantiate a new instance of type `ENTITY`, generally a no-argument constructor of the class.
`String`	`tableName()` The name of the table that is used to persist type `ENTITY`

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

Methods inherited from interface org.hrorm.KeylessDaoDescriptor
allColumns, dataColumns, joinColumns, nonJoinColumns, select

- Field Detail
  - connection
```
protected final Connection connection
```
  - keylessSqlBuilder
```
protected final KeylessSqlBuilder<ENTITY> keylessSqlBuilder
```
  - sqlRunner
```
protected final SqlRunner<ENTITY,BUILDER> sqlRunner
```
- Constructor Detail
  - KeylessDaoImpl
```
public KeylessDaoImpl(Connection connection,
                      DaoDescriptor<ENTITY,BUILDER> daoDescriptor)
```
  - KeylessDaoImpl
```
public KeylessDaoImpl(Connection connection,
                      KeylessDaoDescriptor<ENTITY,BUILDER> daoDescriptor,
                      List<ChildrenDescriptor<ENTITY,?,BUILDER,?>> childrenDescriptors)
```
- Method Detail
  - forKeylessDescriptors
```
public static KeylessDaoImpl forKeylessDescriptors(Connection connection,
                                                   KeylessDaoDescriptor daoDescriptor)
```
  - tableName
```
public String tableName()
```
    Description copied from interface: KeylessDaoDescriptor
    
    The name of the table that is used to persist type ENTITY
    
    Specified by:
    
    tableName in interface KeylessDaoDescriptor<ENTITY,BUILDER>
    
    Returns:
    
    the table name
  - getColumnCollection
```
public ColumnCollection<ENTITY,BUILDER> getColumnCollection()
```
    Specified by:
    
    getColumnCollection in interface KeylessDaoDescriptor<ENTITY,BUILDER>
  - supplier
```
public Supplier<BUILDER> supplier()
```
    Description copied from interface: KeylessDaoDescriptor
    
    The mechanism to use to instantiate a new instance of type ENTITY, generally a no-argument constructor of the class.
    
    Specified by:
    
    supplier in interface KeylessDaoDescriptor<ENTITY,BUILDER>
    
    Returns:
    
    A function pointer to the instantiation mechanism
  - buildFunction
```
public Function<BUILDER,ENTITY> buildFunction()
```
    Description copied from interface: KeylessDaoDescriptor
    
    The mechanism for building a new entity instance.
    
    Specified by:
    
    buildFunction in interface KeylessDaoDescriptor<ENTITY,BUILDER>
    
    Returns:
    
    the build function
  - atomicInsert
```
public Long atomicInsert(ENTITY item)
```
    Description copied from interface: KeylessDao
    
    Insert a record into the database within a transaction that is managed within the Dao. The Dao will either commit or rollback the transaction and close the underlying Connection when complete.
    
    Specified by:
    
    atomicInsert in interface KeylessDao<ENTITY>
    
    Parameters:
    
    item - The instance to be inserted.
    
    Returns:
    
    The newly issued primary key of the record, if there is one. Else, Optional.empty()
  - insert
```
public Long insert(ENTITY item)
```
    Description copied from interface: KeylessDao
    
    Insert a record into the database.
    Depending on how the Dao was constucted (whether from a regular DaoBuilder or an IndirectDaoBuilder) a particular instance of this class may or may not attempt to mutate the state of the passed item by setting its primary key.
    
    Specified by:
    
    insert in interface KeylessDao<ENTITY>
    
    Parameters:
    
    item - The instance to be inserted.
    
    Returns:
    
    The newly issued primary key of the record, if there is one. Else, Optional.empty()
  - newEnvelope
```
protected Envelope<ENTITY> newEnvelope(ENTITY item,
                                       long id)
```
  - mapBuilders
```
protected List<ENTITY> mapBuilders(List<BUILDER> bs)
```
  - selectAll
```
public List<ENTITY> selectAll()
```
    Description copied from interface: KeylessDao
    
    Read all the records in the database of type ENTITY.
    No laziness or caching is involved here. This simply tries to instantiate all the records it can based on the full table.
    
    Specified by:
    
    selectAll in interface KeylessDao<ENTITY>
    
    Returns:
    
    A list of populated instances of type ENTITY.
  - selectAll
```
public List<ENTITY> selectAll(Order order)
```
    Description copied from interface: KeylessDao
    
    Read all the records in the database of type ENTITY in the required order.
    No laziness or caching is involved here. This simply tries to instantiate all the records it can based on the full table.
    
    Specified by:
    
    selectAll in interface KeylessDao<ENTITY>
    
    Parameters:
    
    order - The ordering to use
    
    Returns:
    
    A list of populated instances of type ENTITY.
  - selectByColumns
```
public ENTITY selectByColumns(ENTITY item,
                              String... columnNames)
```
    Description copied from interface: KeylessDao
    
    Select a single record from the database by some search criteria. If multiple records are found that match the passed item, an exception will be thrown.
    
    Specified by:
    
    selectByColumns in interface KeylessDao<ENTITY>
    
    Parameters:
    
    item - An instance of type ENTITY with populated values corresponding to the column names to select by.
    
    columnNames - The names of the database columns
    
    Returns:
    
    The populated instance of type ENTITY with matching values with the passed item for the indicated columnNames.
  - selectManyByColumns
```
public List<ENTITY> selectManyByColumns(ENTITY item,
                                        String... columnNames)
```
    Description copied from interface: KeylessDao
    
    Select multiple records from the database by some search criteria.
    The SQL generated will specify a select by the column names passed, where the values are equal to the values specified in the passed template object. All the values must match, as the where clause will be formed by joining the various column names with 'AND'.
    
    Specified by:
    
    selectManyByColumns in interface KeylessDao<ENTITY>
    
    Parameters:
    
    item - An instance of type ENTITY with populated values corresponding to the column names to select by.
    
    columnNames - The names of the database columns
    
    Returns:
    
    The populated instances of type ENTITY with matching values with the passed item for the indicated columnNames.
  - selectManyByColumns
```
public List<ENTITY> selectManyByColumns(ENTITY template,
                                        Order order,
                                        String... columnNames)
```
    Description copied from interface: KeylessDao
    
    Select multiple records from the database by some search criteria in the required order.
    The SQL generated will specify a select by the column names passed, where the values are equal to the values specified in the passed template object. All the values must match, as the where clause will be formed by joining the various column names with 'AND'.
    
    Specified by:
    
    selectManyByColumns in interface KeylessDao<ENTITY>
    
    Parameters:
    
    template - An instance of type ENTITY with populated values corresponding to the column names to select by.
    
    order - The ordering to use
    
    columnNames - The names of the database columns
    
    Returns:
    
    The populated instances of type ENTITY with matching values with the passed item for the indicated columnNames.
  - runLongFunction
```
public Long runLongFunction(SqlFunction function,
                            String columnName,
                            Where where)
```
    Description copied from interface: KeylessDao
    
    Computes an aggregated Long value, based on the select criteria specified and the given SqlFunction and column name.
    Will run SQL that looks like this:
    select FUNCTION(COLUMN) from TABLE where ...
    
    Specified by:
    
    runLongFunction in interface KeylessDao<ENTITY>
    
    Parameters:
    
    function - The function to run
    
    columnName - The column to apply the function to
    
    where - Predicates to drive selection of results
    
    Returns:
    
    The value returned by applying the specified function to the values in the specified column in the matching results, or null if no results are found.
  - runBigDecimalFunction
```
public BigDecimal runBigDecimalFunction(SqlFunction function,
                                        String columnName,
                                        Where where)
```
    Description copied from interface: KeylessDao
    
    Computes an aggregated BigDecimal value, based on the select criteria specified and the given SqlFunction and column name.
    Will run SQL that looks like this:
    select FUNCTION(COLUMN) from TABLE where ...
    
    Specified by:
    
    runBigDecimalFunction in interface KeylessDao<ENTITY>
    
    Parameters:
    
    function - The function to run
    
    columnName - The column to apply the function to
    
    where - Predicates to drive selection of results
    
    Returns:
    
    The value returned by applying the specified function to the values in the specified column in the matching results, or null if no results are found.
  - foldingSelect
```
public <T> T foldingSelect(T identity,
                           BiFunction<T,ENTITY,T> accumulator,
                           Where where)
```
    Description copied from interface: KeylessDao
    
    Computes a result based on the entities found by a select statement without realizing the entire list of found entities in memory.
    
    Specified by:
    
    foldingSelect in interface KeylessDao<ENTITY>
    
    Type Parameters:
    
    T - The type of the value to be computed.
    
    Parameters:
    
    identity - The identity element of the return type.
    
    accumulator - A function that computes the desired value based on the values seen thus far and the next instance of the entity found in the result set.
    
    where - Predicates to drive selection of results
    
    Returns:
    
    The computed value based on the results found in the underlying store.
  - select
```
public List<ENTITY> select(Where where)
```
    Description copied from interface: KeylessDao
    
    Run a select in the data store for entities matching the given where predicates.
    
    Specified by:
    
    select in interface KeylessDao<ENTITY>
    
    Parameters:
    
    where - The predicates to drive selection.
    
    Returns:
    
    The matching results.
  - select
```
public List<ENTITY> select(Where where,
                           Order order)
```
    Description copied from interface: KeylessDao
    
    Run a select in the data store for entities matching the given where predicates returned in the order specified.
    
    Specified by:
    
    select in interface KeylessDao<ENTITY>
    
    Parameters:
    
    where - The predicates to drive selection.
    
    order - The ordering to use
    
    Returns:
    
    The matching results.
  - fromSingletonList
```
public static <A> A fromSingletonList(List<A> items)
```

Class KeylessDaoImpl<ENTITY,PARENT,BUILDER,PARENTBUILDER>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.hrorm.KeylessDaoDescriptor

Field Detail

connection

keylessSqlBuilder

sqlRunner

Constructor Detail

KeylessDaoImpl

KeylessDaoImpl

Method Detail

forKeylessDescriptors

tableName

getColumnCollection

supplier

buildFunction

atomicInsert

insert

newEnvelope

mapBuilders

selectAll

selectAll

selectByColumns

selectManyByColumns

selectManyByColumns

runLongFunction

runBigDecimalFunction

foldingSelect

select

select

fromSingletonList