> ## Documentation Index
> Fetch the complete documentation index at: https://www.integrate.io/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# ETL: Functions Reference

> Complete reference of all built-in functions in Integrate.io ETL expressions, covering string, math, date, hash, collection, and API functions.

| Name                                                                                  | Description                                                                                                                                                                                           |
| :------------------------------------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [ByteArrayToString](/etl/bytearraytostring/)                                          | Converts a byte array to a string based on the given encoding.                                                                                                                                        |
| [GetBytes](/etl/getbytes/ "Link: /etl/getbytes/")                                     | Returns a byte array for a string input.                                                                                                                                                              |
| [ParseDoubleOrDefault](/etl/parsedoubleordefault/ "Link: /etl/parsedoubleordefault/") | Attempts to convert a string representation of a number to a double-precision numeric equivalent. If successful, returns the string as a double numeric value, otherwise returns the default value.   |
| [ParseFloatOrDefault](/etl/parsefloatordefault/ "Link: /etl/parsefloatordefault/")    | Attempts to convert a string representation of a number to a floating-precision numeric equivalent. If successful, returns the string as a double numeric value, otherwise returns the default value. |
| [ParseIntOrDefault](/etl/parseintordefault/)                                          | Attempts to convert a string representation of a number to a integer-precision numeric equivalent. If successful, returns the string as a double numeric value, otherwise returns the default value.  |
| [ParseLongOrDefault](/etl/parselongordefault/)                                        | Attempts to convert a string representation of a number to a long-precision numeric equivalent. If successful, returns the string as a double numeric value, otherwise returns the default value.     |
| [ParseDate](/etl/parsedate/)                                                          | Convert input datetime string to datetime data type, using the first format that matches the string.                                                                                                  |
| [ToDate](/etl/todate/)                                                                | Convert datetime string to datetime data type                                                                                                                                                         |
| [ToDateCustomFormats](/etl/todatecustomformats/)                                      | Convert input that matches one of multiple formats to datetime data type.                                                                                                                             |
| [ToHexString](/etl/tohexstring/)                                                      | Returns a string representation of the integer argument in base 16                                                                                                                                    |
| [ToString](/etl/tostring/)                                                            | Convert datetime value to string data type                                                                                                                                                            |
| [ToJson](/etl/tojson/)                                                                | Returns the input as a JSON string.                                                                                                                                                                   |

| Name                                       | Description                                                                                                             |
| :----------------------------------------- | :---------------------------------------------------------------------------------------------------------------------- |
| [BagToString](/etl/bagtostring/)           | Concatenates a bag into a string.                                                                                       |
| [BagToTuple](/etl/bagtotuple/)             | Flattens a bag into a tuple. Once the bag is flattened into a tuple, items can be extracted by referencing tuple items. |
| [IsEmpty](/etl/isempty/)                   | Returns true if the input map or bag is empty, false if the input contains items, or null if the input is null.         |
| [MapToBag](/etl/maptobag/)                 | Transforms a hash map to a bag of hash maps where each map contains two keys: key and value.                            |
| [MapToQueryString](/etl/maptoquerystring/) | Converts a map to a URL query string (key1=value1\&key2=value2).                                                        |
| [TOBAG](/etl/tobag/)                       | Converts one or more expressions to type bag                                                                            |
| [TOMAP](/etl/tomap/)                       | Converts key/value expression pairs to type map                                                                         |
| [TOTUPLE](/etl/totuple/)                   | Converts one or more expressions to type tuple                                                                          |

