org.apache.cayenne.exp.property

## Class PropertyFactory

- java.lang.Object
- - org.apache.cayenne.exp.property.PropertyFactory

-     public class PropertyFactory
      extends Object

  Factory class that produces all property types.
  Since:
    4.2
  See Also:
    `org.apache.cayenne.exp.property`

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static NumericProperty<Long>` | `COUNT` Property that can be used to select `COUNT(*)`
    `static DateProperty<LocalDateTime>` | `NOW` Property that corresponds to SQL function `NOW()`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PropertyFactory()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <T> BaseProperty<T>` | `createBase(Expression expression, Class<T> type)` Create base property
    `static <T> BaseProperty<T>` | `createBase(String name, Class<T> type)` Create base property
    `static <T> BaseProperty<T>` | `createBase(String name, Expression expression, Class<T> type)` Create base property
    `static <T> BaseIdProperty<T>` | `createBaseId(String attribute, String entityName, Class<T> propertyType)`
    `static <T> BaseIdProperty<T>` | `createBaseId(String attribute, String path, String entityName, Class<T> propertyType)`
    `static <T> DateProperty<T>` | `createDate(Expression expression, Class<T> type)` Create date property
    `static <T> DateProperty<T>` | `createDate(String name, Class<T> type)` Create date property
    `static <T> DateProperty<T>` | `createDate(String name, Expression expression, Class<T> type)` Create date property
    `static <T extends EmbeddableObject> EmbeddableProperty<T>` | `createEmbeddable(String name, Class<T> embeddableType)` Create property that represents embeddable
    `static <T extends EmbeddableObject> EmbeddableProperty<T>` | `createEmbeddable(String name, Expression exp, Class<T> embeddableType)` Create property that represents embeddable
    `static <T extends Persistent> EntityProperty<T>` | `createEntity(Expression expression, Class<T> type)` Create entity property
    `static <T extends Persistent> EntityProperty<T>` | `createEntity(String name, Class<T> type)` Create entity property
    `static <T extends Persistent> EntityProperty<T>` | `createEntity(String name, Expression expression, Class<T> entityType)` Create entity property
    `static <T extends Persistent> ListProperty<T>` | `createList(String name, Class<T> entityType)` Create to-many relationship mapped on list property
    `static <T extends Persistent> ListProperty<T>` | `createList(String name, Expression expression, Class<T> entityType)` Create to-many relationship mapped on list property
    `static <K,V extends Persistent> MapProperty<K,V>` | `createMap(String name, Class<K> keyType, Class<V> entityType)` Create to-many relationship mapped on map property
    `static <K,V extends Persistent> MapProperty<K,V>` | `createMap(String name, Expression expression, Class<K> keyType, Class<V> entityType)` Create to-many relationship mapped on map property
    `static <T extends Number> NumericProperty<T>` | `createNumeric(Expression expression, Class<T> type)` Create numeric property
    `static <T extends Number> NumericProperty<T>` | `createNumeric(String name, Class<T> type)` Create numeric property
    `static <T extends Number> NumericProperty<T>` | `createNumeric(String name, Expression expression, Class<T> type)` Create numeric property
    `static <T extends Number> NumericIdProperty<T>` | `createNumericId(String attribute, String entityName, Class<T> propertyType)`
    `static <T extends Number> NumericIdProperty<T>` | `createNumericId(String attribute, String path, String entityName, Class<T> propertyType)`
    `static <T extends Persistent> EntityProperty<T>` | `createSelf(Class<T> type)` Self property allows to create column queries that return full objects along with custom column set.
    `static <T extends Persistent> EntityProperty<T>` | `createSelf(Expression expression, Class<T> type)` Self property allows to create column queries that return full objects along with custom column set.
    `static <T extends Persistent> SetProperty<T>` | `createSet(String name, Class<T> entityType)` Create to-many relationship mapped on set property
    `static <T extends Persistent> SetProperty<T>` | `createSet(String name, Expression expression, Class<T> entityType)` Create to-many relationship mapped on set property
    `static <T extends CharSequence> StringProperty<T>` | `createString(Expression expression, Class<T> type)` Create string property
    `static <T extends CharSequence> StringProperty<T>` | `createString(String name, Class<T> type)` Create string property
    `static <T extends CharSequence> StringProperty<T>` | `createString(String name, Expression expression, Class<T> type)` Create string property

    - ### Methods inherited from class java.lang.Object

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

