org.ofbiz.core.entity

Class MemoryHelper

java.lang.Object

org.ofbiz.core.entity.MemoryHelper

All Implemented Interfaces:

GenericHelper

public class MemoryHelper
extends Object
implements GenericHelper

Partial GenericHelper implementation that is entirely memory-based, to be used for simple unit testing (can't do anything beyond searches for primary keys, findByOr and findByAnd).

Author:

Pat Lightbody

Constructor Summary

Constructors

Constructor and Description
MemoryHelper(String helperName)

Method Summary

Methods

Modifier and Type	Method and Description
void	checkDataSource(Map<String,? extends ModelEntity> modelEntities, Collection<String> messages, boolean addMissing) Check the datasource to make sure the entity definitions are correct, optionally adding missing entities or fields on the server
static void	clearCache()
int	count(ModelEntity modelEntity, String fieldName, EntityCondition entityCondition, EntityFindOptions findOptions) Returns the count of the results that matches the specified condition
GenericValue	create(GenericPK primaryKey)
GenericValue	create(GenericValue value) Creates a Entity in the form of a GenericValue and write it to the database
List<GenericValue>	findAllByPrimaryKeys(List<? extends GenericPK> primaryKeys) Find a number of Generic Value objects by their Primary Keys, all at once
List<GenericValue>	findByAnd(ModelEntity modelEntity, List<? extends EntityCondition> expressions, List<String> orderBy)
List<GenericValue>	findByAnd(ModelEntity modelEntity, Map<String,?> fields, List<String> orderBy) Finds Generic Entity records by all of the specified fields (ie: combined using AND)
List<GenericValue>	findByCondition(ModelEntity modelEntity, EntityCondition entityCondition, Collection<String> fieldsToSelect, List<String> orderBy) Finds GenericValues by the conditions specified in the EntityCondition object, the the EntityCondition javadoc for more details.
List<GenericValue>	findByLike(ModelEntity modelEntity, Map<String,?> fields, List<String> orderBy)
List<GenericValue>	findByMultiRelation(GenericValue value, ModelRelation modelRelationOne, ModelEntity modelEntityOne, ModelRelation modelRelationTwo, ModelEntity modelEntityTwo, List<String> orderBy)
List<GenericValue>	findByOr(ModelEntity modelEntity, List<? extends EntityCondition> expressions, List<String> orderBy)
List<GenericValue>	findByOr(ModelEntity modelEntity, Map<String,?> fields, List<String> orderBy) Finds Generic Entity records by all of the specified fields (ie: combined using OR)
GenericValue	findByPrimaryKey(GenericPK primaryKey) Find a Generic Entity by its Primary Key
GenericValue	findByPrimaryKeyPartial(GenericPK primaryKey, Set<String> keys) Find a Generic Entity by its Primary Key and only returns the values requested by the passed keys (names)
EntityListIterator	findListIteratorByCondition(ModelEntity modelEntity, EntityCondition whereEntityCondition, EntityCondition havingEntityCondition, Collection<String> fieldsToSelect, List<String> orderBy, EntityFindOptions findOptions) The memory implementation does the *minimum* that it can to allow tests to work.
String	getHelperName() Gets the name of the server configuration that corresponds to this helper
int	removeAll(List<? extends GenericEntity> dummyPKs) Remove the Entities from the List from the persistent store.
int	removeByAnd(ModelEntity modelEntity, Map<String,?> fields) Removes/deletes Generic Entity records found by all of the specified fields (ie: combined using AND)
int	removeByCondition(ModelEntity modelEntity, EntityCondition whereCondition) Removes/deletes Generic Entity records found by all of the specified fields (ie: combined using AND)
int	removeByPrimaryKey(GenericPK primaryKey) Remove a Generic Entity corresponding to the primaryKey
int	store(GenericValue value) Store the Entity from the GenericValue to the persistent store
int	storeAll(List<? extends GenericValue> values) Store the Entities from the List GenericValue instances to the persistent store.
List<GenericValue>	transform(ModelEntity modelEntity, EntityCondition entityCondition, List<String> orderBy, String lockField, Transformation transformation) Applies the given transformation to any entities matching the given condition.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

MemoryHelper

public MemoryHelper(String helperName)

Method Detail

clearCache

public static void clearCache()

getHelperName

public String getHelperName()

Description copied from interface: GenericHelper

Gets the name of the server configuration that corresponds to this helper

Specified by:

getHelperName in interface GenericHelper

Returns:

server configuration name

create

public GenericValue create(GenericValue value)
                    throws GenericEntityException

Description copied from interface: GenericHelper

Creates a Entity in the form of a GenericValue and write it to the database

Specified by:

create in interface GenericHelper

Returns:

GenericValue instance containing the new instance

Throws:

GenericEntityException

create

public GenericValue create(GenericPK primaryKey)
                    throws GenericEntityException

Throws:

GenericEntityException

findByPrimaryKey

public GenericValue findByPrimaryKey(GenericPK primaryKey)
                              throws GenericEntityException

Description copied from interface: GenericHelper

Find a Generic Entity by its Primary Key

Specified by:

findByPrimaryKey in interface GenericHelper

Parameters:

primaryKey - The primary key to find by.

Returns:

The GenericValue corresponding to the primaryKey

Throws:

GenericEntityException

findByPrimaryKeyPartial

public GenericValue findByPrimaryKeyPartial(GenericPK primaryKey,
                                   Set<String> keys)
                                     throws GenericEntityException

Description copied from interface: GenericHelper

Find a Generic Entity by its Primary Key and only returns the values requested by the passed keys (names)

Specified by:

findByPrimaryKeyPartial in interface GenericHelper

Parameters:

primaryKey - The primary key to find by.

keys - The keys, or names, of the values to retrieve; only these values will be retrieved

Returns:

The GenericValue corresponding to the primaryKey

Throws:

GenericEntityException

findAllByPrimaryKeys

public List<GenericValue> findAllByPrimaryKeys(List<? extends GenericPK> primaryKeys)
                                        throws GenericEntityException

Description copied from interface: GenericHelper

Find a number of Generic Value objects by their Primary Keys, all at once

Specified by:

findAllByPrimaryKeys in interface GenericHelper

Parameters:

primaryKeys - A List of primary keys to find by.

Returns:

List of GenericValue objects corresponding to the passed primaryKey objects

Throws:

GenericEntityException

removeByPrimaryKey

public int removeByPrimaryKey(GenericPK primaryKey)
                       throws GenericEntityException

Description copied from interface: GenericHelper

Remove a Generic Entity corresponding to the primaryKey

Specified by:

removeByPrimaryKey in interface GenericHelper

Parameters:

primaryKey - The primary key of the entity to remove.

Returns:

int representing number of rows effected by this operation

Throws:

GenericEntityException

findByAnd

public List<GenericValue> findByAnd(ModelEntity modelEntity,
                           Map<String,?> fields,
                           List<String> orderBy)
                             throws GenericEntityException

Description copied from interface: GenericHelper

Finds Generic Entity records by all of the specified fields (ie: combined using AND)

Specified by:

findByAnd in interface GenericHelper

Parameters:

modelEntity - The ModelEntity of the Entity as defined in the entity XML file

fields - The fields of the named entity to query by with their corresponging values

orderBy - The fields of the named entity to order the query by; optionally add a " ASC" for ascending or " DESC" for descending

Returns:

List of GenericValue instances that match the query

Throws:

GenericEntityException

findByAnd

public List<GenericValue> findByAnd(ModelEntity modelEntity,
                           List<? extends EntityCondition> expressions,
                           List<String> orderBy)
                             throws GenericEntityException

Throws:

GenericEntityException

findByLike

public List<GenericValue> findByLike(ModelEntity modelEntity,
                            Map<String,?> fields,
                            List<String> orderBy)
                              throws GenericEntityException

Throws:

GenericEntityException

findByOr

public List<GenericValue> findByOr(ModelEntity modelEntity,
                          Map<String,?> fields,
                          List<String> orderBy)
                            throws GenericEntityException

Description copied from interface: GenericHelper

Finds Generic Entity records by all of the specified fields (ie: combined using OR)

Specified by:

findByOr in interface GenericHelper

Parameters:

modelEntity - The ModelEntity of the Entity as defined in the entity XML file

fields - The fields of the named entity to query by with their corresponging values

orderBy - The fields of the named entity to order the query by; optionally add a " ASC" for ascending or " DESC" for descending

Returns:

List of GenericValue instances that match the query

Throws:

GenericEntityException

findByOr

public List<GenericValue> findByOr(ModelEntity modelEntity,
                          List<? extends EntityCondition> expressions,
                          List<String> orderBy)
                            throws GenericEntityException

Throws:

GenericEntityException

findByCondition

public List<GenericValue> findByCondition(ModelEntity modelEntity,
                                 EntityCondition entityCondition,
                                 Collection<String> fieldsToSelect,
                                 List<String> orderBy)
                                   throws GenericEntityException

Description copied from interface: GenericHelper

Finds GenericValues by the conditions specified in the EntityCondition object, the the EntityCondition javadoc for more details.

Specified by:

findByCondition in interface GenericHelper

Parameters:

modelEntity - The ModelEntity of the Entity as defined in the entity XML file

entityCondition - The EntityCondition object that specifies how to constrain this query

fieldsToSelect - The fields of the named entity to get from the database; if empty or null all fields will be retreived

orderBy - The fields of the named entity to order the query by; optionally add a " ASC" for ascending or " DESC" for descending

Returns:

List of GenericValue objects representing the result

Throws:

GenericEntityException

findByMultiRelation

public List<GenericValue> findByMultiRelation(GenericValue value,
                                     ModelRelation modelRelationOne,
                                     ModelEntity modelEntityOne,
                                     ModelRelation modelRelationTwo,
                                     ModelEntity modelEntityTwo,
                                     List<String> orderBy)
                                       throws GenericEntityException

Specified by:

findByMultiRelation in interface GenericHelper

Throws:

GenericEntityException

findListIteratorByCondition

public EntityListIterator findListIteratorByCondition(ModelEntity modelEntity,
                                             EntityCondition whereEntityCondition,
                                             EntityCondition havingEntityCondition,
                                             Collection<String> fieldsToSelect,
                                             List<String> orderBy,
                                             EntityFindOptions findOptions)
                                               throws GenericEntityException

The memory implementation does the *minimum* that it can to allow tests to work. In particular it will return *all* values for a particular entity from this method.

Specified by:

findListIteratorByCondition in interface GenericHelper

Parameters:

modelEntity - The ModelEntity of the Entity as defined in the entity XML file

whereEntityCondition - The EntityCondition object that specifies how to constrain this query before any groupings are done (if this is a view entity with group-by aliases)

havingEntityCondition - The EntityCondition object that specifies how to constrain this query after any groupings are done (if this is a view entity with group-by aliases)

fieldsToSelect - The fields of the named entity to get from the database; if empty or null all fields will be retreived

orderBy - The fields of the named entity to order the query by; optionally add a " ASC" for ascending or " DESC" for descending

findOptions - An instance of EntityFindOptions that specifies advanced query options. See the EntityFindOptions JavaDoc for more details.

Returns:

EntityListIterator representing the result of the query: NOTE THAT THIS MUST BE CLOSED WHEN YOU ARE DONE WITH IT, AND DON'T LEAVE IT OPEN TOO LONG BECAUSE IT WILL MAINTAIN A DATABASE CONNECTION.

Throws:

GenericEntityException

removeByAnd

public int removeByAnd(ModelEntity modelEntity,
              Map<String,?> fields)
                throws GenericEntityException

Description copied from interface: GenericHelper

Removes/deletes Generic Entity records found by all of the specified fields (ie: combined using AND)

Specified by:

removeByAnd in interface GenericHelper

Parameters:

modelEntity - The ModelEntity of the Entity as defined in the entity XML file

fields - The fields of the named entity to query by with their corresponging values

Returns:

int representing number of rows effected by this operation

Throws:

GenericEntityException

removeByCondition

public int removeByCondition(ModelEntity modelEntity,
                    EntityCondition whereCondition)
                      throws GenericEntityException

Description copied from interface: GenericHelper

Removes/deletes Generic Entity records found by all of the specified fields (ie: combined using AND)

Specified by:

removeByCondition in interface GenericHelper

Parameters:

modelEntity - The ModelEntity of the Entity as defined in the entity XML file

whereCondition - The EntityCondition object that specifies how to constrain this query

Returns:

int representing number of rows effected by this operation

Throws:

GenericEntityException

store

public int store(GenericValue value)
          throws GenericEntityException

Description copied from interface: GenericHelper

Store the Entity from the GenericValue to the persistent store

Specified by:

store in interface GenericHelper

Parameters:

value - GenericValue instance containing the entity

Returns:

int representing number of rows effected by this operation

Throws:

GenericEntityException

storeAll

public int storeAll(List<? extends GenericValue> values)
             throws GenericEntityException

Description copied from interface: GenericHelper

Store the Entities from the List GenericValue instances to the persistent store. This is different than the normal store method in that the store method only does an update, while the storeAll method checks to see if each entity exists, then either does an insert or an update as appropriate. These updates all happen in one transaction, so they will either all succeed or all fail, if the data source supports transactions. This is just like to othersToStore feature of the GenericEntity on a create or store.

Specified by:

storeAll in interface GenericHelper

Parameters:

values - List of GenericValue instances containing the entities to store

Returns:

int representing number of rows effected by this operation

Throws:

GenericEntityException

removeAll

public int removeAll(List<? extends GenericEntity> dummyPKs)
              throws GenericEntityException

Description copied from interface: GenericHelper

Remove the Entities from the List from the persistent store.
The List contains GenericEntity objects, can be either GenericPK or GenericValue.
If a certain entity contains a complete primary key, the entity in the datasource corresponding to that primary key will be removed, this is like a removeByPrimary Key.
On the other hand, if a certain entity is an incomplete or non primary key, if will behave like the removeByAnd method.
These updates all happen in one transaction, so they will either all succeed or all fail, if the data source supports transactions.

Specified by:

removeAll in interface GenericHelper

Parameters:

dummyPKs - List of GenericEntity instances containing the entities or by and fields to remove

Returns:

int representing number of rows effected by this operation

Throws:

GenericEntityException

checkDataSource

public void checkDataSource(Map<String,? extends ModelEntity> modelEntities,
                   Collection<String> messages,
                   boolean addMissing)
                     throws GenericEntityException

Description copied from interface: GenericHelper

Check the datasource to make sure the entity definitions are correct, optionally adding missing entities or fields on the server

Specified by:

checkDataSource in interface GenericHelper

Parameters:

modelEntities - Map of entityName names and ModelEntity values

messages - Collection to put any result messages in

addMissing - Flag indicating whether or not to add missing entities and fields on the server

Throws:

GenericEntityException

count

public int count(ModelEntity modelEntity,
        String fieldName,
        EntityCondition entityCondition,
        EntityFindOptions findOptions)
          throws GenericEntityException

Description copied from interface: GenericHelper

Returns the count of the results that matches the specified condition

Specified by:

count in interface GenericHelper

Parameters:

modelEntity - The ModelEntity of the Entity as defined in the entity XML file

fieldName - The field of the named entity to count, if null this is equivalent to count(*)

entityCondition - The EntityCondition object that specifies how to constrain this query The expressions to use for the lookup, each consisting of at least a field name, an EntityOperator, and a value to compare to

findOptions - An instance of EntityFindOptions that specifies advanced query options. The only option that is used is distinct, in which case a select (distinct fieldname) is issued.

If you issue a distinct without a fieldName it will be ignored as select count (distinct *) makes no sense

Returns:

the number of rows that match the query

Throws:

GenericEntityException

transform

public List<GenericValue> transform(ModelEntity modelEntity,
                           EntityCondition entityCondition,
                           List<String> orderBy,
                           String lockField,
                           Transformation transformation)
                             throws GenericEntityException

Description copied from interface: GenericHelper

Applies the given transformation to any entities matching the given condition.

Specified by:

transform in interface GenericHelper

Parameters:

modelEntity - the type of entity to transform (required)

entityCondition - the condition that selects the entities to transform (null means transform all)

orderBy - the order in which the entities should be selected for updating (null means no ordering)

lockField - the entity field to use for optimistic locking; the value of this field will be read between the SELECT and the UPDATE to determine whether another process has updated one of the target records in the meantime; if so, the transformation will be reapplied and another UPDATE attempted

transformation - the transformation to apply (required)

Returns:

the transformed entities in the order they were selected (never null)

Throws:

GenericEntityException