| Name                                               | Description                                                                                                                          |
| :------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------- |
| [AddDuration](/etl/addduration/)                   | Returns the result of a datetime\_field plus a duration\_field.                                                                      |
| [ClockTime](/etl/clocktime/)                       | For each record, returns the datetime value when the function is called.                                                             |
| [CurrentTime](/etl/currenttime/)                   | Returns the datetime value when a job was submitted. Use ClockTime() to get a value per record in the set.                           |
| [DaysBetween](/etl/daysbetween/)                   | Returns the number of days between the end\_datetime and the start\_datetime?.                                                       |
| [GetDay](/etl/getday/)                             | Returns the day of a month from a datetime field.                                                                                    |
| [GetHour](/etl/gethour/)                           | Returns the hour of a day from a datetime field.                                                                                     |
| [GetMilliSecond](/etl/getmillisecond/)             | Returns the millisecond of a second from a datetime field.                                                                           |
| [GetMinute](/etl/getminute/)                       | Returns the minute of a hour from a datetime field.                                                                                  |
| [GetMonth](/etl/getmonth/)                         | Returns the month of a year from a datetime field.                                                                                   |
| [GetSecond](/etl/getsecond/)                       | Returns the second of a minute from a datetime field.                                                                                |
| [GetWeek](/etl/getweek/)                           | Returns the week of a week year from a datetime field.                                                                               |
| [GetWeekYear](/etl/getweekyear/)                   | Returns the week year from a datetime field.                                                                                         |
| [GetYear](/etl/getyear/)                           | Returns the year from a datetime field.                                                                                              |
| [HoursBetween](/etl/hoursbetween/)                 | Returns the number of hours between the end\_datetime and the start\_datetime?.                                                      |
| [IntervalIntersection](/etl/intervalintersection/) | Returns the duration in milliseconds of the overlap between all intervals in the function's arguments.                               |
| [MilliSecondsBetween](/etl/millisecondsbetween/)   | Returns the number of milliseconds between the end\_datetime and the start\_datetime?.                                               |
| [MinutesBetween](/etl/minutesbetween/)             | Returns the number of minutes between the end\_datetime and the start\_datetime?.                                                    |
| [MonthsBetween](/etl/monthsbetween/)               | Returns the number of months between the end\_datetime and the start\_datetime?.                                                     |
| [SecondsBetween](/etl/secondsbetween/)             | Returns the number of seconds between the end\_datetime and the start\_datetime.                                                     |
| [SubtractDuration](/etl/subtractduration/)         | Returns the result of a DateTime object minus a Duration object.                                                                     |
| [SwitchTimeZone](/etl/switchtimezone/)             | Changes a datetime value's time zone from the value's original time zone to the time zone given in tz\_string and returns the value. |
| [ToMilliSeconds](/etl/tomilliseconds/)             | Returns the number of milliseconds elapsed since 1970-01-01T00:00:00Z for a datetime value.                                          |
| [ToUnixTime](/etl/tounixtime/)                     | Returns the Unix Time for a datetime value.                                                                                          |
| [WeeksBetween](/etl/weeksbetween/)                 | Returns the number of weeks between the end\_datetime and the start\_datetime                                                        |
| [YearsBetween](/etl/yearsbetween/)                 | Returns the number of years between the end\_datetime and the start\_datetime.                                                       |

ISO 8601 String Functions

| Name                                                               | Description                                                                                               |
| :----------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------- |
| [DateDiffDays](/etl/datediffdays/)                                 | Returns the number of days between the end\_datetime and the start\_datetime.                             |
| [DateDiffHours](/etl/datediffhours/)                               | Returns the number of hours between the end\_datetime and the start\_datetime.                            |
| [DateDiffMinutes](/etl/datediffminutes/)                           | Returns the number of minutes between the end\_datetime and the start\_datetime.                          |
| [DateDiffMonths](/etl/datediffmonths/)                             | Returns the number of months between the end\_datetime and the start\_datetime.                           |
| [DateDiffSeconds](/etl/datediffseconds/)                           | Returns the number of seconds between the end\_datetime and the start\_datetime.                          |
| [DateDiffYears](/etl/datediffyears/)                               | Returns the number of years between the end\_datetime and the start\_datetime.                            |
| [IsISODatetime](/etl/isisodatetime/)                               | Checks if the datetime\_field is in ISO 8601 date time format.                                            |
| [ISOAddDuration](/etl/isoaddduration/)                             | Adds the value represented by the duration field to the datetime\_field.                                  |
| [ISODatetimeToString](/etl/isodatetimetostring/)                   | Convert datetime string in ISO format to JDBC timestamp string format                                     |
| [ISODatetimeToTimestampFormat](/etl/isodatetimetotimestampformat/) | Convert datetime string in ISO format to JDBC timestamp string format                                     |
| [ISOSubtractDuration](/etl/isosubtractduration/)                   | Subtracts the value represented by the duration field from the datetime\_field.                           |
| [ISOToDay](/etl/isotoday/)                                         | Resets the ISO datetime string to the beginning of the day specified in the string.                       |
| [ISOToHour](/etl/isotohour/)                                       | Resets the ISO datetime string to the beginning of the hour specified in the string.                      |
| [ISOToMinute](/etl/isotominute/)                                   | Resets the ISO datetime string to the beginning of the minute specified in the string.                    |
| [ISOToMonth](/etl/isotomonth/)                                     | Resets the ISO datetime string to the beginning of the month specified in the string.                     |
| [ISOToSecond](/etl/isotosecond/)                                   | Resets the ISO datetime string to the beginning of the second specified in the string.                    |
| [ISOToWeek](/etl/isotoweek/)                                       | Resets the ISO datetime string to the beginning of the week (Monday) specified in the string.             |
| [ISOToYear](/etl/isotoyear/)                                       | Resets the ISO datetime string to the beginning of the year specified in the string.                      |
| [StringToISODatetime](/etl/stringtoisodatetime/)                   | Converts a non-ISO datetime string whose structure is defined by a format string into an ISO 8601 format. |
| [TimestampFormatToISODatetime](/etl/timestampformattoisodatetime/) | Convert datetime string in JDBC timestamp string format to ISO format                                     |

