Package org.apache.cayenne.exp.property

## Class StringProperty<E extends CharSequence>

- java.lang.Object
- - org.apache.cayenne.exp.property.BaseProperty<E>
  - - org.apache.cayenne.exp.property.StringProperty<E>

- All Implemented Interfaces:
    `ComparableProperty<E>`, `Property<E>`

      public class StringProperty<E extends CharSequence>
      extends BaseProperty<E>
      implements ComparableProperty<E>

  Property that represents attributes mapped on string types

  String type is an any type inherited from `CharSequence`.

  Provides basic string functions like `like(String)`, `concat(Object...)`, `upper()` and `contains(String)`}.

  Example:

       ObjectSelect.query(Artist.class)
            .where(Artist.FIRST_NAME.trim().concat(Artist.LAST_NAME.trim()).length().gt(30))

  Since:
    4.2
  See Also:
    `org.apache.cayenne.exp.property`

- - ### Field Summary

    - ### Fields inherited from class org.apache.cayenne.exp.property.BaseProperty

      `expressionSupplier, name, type`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor | Description
    --- | --- | ---
    `protected` | `StringProperty​(String name, Expression expression, Class<E> type)` | Constructs a new property with the given name and expression

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `StringProperty<E>` | `alias​(String alias)` | Creates alias with different name for this property
    `StringProperty<String>` | `concat​(Object... args)` | Arguments will be converted as follows: if argument is a `BaseProperty` than its expression will be used if argument is a `Expression` than it will be used as is all other values will be converted to String
    `Expression` | `contains​(String substring)` | Creates an expression for a database "LIKE" query with the value converted to a pattern matching anywhere in the String.
    `Expression` | `containsIgnoreCase​(String value)` | Same as `contains(String)`, only using case-insensitive comparison.
    `StringProperty<E>` | `enclosing()` |
    `Expression` | `endsWith​(String value)` | Creates an expression for a database "LIKE" query with the value converted to a pattern matching the tail of a String.
    `Expression` | `endsWithIgnoreCase​(String value)` | Same as `endsWith(String)`, only using case-insensitive comparison.
    `NumericProperty<Integer>` | `length()` |
    `Expression` | `like​(String pattern)` |
    `Expression` | `like​(String pattern, char escapeChar)` |
    `Expression` | `like​(StringProperty<?> pattern)` |
    `Expression` | `likeIgnoreCase​(String pattern)` |
    `Expression` | `likeIgnoreCase​(StringProperty<?> pattern)` |
    `NumericProperty<Integer>` | `locate​(String string)` |
    `NumericProperty<Integer>` | `locate​(StringProperty<? extends String> property)` |
    `StringProperty<String>` | `lower()` |
    `Expression` | `nlike​(String value)` |
    `Expression` | `nlike​(StringProperty<?> value)` |
    `Expression` | `nlikeIgnoreCase​(String value)` |
    `Expression` | `nlikeIgnoreCase​(StringProperty<?> value)` |
    `Expression` | `startsWith​(String value)` | Creates an expression for a database "LIKE" query with the value converted to a pattern matching the beginning of a String.
    `Expression` | `startsWithIgnoreCase​(String value)` | Same as `startsWith(String)`, only using case-insensitive comparison.
    `StringProperty<String>` | `substring​(int offset, int length)` |
    `StringProperty<String>` | `substring​(NumericProperty<?> offset, NumericProperty<?> length)` |
    `StringProperty<String>` | `trim()` |
    `StringProperty<String>` | `upper()` |

    - ### Methods inherited from class org.apache.cayenne.exp.property.BaseProperty

      `asc, ascInsensitive, ascInsensitives, ascs, count, countDistinct, desc, descInsensitive, descInsensitives, descs, eq, eq, equals, function, function, getAlias, getExpression, getFrom, getFromAll, getName, getType, hashCode, in, in, in, isFalse, isNotNull, isNull, isTrue, ne, ne, nin, nin, nin, operator, operator, path, setIn, setInAll`

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

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

    - ### Methods inherited from interface org.apache.cayenne.exp.property.ComparableProperty

      `between, between, gt, gt, gte, gte, lt, lt, lte, lte, max, min`

    - ### Methods inherited from interface org.apache.cayenne.exp.property.Property

      `getAlias, getExpression, getName, getType`

