Package ch.tocco.nice2.persist.core.api.qb2

Class Conditions

java.lang.Object
ch.tocco.nice2.persist.core.api.qb2.Conditions
public final class Conditions extends Object
This is a hub-class that defines some nice-to-have shortcuts but also collects static methods from other places. The idea is to have a single import line to access the query builder "dsl".

  • Method Details

    • equation

      public static Condition equation(Factor left, EquationNode.Operator op, Factor right)

    • equations

      public static Iterable<Condition> equations(Factor left, EquationNode.Operator op, Iterable<? extends Factor> right)
      Creates as many equation conditions as right factors are specified.

    • and

      public static Junction and(Condition... conditions)

    • and

      public static Junction and(Iterable<? extends Condition> conditions)

    • or

      public static Junction or(Condition... conditions)

    • or

      public static Junction or(Iterable<? extends Condition> conditions)

    • not

      public static Junction not(Condition... conditions)

    • not

      public static Junction not(Iterable<? extends Condition> conditions)

    • function

      public static Function function(String identifier)

    • fulltext

      public static Function fulltext(String query)

    • likeall

      public static Function likeall(String query, Iterable<String> pathList)

    • likeall

      public static Function likeall(String query, String... pathList)

    • count

      public static SubQuery count(String path)

    • exists

      public static SubQuery exists(String path)
      Creates a new EXISTS subquery to the given path.

    • existsNested

      public static SubQuery existsNested(String path)
      If `path` involves multiple paths (like relFoo.relBar), create nested exists. Otherwise it is the same as SubQuery.exists(String). Example: instead of `exists(relFoo.relBar where …` do `exists(relFoo where exists(relBar where –))` A special SubQuery class is returned, where each condition that is added via `where` calls is appended to the innermost subquery. Calls to `isTrue` apply to all subqueries. All other (reading) operations are applied to the root subquery.

    • subSelect

      public static UncorrelatedSubQuery subSelect(String column, EntityModel model)
      Create an uncorrelated sub select that may select a column from an the provided entity model. E.g. 
           EntityModel userModel = context.getEntityManager("User").getModel();
     EntityList foundUsers = queryBuilder.find("User").where(
         field("birthdate").greaterThan(subSelect("birthdate", userModel).where(
             field("lastname").is("Ott")
         )),
         field("firstname").is("Robin")
     ).build(context).execute());
      Parameters:
      column - the column to select
      model - the target entity model
      Returns:
      the UncorrelatedSubQuery instance

    • relationTo

      public static Condition relationTo(String relationPath, PrimaryKey key)
      Creates a condition that checks whether the given relationPath points to the entity specified by key.

    • relationToOne

      public static Condition relationToOne(String relationPath, Iterable<PrimaryKey> keys)
      Creates a condition that checks whether the given relationPath points to at least one of the entities specified by keys.

    • relationToAll

      public static Condition relationToAll(String relationPath, Iterable<PrimaryKey> keys)
      Creates a condition that checks whether the given relationPath points to all entities given by keys.

    • field

      public static FieldDef field(String name)
      Creates a new field defintion that can be used to create conditions starting from a field.

    • fieldExists

      public static FieldDef fieldExists(String name)
      Same as field(String) but uses (nested) exists statements.

    • relation

      public static RelationDef relation(String relationPath)
      Creates a new relation definition that can be used to create conditions starting from a relation.

    • param

      public static Factor param(String paramName)

    • literal

      public static Factor literal(@Nullable @Nullable Object value)

    • path

      public static Factor path(String pathName)

    • primaryKeyIs

      public static Condition primaryKeyIs(PrimaryKey key)

    • primaryKeyIn

      public static Condition primaryKeyIn(Iterable<PrimaryKey> keys)

    • primaryKeyIsNot

      public static Condition primaryKeyIsNot(PrimaryKey key)

    • commaSeparatedListContains

      public static Condition commaSeparatedListContains(String fieldName, String string, boolean orEmpty)
      Condition that checks whether the provided `string` is contained (exact match!) in a comma separated list to be found in field `fieldName`.
      Parameters:
      fieldName - the name of the field containing the comma separated list on the entity
      string - a string to be found in the list
      orEmpty - set to `true` to also return entities if the field `fieldName` is empty
      Returns:
      a `Condition`

    • isFalse

      public static Condition isFalse()

    • isTrue

      public static Condition isTrue()

    • raw

      public static Condition raw(Node node)