**IP to Location** Functions

| Name                                             | Description                                                                                                                                  |
| :----------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------- |
| [CityNameFromIP](/etl/citynamefromip/)           | Extracts the city name from a given IPv4 string (dot-decimal notation).                                                                      |
| [ContinentCodeFromIP](/etl/continentcodefromip/) | Extracts the continent code from a given IPv4 string (dot-decimal notation).                                                                 |
| [ContinentNameFromIP](/etl/continentnamefromip/) | Extracts the continent name from a given IPv4 string (dot-decimal notation).                                                                 |
| [CountryCodeFromIP](/etl/countrycodefromip/)     | Extracts the country code (ISO-3166-1 alpha2) from a given IPv4 string (dot-decimal notation).                                               |
| [CountryNameFromIP](/etl/countrynamefromip/)     | Extracts the country name from a given IPv4 string (dot-decimal notation).                                                                   |
| [LatitudeFromIP](/etl/latitudefromip/)           | Extracts the latitude from a given IPv4 string (dot-decimal notation).                                                                       |
| [LongitudeFromIP](/etl/longitudefromip/)         | Extracts the longitude from a given IPv4 string (dot-decimal notation).                                                                      |
| [RegionCodeFromIP](/etl/regioncodefromip/)       | Extracts the two character ISO-3166-2 (US or Canada) or FIPS 10-4 code for the state/region from a given IPv4 string (dot-decimal notation). |
| [RegionNameFromIP](/etl/regionnamefromip/)       | Extracts the region, state (US) or province (Canada) from a given IPv4 string (dot-decimal notation).                                        |

