> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://help.sigmacomputing.com/docs/text-functions/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://help.sigmacomputing.com/_mcp/server.

# Text functions

> Browse Sigma text functions available in formulas and calculations.

Text functions evaluate or manipulate string data to perform operations like text modification, formatting, and extraction.

| Function                             | Description                                                                                                                                                                    |
| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [Concat](/docs/concat)               | Combines multiple strings into a single text value.                                                                                                                            |
| [Contains](/docs/contains)           | Searches for a specified substring in a text value. If the substring is found, the function returns `True`, otherwise it returns `False`.                                      |
| [EndsWith](/docs/endswith)           | Determines if a text value ends with a specified substring. If the substring is found at the end of the text value, the function returns `True`, otherwise it returns `False`. |
| [Find](/docs/find)                   | Returns the index where it first finds the specified substring within a string. Returns `0` if not found.                                                                      |
| [ILike](/docs/ilike)                 | Returns `True` if the string matches the pattern. Case insensitive.                                                                                                            |
| [Left](/docs/left)                   | Returns the left portion of the string (the beginning), up to specified number of characters.                                                                                  |
| [Len](/docs/len)                     | Returns the number of characters in a string, including spaces.                                                                                                                |
| [Like](/docs/like)                   | Returns `True` if the string value matches the pattern. Case sensitive.                                                                                                        |
| [LPad](/docs/lpad)                   | Sets the string to a desired length by adding or removing characters at the front. Uses an optional fill character or defaults to extra spaces.                                |
| [Lower](/docs/lower)                 | Converts a string to all lower case.                                                                                                                                           |
| [LTrim](/docs/ltrim)                 | Removes leading spaces from a string.                                                                                                                                          |
| [MD5](/docs/md5)                     | Calculates the hash value of a string for the [MD5](https://en.wikipedia.org/wiki/MD5) message-digest algorithm (hashing function).                                            |
| [Mid](/docs/mid)                     | Returns a substring from a string, defined by offset and length. Same as [Substring](/docs/substring).                                                                         |
| [Proper](/docs/proper)               | Converts text to proper case, capitalizing the first letter of each word.                                                                                                      |
| [RegexpCount](/docs/regexpcount)     | Returns the number of times a regular expression pattern is matched in a string.                                                                                               |
| [RegexpExtract](/docs/regexpextract) | Returns the substring that matches a regular expression within a string.                                                                                                       |
| [RegexpMatch](/docs/regexpmatch)     | Returns `True` if a string matches a regular expression.                                                                                                                       |
| [RegexpReplace](/docs/regexpreplace) | Returns a string for a pattern and replaces it with a specified string.                                                                                                        |
| [Repeat](/docs/repeat)               | Returns the result of repeating the string a specified number of times.                                                                                                        |
| [Replace](/docs/replace)             | Replaces every instance of a specified string with a replacement string.                                                                                                       |
| [Reverse](/docs/reverse)             | Reverses the order of characters in a string.                                                                                                                                  |
| [Right](/docs/right)                 | Returns the right portion of a string (the end), up to the specified number of characters.                                                                                     |
| [RPad](/docs/rpad)                   | Sets the string to a desired length by adding or removing characters at the end. Uses an optional fill character, or defaults to extra spaces.                                 |
| [RTrim](/docs/rtrim)                 | Removes trailing spaces from the end of a string.                                                                                                                              |
| [SHA256](/docs/sha256)               | Transforms text input into a 256-bit hash value.                                                                                                                               |
| [SplitPart](/docs/splitpart)         | Splits the string into multiple parts at the positions of each appearance of the delimiter and returns the nth part of the string at the specified position.                   |
| [StartsWith](/docs/startswith)       | Determines if a string starts with the specified substring. Returns `True` or `False`.                                                                                         |
| [Substring](/docs/substring)         | Returns a substring from a string, defined by offset and length. Same as [Mid](/docs/mid).                                                                                     |
| [TextJoin](/docs/textjoin)           | Combines multiple strings into a single text value, separated by a delimiter.                                                                                                  |
| [Trim](/docs/trim)                   | Removes both leading and trailing spaces from a string.                                                                                                                        |
| [Upper](/docs/upper)                 | Converts a string to upper case (all capital letters).                                                                                                                         |
| [UrlPart](/docs/urlpart)             | Extracts a component from a URL.                                                                                                                                               |

> Official documentation and guidance for using Sigma to build AI apps, dashboards, and agents on governed warehouse data.

## Docs

- [Concat](https://help.sigmacomputing.com/docs/concat.md): Use the Sigma Concat function to combine one or more text strings into a single string.
- [Contains](https://help.sigmacomputing.com/docs/contains.md): Use the Sigma Contains function to search for a specified substring in a text value.
- [EndsWith](https://help.sigmacomputing.com/docs/endswith.md): Returns True if a string ends with a substring.
- [Find](https://help.sigmacomputing.com/docs/find.md): Returns the index at which a substring is first found within a given string.
- [ILike](https://help.sigmacomputing.com/docs/ilike.md): Returns true if the string value matches the case-insensitive pattern.
- [Left](https://help.sigmacomputing.com/docs/left.md): Returns a substring that begins at the start of a given string.
- [Len](https://help.sigmacomputing.com/docs/len.md): Returns the number of characters in a string, including spaces.
- [Like](https://help.sigmacomputing.com/docs/like.md): Returns true if the string value matches the case-sensitive pattern.
- [LPad](https://help.sigmacomputing.com/docs/lpad.md): Prepends a pattern to or truncates a string to the desired length.
- [Lower](https://help.sigmacomputing.com/docs/lower.md): Converts a given string to lowercase.
- [LTrim](https://help.sigmacomputing.com/docs/ltrim.md): Removes leading spaces from the beginning of a given string.
- [MD5](https://help.sigmacomputing.com/docs/md5.md): Utilizes the MD5 algorithm to calculate the hash value of a given string.
- [Mid](https://help.sigmacomputing.com/docs/mid.md): Returns a substring defined by offset and length.
- [Proper](https://help.sigmacomputing.com/docs/proper.md): Use the Sigma Proper function to convert text to proper case, capitalizing each word and lowercasing the rest.
- [RegexpCount](https://help.sigmacomputing.com/docs/regexpcount.md): Use the Sigma RegexpCount function to return the number of times a regular expression pattern is matched in a string.
- [RegexpExtract](https://help.sigmacomputing.com/docs/regexpextract.md): Use the Sigma RegexpExtract function to return the substring that matches a regular expression within a string.
- [RegexpMatch](https://help.sigmacomputing.com/docs/regexpmatch.md): Returns True if a string matches a regular expression.
- [RegexpReplace](https://help.sigmacomputing.com/docs/regexpreplace.md): Use the Sigma RegexpReplace function to search a string for a pattern and replace all matches with the replacement string.
- [Repeat](https://help.sigmacomputing.com/docs/repeat.md): Use the Sigma Repeat function to return a string created by repeating a given string a specified number of times.
- [Replace](https://help.sigmacomputing.com/docs/replace.md): Use the Sigma Replace function to search through a input string for a substring and replace every instance of it with a replacement string.
- [Reverse](https://help.sigmacomputing.com/docs/reverse.md): Use the Sigma Reverse function to revers the order of the characters in a string.
- [Right](https://help.sigmacomputing.com/docs/right.md): Use the Sigma Right function to return a substring from the end of a string.
- [RPad](https://help.sigmacomputing.com/docs/rpad.md): Use the Sigma RPad function to make a string a desired length by either adding or removing characters at the end of the string.
- [RTrim](https://help.sigmacomputing.com/docs/rtrim.md): RTrim removes trailing spaces from the end of a string.
- [SHA256](https://help.sigmacomputing.com/docs/sha256.md): The SHA256 (Secure Hash Algorithm 256-bit) function is a cryptographic hash function that transforms text input into a 256-bit hash value.
- [SplitPart](https://help.sigmacomputing.com/docs/splitpart.md): Use the Sigma SplitPart function to split a string into multiple parts at the position of a specified delimiter in the string, then returns the nth.
- [StartsWith](https://help.sigmacomputing.com/docs/startswith.md): Use the Sigma StartsWith function to determine whether a string starts with a specified substring.
- [Substring](https://help.sigmacomputing.com/docs/substring.md): Use the Sigma Substring function as an alias of Mid. Returns a substring defined by offset and length.
- [TextJoin](https://help.sigmacomputing.com/docs/textjoin.md): Use the Sigma TextJoin function to combine multiple text strings into a single string separated by a delimiter.
- [Trim](https://help.sigmacomputing.com/docs/trim.md): Use the Sigma Trim function to remove leading and trailing spaces from a given string.
- [Upper](https://help.sigmacomputing.com/docs/upper.md): Use the Sigma Upper function to convert a given string to uppercase.
- [UrlPart](https://help.sigmacomputing.com/docs/urlpart.md): Use the Sigma UrlPart function to extract a specified component from a URL and return it as text.