- - ### Field Detail

    - #### COUNT

          public static final NumericProperty<Long> COUNT

      Property that can be used to select `COUNT(*)`

      Usage:

           ObjectSelect.columnQuery(Artist.class, Artist.ARTIST_NAME, PropertyFactory.COUNT);

      See Also:
        `ObjectSelect.selectCount(ObjectContext)`

    - #### NOW

          public static final DateProperty<LocalDateTime> NOW

      Property that corresponds to SQL function `NOW()`

      Usage:

           ObjectSelect.query(Artist.class).where(Artist.DATE_OF_BIRTH.year().lt(PropertyFactory.NOW.year().sub(100)));

  - ### Constructor Detail

    - #### PropertyFactory

          public PropertyFactory()

  - ### Method Detail

    - #### createBase

          public static <T> BaseProperty<T> createBase(String name,
                                                       Expression expression,
                                                       Class<T> type)

      Create base property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `name` - of the property
        `expression` - that property will use
        `type` - type of represented attribute
      Returns:
        new property with custom expression

    - #### createBase

          public static <T> BaseProperty<T> createBase(String name,
                                                       Class<T> type)

      Create base property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `name` - of the property, will be used as value for path expression
        `type` - type of represented attribute
      Returns:
        new path property

    - #### createBase

          public static <T> BaseProperty<T> createBase(Expression expression,
                                                       Class<T> type)

      Create base property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `expression` - that property will use
        `type` - type of represented attribute
      Returns:
        new property with custom expression without name

    - #### createString

          public static <T extends CharSequence> StringProperty<T> createString(String name,
                                                                                Expression expression,
                                                                                Class<T> type)

      Create string property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `name` - of the property
        `expression` - that property will use
        `type` - type of represented attribute
      Returns:
        new property with custom expression

    - #### createString

          public static <T extends CharSequence> StringProperty<T> createString(String name,
                                                                                Class<T> type)

      Create string property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `name` - of the property, will be used as value for path expression
        `type` - type of represented attribute
      Returns:
        new path property

    - #### createString

          public static <T extends CharSequence> StringProperty<T> createString(Expression expression,
                                                                                Class<T> type)

      Create string property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `expression` - that property will use
        `type` - type of represented attribute
      Returns:
        new property with custom expression without name

    - #### createNumeric

          public static <T extends Number> NumericProperty<T> createNumeric(String name,
                                                                            Expression expression,
                                                                            Class<T> type)

      Create numeric property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `name` - of the property
        `expression` - that property will use
        `type` - type of represented attribute
      Returns:
        new property with custom expression

    - #### createNumeric

          public static <T extends Number> NumericProperty<T> createNumeric(String name,
                                                                            Class<T> type)

      Create numeric property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `name` - of the property, will be used as value for path expression
        `type` - type of represented attribute
      Returns:
        new path property

    - #### createNumeric

          public static <T extends Number> NumericProperty<T> createNumeric(Expression expression,
                                                                            Class<T> type)

      Create numeric property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `expression` - that property will use
        `type` - type of represented attribute
      Returns:
        new property with custom expression without name

    - #### createDate

          public static <T> DateProperty<T> createDate(String name,
                                                       Expression expression,
                                                       Class<T> type)

      Create date property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `name` - of the property
        `expression` - that property will use
        `type` - type of represented attribute
      Returns:
        new property with custom expression

    - #### createDate

          public static <T> DateProperty<T> createDate(String name,
                                                       Class<T> type)

      Create date property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `name` - of the property, will be used as value for path expression
        `type` - type of represented attribute
      Returns:
        new path property

    - #### createDate

          public static <T> DateProperty<T> createDate(Expression expression,
                                                       Class<T> type)

      Create date property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `expression` - that property will use
        `type` - type of represented attribute
      Returns:
        new property with custom expression without name

    - #### createEntity

          public static <T extends Persistent> EntityProperty<T> createEntity(String name,
                                                                              Expression expression,
                                                                              Class<T> entityType)

      Create entity property
      Type Parameters:
        `T` - type of represented relationship entity
      Parameters:
        `name` - of the property
        `expression` - that property will use
        `entityType` - type of represented relationship entity
      Returns:
        new property with custom expression

    - #### createEntity

          public static <T extends Persistent> EntityProperty<T> createEntity(String name,
                                                                              Class<T> type)

      Create entity property
      Type Parameters:
        `T` - type of represented relationship entity
      Parameters:
        `name` - of the property, will be used as value for path expression
        `type` - type of represented relationship entity
      Returns:
        new path property

    - #### createEntity

          public static <T extends Persistent> EntityProperty<T> createEntity(Expression expression,
                                                                              Class<T> type)

      Create entity property
      Type Parameters:
        `T` - type of represented relationship entity
      Parameters:
        `expression` - that property will use
        `type` - type of represented relationship entity
      Returns:
        new property with custom expression without name

    - #### createSelf

          public static <T extends Persistent> EntityProperty<T> createSelf(Class<T> type)

      Self property allows to create column queries that return full objects along with custom column set.

      Usage example, query will return object with dependent objects count:

            List<Object[]> result = ObjectSelect.columnQuery(Artist.class,
                    PropertyFactory.createSelf(Artist.class),
                    Artist.PAINTING_ARRAY.count())
                .select(context);

      Type Parameters:
        `T` - type of represented entity
      Parameters:
        `type` - of represented entity
      Returns:
        new 'self' property

    - #### createSelf

          public static <T extends Persistent> EntityProperty<T> createSelf(Expression expression,
                                                                            Class<T> type)

      Self property allows to create column queries that return full objects along with custom column set.

      This method is not much useful, as to-one property can be used as is in this case, example is purely for demonstration purpose only. See `EntityProperty` usage examples.

      Usage example, query will return object with dependent objects count:

            List<Object[]> result = ObjectSelect.columnQuery(Painting.class,
                    Painting.PAINTING_TITLE,
                    PropertyFactory.createSelf(Painting.TO_ARTIST.getExpression(), Painting.class))
                .select(context);

      Type Parameters:
        `T` - type of represented entity
      Parameters:
        `expression` - expression to be used for this property (usually it will be path from other property)
        `type` - of represented entity
      Returns:
        new 'self' property

    - #### createList

          public static <T extends Persistent> ListProperty<T> createList(String name,
                                                                          Expression expression,
                                                                          Class<T> entityType)

      Create to-many relationship mapped on list property
      Type Parameters:
        `T` - type of represented relationship entity
      Parameters:
        `name` - of the property
        `expression` - that property will use
        `entityType` - type of represented relationship entity
      Returns:
        new property with custom expression

    - #### createList

          public static <T extends Persistent> ListProperty<T> createList(String name,
                                                                          Class<T> entityType)

      Create to-many relationship mapped on list property
      Type Parameters:
        `T` - type of represented relationship entity
      Parameters:
        `name` - of the property, will be used as value for path expression
        `entityType` - type of represented relationship entity
      Returns:
        new path property

    - #### createSet

          public static <T extends Persistent> SetProperty<T> createSet(String name,
                                                                        Expression expression,
                                                                        Class<T> entityType)

      Create to-many relationship mapped on set property
      Type Parameters:
        `T` - type of represented attribute
      Parameters:
        `name` - of the property
        `expression` - that property will use
        `entityType` - type of represented attribute
      Returns:
        new property with custom expression

    - #### createSet

          public static <T extends Persistent> SetProperty<T> createSet(String name,
                                                                        Class<T> entityType)

      Create to-many relationship mapped on set property
      Type Parameters:
        `T` - type of represented relationship entity
      Parameters:
        `name` - of the property, will be used as value for path expression
        `entityType` - type of represented relationship entity
      Returns:
        new path property

    - #### createMap

          public static <K,V extends Persistent> MapProperty<K,V> createMap(String name,
                                                                            Expression expression,
                                                                            Class<K> keyType,
                                                                            Class<V> entityType)

      Create to-many relationship mapped on map property
      Type Parameters:
        `K` - type of represented relationship keys
        `V` - type of represented relationship values
      Parameters:
        `name` - of the property
        `expression` - that property will use
        `keyType` - type of represented relationship keys
        `entityType` - type of represented relationship values
      Returns:
        new property with custom expression

    - #### createMap

          public static <K,V extends Persistent> MapProperty<K,V> createMap(String name,
                                                                            Class<K> keyType,
                                                                            Class<V> entityType)

      Create to-many relationship mapped on map property
      Type Parameters:
        `K` - type of represented relationship keys
        `V` - type of represented relationship values
      Parameters:
        `name` - of the property, will be used as value for path expression
        `keyType` - type of represented relationship keys
        `entityType` - type of represented relationship values
      Returns:
        new path property

    - #### createEmbeddable

          public static <T extends EmbeddableObject> EmbeddableProperty<T> createEmbeddable(String name,
                                                                                            Class<T> embeddableType)

      Create property that represents embeddable
      Type Parameters:
        `T` - type of represented embeddable entity
      Parameters:
        `name` - of the property, will be used as value for path expression
        `embeddableType` - type of represented embeddable entity
      Returns:
        new path property

    - #### createEmbeddable

          public static <T extends EmbeddableObject> EmbeddableProperty<T> createEmbeddable(String name,
                                                                                            Expression exp,
                                                                                            Class<T> embeddableType)

      Create property that represents embeddable
      Type Parameters:
        `T` - type of represented embeddable entity
      Parameters:
        `name` - of the property, will be used as value for path expression
        `exp` - that property will use
        `embeddableType` - type of represented embeddable entity
      Returns:
        new path property

    - #### createBaseId

          public static <T> BaseIdProperty<T> createBaseId(String attribute,
                                                           String entityName,
                                                           Class<T> propertyType)

    - #### createBaseId

          public static <T> BaseIdProperty<T> createBaseId(String attribute,
                                                           String path,
                                                           String entityName,
                                                           Class<T> propertyType)

    - #### createNumericId

          public static <T extends Number> NumericIdProperty<T> createNumericId(String attribute,
                                                                                String entityName,
                                                                                Class<T> propertyType)

    - #### createNumericId

          public static <T extends Number> NumericIdProperty<T> createNumericId(String attribute,
                                                                                String path,
                                                                                String entityName,
                                                                                Class<T> propertyType)

Copyright © 2001–2021 Apache Cayenne. All rights reserved.