| Name                                                                         | Description                                                                                                                                                                                                   |
| :--------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [JsonExtract](/etl/jsonextract/)                                             | Extracts the value referenced by  [jsonpath](https://goessner.net/articles/JsonPath/)-like expression json\_path from a given JSON string (a string containing JSON) and returns the result as a JSON string. |
| [JsonExtractScalar](/etl/jsonextractscalar/ "Link: /etl/jsonextractscalar/") | Extracts the value referenced by JSONPath-like expression json\_path from a given JSON string (a string containing JSON) and returns the result as a string                                                   |
| [JsonStringToBag](/etl/jsonstringtobag/ "Link: /etl/jsonstringtobag/")       | Converts a string field that contains a json array to a bag (array).                                                                                                                                          |
| [JsonStringToMap](/etl/jsonstringtomap/ "Link: /etl/jsonstringtomap/")       | Converts a string field that contains a Json object to a map (key:value pairs). From   the map you can extract fields using the notation map#'fieldname'.                                                     |

| Name                                                                   | Description                                                                                           |
| :--------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------- |
| [ExecuteBQInsert](/etl/executebqinsert/ "Link: /etl/executebqinsert/") | Starts a query job in Google BigQuery and writes the query results to a destination table.            |
| [ExecuteSqlBoolean](/etl/executesqlboolean/)                           | Execute a SQL query that returns a scalar boolean value.                                              |
| [ExecuteSqlDateTime](/etl/executesqldatetime/)                         | Execute a SQL query that returns a scalar datetime value.                                             |
| [ExecuteSqlDouble](/etl/executesqldouble/)                             | Execute a SQL query that returns a scalar double value.                                               |
| [ExecuteSqlFloat](/etl/executesqlfloat/)                               | Execute a SQL query that returns a scalar float value.                                                |
| [ExecuteSqlInt](/etl/executesqlint/)                                   | Execute a SQL query that returns a scalar int value.                                                  |
| [ExecuteSqlLong](/etl/executesqllong/)                                 | Execute a SQL query that returns a scalar long value.                                                 |
| [ExecuteSqlString](/etl/executesqlstring/)                             | Execute a SQL query that returns a scalar string value.                                               |
| [ExecuteSqlNonQuery](/etl/executesqlnonquery/)                         | Execute a SQL statement or a batch of SQL statements that modify the data or the schema (DML or DDL). |

| Name                           | Description                                                                                  |
| :----------------------------- | :------------------------------------------------------------------------------------------- |
| [XPath](/etl/xpath/)           | Extracts part of an XML document using an XPath expression.                                  |
| [XPathToBag](/etl/xpathtobag/) | Extracts part of an XML document using an XPath expression and returns a bag of all matches. |

| Name                        | Description                                                                               |
| :-------------------------- | :---------------------------------------------------------------------------------------- |
| [ABS](/etl/abs/)            | Returns the absolute value of a number                                                    |
| [ACOS](/etl/acos/)          | Returns the arc cosine of a number                                                        |
| [ASIN](/etl/sin/)           | Returns the arc sine of a number                                                          |
| [ATAN](/etl/atan/)          | Returns the arc tangent of a number                                                       |
| [CBRT](/etl/cbrt/)          | Returns the cube root of a number                                                         |
| [CEIL](/etl/ceil/)          | Rounds the expression up to the nearest integer.                                          |
| [COS](/etl/cos/)            | Returns the trigonometric cosine of a number                                              |
| [COSH](/etl/cosh/)          | Returns the hyperbolic cosine of a number                                                 |
| [EXP](/etl/exp/)            | Returns Euler's number e raised to the power of the expression                            |
| [FLOOR](/etl/floor/)        | Rounds the expression down to the nearest integer.                                        |
| [LOG](/etl/log/)            | Returns the natural logarithm of a number                                                 |
| [LOG10](/etl/log10/)        | Returns the base 10 logarithm of a number                                                 |
| [POW](/etl/pow/)            | Returns x raised to the power of y                                                        |
| [RANDOM](/etl/random/)      | Returns a pseudo-random number between 0.0 and 1.0                                        |
| [ROUND](/etl/round/)        | Rounds the expression up or down to the nearest integer according to standard math rules. |
| [ROUND\_TO](/etl/round-to/) | Rounds the expression to a fixed number of decimal digits.                                |
| [SIN](/etl/sin/)            | Returns the trigonometric sine of a number                                                |
| [SINH](/etl/sinh/)          | Returns the hyperbolic sine of a number                                                   |
| [SQRT](/etl/sqrt/)          | Returns the square root of a number                                                       |
| [TAN](/etl/tan/)            | Returns the trigonometric tangent of a number                                             |
| [TANH](/etl/tanh/)          | Returns the hyperbolic tangent of a number                                                |

| Name                                                     | Description                                                                                                                                                                                                 |
| :------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Base64Decode](/etl/base64decode/)                       | Decodes a Base64 string into a bytearray.                                                                                                                                                                   |
| [Base64DecodeToString](/etl/base64decodetostring/)       | Decodes a Base64 string into string.                                                                                                                                                                        |
| [Base64Encode](/etl/base64encode/)                       | Encodes a byte array argument into a Base64 byte array.                                                                                                                                                     |
| [Base64EncodeToString](/etl/base64encodetostring/)       | Encodes a byte array argument into a string using Base64 encoding scheme.                                                                                                                                   |
| [CONCAT](/etl/concat/)                                   | Concatenates a variable number of strings and returns them as one string.                                                                                                                                   |
| [ExtractQueryStringParam](/etl/extractquerystringparam/) | Extracts the value from a specified query string parameter for a url field.                                                                                                                                 |
| [ExtractSearchQuery](/etl/extractsearchquery/)           | Returns the search string from a search engine query url.                                                                                                                                                   |
| [ExtractUrlPart](/etl/extracturlpart/)                   | Extracts a specified part from a URL field.                                                                                                                                                                 |
| [INDEXOF](/etl/indexof/)                                 | Returns the position of the first occurrence of a search string in a string field, when searching forward from the start index.                                                                             |
| [LAST\_INDEX\_OF](/etl/last-index-of/)                   | Returns the position of the last occurrence of a search string in a string field, when searching backward from the end of the string.                                                                       |
| [LCFIRST](/etl/lcfirst/)                                 | Converts the first character in a string to lower case                                                                                                                                                      |
| [Length](/etl/length/)                                   | Returns the number of characters in a string field.                                                                                                                                                         |
| [LOWER](/etl/lower/)                                     | Converts the characters in a string\_field to lower case.                                                                                                                                                   |
| [QueryStringToMap](/etl/querystringtomap/)               | Converts a string field that contains a query string (...?key1=value1\&key2=value2) to a map of key:value pairs. From the map you can extract fields using the notation map#'fieldname'.                    |
| [REGEX\_EXTRACT](/etl/regex-extract/)                    | Returns the nth occurrence (specified by index) of a string that matches the regular expression.                                                                                                            |
| [REGEX\_EXTRACT\_ALL](/etl/regex-extract-all/)           | Returns a tuple with all matched groups.                                                                                                                                                                    |
| [REGEX\_FIND\_ALL](/etl/regex-find-all/)                 | Return all occurrences of strings that match a regular expression in a bag.                                                                                                                                 |
| [REPLACE](/etl/replace/)                                 | In a string field, replaces all occurrences of a string with a different string.                                                                                                                            |
| [SPRINTF](/etl/sprintf/)                                 | Uses printf-style template to formats a set of values using the native Java formatter library.                                                                                                              |
| [STRSPLIT](/etl/strsplit/)                               | Splits a string around matches of a delimiter                                                                                                                                                               |
| [STRSPLITTOBAG](/etl/strsplittobag/)                     | Splits a string into a bag around matches of a delimiter.                                                                                                                                                   |
| [SUBSTRING](/etl/substring/)                             | Returns part of a string field.                                                                                                                                                                             |
| [TOKENIZE](/etl/tokenize/)                               | Generates a bag from delimited strings in string field. If you don't specify a single-character delimiter, tokenize will use any of the following characters: space, double-quote, comma, parenthesis, star |
| [TRIM](/etl/trim/)                                       | Removes leading and trailing spaces from a string field.                                                                                                                                                    |
| [INITCAP](/etl/initialcap/)                              | Capitalizes the first letter of each word in a string and lowercases the rest. Words are delimited by whitespace, hyphen, apostrophe, or period.                                                            |
| [UCFIRST](/etl/ucfirst/)                                 | Converts the first character in a string to upper case                                                                                                                                                      |
| [UPPER](/etl/upper/)                                     | Converts the characters in a string\_field to upper case.                                                                                                                                                   |
| [URLDecode](/etl/urldecode/)                             | Decodes a string field containing an encoded url.                                                                                                                                                           |
| [URLEncode](/etl/urlencode/)                             | URL-encodes a given string expression..                                                                                                                                                                     |
| [UUID](/etl/uuid/)                                       | Returns a universally unique   identifier (string)                                                                                                                                                          |

