KeylessDaoImpl (hrorm 0.6.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 Function<BUILDER,ENTITY>`	`buildFunction`
`protected List<ChildrenDescriptor<ENTITY,?,BUILDER,?>>`	`childrenDescriptors`
`protected Connection`	`connection`
`protected KeylessSqlBuilder<ENTITY>`	`keylessSqlBuilder`
`protected ParentColumn<ENTITY,PARENT,BUILDER,PARENTBUILDER>`	`parentColumn`
`protected SqlRunner<ENTITY,BUILDER>`	`sqlRunner`
`protected Supplier<BUILDER>`	`supplier`
`protected String`	`tableName`

Constructor Summary

Constructors
Constructor and Description

KeylessDaoImpl(Connection connection, DaoDescriptor<ENTITY,BUILDER> daoDescriptor)

Constructors
Constructor and Description
`KeylessDaoImpl(Connection connection, DaoDescriptor<ENTITY,BUILDER> daoDescriptor)`

Method Summary

All 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()`
`List<ChildrenDescriptor<ENTITY,?,BUILDER,?>>`	`childrenDescriptors()` The definitions of any entities that are owned by type `ENTITY`
`List<Column<ENTITY,BUILDER>>`	`dataColumns()` The columns that contain the data that make up the object
`<T> T`	`foldingSelect(ENTITY item, T identity, BiFunction<T,ENTITY,T> accumulator, String... columnNames)` Computes a result based on the entities found by a select statement without realizing the entire list of found entities in memory.
`protected <A> A`	`fromSingletonList(List<A> items)`
`Long`	`insert(ENTITY item)` Insert a record into the database.
`List<JoinColumn<ENTITY,?,BUILDER,?>>`	`joinColumns()` The columns that contain references to foreign keys to other objects
`protected List<ENTITY>`	`mapBuilders(List<BUILDER> bs)`
`protected Envelope<ENTITY>`	`newEnvelope(ENTITY item, long id)`
`ParentColumn<ENTITY,PARENT,BUILDER,PARENTBUILDER>`	`parentColumn()`
`List<ENTITY>`	`selectAll()` Read all the records in the database of type ENTITY.
`ENTITY`	`selectByColumns(ENTITY item, String... columnNames)` Select a single record from the database by some search criteria.
`List<ENTITY>`	`selectManyByColumns(ENTITY template, Map<String,Operator> columnNamesMap)` Select multiple records from the database by some search criteria.
`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, columnMap, dataColumnsWithParent, dataColumnsWithParent, hasParent

- Field Detail
  - connection
```
protected final Connection connection
```
  - tableName
```
protected final String tableName
```
  - supplier
```
protected final Supplier<BUILDER> supplier
```
  - childrenDescriptors
```
protected final List<ChildrenDescriptor<ENTITY,?,BUILDER,?>> childrenDescriptors
```
  - keylessSqlBuilder
```
protected final KeylessSqlBuilder<ENTITY> keylessSqlBuilder
```
  - sqlRunner
```
protected final SqlRunner<ENTITY,BUILDER> sqlRunner
```
  - parentColumn
```
protected final ParentColumn<ENTITY,PARENT,BUILDER,PARENTBUILDER> parentColumn
```
  - buildFunction
```
protected final Function<BUILDER,ENTITY> buildFunction
```
- Constructor Detail
  - KeylessDaoImpl
```
public KeylessDaoImpl(Connection connection,
                      DaoDescriptor<ENTITY,BUILDER> daoDescriptor)
```
- Method Detail
  - 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
  - dataColumns
```
public List<Column<ENTITY,BUILDER>> dataColumns()
```
    Description copied from interface: KeylessDaoDescriptor
    
    The columns that contain the data that make up the object
    
    Specified by:
    
    dataColumns in interface KeylessDaoDescriptor<ENTITY,BUILDER>
    
    Returns:
    
    all the data columns supported
  - joinColumns
```
public List<JoinColumn<ENTITY,?,BUILDER,?>> joinColumns()
```
    Description copied from interface: KeylessDaoDescriptor
    
    The columns that contain references to foreign keys to other objects
    
    Specified by:
    
    joinColumns in interface KeylessDaoDescriptor<ENTITY,BUILDER>
    
    Returns:
    
    all the reference columns supported
  - 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
  - childrenDescriptors
```
public List<ChildrenDescriptor<ENTITY,?,BUILDER,?>> childrenDescriptors()
```
    Description copied from interface: KeylessDaoDescriptor
    
    The definitions of any entities that are owned by type ENTITY
    
    Specified by:
    
    childrenDescriptors in interface KeylessDaoDescriptor<ENTITY,BUILDER>
    
    Returns:
    
    all the owned entities
  - parentColumn
```
public ParentColumn<ENTITY,PARENT,BUILDER,PARENTBUILDER> parentColumn()
```
    Specified by:
    
    parentColumn in interface KeylessDaoDescriptor<ENTITY,BUILDER>
  - buildFunction
```
public Function<BUILDER,ENTITY> buildFunction()
```
    Specified by:
    
    buildFunction in interface KeylessDaoDescriptor<ENTITY,BUILDER>
  - 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.
  - 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,
                                        Map<String,Operator> columnNamesMap)
```
    Description copied from interface: KeylessDao
    
    Select multiple records from the database by some search criteria.
    This method will perform a select on the database and return the results found. The where clause will be generated to include tests of the column names specified in the columnNames parameter. Each entry in that Map should be accompanied by an Operation specifying what comparison should be used, e.g. =, LIKE, >, etc.
    
    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.
    
    columnNamesMap - The names of the database columns paired with the operation that should be used to construct the SQL select statement.
    
    Returns:
    
    The populated instances of type ENTITY with matching values with the passed item for the indicated columnNames.
  - foldingSelect
```
public <T> T foldingSelect(ENTITY item,
                           T identity,
                           BiFunction<T,ENTITY,T> accumulator,
                           String... columnNames)
```
    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:
    
    item - An instance of type ENTITY with populated values corresponding to the column names to select by.
    
    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.
    
    columnNames - The names of the columns to include in the select where clause.
    
    Returns:
    
    The computed value based on the results found in the underlying store.
  - fromSingletonList
```
protected <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

tableName

supplier

childrenDescriptors

keylessSqlBuilder

sqlRunner

parentColumn

buildFunction

Constructor Detail

KeylessDaoImpl

Method Detail

tableName

dataColumns

joinColumns

supplier

childrenDescriptors

parentColumn

buildFunction

atomicInsert

insert

newEnvelope

mapBuilders

selectAll

selectByColumns

selectManyByColumns

selectManyByColumns

foldingSelect

fromSingletonList