- - ### Constructor Detail

    - #### StringProperty

          protected StringProperty​(String name,
                                   Expression expression,
                                   Class<E> type)

      Constructs a new property with the given name and expression
      Parameters:
        `name` - of the property (will be used as alias for the expression)
        `expression` - expression for property
        `type` - of the property
      See Also:
        `PropertyFactory.createString(String, Expression, Class)`

  - ### Method Detail

    - #### like

          public Expression like​(String pattern)

      Parameters:
        `pattern` - a pattern matching property value. Pattern may include "_" and "%" wildcard symbols to match any single character or a sequence of characters. To prevent "_" and "%" from being treated as wildcards, they need to be escaped and escape char passed with `like(String, char)` method.
      Returns:
        An expression for a Database "LIKE" query.

    - #### like

          public Expression like​(StringProperty<?> pattern)

      Parameters:
        `pattern` - a pattern matching property value. Pattern may include "_" and "%" wildcard symbols to match any single character or a sequence of characters.
      Returns:
        An expression for a Database "LIKE" query.

    - #### like

          public Expression like​(String pattern,
                                 char escapeChar)

      Parameters:
        `pattern` - a properly escaped pattern matching property value. Pattern may include "_" and "%" wildcard symbols to match any single character or a sequence of characters.
        `escapeChar` - an escape character used in the pattern to escape "%" and "_".
      Returns:
        An expression for a Database "LIKE" query.

    - #### likeIgnoreCase

          public Expression likeIgnoreCase​(String pattern)

      Returns:
        An expression for a case insensitive "LIKE" query.

    - #### likeIgnoreCase

          public Expression likeIgnoreCase​(StringProperty<?> pattern)

      Returns:
        An expression for a case insensitive "LIKE" query.

    - #### nlike

          public Expression nlike​(String value)

      Returns:
        An expression for a Database "NOT LIKE" query.

    - #### nlike

          public Expression nlike​(StringProperty<?> value)

      Returns:
        An expression for a Database "NOT LIKE" query.

    - #### nlikeIgnoreCase

          public Expression nlikeIgnoreCase​(String value)

      Returns:
        An expression for a case insensitive "NOT LIKE" query.

    - #### nlikeIgnoreCase

          public Expression nlikeIgnoreCase​(StringProperty<?> value)

      Returns:
        An expression for a case insensitive "NOT LIKE" query.

    - #### contains

          public Expression contains​(String substring)

      Creates an expression for a database "LIKE" query with the value converted to a pattern matching anywhere in the String.
      Parameters:
        `substring` - a String to match against property value. "_" and "%" symbols are NOT treated as wildcards and are escaped when converted to a LIKE expression.
      Returns:
        a newly created expression.

    - #### startsWith

          public Expression startsWith​(String value)

      Creates an expression for a database "LIKE" query with the value converted to a pattern matching the beginning of a String.
      Parameters:
        `value` - a String to match against property value. "_" and "%" symbols are NOT treated as wildcards and are escaped when converted to a LIKE expression.
      Returns:
        a newly created expression.

    - #### endsWith

          public Expression endsWith​(String value)

      Creates an expression for a database "LIKE" query with the value converted to a pattern matching the tail of a String.
      Parameters:
        `value` - a String to match against property value. "_" and "%" symbols are NOT treated as wildcards and are escaped when converted to a LIKE expression.
      Returns:
        a newly created expression.

    - #### containsIgnoreCase

          public Expression containsIgnoreCase​(String value)

      Same as `contains(String)`, only using case-insensitive comparison.

    - #### startsWithIgnoreCase

          public Expression startsWithIgnoreCase​(String value)

      Same as `startsWith(String)`, only using case-insensitive comparison.

    - #### endsWithIgnoreCase

          public Expression endsWithIgnoreCase​(String value)

      Same as `endsWith(String)`, only using case-insensitive comparison.

    - #### length

          public NumericProperty<Integer> length()

      See Also:
        `FunctionExpressionFactory.lengthExp(Expression)`

    - #### locate

          public NumericProperty<Integer> locate​(String string)

      See Also:
        `FunctionExpressionFactory.locateExp(String, Expression)`

    - #### locate

          public NumericProperty<Integer> locate​(StringProperty<? extends String> property)

      See Also:
        `FunctionExpressionFactory.locateExp(Expression, Expression)`

    - #### trim

          public StringProperty<String> trim()

      See Also:
        `FunctionExpressionFactory.trimExp(Expression)`

    - #### upper

          public StringProperty<String> upper()

      See Also:
        `FunctionExpressionFactory.upperExp(Expression)`

    - #### lower

          public StringProperty<String> lower()

      See Also:
        `FunctionExpressionFactory.lowerExp(Expression)`

    - #### concat

          public StringProperty<String> concat​(Object... args)

      Arguments will be converted as follows:

      - if argument is a `BaseProperty` than its expression will be used
      - if argument is a `Expression` than it will be used as is
      - all other values will be converted to String

      Usage:

               Property<String> fullName = Artist.FIRST_NAME.concat(" ", Artist.SECOND_NAME);

      See Also:
        `FunctionExpressionFactory.concatExp(Expression...)`

    - #### substring

          public StringProperty<String> substring​(int offset,
                                                  int length)

      See Also:
        `FunctionExpressionFactory.substringExp(Expression, int, int)`

    - #### substring

          public StringProperty<String> substring​(NumericProperty<?> offset,
                                                  NumericProperty<?> length)

      See Also:
        `FunctionExpressionFactory.substringExp(Expression, Expression, Expression)`

    - #### alias

          public StringProperty<E> alias​(String alias)

      Creates alias with different name for this property
      Overrides:
        `alias` in class `BaseProperty<E extends CharSequence>`

    - #### enclosing

          public StringProperty<E> enclosing()

      Overrides:
        `enclosing` in class `BaseProperty<E extends CharSequence>`
      Returns:
        property that will be translated relative to parent query