| Name                                 | Description                                                                                                               |
| :----------------------------------- | :------------------------------------------------------------------------------------------------------------------------ |
| [MD2](/etl/md2/)                     | Calculates the MD2 hash of a string                                                                                       |
| [MD5](/etl/md5/)                     | Calculates the MD5 hash of a string                                                                                       |
| [SHA1](/etl/sha1/)                   | Calculates the SHA1 hash of a string                                                                                      |
| [SHA256](/etl/sha256/)               | Calculates the SHA256 hash of a string                                                                                    |
| [SHA256WithRSA](/etl/sha256withrsa/) | Sign an input string with an RSA private key using the SHA256withRSA signature algorithm. Useful with JWT authentication. |
| [SHA384](/etl/sha384/)               | Calculates the SHA384 hash of a string                                                                                    |
| [SHA512](/etl/sha512/)               | Calculates the SHA512 hash of a string                                                                                    |

| Name                     | Description                                                                                                                          |
| :----------------------- | :----------------------------------------------------------------------------------------------------------------------------------- |
| [Encrypt](/etl/encrypt/) | AES encrypt a string using the specified AWS KMS key ARN and encryption context.                                                     |
| [Decrypt](/etl/decrypt/) | Decrypt an Integrate.io ETL encrypted string using the specified AWS KMS key ARN and the encryption context used for the encryption. |

