String operators
Learn how to use and combine different query operators for searching string data types.
The table summarizes the string operators available in APL.
Operator | Description | Case sensitive | Example |
---|---|---|---|
== | Equals | Yes | "aBc" == "aBc" |
!= | Not equals | Yes | "abc" != "ABC" |
=~ | Equals | No | "abc" =~ "ABC" |
!~ | Not equals | No | "aBc" !~ "xyz" |
contains | RHS occurs as a subsequence of LHS | No | "parentSpanId" contains "Span" |
!contains | RHS doesn’t occur in LHS | No | "parentSpanId" !contains "abc" |
contains_cs | RHS occurs as a subsequence of LHS | Yes | "parentSpanId" contains_cs "Id" |
!contains_cs | RHS doesn’t occur in LHS | Yes | "parentSpanId" !contains_cs "Id" |
startswith | RHS is an initial subsequence of LHS | No | "parentSpanId" startswith "parent" |
!startswith | RHS isn’t an initial subsequence of LHS | No | "parentSpanId" !startswith "Id" |
startswith_cs | RHS is an initial subsequence of LHS | Yes | "parentSpanId" startswith_cs "parent" |
!startswith_cs | RHS isn’t an initial subsequence of LHS | Yes | "parentSpanId" !startswith_cs "parent" |
endswith | RHS is a closing subsequence of LHS | No | "parentSpanId" endswith "Id" |
!endswith | RHS isn’t a closing subsequence of LHS | No | "parentSpanId" !endswith "Span" |
endswith_cs | RHS is a closing subsequence of LHS | Yes | "parentSpanId" endswith_cs "Id" |
!endswith_cs | RHS isn’t a closing subsequence of LHS | Yes | "parentSpanId" !endswith_cs "Span" |
in | Equals to one of the elements | Yes | "abc" in ("123", "345", "abc") |
!in | Not equals to any of the elements | Yes | "bca" !in ("123", "345", "abc") |
in~ | Equals to one of the elements | No | "abc" in~ ("123", "345", "ABC") |
!in~ | Not equals to any of the elements | No | "bca" !in~ ("123", "345", "ABC") |
matches regex | LHS contains a match for RHS | Yes | "parentSpanId" matches regex "g.*r" |
!matches regex | LHS doesn’t contain a match for RHS | Yes | "parentSpanId" !matches regex "g.*r" |
has | RHS is a whole term in LHS | No | "North America" has "america" |
!has | RHS isn’t a whole term in LHS | No | "North America" !has "america" |
has_cs | RHS is a whole term in LHS | Yes | "North America" has_cs "America" |
!has_cs | RHS isn’t a whole term in LHS | Yes | "North America" !has_cs "America" |
hasprefix | LHS string starts with the RHS string | No | "Admin_User" hasprefix "Admin" |
!hasprefix | LHS string doesn’t start with the RHS string | No | "Admin_User" !hasprefix "Admin" |
hasprefix_cs | LHS string starts with the RHS string | Yes | "DOCS_file" hasprefix_cs "DOCS" |
!hasprefix_cs | LHS string doesn’t start with the RHS string | Yes | "DOCS_file" !hasprefix_cs "DOCS" |
hassuffix | LHS string ends with the RHS string | No | "documentation.docx" hassuffix ".docx" |
!hassuffix | LHS string doesn’t end with the RHS string | No | "documentation.docx" !hassuffix ".docx" |
hassuffix_cs | LHS string ends with the RHS string | Yes | "Document.HTML" hassuffix_cs ".HTML" |
!hassuffix_cs | LHS string doesn’t end with the RHS string | Yes | "Document.HTML" !hassuffix_cs ".HTML" |
RHS = right-hand side of the expression LHS = left-hand side of the expression
Case-sensitivity
Operators with _cs
suffix are case-sensitive.
When two operators do the same task, use the case-sensitive one for better performance.
For example:
- Instead of
=~
, use==
- Instead of
in~
, usein
- Instead of
contains
, usecontains_cs
Best practices
- Use case-sensitive operators when you know the case to improve performance.
- Avoid complex regular expressions for basic matching tasks. Use basic string operators instead.
- When matching against a set of values, ensure the set is as small as possible to improve performance.
- For matching substrings, use prefix or suffix matching instead of general substring matching for better performance.
Equality and inequality operators
Operators:
==
!=
=~
!~
in
!in
in~
!in~
Query examples:
- Use
==
or!=
for exact match comparisons when case sensitivity is important. - Use
=~
or!~
for case-insensitive comparisons or when you don’t know the exact case. - Use
in
or!in
for checking membership within a set of values which can be efficient for a small set of values.
Subsequence-matching operators
Operators:
contains
!contains
contains_cs
!contains_cs
startswith
!startswith
startswith_cs
!startswith_cs
endswith
!endswith
endswith_cs
!endswith_cs
Query examples:
Use case-sensitive operators (contains_cs
, startswith_cs
, endswith_cs
) when you know the case to improve performance.
Regular-expression-matching operators
Operators:
matches regex
!matches regex
Query examples:
Avoid complex regular expressions or use string operators for simple substring, prefix, or suffix matching.
Term-matching operators
Operators:
has
!has
has_cs
!has_cs
hasprefix
!hasprefix
hasprefix_cs
!hasprefix_cs
hassuffix
!hassuffix
hassuffix_cs
!hassuffix_cs
Query examples:
- Use
has
orhas_cs
for term matching which can be more efficient than regular expression matching for simple term searches. - Use
has_cs
when you know the case to improve performance. - Unlike the
contains
operator, which matches any substring, thehas
operator looks for exact terms, ensuring more precise results.