Package com.sap.cds.ql

Interface CQL

public interface CQL

  • Field Details

  • Method Details

    • copy

      static RefBuilder<StructuredTypeRef> copy(CqnStructuredTypeRef ref)
      Creates a RefBuilder from the given ref, which allows for in-place modification of the ref.
      Parameters:
      ref - the ref to be copied
      Returns:
      the ref builder

    • copy

      static RefBuilder<ElementRef<?>> copy(CqnElementRef ref)
      Creates a RefBuilder from the given ref, which allows for in-place modification of the ref.
      Parameters:
      ref - the element ref to be copied
      Returns:
      the ref builder

    • copy

      static Expand<?> copy(CqnExpand expand)
      Creates a copy of the given expand.
      Parameters:
      expand - the expand to be copied
      Returns:
      the copy

    • copy

      static Predicate copy(CqnPredicate pred)
      Creates a copy of the given predicate.
      Parameters:
      pred - the predicate to be copied
      Returns:
      the copy

    • copy

      static Predicate copy(CqnPredicate pred, Modifier modifier)
      Creates a modified copy of the given predicate.
      Parameters:
      pred - the predicate to be copied
      modifier - the modifier for altering the copy
      Returns:
      the modified copy

    • copy

      static <S extends CqnStatement> S copy(S statement)
      Creates a copy of the given CQN statement.
      Type Parameters:
      S - the type of CqnStatement
      Parameters:
      statement - the CQN statement to be copied
      Returns:
      the copy

    • copy

      static <S extends CqnStatement> S copy(S statement, Modifier modifier)
      Creates a modified copy of the given CQN statement.
      Type Parameters:
      S - the type of CqnStatement
      Parameters:
      statement - the CQN statement to be copied
      modifier - the modifier for altering the copy
      Returns:
      the modified copy

    • func

      static <T> FunctionCall<T> func(String name, CqnValue... args)
      Creates a CDS QL function call that is send to the underlying data store.
      Type Parameters:
      T - the return type of the function call
      Parameters:
      name - the name of the function to be called
      args - the arguments of the function
      Returns:
      the CDS QL function call

    • func

      static <T> FunctionCall<T> func(String name, List<? extends CqnValue> args)
      Creates a CDS QL function call that is send to the underlying data store.
      Type Parameters:
      T - the return type of the function call
      Parameters:
      name - the name of the function to be called
      args - the arguments of the function
      Returns:
      the CDS QL function call

    • booleanFunc

      static BooleanFunction booleanFunc(String name, List<? extends CqnValue> args)
      Creates a CDS QL function call that is send to the underlying data store.
      Parameters:
      name - the name of the function to be called
      args - the arguments of the function
      Returns:
      the CDS QL function call

    • constant

      static <T> Literal<T> constant(T value)
      Creates a Value of type CQL with a hint that the value should be treated as constant.
      Type Parameters:
      T - the type of the constant
      Parameters:
      value - the value
      Returns:
      the constant

    • val

      static <T> Literal<T> val(T value)
      Creates a Value of type CQL.
      Type Parameters:
      T - the type of the non-constant value
      Parameters:
      value - the value of the non-constant value
      Returns:
      the value
      See Also:

    • vector

      @Beta static CqnVector vector(Object vector)
      Creates a new CqnVector which can be used in vector functions such as cosineSimilarity(com.sap.cds.ql.cqn.CqnValue, com.sap.cds.ql.cqn.CqnValue) and l2Distance(com.sap.cds.ql.cqn.CqnValue, com.sap.cds.ql.cqn.CqnValue).
      Parameters:
      vector - the vector as float[] or in String format
      Returns:
      the CqnVector

    • not

      static Predicate not(CqnPredicate predicate)
      Negates a given CqnPredicate.
      Parameters:
      predicate - the CqnPredicate to be negated
      Returns:
      the negated predicate

    • and

      static Predicate and(CqnPredicate p1, CqnPredicate p2)
      Creates a conjunction of two given predicates
      Parameters:
      p1 - 1st operand of the conjunction
      p2 - 2nd operand of the conjunction
      Returns:
      the conjunction

    • withAnd

      static Collector<CqnPredicate,?,CqnPredicate> withAnd()
      Returns a Collector that connects the input predicates with AND. If there are none the Collector returns TRUE.
      Returns:
      the collector

    • or

      static Predicate or(CqnPredicate p1, CqnPredicate p2)
      Creates a disjunction of two given predicates
      Parameters:
      p1 - 1st operand of the disjunction
      p2 - 2nd operand of the disjunction
      Returns:
      the disjunction

    • and

      static Predicate and(Iterable<? extends CqnPredicate> predicates)
      Creates a conjunction of given predicates
      Parameters:
      predicates - the predicates to connect
      Returns:
      the conjunction

    • or

      static Predicate or(Iterable<? extends CqnPredicate> predicates)
      Creates a disjunction of given predicates
      Parameters:
      predicates - the predicates to connect
      Returns:
      the disjunction

    • withOr

      static Collector<CqnPredicate,?,CqnPredicate> withOr()
      Returns a Collector that connects the input predicates with OR. If there are none the Collector returns FALSE.
      Returns:
      the collector

    • connect

      static Predicate connect(CqnConnectivePredicate.Operator operator, Iterable<? extends CqnPredicate> predicates)
      Creates a logical connection of given predicates CqnPredicate.
      Parameters:
      operator - operator to connect the predicates with
      predicates - the predicates to connect
      Returns:
      the logical connection

    • param

      static <T> Parameter<T> param(int index)
      Creates an indexed Parameter to be used in CQN statements. Can be used with positional parameter values.
      Type Parameters:
      T - the type of the parameter
      Parameters:
      index - the parameter index. If used with positional parameter values, start with 0 for the first parameter
      Returns:
      the parameter

    • param

      static <T> Parameter<T> param(String name)
      Creates a named Parameter to be used in queries.
      Type Parameters:
      T - the type of the parameter
      Parameters:
      name - the parameter name
      Returns:
      the parameter

    • plain

      static Value<?> plain(String value)
      Creates a CQN plain value, which is directly send to the underlying data store.
      Parameters:
      value - the value content
      Returns:
      the plain value

    • count

      static Value<Long> count()
      Creates a count all function call.
      Returns:
      the count value

    • count

      static Value<Long> count(CqnElementRef element)
      Creates a count function call on the given element.
      Parameters:
      element - the ref to the element to be counted
      Returns:
      the count value

    • min

      static <T> Value<T> min(CqnValue value)
      Creates a min function call on the given element or expression.
      Type Parameters:
      T - the type of the value
      Parameters:
      value - the ref to the element to be counted or an expression
      Returns:
      the minimum value

    • max

      static <T> Value<T> max(CqnValue value)
      Creates a max function call on the given element or expression.
      Type Parameters:
      T - the type of the value
      Parameters:
      value - the ref to the element to be counted or an expression
      Returns:
      the maximum value

    • sum

      static Value<Number> sum(CqnValue value)
      Creates a sum function call on the given element or expression.
      Parameters:
      value - the ref to the element to be counted or an expression
      Returns:
      the sum value

    • average

      static Value<Number> average(CqnValue value)
      Creates an average function call on the given element or expression.
      Parameters:
      value - the ref to the element to be counted or an expression
      Returns:
      the average value

    • countDistinct

      static Value<Long> countDistinct(CqnValue value)
      Creates an count distinct function call on the given element or expression.
      Parameters:
      value - the ref to the element to be counted or an expression
      Returns:
      the count of distinct values

    • contains

      static Predicate contains(CqnValue value, CqnValue substring, boolean caseInsensitive)
      Creates a predicate that tests whether a string value contains a given substring
      Parameters:
      value - the string value
      substring - the substring to test for
      caseInsensitive - whether the test should be case insensitive
      Returns:
      the predicate for the containment test

    • startsWith

      static Predicate startsWith(CqnValue value, CqnValue prefix, boolean caseInsensitive)
      Creates a predicate that tests whether a string value starts with a given prefix
      Parameters:
      value - the string value
      prefix - the prefix to test for
      caseInsensitive - whether the test should be case insensitive
      Returns:
      the predicate for the containment test

    • endsWith

      static Predicate endsWith(CqnValue value, CqnValue suffix, boolean caseInsensitive)
      Creates a predicate that tests whether a string value ends with a given suffix
      Parameters:
      value - the string value
      suffix - the suffix to test for
      caseInsensitive - whether the test should be case insensitive
      Returns:
      the predicate for the containment test

    • containment

      static Predicate containment(CqnContainmentTest.Position position, CqnValue value, CqnValue substring, boolean caseInsensitive)
      Creates a predicate that tests whether a string value contains a given substring at a given position CqnContainmentTest.Position
      Parameters:
      position - the position
      value - the string value
      substring - the substring to test for
      caseInsensitive - whether the test should be case insensitive
      Returns:
      the predicate for the containment test

    • toLower

      static Value<String> toLower(Value<String> val)
      Creates a CDS QL expression for converting the given string value to lower case using the rules of the underlying data store.
      Parameters:
      val - the String value to be converted
      Returns:
      the CDS QL expression for lower case conversion

    • toLower

      static Value<String> toLower(String val)
      Creates a CDS QL expression for converting the given string value to lower case using the rules of the underlying data store.
      Parameters:
      val - the String value to be converted
      Returns:
      the CDS QL expression for lower case conversion

    • toUpper

      static Value<String> toUpper(Value<String> val)
      Creates a CDS QL expression for converting the given string value to upper case using the rules of the underlying data store.
      Parameters:
      val - the String value to be converted
      Returns:
      the CDS QL expression for upper case conversion

    • toUpper

      static Value<String> toUpper(String val)
      Creates a CDS QL expression for converting the given string value to upper case using the rules of the underlying data store.
      Parameters:
      val - the String value to be converted
      Returns:
      the CDS QL expression for upper case conversion

    • cosineSimilarity

      static Value<Double> cosineSimilarity(CqnValue vector1, CqnValue vector2)
      Creates a CDS QL function to compute the cosine similarity of two vectors.
      Parameters:
      vector1 - the first vector
      vector2 - the second vector
      Returns:
      the cosine similarity function

    • l2Distance

      static Value<Double> l2Distance(CqnValue vector1, CqnValue vector2)
      Creates a CDS QL function to compute the L2 distance of two vectors.
      Parameters:
      vector1 - the first vector
      vector2 - the second vector
      Returns:
      the L2 distance function

    • entity

      static StructuredType<?> entity(String qualifiedName)
      Creates a StructuredType representing a CDS entity.
      Parameters:
      qualifiedName - the qualified name of the CDS entity
      Returns:
      the StructuredType representing the CDS entity

    • entity

      static <T extends StructuredType<T>> T entity(Class<T> type)
      Creates a StructuredType representing a CDS entity.
      Type Parameters:
      T - the type of the entity
      Parameters:
      type - the class of the entity type
      Returns:
      the StructuredType representing the CDS entity

    • to

      static StructuredType<?> to(String path)
      Creates a StructuredType representing a path from a CDS entity to another entity.
      Parameters:
      path - a String of association element names separated by '.'
      Returns:
      the StructuredType representing the path to a CDS entity

    • to

      static StructuredType<?> to(List<? extends CqnReference.Segment> segments)
      Creates a StructuredType representing a path from a CDS entity to another entity. To create a StructuredTypeRef, use CQL.to(segments).asRef().
      Parameters:
      segments - the segments of the path
      Returns:
      the StructuredType representing the path to a CDS entity

    • get

      static <T> ElementRef<T> get(String path)
      Creates an ElementRef representing a path from a CDS entity to an element of this or another entity.
      Type Parameters:
      T - the type of the element
      Parameters:
      path - a String of element names separated by '.', where all except the last segment represent association elements.
      Returns:
      the ElementRef representing the path to the CDS element

    • get

      static <T> ElementRef<T> get(List<? extends CqnReference.Segment> segments)
      Creates an ElementRef representing a path from a CDS entity to an element of this or another entity.
      Type Parameters:
      T - the type of the element
      Parameters:
      segments - the segments of the path
      Returns:
      the ElementRef representing the path to the CDS element

    • refSegment

      static CqnReference.Segment refSegment(String id)
      Creates a segment of a structured type or element reference without filter. Use refSegment(String, CqnPredicate) to create a segment with filter condition.
      Parameters:
      id - the id of the segment
      Returns:
      the segment

    • refSegment

      static CqnReference.Segment refSegment(String id, CqnPredicate filter)
      Creates a segment of a structured type or element reference with a filter condition.
      Parameters:
      id - the id of the segment
      filter - the filter of the segment
      Returns:
      the segment

    • refSegments

      static List<CqnReference.Segment> refSegments(List<String> segmentIds)
      Creates a list of reference segments without filter.
      Parameters:
      segmentIds - the ids of the segments
      Returns:
      the segments

    • expression

      static Value<Number> expression(CqnValue left, CqnArithmeticExpression.Operator op, CqnValue right)
      Creates an arithmetic expression.
      Parameters:
      left - the left-hand side of the expression
      op - the operator
      right - the right-hand side of the expression
      Returns:
      the arithmetic expression

    • comparison

      static Predicate comparison(CqnValue lhs, CqnComparisonPredicate.Operator op, CqnValue rhs)
      Creates a comparison predicate.
      Parameters:
      lhs - the left-hand side of the comparison
      op - the comparison operator
      rhs - the right-hand side of the comparison
      Returns:
      the comparison predicate

    • in

      static Predicate in(CqnValue value, Collection<? extends CqnValue> values)
      Creates an in predicate.
      Parameters:
      value - the value to be checked if it's contained in the collection
      values - the collection of values
      Returns:
      the in predicate

    • between

      static Predicate between(CqnValue value, CqnValue low, CqnValue high)
      Creates a between predicate that tests if this value is within a closed interval with given bounds
      Parameters:
      value - the value to be checked if it's contained in a closed interval between low and high
      low - the lower bound
      high - the upper bound
      Returns:
      the between predicate

    • in

      static Predicate in(CqnValue value, CqnValue valueSet)
      Creates an in predicate.
      Parameters:
      value - the value to be checked if it's contained in the collection
      valueSet - the value describing a collection of values
      Returns:
      the in predicate

    • in

      static Predicate in(List<String> elements, Collection<? extends Map<String,?>> valueMaps)
      Creates a predicate that checks if the values of the given elements match any of the given value sets. The value sets to test against are computed from the given value maps by extracting the values for the given elements.
      Parameters:
      elements - the element names
      valueMaps - the value maps to match against

    • eTag

      @Beta static Predicate eTag(CqnListValue values)
      Creates a CqnEtagPredicate predicate.
      Parameters:
      values - the list of ETag values
      Returns:
      the eTag predicate

    • eTag

      @Beta static Predicate eTag(Object value)
      Creates a CqnEtagPredicate predicate.
      Parameters:
      value - the ETag value
      Returns:
      the eTag predicate

    • eTag

      @Beta static Predicate eTag(CqnElementRef elementRef, Object value)
      Creates a CqnEtagPredicate predicate.
      Parameters:
      elementRef - the reference to ETag element
      value - the ETag values
      Returns:
      the eTag predicate

    • search

      static Predicate search(String term)
      Creates a search predicate.
      Parameters:
      term - the search term
      Returns:
      the search predicate

    • exists

      static Predicate exists(CqnSelect subQuery)
      Creates an exists predicate that tests if a given subquery returns any row
      Parameters:
      subQuery - the subquery that performs the existence test
      Returns:
      the exists predicate

    • match

      static Predicate match(CqnStructuredTypeRef ref, CqnPredicate pred, CqnMatchPredicate.Quantifier quantifier)
      Creates a match predicate that tests if a given ref matches a given filter
      Parameters:
      ref - the reference
      pred - the filter
      quantifier - all or any
      Returns:
      the match predicate

    • now

      static Value<Instant> now()
      Creates an ElementRef to be used in queries to represent $now.
      Returns:
      the now value

    • validFrom

      static Value<Instant> validFrom()
      Creates an ElementRef on the available $validFrom value.
      Returns:
      the validFrom value

    • validTo

      static Value<Instant> validTo()
      Creates an ElementRef on the available $validTo value.
      Returns:
      the validTo value

    • userLocale

      static Value<String> userLocale()
      Creates an ElementRef on the available $user.locale value.
      Returns:
      the locale string value

    • userId

      static Value<String> userId()
      Creates an ElementRef on the available $user.id value.
      Returns:
      the user.id value

    • star

      static CqnStar star()

    • list

      static CqnListValue list(List<? extends CqnValue> values)
      Creates a CqnListValue composing given values
      Parameters:
      values - the components
      Returns:
      the list value

    • list

      static CqnListValue list(CqnValue... values)
      Creates a CqnListValue composing given values
      Parameters:
      values - the items
      Returns:
      the list value

    • matching

      static Predicate matching(Map<String,?> elementToValueMap)
      Creates a predicate from a map of element names to values or parameters. The map entries are transformed into equality predicates and joined via and.
      Parameters:
      elementToValueMap - the element name to value map defining the condition
      Returns:
      the matching predicate

    • sort

      static CqnSortSpecification sort(CqnValue value, CqnSortSpecification.Order order)
      Creates a CqnSortSpecification that sorts a value by a given order
      Parameters:
      value - the value
      order - the order
      Returns:
      the sort specification

    • matchesPattern

      static Predicate matchesPattern(CqnValue value, CqnValue pattern, CqnValue options)
      Creates a predicate that tests if this value matches a specified regular expression
      Parameters:
      value - the value that is tested
      pattern - Regular expression represented as a string value
      options - Regular expression options represented as a string value
      Returns:
      the predicate to match the expression

    • matchesPattern

      static Predicate matchesPattern(CqnValue value, CqnValue pattern)
      Creates a predicate that tests if this value matches a specified regular expression
      Parameters:
      value - the value that is tested
      pattern - Regular expression represented as a string value
      Returns:
      the predicate to match the expression

    • matchesPattern

      static Predicate matchesPattern(CqnValue value, String pattern)
      Creates a predicate that tests if this value matches a specified regular expression
      Parameters:
      value - the value that is tested
      pattern - Regular expression represented as a plain string
      Returns:
      the predicate to match the expression

    • matchesPattern

      static Predicate matchesPattern(CqnValue value, CqnValue pattern, boolean caseInsensitive, boolean multiLineSensitive)
      Creates a predicate that tests if this value matches a specified regular expression
      Parameters:
      value - the value that is tested
      pattern - Regular expression represented as a string value
      caseInsensitive - If true, the test is case-insensitive
      multiLineSensitive - If true, the test is multi-line sensitive
      Returns:
      the predicate to match the expression