| Name                                               | Description                                                       |
| :------------------------------------------------- | :---------------------------------------------------------------- |
| [BrowserFamily](/etl/browserfamily/)               | Extract browser family from user agent string                     |
| [BrowserFullName](/etl/browserfullname/)           | Extract browser full name (family+version) from user agent string |
| [BrowserMajor](/etl/browsermajor/)                 | Extract browser major version from user agent string              |
| [BrowserMinor](/etl/browserminor/)                 | Extract browser minor version from user agent string              |
| [BrowserPatch](/etl/browserpatch/)                 | Extract browser patch version from user agent string              |
| [BrowserVersion](/etl/browserversion/)             | Extract browser version from user agent string                    |
| [DeviceFamily](/etl/devicefamily/)                 | Extract device family from user agent string                      |
| [ExtractUABrowserID](/etl/extractuabrowserid/)     | Returns a browser ID for a given user agent string.               |
| [ExtractUABrowserName](/etl/extractuabrowsername/) | Returns a browser name for a given user agent string.             |
| [OsFamily](/etl/osfamily/)                         | Extract OS family from user agent string                          |
| [OsFullName](/etl/osfullname/)                     | Extract OS full name (family+version) from uesr agent string      |
| [OsMajor](/etl/osmajor/)                           | Extract OS major version from user agent string                   |
| [OsMinor](/etl/osminor/)                           | Extract OS minor version from user agent string                   |
| [OsPatch](/etl/ospatch/)                           | Extract OS patch version from user agent string                   |
| [OsPatchMinor](/etl/ospatchminor/)                 | Extract OS patch minor version from user agent string             |
| [OsVersion](/etl/osversion/)                       | Extract OS version from user agent string                         |
| [PlatformFamily](/etl/platformfamily/)             | Extract platform family from user agent string                    |

| Name                                               | Description                                                                                                                                                                        |
| :------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [CCurl](/etl/ccurl/)                               | Makes a REST API call and returns the response received from the server. Requests are authenticated using an Integrate.io ETL connection.                                          |
| [BinaryCCurl](/etl/binaryccurl/)                   | Makes a REST API call and returns the binary response received from the server. Requests are authenticated using an Integrate.io ETL connection.                                   |
| [CCurlWithPagination](/etl/ccurlwithpagination/)   | Makes one or more REST API calls and returns the responses received from all the pages requested from the server. Requests are authenticated using an Integrate.io ETL connection. |
| [COALESCE](/etl/coalesce/)                         | Returns the first non-NULL argument                                                                                                                                                |
| [Curl](/etl/curl/)                                 | Makes a REST API call and returns the response received from the server.                                                                                                           |
| [BinaryCurl](/etl/binarycurl/)                     | Makes a REST API call and returns the binary response received from the server. Requests are made either anonymous or with basic authentication                                    |
| [CurlWithPagination](/etl/curlwithpagination/)     | Makes one or more REST API calls and returns the responses received from all the pages requested from the server. Requests are made either anonymous or with basic authentication. |
| [CurlPoll](/etl/curlpoll/)                         | Makes a REST API request continuously until a regular expression is matched or timeout is reached.                                                                                 |
| [CCurlPoll](/etl/ccurlpoll/)                       | Makes a REST API request continuously until a regular expression is matched or timeout is reached. Requests are authenticated using an Integrate.io ETL connection.                |
| [DistInMilesHaversine](/etl/distinmileshaversine/) | Computes the distance (in miles) between two latitude-longitude pairs using the Haversine formula, base on Apache DataFu.                                                          |
| [Flatten](/etl/flatten/)                           | For each item in a bag, flatten creates a new record containing the item and the data of all the other fields in the component.                                                    |
| [SIZE](/etl/size/)                                 | Calculates the number of elements based on the data type.                                                                                                                          |
| [Sleep](/etl/sleep/)                               | Causes the process to sleep for a specified number of milliseconds                                                                                                                 |
| [CSVSPLIT](/etl/csvsplit/)                         | Splits a CSV string into a tuple around matches of a field delimiter.                                                                                                              |
