Select Page

## Logic Apps (Standard) Data Mapper: Math (or Mathematical) Functions (Part 2)

Because the Math (or Mathematical) functions category has too many functions, I decide to break this blog post into different parts, so welcome to the second part!

## Overview

Math (or Mathematical) functions are used to perform a variety of mathematical and scientific operations, such as addition and multiplication. If you come from the BizTalk Server background or are migrating BizTalk Server projects, they are the equivalent of Mathematical and Scientific Functoids inside BizTalk Mapper Editor.

## Available Functions

The Math functions are:

• Absolute: Returns the absolute value of the specified number.
• Add: Returns the sum from adding two or more numbers.
• Arctangent: Returns the arc tangent of a number.
• Ceiling: Returns the smallest integral value greater than or equal to the specified number.
• Cosine: Returns the cosine for the specified angle.
• Divide: Returns the result from dividing two numbers.
• Exponential: Raises the “e” constant to the specified power and returns the result.
• Exponential (base 10): Returns the number 10 raised to the specified power.
• Floor: Returns the largest integral value less than or equal to the specified number.
• Integer divide: Divides two numbers and returns the integer part from the result.
• Log: Returns the logarithm for the specified number in the specified base.
• Log (base 10): Returns the base 10 logarithm for the specified number.
• Modulo: Returns the remainder from dividing the specified numbers.
• Multiply: Returns the product from multiplying two or more specified numbers.
• Power: Returns the specified number raised to the specified power.
• Round: Rounds a value to the nearest integer or the specified number of fractional digits and returns the result.
• Sine: Returns the sine for the specified angle.
• Square root: Returns the square root for the specified number.
• Subtract: Subtracts the second number from the first number and returns the result.
• Tangent: Returns the tangent for the specified angle.

## Log

This function states that it will return the logarithm for the specified number in the specified base.

Behind the scenes, this function is translated to the following XPath function: math:log(\$arg)

• `math:log`(`\$arg as xs:double?`)` as xs:double?`

Rules:

• The result is the natural logarithm of `\$arg`

Sample:

• The expression `math:log(0)` returns `xs:double('-INF')`.
• The expression `math:log(-1)` returns `xs:double('NaN')`.
• The expression `math:log(2)` returns `0.6931471805599453`

## Log (base 10)

This function states that it will return the base 10 logarithm for the specified number.

Behind the scenes, this function is translated to the following XPath function: math:log10(\$arg)

• `math:log10`(`\$arg as xs:double?`)` as xs:double?`

Rules:

• The result is the base-10 logarithm of `\$arg`

Sample:

• The expression `math:log10(0)` returns `xs:double('-INF')`
• The expression `math:log10(2)` returns `0.3010299956639812`
• The expression `math:log10(-1)` returns `xs:double('NaN')`

## Modulo

This function states that it will return the remainder from dividing the specified numbers.

Behind the scenes, this function is translated to the following XPath expression: (\$arg1) mod (\$arg2)

• `fn:error`(`\$code as xs:QName?``\$description as xs:string`)` as none`

Rules:

• Returns the remainder resulting from dividing `\$arg1`, the dividend, by `\$arg2`, the divisor.
• The operation `a mod b` for operands that are `xs:integer` or `xs:decimal`, or types derived from them, produces a result such that `(a idiv b)*b+(a mod b)` is equal to `a` and the magnitude of the result is always less than the magnitude of `b`. This identity holds even in the special case that the dividend is the negative integer of largest possible magnitude for its type and the divisor is -1 (the remainder is 0). It follows from this rule that the sign of the result is the sign of the dividend.

Sample:

• The expression `(10) mod (3)` returns `1`.
• The expression `(6) mod (-2)` returns `0`.
• The expression `(4.5) mod (1.2)` returns `0.9`.

## Multiply

This function states that it will return the product from multiplying two or more specified numbers.

Behind the scenes, this function is translated to the following XPath expression: (\$arg1) * (\$arg2) (allows more inputs)

• (\$arg1) * (\$arg2) `as xs:numeric?`

Rules:

• Returns the arithmetic product of its operands: (`\$arg1 * \$arg2`).
• For the four types `xs:float``xs:double``xs:decimal` and `xs:integer`, it is guaranteed that if the type of `\$arg` is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if `\$arg` is an instance of `xs:decimal` then the result may be an instance of `xs:integer`.
• This function allows two or more inputs.

Sample:

• The expression (`5) + (2)` returns `10`.
• The expression (`5.1) + (2)` returns `10.2`.

## Power

This function states that it will return the specified number raised to the specified power.

Behind the scenes, this function is translated to the following XPath function: math:pow(\$arg1, \$arg2)

• `math:pow`(`\$arg1 as xs:double?``\$arg2 as xs:numeric`)` as xs:double?`

Rules:

• If `\$arg2` is an instance of `xs:integer`, the result is `\$arg1` raised to the power of `\$arg2`. Otherwise `\$arg2` is converted to an `xs:double` by numeric promotion, and the result is the value of `\$arg1` raised to the power of `\$arg2`.

Sample:

• The expression `math:pow(2, 3)` returns `8`.
• The expression `math:pow(-2, 3)` returns `-8`
• The expression `math:pow(2, 0)` returns `1`
• The expression `math:pow(2.5, 2)` returns 6.25

## Round

This function states that it will round a value to the nearest integer or the specified number of fractional digits and returns the result.

Behind the scenes, this function is translated to the following XPath function: round(\$arg1, \$arg2)

• `fn:round`(`\$arg as xs:numeric?``\$precision as xs:integer`)` as xs:numeric?`

Rules:

• The function returns the nearest (that is, numerically closest) value to `\$arg` that is a multiple of ten to the power of minus `\$precision`. If two such values are equally near (for example, if the fractional part in `\$arg` is exactly .5), the function returns the one that is closest to positive infinity.
• For the four types `xs:float``xs:double``xs:decimal` and `xs:integer`, it is guaranteed that if the type of `\$arg` is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if `\$arg` is an instance of `xs:decimal` and `\$precision` is less than one, then the result may be an instance of `xs:integer`.

Sample:

• The expression `fn:round(1.125, 2)` returns `1.13`
• The expression `fn:round(8452, -2)` returns `8500`

## Sine

This function states that it will return the sine for the specified angle.

Behind the scenes, this function is translated to the following XPath function: math:sin(\$arg)

• `math:sin`(`\$`arg` as xs:double?`)` as xs:double?`

Rules:

• If `\$`arg is positive or negative zero, the result is `\$`arg.
• Returns the sine of the argument. The argument is an angle in radians.

Sample:

• The expression `math:sin(0)` returns `0`.
• The expression `math:sin(45)` returns `0.8509035245341184`.

## Square root

This function states that it will return the square root for the specified number.

Behind the scenes, this function is translated to the following XPath function: math:sqrt(\$arg)

• `math:sqrt`(`\$arg as xs:double?`)` as xs:double?`

Rules:

• If `\$arg` is positive or negative zero, positive infinity, or `NaN`, then the result is `\$arg`. (Negative zero is the only case where the result can have negative sign)
• The result is the mathematical non-negative square root of `\$arg`

Sample:

• The expression `math:sqrt(0)` returns `0`.
• The expression `math:sqrt(-2)` returns `NaN.`
• The expression `math:sqrt(4)` returns `2`.

## Subtract

This function states that it will subtract the second number from the first number and returns the result.

Behind the scenes, this function is translated to the following XPath function: (`\$arg1) - (\$arg2`)

• `(\$arg1 as xs:numeric - \$arg2 as xs:numeric) as xs:numeric`

Rules:

• Returns the arithmetic difference of its operands: (`\$arg1 - \$arg2`).
• `\$arg1 and \$arg2` are numeric values (`xs:float``xs:double``xs:decimal` and `xs:integer`)

Sample:

• The expression (`3) - (1)` returns `2`.
• The expression (2`) - (1.12)` returns `0.88`.

## Tangent

This function states that it will return the tangent for the specified angle.

Behind the scenes, this function is translated to the following XPath function: math:tan(\$arg)

• `math:tan`(`\$`arg` as xs:double?`)` as xs:double?`

Rules:

• If `\$`arg is positive or negative infinity, or `NaN`, then the result is `NaN`.
• Returns the tangent of the argument. The argument is an angle in radians.

Sample:

• The expression `math:tan(0)` returns `0`
• The expression math:tan(12) returns `-0.6358599286615808`

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more, you can buy (or help buy) my son a Star Wars Lego!

##### Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

## Overview

Math (or Mathematical) functions are used to perform a variety of mathematical and scientific operations, such as addition and multiplication. If you come from the BizTalk Server background or are migrating BizTalk Server projects, they are the equivalent of Mathematical and Scientific Functoids inside BizTalk Mapper Editor.

## Available Functions

The Math functions are:

• Absolute: Returns the absolute value of the specified number.
• Add: Returns the sum from adding two or more numbers.
• Arctangent: Returns the arc tangent of a number.
• Ceiling: Returns the smallest integral value greater than or equal to the specified number.
• Cosine: Returns the cosine for the specified angle.
• Divide: Returns the result from dividing two numbers.
• Exponential: Raises the “e” constant to the specified power and returns the result.
• Exponential (base 10): Returns the number 10 raised to the specified power.
• Floor: Returns the largest integral value less than or equal to the specified number.
• Integer divide: Divides two numbers and returns the integer part from the result.
• Log: Returns the logarithm for the specified number in the specified base.
• Log (base 10): Returns the base 10 logarithm for the specified number.
• Modulo: Returns the remainder from dividing the specified numbers.
• Multiply: Returns the product from multiplying two or more specified numbers.
• Power: Returns the specified number raised to the specified power.
• Round: Rounds a value to the nearest integer or the specified number of fractional digits and returns the result.
• Sine: Returns the sine for the specified angle.
• Square root: Returns the square root for the specified number.
• Subtract: Subtracts the second number from the first number and returns the result.
• Tangent: Returns the tangent for the specified angle.

## Absolute

This function states that it will return the absolute value of the specified number.

Behind the scenes, this function is translated to the following XPath function: abs(\$arg)

• `fn:abs`(`\$arg as xs:numeric?`)` as xs:numeric?`

Rules:

• If `\$arg` is negative, the function returns `-\$arg`. Otherwise, it returns `\$arg`.
• For the four types `xs:float``xs:double``xs:decimal` and `xs:integer`, it is guaranteed that if the type of `\$arg` is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if `\$arg` is an instance of `xs:positiveInteger` then the value of `\$arg` may be returned unchanged.
• For `xs:float` and `xs:double` arguments, if the argument is positive zero or negative zero, then positive zero is returned. If the argument is positive or negative infinity, positive infinity is returned.

Sample:

• The expression `fn:abs(10.5)` returns `10.5`.
• The expression `fn:abs(-10.5)` returns `10.5`.

This function states that it will return the sum from adding two or more numbers.

Behind the scenes, this function is translated to the following XPath expression: \$arg1 + \$arg2 (allows more inputs)

• `(\$arg1 as xs:numeric + \$arg2 as xs:numeric) as xs:numeric`

Rules:

• Returns the arithmetic sum of its operands: (`\$arg1 + \$arg2`).
• `\$arg1 and \$arg2` are numeric values (`xs:float``xs:double``xs:decimal` and `xs:integer`)
• This function allows two or more inputs.

Sample:

• The expression (`1) + (3)` returns `4`.
• The expression (`1.12) + (2)` returns `3.12`.

## Arctangent

This function states that it will return the arc tangent of a number.

Behind the scenes, this function is translated to the following XPath function: math:atan(\$arg)

• `math:atan`(`\$arg as xs:double?`)` as xs:double?`

Rules:

• If `\$arg` is a non-numeric value, then the result is `empty`.

Sample:

• The expression `math:atan(0)` returns `0`.
• The expression `math:atan(1.28)` returns `0.9075933340888034`.

## Ceiling

This function states that it will return the smallest integral value greater than or equal to the specified number.

Behind the scenes, this function is translated to the following XPath function: ceiling(\$arg)

• `fn:ceiling`(`\$arg as xs:numeric?`)` as xs:numeric?`

Rules:

• The function returns the smallest (closest to negative infinity) number with no fractional part that is not less than the value of `\$arg`.
• For the four types `xs:float``xs:double``xs:decimal` and `xs:integer`, it is guaranteed that if the type of `\$arg` is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if `\$arg` is an instance of `xs:decimal` then the result may be an instance of `xs:integer`.

Sample:

• The expression `fn:ceiling(10.5)` returns `11`.
• The expression `fn:ceiling(-10.5)` returns `-10`.

## Cosine

This function states that it will return the cosine for the specified angle.

Behind the scenes, this function is translated to the following XPath function: math:cos(\$arg)

• `math:cos`(`\$`arg` as xs:double?`)` as xs:double?`

Rules:

• If `\$`arg is positive or negative zero, the result is `\$`arg.

Sample:

• The expression `math:cos(0)` returns `1`
• The expression `math:cos(1212)` returns 0.7931914936378434

## Divide

This function states that it will return the result from dividing two numbers.

Behind the scenes, this function is translated to the following XPath function: \$arg1 div \$arg2

• \$arg1 div \$arg2` as xs:numeric?`

Rules:

• For the four types `xs:float``xs:double``xs:decimal` and `xs:integer`, it is guaranteed that if the type of `\$arg` is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if `\$arg` is an instance of `xs:decimal` then the result may be an instance of `xs:integer`.

Sample:

• The expression `(10) div (3)` returns `3`.
• The expression `(-3) div (-2)` returns `1.5`.
• The expression `(-3) div (2)` returns `-1`.
• The expression `(-3.5) div (3)` returns `0.7`.

## Exponential

This function states that it will raise the “e” constant to the specified power and returns the result.

Behind the scenes, this function is translated to the following XPath function: math:exp(\$arg)

• `math:exp`(`\$arg as xs:double?`)` as xs:double?`

Rules:

• Returns the value of e

Sample:

• The expression `math:exp(0)` returns `1`.
• The expression `math:exp(1)` returns `2.7182818284590455`.

## Exponential (base 10)

This function states that it will return the number 10 raised to the specified power.

Behind the scenes, this function is translated to the following XPath function: math:exp10(\$arg)

• `math:exp10`(`\$arg as xs:double?`)` as xs:double?`

Rules:

• Returns the value of `10`

Sample:

• The expression `math:exp10(0)` returns `1`
• The expression `math:exp10(1)` returns `1.0e1`.
• The expression `math:exp10(0.5)` returns `3.1622776601683795`

## Floor

This function states that it will return the largest integral value less than or equal to the specified number.

Behind the scenes, this function is translated to the following XPath function: floor(\$arg)

• `fn:error`(`\$code as xs:QName?``\$description as xs:string`)` as none`

Rules:

• The function returns the largest (closest to positive infinity) number with no fractional part that is not greater than the value of `\$arg`.
• For the four types `xs:float``xs:double``xs:decimal` and `xs:integer`, it is guaranteed that if the type of `\$arg` is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if `\$arg` is an instance of `xs:decimal` then the result may be an instance of `xs:integer`.

Sample:

• The expression `fn:floor(10.5)` returns `10`.
• The expression `fn:floor(10.9)` returns `10`.
• The expression `fn:floor(-10.5)` returns `-11`.

## Integer divide

This function states that it will divide two numbers and returns the integer part from the result.

Behind the scenes, this function is translated to the following XPath expression: (\$arg1) idiv (\$arg2)

• `(\$arg1) idiv (\$arg2) as xs:integer`

Rules:

• Performs an integer division.
• For the four types `xs:float``xs:double``xs:decimal` and `xs:integer`, it is guaranteed that if the type of `\$arg` is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if `\$arg` is an instance of `xs:decimal` then the result may be an instance of `xs:integer`.

Sample:

• The expression `(10) idiv (3)` returns `3`.
• The expression `(-3) idiv (-2)` returns `1`.
• The expression `(-3) idiv (2)` returns `-1`.
• The expression `(-3.5) idiv (3)` returns `-1`.

Stay tune for the second part of this blog post.

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more, you can buy (or help buy) my son a Star Wars Lego!

##### Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

## Overview

Utility functions are used to perform a variety of additional and distinct operations that don’t fit in the above Categories, such as stopping a transformation and returning the specified error code and description or format, etc.

## Available Functions

The Utility functions are:

• Copy: Copies any and all of the input’s substructure.
• Error: Stops a transformation and returns the specified error code and description.
• Format date: Returns a date in the specified format.
• Format DateTime value: Returns a timestamp in the specified format.
• Format number: Returns a number in the specified format.
• Format time: Returns a time in the specified format.

## Copy

This function states that it will copy any and all of the input’s substructure. It enables your maps to use schemas that include any and anyAttribute elements. These elements are, in essence, wildcards provided in the Schema definition language to match unknown structures or attributes.

The following figure shows the Copy function used in a map.

Behind the scenes, this function is translated to the following XPath expression: copy-of(\$arg)

```

```

Rules:

• The Copy function copies the element in the input instance message corresponding to the source schema node connected to the Copy function. The function also copies any and all of its substructure and re-creates it in the output instance message at the linked node in the destination schema. Thus, you can also use the Copy function to copy any source and destination records having identical substructures.

## Error

This function states that it will stop a transformation and returns the specified error code and description.

Behind the scenes, this function is translated to the following XPath function: error(\$code, \$description)

• `fn:error`(`\$code as xs:QName?``\$description as xs:string`)` as none`

Rules:

• Calling the `fn:error` function raises an application-defined error.
• This function never returns a value. Instead, it always raises an error. The effect of the error is identical to the effect of dynamic errors raised implicitly, for example, when an incorrect argument is supplied to a function.
• The `\$code` is an error code that distinguishes this error from others. It is an `xs:QName`; the namespace URI conventionally identifies the component, subsystem, or authority responsible for defining the meaning of the error code, while the local part identifies the specific error condition. The namespace URI `http://www.w3.org/2005/xqt-errors` is used for errors defined in this specification; other namespace URIs may be used for errors defined by the application.
• The `\$description` is a natural-language description of the error condition.

## Format date

This function states that it returns a date in the specified format.

Behind the scenes, this function is translated to the following XPath function: format-date(\$arg1, \$arg2)

• `fn:format-date`(`\$value as xs:date?``\$picture as xs:string`)` as xs:string?`

Rules:

• The `\$arg`1 needs to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.
• The `\$arg`2 (or picture) consists of a sequence of variable markers and literal substrings. A substring enclosed in square brackets is interpreted as a variable marker; substrings not enclosed in square brackets are taken as literal substrings. The literal substrings are optional and, if present, are rendered unchanged, including any whitespace. The variable markers are replaced in the result by strings representing aspects of the date and/or time to be formatted. These are described in detail below:
• Y – year (absolute value);
• M – month in the year
• D – day in the month
• d – day in the year
• F – day of the week
• W – week in year
• w – week in the month
• C – calendar: the name or abbreviation of a calendar name
• E – era: the name of a baseline for the numbering of years, for example, the reign of a monarch

Sample:

• The expression `fn:`format-date(\$d, “[Y0001]-[M01]-[D01]”) returns 2002-12-31
• The expression `fn:format-date(\$d, "[M]-[D]-[Y]")` returns 12-31-2002.
• The expression `fn:format-date(\$d, "[D1] [MI] [Y]")` returns `31 XII 2002`.
• The expression `fn:`format-date(\$d, “[D1o] [MNn], [Y]”) returns 31st December, 2002
• The expression `fn:format-date(\$d, "[D01] [MN,*-3] [Y0001]")` returns 31 DEC 2002.
• The expression `fn:format-date(\$d, "[YWw]")` returns `Two Thousand and Three`.

## Format DateTime value

Returns a timestamp in the specified format.

This function states that it returns the specified value as an integer.

Behind the scenes, this function is translated to the following XPath function: format-dateTime(\$arg1, \$arg2)

• `fn:format-dateTime`(`\$value as xs:dateTime?``\$picture as xs:string`)` as xs:string?`

Rules:

• The `\$arg`1 needs to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ssZ or yyyy-MM-DDTHH:mm:ss-hh:mm.
• The `\$arg`2 (or picture) consists of a sequence of variable markers and literal substrings. A substring enclosed in square brackets is interpreted as a variable marker; substrings not enclosed in square brackets are taken as literal substrings. The literal substrings are optional and, if present, are rendered unchanged, including any whitespace. The variable markers are replaced in the result by strings representing aspects of the date and/or time to be formatted. These are described in detail below:
• Y – year (absolute value);
• M – month in the year
• D – day in the month
• d – day in the year
• F – day of the week
• W – week in year
• w – week in the month
• H – hour in the day (24 hours)
• h – hour in half-day (12 hours)
• P – am/pm marker
• m – minute in the hour
• s – second in a minute
• f – fractional seconds
• Z – timezone
• z – timezone (same as Z, but modified where appropriate to include a prefix as a time offset using GMT, for example, GMT+1 or GMT-05:00. For this component, there is a fixed prefix of GMT or a localized variation thereof for the chosen language, and the remainder of the value is formatted as for specifier Z. 01:01
• C – calendar: the name or abbreviation of a calendar name
• E – era: the name of a baseline for the numbering of years, for example, the reign of a monarch

Sample:

• The expression `fn:`format-dateTime(\$dt, “[h].[m01][Pn] on [FNn], [D1o] [MNn]”) returns 3.58pm on Tuesday, 31st December
• The expression `fn:format-date(\$d, "[M]-[D]-[Y]")` returns 12-31-2002.
• The expression `fn:format-dateTime(\$dt, "[M01]/[D01]/[Y0001] at [H01]:[m01]:[s01]")` returns 12/31/2002 at 15:58:45.

## Format number

Returns a number in the specified format.

This function states that it returns the specified value as an integer.

Behind the scenes, this function is translated to the following XPath function: format-number(\$arg1, \$arg2)

• `fn:format-number`(`\$value as xs:numeric?``\$picture as xs:string`)` as xs:string`

Rules:

• Returns a string containing a number formatted according to a given picture string, taking account of decimal formats specified in the static context.
• The `\$arg1 `maybe of any numeric data type (xs:double, xs:float, xs:decimal, or their subtypes, including `xs:integer`).

Sample:

• The expression `format-number(12345.6, '#,###.00')` returns `"12,345.60"`.
• The expression `format-number(12345678.9, '9,999.99')` returns `"12,345,678.90"`.
• The expression `format-number(123.9, '9999')` returns `"0124"`.
• The expression `format-number(0.14, '01%')` returns `"14%"`.
• The expression `format-number(-6, '000')` returns `"-006"`.

## Format time

Returns a time in the specified format.

This function states that it returns the specified value as an integer.

Behind the scenes, this function is translated to the following XPath function: format-time(\$arg1, \$arg2)

• `fn:format-time`(`\$value as xs:time?``\$picture as xs:string`)` as xs:string?`

Rules:

• The `\$arg`1 needs to be an xs:time in the following format HH:mm:ssZ or HH:mm:ss-hh:mm.
• The `\$arg`2 (or picture) consists of a sequence of variable markers and literal substrings. A substring enclosed in square brackets is interpreted as a variable marker; substrings not enclosed in square brackets are taken as literal substrings. The literal substrings are optional and, if present, are rendered unchanged, including any whitespace. The variable markers are replaced in the result by strings representing aspects of the date and/or time to be formatted. These are described in detail below:
• H – hour in the day (24 hours)
• h – hour in half-day (12 hours)
• P – am/pm marker
• m – minute in the hour
• s – second in a minute
• f – fractional seconds
• Z – timezone
• z – timezone (same as Z, but modified where appropriate to include a prefix as a time offset using GMT, for example, GMT+1 or GMT-05:00. For this component, there is a fixed prefix of GMT or a localized variation thereof for the chosen language, and the remainder of the value is formatted as for specifier Z. 01:01
• C – calendar: the name or abbreviation of a calendar name
• E – era: the name of a baseline for the numbering of years, for example, the reign of a monarch

Sample:

• The expression `fn:`format-time(\$t, “[h]:[m01] [PN]”) returns 3:58 PM
• The expression `fn:format-time(\$t, "[h]:[m01]:[s01] [PN] [ZN,*-3]")` returns 3:58:45 PM PDT.
• The expression `fn:`format-time(\$t, “[h]:[m01]:[s01] o’clock [PN] [ZN,*-3]”) returns 3:58:45 o’clock PM PDT.
• The expression `fn:`format-time(\$t,”[H01]:[m01]:[s01] [z,6-6]”) returns 15:58:45 GMT+02:00.

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more, you can buy (or help buy) my son a Star Wars Lego!

##### Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

## Logic Apps (Standard) Data Mapper: Date and Time Functions (Part 5)

Because the Date and Time functions category has too many functions, I decide to break this blog post into different parts, so welcome to the fourth part!

## Overview

Date and Time functions are used to perform a variety of operations over Dates, such as retrieving the current date and time or adding dates, etc. If you come from the BizTalk Server background or are migrating BizTalk Server projects, they are the equivalent of Date/Time Functoids inside BizTalk Mapper Editor.

## Available Functions

The Date and Time functoids are:

• Add days: Adds a positive or negative number of days to the specified timestamp. Returns a timestamp that’s respectively later or earlier than the specified timestamp.
• Add DayTime to Date: Adds a positive or negative DayTime duration to the specified Date value (xs:date). Returns a Date that’s respectively after or before the specified Date.
• Add DayTime to DateTime: Adds a positive or negative DayTime duration to the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively after or before the specified DateTime.
• Add DayTime to Time: Adds a positive or negative DayTime duration to the specified Time value (xs:time). Returns a Time that’s respectively after or before the specified Time. Durations that wrap around past midnight also return an earlier Time.
• Add YearMonth to DateTime: Adds a positive or negative YearMonth duration to the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively after or before the specified DateTime.
• Adjust Date: Adjusts the specified Date value (xs:date) to the current or dynamic time zone.
• Adjust DateTime: Adjusts the specified DateTime value (xs:dateTime) to the current or dynamic time zone.
• Adjust Time: Adjusts the specified Time value (xs:time) to the current or dynamic time zone.
• Current date: Returns the current date in YYYY-MM-DD format.
• Current DateTime value: Returns the current date and time in YYYY-MM-DDThh:mm:ss format.
• Current time: Returns the current date and time in YYYY-MM-DDThh:mm:ss format.
• DateTime: Creates and returns a DateTime value based on the specified Date and Time.
• Day from Date: Returns the day from the specified Date value (xs:date).
• Day from DateTime: Returns the day from the specified DateTime value (xs:dateTime).
• Equal Date: Returns true or false based on whether the specified Date values are equal.
• Equal DateTime: Returns true or false based on whether with the specified DateTime values are equal.
• Equal Day: Returns true or false based on whether the specified Day values (xs:gDay) are equal with the same starting time when the day values are in the same month and year.
• Equal Month: Returns true or false based on whether the specified Month values (xs:gMonth) have the same starting time when the month values are in the same year.
• Equal MonthDay: Returns true or false based on whether the specified MonthDay values (xs:gMonthDay) are equal with the same starting time when the day values are in the same year.
• Equal Time: Returns true or false based on whether the specified Time values are equal.
• Equal Year: Returns true or false based on whether the specified Year values (xs:gYear) have the same starting time.
• Equal YearMonth: Returns true or false based on whether the specified YearMonth values (xs:gYearMonth) are the same.
• Greater Date: Returns true or false based on whether the first Date value is later than the second Date value.
• Greater DateTime: Returns true or false based on whether the first DateTime value is later than the second DateTime value.
• Greater Time: Returns true or false based on whether the first Time value is later than the second Time value.
• Hours from DateTime: Returns the hours from the specified DateTime value (xs:dateTime).
• Hours from Time: Returns the hours from the specified Time value (xs:time).
• Less Date: Returns true or false based on whether the first Date value is earlier than the second Date value.
• Less DateTime: Returns true or false based on whether the first DateTime value is earlier than the second DateTime value.
• Less Time: Returns true or false based on whether the first Time value is earlier than the second Time value.
• Minutes from DateTime: Returns the minutes from the specified DateTime value (xs:dateTime).
• Minutes from Time: Returns the minutes from the specified Time value (xs:time).
• Month from Date: Returns the month from the specified Date value (xs:date).
• Month from DateTime: Returns the month from the specified DateTime value (xs:dateTime).
• Seconds from DateTime: Returns the seconds from the specified DateTime value (xs:dateTime).
• Seconds from Time: Returns the seconds from the specified Time value (xs:time).
• Subtract Dates: Returns the DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the starting times for the specified Date values.
• Subtract DateTimes: Returns a DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the specified DateTime values..
• Subtract DateTime from Date: Subtracts a positive or negative DayTime duration from the specified Date value (xs:date). Returns a Date that’s respectively before or after the specified Date..
• Subtract DateTime from DateTime: Subtracts a positive or negative DayTime duration from the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively before or after the specified DateTime.
• Subtract DateTime from Time: Subtracts a positive or negative Time duration from the specified Time value (xs:time). Returns a Time that’s respectively before or after the specified Time. A duration that wraps around past midnight also returns a later Time.
• Subtract Times: Returns a DayTime: Duration value (xs:dayTimeDuration) representing the elapsed time between the specified Time values, which are treated as times on the same date.
• Subtract YearMonth from Date: Subtracts a positive or negative YearMonth duration from the specified Date value (xs:date). Returns a Date that’s respectively before or after the specified Date.
• Subtract YearMonth from DateTime: Subtracts a positive or negative YearMonth duration from the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively before or after the specified DateTime.
• Time zone from Date: Returns the time zone from the specified Date value (xs:date).
• Time zone from DateTime: Returns the time zone from the specified DateTime value (xs:dateTime).
• Time zone from Time: Returns the time zone from the specified Time value (xs:time).
• Year from Date: Returns the year from the specified Date value (xs:date).
• Year from DateTime: Returns the year from the specified DateTime value (xs:dateTime).

## Time zone from Date

This function states that it will return the time zone from the specified Date value (xs:date).

Behind the scenes, this function is translated to the following XPath function: timezone-from-date(\$arg)

• `fn:timezone-from-date`(`\$arg as xs:date?`)` as xs:dayTimeDuration?`

Rules:

• The function returns the timezone component of `\$arg`, if any. If `\$arg` has a timezone component, then the result is an `xs:dayTimeDuration` that indicates deviation from UTC; its value may range from +14:00 to -14:00 hours, both inclusive. If `\$arg` has no timezone component, the result is the empty sequence.
• The `\$arg`1 needs to be an xs:date in the following format yyyy-MM-DD-hh:mm or yyyy-MM-DDZ.

Sample:

• The expression `fn:timezone-from-date(xs:date("2023-07-29-05:00"))` returns `xs:dayTimeDuration("-PT5H")`.
• The expression `fn:timezone-from-date(xs:date("2023-07-29Z"))` returns `xs:dayTimeDuration("PT0S")`.
• The expression `fn:timezone-from-date(xs:date("2023-07-29"))` returns `()`.

## Time zone from DateTime

This function states that it will return the time zone from the specified DateTime value (xs:dateTime).

Behind the scenes, this function is translated to the following XPath function: timezone-from-dateTime(\$arg)

• `fn:timezone-from-dateTime`(`\$arg as xs:dateTime?`)` as xs:dayTimeDuration?`

Rules:

• The function returns the timezone component of `\$arg`, if any. If `\$arg` has a timezone component, the result indicates deviation from UTC; its value may range from +14:00 to -14:00 hours, both inclusive. If `\$arg` has no timezone component, the result is an empty sequence.
• The `\$arg`1 needs to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ssZ or yyyy-MM-DDTHH:mm:ss-hh:mm.

Sample:

• The expression `fn:timezone-from-dateTime(xs:dateTime("2023-07-29T13:20:00-05:00"))` returns `xs:dayTimeDuration("-PT5H")`.
• The expression `fn:timezone-from-dateTime(xs:dateTime("2023-07-29T13:20:00Z"))` returns `xs:dayTimeDuration("PT0S")`.
• The expression `fn:timezone-from-dateTime(xs:dateTime("2023-07-29T00:00:00"))` returns `()`.

## Time zone from Time

This function states that it will return the time zone from the specified Time value (xs:time).

Behind the scenes, this function is translated to the following XPath function: timezone-from-time(\$arg)

• `fn:timezone-from-time`(`\$arg as xs:time?`)` as xs:dayTimeDuration?`

Rules:

• The function returns the timezone component of \$arg, if any. If \$arg it has a timezone component, the result indicates deviation from UTC; its value may range from +14:00 to -14:00 hours, both inclusive. If `\$arg` has no timezone component, the result is an empty sequence.
• The `\$arg` needs to be an xs:time in the following format HH:mm:ssZ or HH:mm:ss-hh:mm.

Sample:

• The expression `fn:timezone-from-time(xs:time("13:20:00-05:00"))` returns `xs:dayTimeDuration("-PT5H")`.
• The expression `fn:timezone-from-time(xs:time("13:20:00Z"))` returns `xs:dayTimeDuration("PT0S")`.
• The expression `fn:timezone-from-time(xs:time("13:20:00"))` returns `()`.

## Year from Date

This function states that it will return the year from the specified Date value (xs:date).

Behind the scenes, this function is translated to the following XPath function: year-from-date(\$arg)

• `fn:year-from-date`(`\$arg as xs:date?`)` as xs:integer?`

Rules:

• The function returns an `xs:integer` representing the year in the local value of `\$arg`. The value may be negative.
• The `\$arg` needs to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.

Sample:

• The expression `fn:year-from-date(xs:date("2023-07-29"))` returns `2023`.
• The expression `fn:year-from-date(xs:date("2023-07-29+05:00"))` returns `2023`.
• The expression `fn:year-from-date(xs:date("-0002-06-01"))` returns `-2`

## Year from DateTime

This function states that it will return the year from the specified DateTime value (xs:dateTime).

Behind the scenes, this function is translated to the following XPath function: year-from-dateTime(\$arg)

• `fn:year-from-dateTime`(`\$arg as xs:dateTime?`)` as xs:integer?`

Rules:

• The function returns an `xs:integer` representing the year in the local value of `\$arg`. The value may be negative.
• The `\$arg` needs to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.

Sample:

• The expression `fn:year-from-dateTime(xs:dateTime("2023-07-29T21:30:00-05:00"))` returns `2023`.
• The expression `fn:year-from-dateTime(xs:dateTime("2023-07-29T19:20:00"))` returns `2023`.
• The expression `fn:year-from-dateTime(xs:dateTime("2021-12-31T24:00:00"))` returns `2022`.
• The expression `fn:year-from-dateTime(xs:dateTime("-0002-06-06T00:00:00"))` returns `-2`

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more, you can buy (or help buy) my son a Star Wars Lego!

##### Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

## Logic Apps (Standard) Data Mapper: Date and Time Functions (Part 4)

Because the Date and Time functions category has too many functions, I decide to break this blog post into different parts, so welcome to the fourth part!

## Overview

Date and Time functions are used to perform a variety of operations over Dates, such as retrieving the current date and time or adding dates, etc. If you come from the BizTalk Server background or are migrating BizTalk Server projects, they are the equivalent of Date/Time Functoids inside BizTalk Mapper Editor.

## Available Functions

The Date and Time functoids are:

• Add days: Adds a positive or negative number of days to the specified timestamp. Returns a timestamp that’s respectively later or earlier than the specified timestamp.
• Add DayTime to Date: Adds a positive or negative DayTime duration to the specified Date value (xs:date). Returns a Date that’s respectively after or before the specified Date.
• Add DayTime to DateTime: Adds a positive or negative DayTime duration to the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively after or before the specified DateTime.
• Add DayTime to Time: Adds a positive or negative DayTime duration to the specified Time value (xs:time). Returns a Time that’s respectively after or before the specified Time. Durations that wrap around past midnight also return an earlier Time.
• Add YearMonth to DateTime: Adds a positive or negative YearMonth duration to the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively after or before the specified DateTime.
• Adjust Date: Adjusts the specified Date value (xs:date) to the current or dynamic time zone.
• Adjust DateTime: Adjusts the specified DateTime value (xs:dateTime) to the current or dynamic time zone.
• Adjust Time: Adjusts the specified Time value (xs:time) to the current or dynamic time zone.
• Current date: Returns the current date in YYYY-MM-DD format.
• Current DateTime value: Returns the current date and time in YYYY-MM-DDThh:mm:ss format.
• Current time: Returns the current date and time in YYYY-MM-DDThh:mm:ss format.
• DateTime: Creates and returns a DateTime value based on the specified Date and Time.
• Day from Date: Returns the day from the specified Date value (xs:date).
• Day from DateTime: Returns the day from the specified DateTime value (xs:dateTime).
• Equal Date: Returns true or false based on whether the specified Date values are equal.
• Equal DateTime: Returns true or false based on whether with the specified DateTime values are equal.
• Equal Day: Returns true or false based on whether the specified Day values (xs:gDay) are equal with the same starting time when the day values are in the same month and year.
• Equal Month: Returns true or false based on whether the specified Month values (xs:gMonth) have the same starting time when the month values are in the same year.
• Equal MonthDay: Returns true or false based on whether the specified MonthDay values (xs:gMonthDay) are equal with the same starting time when the day values are in the same year.
• Equal Time: Returns true or false based on whether the specified Time values are equal.
• Equal Year: Returns true or false based on whether the specified Year values (xs:gYear) have the same starting time.
• Equal YearMonth: Returns true or false based on whether the specified YearMonth values (xs:gYearMonth) are the same.
• Greater Date: Returns true or false based on whether the first Date value is later than the second Date value.
• Greater DateTime: Returns true or false based on whether the first DateTime value is later than the second DateTime value.
• Greater Time: Returns true or false based on whether the first Time value is later than the second Time value.
• Hours from DateTime: Returns the hours from the specified DateTime value (xs:dateTime).
• Hours from Time: Returns the hours from the specified Time value (xs:time).
• Less Date: Returns true or false based on whether the first Date value is earlier than the second Date value.
• Less DateTime: Returns true or false based on whether the first DateTime value is earlier than the second DateTime value.
• Less Time: Returns true or false based on whether the first Time value is earlier than the second Time value.
• Minutes from DateTime: Returns the minutes from the specified DateTime value (xs:dateTime).
• Minutes from Time: Returns the minutes from the specified Time value (xs:time).
• Month from Date: Returns the month from the specified Date value (xs:date).
• Month from DateTime: Returns the month from the specified DateTime value (xs:dateTime).
• Seconds from DateTime: Returns the seconds from the specified DateTime value (xs:dateTime).
• Seconds from Time: Returns the seconds from the specified Time value (xs:time).
• Subtract Dates: Returns the DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the starting times for the specified Date values.
• Subtract DateTimes: Returns a DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the specified DateTime values..
• Subtract DateTime from Date: Subtracts a positive or negative DayTime duration from the specified Date value (xs:date). Returns a Date that’s respectively before or after the specified Date..
• Subtract DateTime from DateTime: Subtracts a positive or negative DayTime duration from the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively before or after the specified DateTime.
• Subtract DateTime from Time: Subtracts a positive or negative Time duration from the specified Time value (xs:time). Returns a Time that’s respectively before or after the specified Time. A duration that wraps around past midnight also returns a later Time.
• Subtract Times: Returns a DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the specified Time values, which are treated as times on the same date.
• Subtract YearMonth from Date: Subtracts a positive or negative YearMonth duration from the specified Date value (xs:date). Returns a Date that’s respectively before or after the specified Date.
• Subtract YearMonth from DateTime: Subtracts a positive or negative YearMonth duration from the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively before or after the specified DateTime.
• Time zone from Date: Returns the time zone from the specified Date value (xs:date).
• Time zone from DateTime: Returns the time zone from the specified DateTime value (xs:dateTime).
• Time zone from Time: Returns the time zone from the specified Time value (xs:time).
• Year from Date: Returns the year from the specified Date value (xs:date).
• Year from DateTime: Returns the year from the specified DateTime value (xs:dateTime).

## Seconds from DateTime

This function states that it will return the seconds from the specified DateTime value (xs:dateTime).

Behind the scenes, this function is translated to the following XPath function: seconds-from-dateTime(\$ard)

• `fn:seconds-from-dateTime`(`\$arg as xs:dateTime?`)` as xs:decimal?`

Rules:

• The function returns an `xs:decimal` value greater than or equal to zero and less than 60, representing the seconds and fractional seconds defined in `\$arg` without adjusting the timezone.
• The `\$arg` needs to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.

Sample:

• The expression `fn:seconds-from-dateTime(xs:dateTime("1999-05-31T13:20:32-05:00"))` returns `32`.

## Seconds from Time

This function states that it will return the seconds from the specified Time value (xs:time).

Behind the scenes, this function is translated to the following XPath function: seconds-from-time(\$arg)

• `fn:seconds-from-time`(`\$arg as xs:time?`)` as xs:decimal?`

Rules:

• the function returns an `xs:decimal` value greater than or equal to zero and less than 60, representing the seconds and fractional seconds defined in `\$arg` without adjusting the timezone.
• The `\$arg` needs to be an xs:time in the following format HH:mm:ss or HH:mm:ss-hh:mm.

Sample:

• The expression `fn:seconds-from-time(xs:time("13:20:10.5"))` returns `10.5`.

## Subtract Dates

This function states that it will return the DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the starting times for the specified Date values.

Behind the scenes, this function is translated to the following XPath expression: xs:dayTimeDuration(xs:date(\$arg1) – xs:date(\$arg2))

• xs:dayTimeDuration(xs:date(\$arg1) – xs:date(\$arg2)) `as xs:dayTimeDuration`

Rules:

• If the starting instant of `\$arg1` precedes in time the starting instant of `\$arg2`, then the returned value is a negative duration.
• Returns the `xs:dayTimeDuration` (for example, “PT2H12M”) that corresponds to the elapsed time between the starting instant of `\$arg1` and the starting instant of `\$arg2`.
• The `\$arg`1 and \$arg2 need to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.

Sample:

• The following Data Mapper transformation rule: subtract-dates(“2023-07-28”, “1978-04-04”) will be translated to {xs:dayTimeDuration(xs:date(‘2023-07-28’) – xs:date(‘1978-04-04’))} and the return will be P16551D.

## Subtract DateTimes

This function states that it will return a DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the specified DateTime values.

Behind the scenes, this function is translated to the following XPath expression: xs:dayTimeDuration(xs:dateTime(\$arg1) – xs:dateTime(\$arg2))

• xs:dayTimeDuration(xs:dateTime(\$arg1) – xs:dateTime(\$arg2)) `as xs:dayTimeDuration`

Rules:

• If the normalized value of `\$arg1` precedes in time the normalized value of `\$arg2`, then the returned value is a negative duration.
• Returns an `xs:dayTimeDuration` representing the amount of elapsed time between the instants `arg2` and `arg1`.
• The `\$arg`1 and \$arg2 need to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.

Sample:

• The following Data Mapper transformation rule: subtract-datetimes(“2023-07-28T23:00:00”, “1978-04-04T10:30:00”) will be translated to {xs:dayTimeDuration(xs:dateTime(‘2023-07-28T23:00:00’) – xs:dateTime(‘1978-04-04T10:30:00’))} and the return will be P16551DT12H30M.

## Subtract DateTime from Date

This function states that it will subtract a positive or negative DayTime duration from the specified Date value (xs:date). Returns a Date that’s respectively before or after the specified Date.

Behind the scenes, this function is translated to the following XPath expression: xs:date(xs:date(\$arg1) – xs:dayTimeDuration(\$arg2))

• xs:date(xs:date(\$arg1) – xs:dayTimeDuration(\$arg2)) as xs:date

Rules:

• Returns the `xs:date` that is a given duration before a specified `xs:date` (or after, if the duration is negative).
• The `\$arg`1 needs to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.
• The `\$arg`1 needs to be an xs:dayTimeDuration in the ISO 8601 format. ISO-8601 standard was created to elaborate crystal clear language to talk about dates and periods and avoid misinterpretation. Where Duration (“how long“) is represented with the format P[n]Y[n]M[n]DT[n]H[n]M[n]S, where n is a number.

Sample:

• The following Data Mapper transformation rule: subtract-daytime-from-date(“2023-07-28”, “P16551D”) will be translated to {xs:date(xs:date(‘2023-07-28’) – xs:dayTimeDuration(‘P16551D’))} and the return will be 1978-04-04.

## Subtract DateTime from DateTime

This function states that it will subtract a positive or negative DayTime duration from the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively before or after the specified DateTime.

Behind the scenes, this function is translated to the following XPath expression: xs:dateTime(xs:dateTime(\$arg1) – xs:dayTimeDuration(\$arg2))

• xs:dateTime(xs:dateTime(\$arg1) – xs:dayTimeDuration(\$arg2)) as xs:dateTime

Rules:

• Returns the `xs:dateTime` that is a given duration before a specified `xs:dateTime` (or after, if the duration is negative).
• The `\$arg`1 needs to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.
• The `\$arg`1 needs to be an xs:dayTimeDuration in the ISO 8601 format. ISO-8601 standard was created to elaborate crystal clear language to talk about dates and periods and avoid misinterpretation. Where Duration (“how long“) is represented with the format P[n]Y[n]M[n]DT[n]H[n]M[n]S, where n is a number.

Sample:

• The following Data Mapper transformation rule: subtract-daytime-from-datetime(“2023-07-28T23:00:00”, “P16551DT12H30M”) will be translated to {xs:dateTime(xs:dateTime(‘2023-07-28T23:00:00’) – xs:dayTimeDuration(‘P16551DT12H30M’))} and the return will be 1978-04-04T10:30:00.

## Subtract DateTime from Time

This function states that it will subtract a positive or negative Time duration from the specified Time value (xs:time). Returns a Time that’s respectively before or after the specified Time. A duration that wraps around past midnight also returns a later Time.

Behind the scenes, this function is translated to the following XPath expression: xs:time(xs:time(\$arg1) – xs:dayTimeDuration(\$arg2))

• xs:time(xs:time(\$arg1) – xs:dayTimeDuration(\$arg2)) as xs:time

Rules:

• Returns the `xs:time` value that is a given duration before a specified `xs:time` (or after, if the duration is negative or causes wrap-around past midnight)
• The `\$arg`1 needs to be an xs:time in the following format HH:mm:ss or HH:mm:ss-hh:mm.
• The `\$arg`1 needs to be an xs:dayTimeDuration in the ISO 8601 format. ISO-8601 standard was created to elaborate crystal clear language to talk about dates and periods and avoid misinterpretation. Where Duration (“how long“) is represented with the format P[n]Y[n]M[n]DT[n]H[n]M[n]S, where n is a number.

Sample:

• The following Data Mapper transformation rule: subtract-daytime-from-time(“11:00:00”, “PT30M”) will be translated to {xs:time(xs:time(’11:00:00?) – xs:dayTimeDuration(‘PT30M’))} and the return will be 10:30:00.

## Subtract Times

This function states that it will return a DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the specified Time values, which are treated as times on the same date.

Behind the scenes, this function is translated to the following XPath expression: xs:dayTimeDuration(xs:time(\$arg1) – xs:time(\$arg2))

• xs:dayTimeDuration(xs:time(\$arg1) – xs:time(\$arg2)) as xs:dayTimeDuration

Rules:

• Returns the `xs:dayTimeDuration` that corresponds to the elapsed time between the values of `\$arg2` and `\$arg1` treated as times on the same date.
• The `\$arg`1 and \$arg2 need to be an xs:time in the following format HH:mm:ss or HH:mm:ss-hh:mm.

Sample:

• The following Data Mapper transformation rule: subtract-times(“10:30:00”, “10:00:00”) will be translated to {xs:dayTimeDuration(xs:time(’10:30:00?) – xs:time(’10:00:00?))} and the return will be PT30M.

## Subtract YearMonth from Date

This function states that it will subtract a positive or negative YearMonth duration from the specified Date value (xs:date). Returns a Date that’s respectively before or after the specified Date.

Behind the scenes, this function is translated to the following XPath expression: xs:date(xs:date(\$arg1) – xs:yearMonthDuration(\$arg2))

• xs:date(xs:date(\$arg1) – xs:yearMonthDuration(\$arg2)) as xs:date

Rules:

• Returns the `xs:date` that is a given duration after a specified `xs:date` (or before, if the duration is negative).
• The `\$arg`1 needs to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.
• The `\$arg`2 needs to be an interval in ISO 8601 format. ISO-8601 standard was created to elaborate crystal clear language to discuss dates and periods and avoid misinterpretation. Where Duration (“how long“) is represented with the format P[n]Y[n], where n is a number – xs:yearMonthDuration.

Sample:

• The following Data Mapper transformation rule: subtract-yearmonth-from-date(“2023-07-28”, “P1Y”) will be translated to {xs:date(xs:date(‘2023-07-28’) – xs:yearMonthDuration(‘P1Y’))} and the return will be 2022-07-28.

## Subtract YearMonth from DateTime

This function states that it will subtract a positive or negative YearMonth duration from the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively before or after the specified DateTime.

Behind the scenes, this function is translated to the following XPath expression: xs:dateTime(xs:dateTime(\$arg1) – xs:yearMonthDuration(\$arg2)

• xs:dateTime(xs:dateTime(\$arg1) – xs:yearMonthDuration(\$arg2) as xs:dateTime

Rules:

• Returns the `xs:dateTime` that is a given duration before a specified `xs:dateTime` (or after, if the duration is negative).
• The `\$arg`1 needs to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.
• The `\$arg`2 needs to be an interval in ISO 8601 format. ISO-8601 standard was created to elaborate crystal clear language to discuss dates and periods and avoid misinterpretation. Where Duration (“how long“) is represented with the format P[n]Y[n], where n is a number – xs:yearMonthDuration.

Sample:

• The following Data Mapper transformation rule: subtract-yearmonth-from-datetime(“2023-07-28T12:00:00”, “P1Y”) will be translated to {xs:dateTime(xs:dateTime(‘2023-07-28T12:00:00’) – xs:yearMonthDuration(‘P1Y’))} and the return will be 2022-07-28T12:00:00.

Stay tuned for the fifth part of this blog post.

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more, you can buy (or help buy) my son a Star Wars Lego!

##### Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

## Logic Apps (Standard) Data Mapper: Date and Time Functions (Part 3)

Because the Date and Time functions category has too many functions, I decide to break this blog post into different parts, so welcome to the third part!

## Overview

Date and Time functions are used to perform a variety of operations over Dates, such as retrieving the current date and time or adding dates, etc. If you come from the BizTalk Server background or are migrating BizTalk Server projects, they are the equivalent of Date/Time Functoids inside BizTalk Mapper Editor.

## Available Functions

The Date and Time functoids are:

• Add days: Adds a positive or negative number of days to the specified timestamp. Returns a timestamp that’s respectively later or earlier than the specified timestamp.
• Add DayTime to Date: Adds a positive or negative DayTime duration to the specified Date value (xs:date). Returns a Date that’s respectively after or before the specified Date.
• Add DayTime to DateTime: Adds a positive or negative DayTime duration to the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively after or before the specified DateTime.
• Add DayTime to Time: Adds a positive or negative DayTime duration to the specified Time value (xs:time). Returns a Time that’s respectively after or before the specified Time. Durations that wrap around past midnight also return an earlier Time.
• Add YearMonth to DateTime: Adds a positive or negative YearMonth duration to the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively after or before the specified DateTime.
• Adjust Date: Adjusts the specified Date value (xs:date) to the current or dynamic time zone.
• Adjust DateTime: Adjusts the specified DateTime value (xs:dateTime) to the current or dynamic time zone.
• Adjust Time: Adjusts the specified Time value (xs:time) to the current or dynamic time zone.
• Current date: Returns the current date in YYYY-MM-DD format.
• Current DateTime value: Returns the current date and time in YYYY-MM-DDThh:mm:ss format.
• Current time: Returns the current date and time in YYYY-MM-DDThh:mm:ss format.
• DateTime: Creates and returns a DateTime value based on the specified Date and Time.
• Day from Date: Returns the day from the specified Date value (xs:date).
• Day from DateTime: Returns the day from the specified DateTime value (xs:dateTime).
• Equal Date: Returns true or false based on whether the specified Date values are equal.
• Equal DateTime: Returns true or false based on whether with the specified DateTime values are equal.
• Equal Day: Returns true or false based on whether the specified Day values (xs:gDay) are equal with the same starting time when the day values are in the same month and year.
• Equal Month: Returns true or false based on whether the specified Month values (xs:gMonth) have the same starting time when the month values are in the same year.
• Equal MonthDay: Returns true or false based on whether the specified MonthDay values (xs:gMonthDay) are equal with the same starting time when the day values are in the same year.
• Equal Time: Returns true or false based on whether the specified Time values are equal.
• Equal Year: Returns true or false based on whether the specified Year values (xs:gYear) have the same starting time.
• Equal YearMonth: Returns true or false based on whether the specified YearMonth values (xs:gYearMonth) are the same.
• Greater Date: Returns true or false based on whether the first Date value is later than the second Date value.
• Greater DateTime: Returns true or false based on whether the first DateTime value is later than the second DateTime value.
• Greater Time: Returns true or false based on whether the first Time value is later than the second Time value.
• Hours from DateTime: Returns the hours from the specified DateTime value (xs:dateTime).
• Hours from Time: Returns the hours from the specified Time value (xs:time).
• Less Date: Returns true or false based on whether the first Date value is earlier than the second Date value.
• Less DateTime: Returns true or false based on whether the first DateTime value is earlier than the second DateTime value.
• Less Time: Returns true or false based on whether the first Time value is earlier than the second Time value.
• Minutes from DateTime: Returns the minutes from the specified DateTime value (xs:dateTime).
• Minutes from Time: Returns the minutes from the specified Time value (xs:time).
• Month from Date: Returns the month from the specified Date value (xs:date).
• Month from DateTime: Returns the month from the specified DateTime value (xs:dateTime).
• Seconds from DateTime: Returns the seconds from the specified DateTime value (xs:dateTime).
• Seconds from Time: Returns the seconds from the specified Time value (xs:time).
• Subtract Dates: Returns the DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the starting times for the specified Date values.
• Subtract DateTimes: Returns a DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the specified DateTime values..
• Subtract DateTime from Date: Subtracts a positive or negative DayTime duration from the specified Date value (xs:date). Returns a Date that’s respectively before or after the specified Date..
• Subtract DateTime from DateTime: Subtracts a positive or negative DayTime duration from the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively before or after the specified DateTime.
• Subtract DateTime from Time: Subtracts a positive or negative Time duration from the specified Time value (xs:time). Returns a Time that’s respectively before or after the specified Time. A duration that wraps around past midnight also returns a later Time.
• Subtract Times: Returns a DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the specified Time values, which are treated as times on the same date.
• Subtract YearMonth from Date: Subtracts a positive or negative YearMonth duration from the specified Date value (xs:date). Returns a Date that’s respectively before or after the specified Date.
• Subtract YearMonth from DateTime: Subtracts a positive or negative YearMonth duration from the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively before or after the specified DateTime.
• Time zone from Date: Returns the time zone from the specified Date value (xs:date).
• Time zone from DateTime: Returns the time zone from the specified DateTime value (xs:dateTime).
• Time zone from Time: Returns the time zone from the specified Time value (xs:time).
• Year from Date: Returns the year from the specified Date value (xs:date).
• Year from DateTime: Returns the year from the specified DateTime value (xs:dateTime).

## Greater Date

This function states that it will return true or false based on whether the first Date value is later than the second Date value.

Behind the scenes, this function is translated to the following XPath expression: xs:date(\$arg1) > xs:date(\$arg2)

• xs:date(\$arg1) > xs:date(\$arg2) as xs:boolean

Rules:

• Returns `true` if and only if the starting instant of `\$arg1` is greater than the starting instant of `\$arg2`. Returns `false` otherwise.
• The `\$arg`1 and \$arg2 need to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.

Sample:

• The following Data Mapper transformation rule: is-greater-than-date(“2013-07-28”, “2013-07-29”) will be translated to {xs:date(‘2013-07-28’) > xs:date(‘2013-07-29’)} and the return will be false.

## Greater DateTime

This function states that it will return true or false based on whether the first DateTime value is later than the second DateTime value.

Behind the scenes, this function is translated to the following XPath expression: xs:dateTime(\$arg1) > xs:dateTime(\$arg2)

• xs:dateTime(\$arg1) > xs:dateTime(\$arg2) as xs:boolean

Rules:

• Returns `true` if the first argument represents a later instant in time than the second argument. Returns `false` otherwise.
• The `\$arg`1 and \$arg2 need to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.

Sample:

• The following Data Mapper transformation rule: is-greater-than-datetime(“2023-07-25T12:00:00+01:00”, “2023-07-25T13:00:00+01:00”) will be translated to {xs:dateTime(‘2023-07-25T12:00:00+01:00’) > xs:dateTime(‘2023-07-25T13:00:00+01:00’)} and the return will be false.

## Greater Time

This function states that it will return true or false based on whether the first Time value is later than the second Time value.

Behind the scenes, this function is translated to the following XPath expression: xs:time(\$arg1) > xs:time(\$arg2)

• xs:time(\$arg1) > xs:time(\$arg2) as xs:boolean

Rules:

• Returns `true` if the first `xs:time` value represents a later instant in time than the second, when both are treated as being times on the same date, before adjusting the timezone.
• The `\$arg1 and \$arg2 need` to be an xs:time in the following format HH:mm:ss or HH:mm:ss-hh:mm.

Sample:

• The following Data Mapper transformation rule: is-greater-than-time(“01:00:00”, “02:00:00”) will be translated to {xs:time(’01:00:00?) > xs:time(’02:00:00?)} and the return will be false.

## Hours from DateTime

This function states that it will return the hours from the specified DateTime value (xs:dateTime).

Behind the scenes, this function is translated to the following XPath function: hours-from-dateTime(\$arg1)

• `fn:hours-from-dateTime`(`\$arg as xs:dateTime?`)` as xs:integer?`

Rules:

• Returns the hours component of an `xs:dateTime` without adjusting the timezone.
• The `\$arg`1 needs to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.

Sample:

• The expression `fn:hours-from-dateTime(xs:dateTime("1999-05-31T08:20:00-05:00"))` returns `8`.

## Hours from Time

This function states that it will return the hours from the specified Time value (xs:time).

Behind the scenes, this function is translated to the following XPath function: hours-from-time(\$arg1)

• `fn:hours-from-time`(`\$arg as xs:time?`)` as xs:integer?`

Rules:

• Returns the hours component of an `xs:time` without adjusting the timezone.
• The `\$arg`1 needs to be an xs:time in the following format HH:mm:ss or HH:mm:ss-hh:mm.

Sample:

• The following Data Mapper transformation rule: is-less-than-datetime(“2023-07-25T12:00:00+01:00”, “2023-07-25T13:00:00+01:00”) will be translated to {xs:dateTime(‘2023-07-25T12:00:00+01:00’) > xs:dateTime(‘2023-07-25T13:00:00+01:00’)} and the return will be false.

## Less Date

This function states that it will return true or false based on whether the first Date value is earlier than the second Date value.

Behind the scenes, this function is translated to the following XPath expression: xs:date(\$arg1) < xs:date(\$arg2)

• xs:date(\$arg1) < xs:date(\$arg2) as xs:boolean

Rules:

• Returns `true` if and only if the starting instant of `\$arg1` is less than the starting instant of `\$arg2`. Returns `false` otherwise.
• The `\$arg`1 and \$arg2 need to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.

Sample:

• The following Data Mapper transformation rule: is-less-than-date(“2023-07-28”, “2023-07-29”) will be translated to {xs:date(‘2023-07-28’) < xs:date(‘2023-07-29’)} and the return will be true.

## Less DateTime

This function states that it will return true or false based on whether the first DateTime value is earlier than the second DateTime value.

Behind the scenes, this function is translated to the following XPath function: xs:dateTime(\$arg1) < xs:dateTime(\$arg2)

• xs:dateTime(\$arg1) < xs:dateTime(\$arg2) as xs:boolean

Rules:

• Returns `true` if the first argument represents an earlier instant in time than the second argument.
• The `\$arg`1 and \$arg2 need to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.

Sample:

• The following Data Mapper transformation rule: is-less-than-datetime(“2023-07-25T12:00:00+01:00”, “2023-07-25T13:00:00+01:00”) will be translated to {xs:dateTime(‘2023-07-25T12:00:00+01:00’) < xs:dateTime(‘2023-07-25T13:00:00+01:00’)} and the return will be true.

## Less Time

This function states that it will return true or false based on whether the first Time value is earlier than the second Time value.

Behind the scenes, this function is translated to the following XPath function: xs:time(\$arg1) < xs:time(\$arg2)

• xs:time(\$arg1) < xs:time(\$arg2) as xs:boolean

Rules:

• Returns `true` if the first `xs:time` value represents an earlier instant in time than the second, when both are treated as being times on the same date, before adjusting the timezone.
• The `\$arg1 and \$arg2 need` to be an xs:time in the following format HH:mm:ss or HH:mm:ss-hh:mm.

Sample:

• The following Data Mapper transformation rule: is-less-than-time(“12:00:00”, “13:00:00”) will be translated to {xs:time(’12:00:00?) < xs:time(’13:00:00?)} and the return will be true.

## Minutes from DateTime

This function states that it will return the minutes from the specified DateTime value (xs:dateTime).

Behind the scenes, this function is translated to the following XPath function: minutes-from-dateTime(\$arg)

• `fn:minutes-from-dateTime`(`\$arg as xs:dateTime?`)` as xs:integer?`

Rules:

• The function returns an `xs:integer` value between 0 and 59, both inclusive, representing the minute component defined in the `\$arg` without adjusting the timezone.
• The `\$arg` needs to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.

Sample:

• The expression `fn:minutes-from-dateTime(xs:dateTime("1999-05-31T13:30:00+05:30"))` returns `30`.

## Minutes from Time

This function states that it will return the minutes from the specified Time value (xs:time).

Behind the scenes, this function is translated to the following XPath function: minutes-from-time(\$arg)

• number(\$arg as xs:anyAtomicType?) as xs:boolean

Rules:

• Returns the minutes component of an `xs:time` without adjusting the timezone.
• The `\$arg` needs to be an xs:time in the following format HH:mm:ss or HH:mm:ss-hh:mm.

Sample:

• The expression `fn:minutes-from-time(xs:time("13:00:00Z"))` returns `0`.

## Month from Date

This function states that it will return the month from the specified Date value (xs:date).

Behind the scenes, this function is translated to the following XPath function: month-from-date(\$arg)

• `fn:month-from-date`(`\$arg as xs:date?`)` as xs:integer?`

Rules:

• The function returns an `xs:integer` between 1 and 12, both inclusive, representing the month component in the local value of `\$arg`.
• The `\$arg` needs to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.

Sample:

• The expression `fn:month-from-date(xs:date("1999-05-31"))` returns `5`

## Month from DateTime

This function states that it will return the month from the specified DateTime value (xs:dateTime).

Behind the scenes, this function is translated to the following XPath function: month-from-dateTime(\$arg)

• number(\$arg as xs:anyAtomicType?) as xs:boolean

Rules:

• The function returns an `xs:integer` between 1 and 12, both inclusive, representing the month defined on the `\$arg without adjusting the timezone`.
• The `\$arg` needs to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.

Sample:

• The expression `fn:month-from-dateTime(xs:dateTime("1999-05-31T13:20:00-05:00"))` returns `5`.

Stay tuned for the fourth part of this blog post.

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more, you can buy (or help buy) my son a Star Wars Lego!

##### Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

## Logic Apps (Standard) Data Mapper: Date and Time Functions (Part 2)

Because the Date and Time functions category has too many functions, I decide to break this blog post into different parts, so welcome to the second part!

## Overview

Date and Time functions are used to perform a variety of operations over Dates, such as retrieving the current date and time or adding dates, etc. If you come from the BizTalk Server background or are migrating BizTalk Server projects, they are the equivalent of Date/Time Functoids inside BizTalk Mapper Editor.

## Available Functions

The Date and Time functoids are:

• Add days: Adds a positive or negative number of days to the specified timestamp. Returns a timestamp that’s respectively later or earlier than the specified timestamp.
• Add DayTime to Date: Adds a positive or negative DayTime duration to the specified Date value (xs:date). Returns a Date that’s respectively after or before the specified Date.
• Add DayTime to DateTime: Adds a positive or negative DayTime duration to the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively after or before the specified DateTime.
• Add DayTime to Time: Adds a positive or negative DayTime duration to the specified Time value (xs:time). Returns a Time that’s respectively after or before the specified Time. Durations that wrap around past midnight also return an earlier Time.
• Add YearMonth to DateTime: Adds a positive or negative YearMonth duration to the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively after or before the specified DateTime.
• Adjust Date: Adjusts the specified Date value (xs:date) to the current or dynamic time zone.
• Adjust DateTime: Adjusts the specified DateTime value (xs:dateTime) to the current or dynamic time zone.
• Adjust Time: Adjusts the specified Time value (xs:time) to the current or dynamic time zone.
• Current date: Returns the current date in YYYY-MM-DD format.
• Current DateTime value: Returns the current date and time in YYYY-MM-DDThh:mm:ss format.
• Current time: Returns the current date and time in YYYY-MM-DDThh:mm:ss format.
• DateTime: Creates and returns a DateTime value based on the specified Date and Time.
• Day from Date: Returns the day from the specified Date value (xs:date).
• Day from DateTime: Returns the day from the specified DateTime value (xs:dateTime).
• Equal Date: Returns true or false based on whether the specified Date values are equal.
• Equal DateTime: Returns true or false based on whether with the specified DateTime values are equal.
• Equal Day: Returns true or false based on whether the specified Day values (xs:gDay) are equal with the same starting time when the day values are in the same month and year.
• Equal Month: Returns true or false based on whether the specified Month values (xs:gMonth) have the same starting time when the month values are in the same year.
• Equal MonthDay: Returns true or false based on whether the specified MonthDay values (xs:gMonthDay) are equal with the same starting time when the day values are in the same year.
• Equal Time: Returns true or false based on whether the specified Time values are equal.
• Equal Year: Returns true or false based on whether the specified Year values (xs:gYear) have the same starting time.
• Equal YearMonth: Returns true or false based on whether the specified YearMonth values (xs:gYearMonth) are the same.
• Greater Date: Returns true or false based on whether the first Date value is later than the second Date value.
• Greater DateTime: Returns true or false based on whether the first DateTime value is later than the second DateTime value.
• Greater Time: Returns true or false based on whether the first Time value is later than the second Time value.
• Hours from DateTime: Returns the hours from the specified DateTime value (xs:dateTime).
• Hours from Time: Returns the hours from the specified Time value (xs:time).
• Less Date: Returns true or false based on whether the first Date value is earlier than the second Date value.
• Less DateTime: Returns true or false based on whether the first DateTime value is earlier than the second DateTime value.
• Less Time: Returns true or false based on whether the first Time value is earlier than the second Time value.
• Minutes from DateTime: Returns the minutes from the specified DateTime value (xs:dateTime).
• Minutes from Time: Returns the minutes from the specified Time value (xs:time).
• Month from Date: Returns the month from the specified Date value (xs:date).
• Month from DateTime: Returns the month from the specified DateTime value (xs:dateTime).
• Seconds from DateTime: Returns the seconds from the specified DateTime value (xs:dateTime).
• Seconds from Time: Returns the seconds from the specified Time value (xs:time).
• Subtract Dates: Returns the DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the starting times for the specified Date values.
• Subtract DateTimes: Returns a DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the specified DateTime values..
• Subtract DateTime from Date: Subtracts a positive or negative DayTime duration from the specified Date value (xs:date). Returns a Date that’s respectively before or after the specified Date..
• Subtract DateTime from DateTime: Subtracts a positive or negative DayTime duration from the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively before or after the specified DateTime.
• Subtract DateTime from Time: Subtracts a positive or negative Time duration from the specified Time value (xs:time). Returns a Time that’s respectively before or after the specified Time. A duration that wraps around past midnight also returns a later Time.
• Subtract Times: Returns a DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the specified Time values, which are treated as times on the same date.
• Subtract YearMonth from Date: Subtracts a positive or negative YearMonth duration from the specified Date value (xs:date). Returns a Date that’s respectively before or after the specified Date.
• Subtract YearMonth from DateTime: Subtracts a positive or negative YearMonth duration from the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively before or after the specified DateTime.
• Time zone from Date: Returns the time zone from the specified Date value (xs:date).
• Time zone from DateTime: Returns the time zone from the specified DateTime value (xs:dateTime).
• Time zone from Time: Returns the time zone from the specified Time value (xs:time).
• Year from Date: Returns the year from the specified Date value (xs:date).
• Year from DateTime: Returns the year from the specified DateTime value (xs:dateTime).

## DateTime

This function states that it will create and returns a DateTime value based on the specified Date and Time.

Behind the scenes, this function is translated to the following XPath function: dateTime(xs:date(\$arg1), xs:time(\$arg1))

• dateTime(xs:date(\$arg1), xs:time(\$arg1)) as xs:dateTime

Rules:

• The `\$arg`1 needs to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.
• The `\$arg`2 needs to be an xs:time in the following format HH:mm:ss or HH:mm:ss-hh:mm.

Sample:

• The following Data Mapper transformation rule: datetime(“2023-07-27”, “12:00:00”) will be translated to {dateTime(xs:date(‘2023-07-27?), xs:time(’12:00:00’))} and the return will be 2023-07-27T12:00:00

## Day from Date

This function states that it will return the day from the specified Date value (xs:date).

Behind the scenes, this function is translated to the following XPath function: day-from-date(xs:date(\$arg))

• `fn:day-from-date`(`\$arg as xs:date?`)` as xs:integer?`

Rules:

• The function returns an `xs:integer` between 1 and 31, both inclusive, representing the day component in the localized value of `\$arg`.
• The `\$arg` needs to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.

Sample:

• The following Data Mapper transformation rule: day-from-date(“2023-07-27”) will be translated to {day-from-date(xs:date(‘2023-07-27’))} and the return will be 27.

## Day from DateTime

This function states that it will return the day from the specified DateTime value (xs:dateTime).

Behind the scenes, this function is translated to the following XPath function: day-from-dateTime(xs:dateTime(\$arg))

• `fn:day-from-dateTime`(`\$arg as xs:dateTime?`)` as xs:integer?`

Rules:

• The function returns an `xs:integer` between 1 and 31, both inclusive, representing the day component in the localized value of `\$arg`.
• The `\$arg` needs to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.

Sample:

• The following Data Mapper transformation rule: day-from-datetime(“2023-07-27T12:00:00”) will be translated to {day-from-dateTime(xs:dateTime(‘2023-07-27T12:00:00’))} and the return will be 27.

## Equal Date

This function states that it will return true or false based on whether the specified Date values are equal.

Behind the scenes, this function is translated to the following XPath expression: xs:date(\$arg1) = xs:date(\$arg2)

• xs:date(\$arg1) = xs:date(\$arg2) as xs:boolean

Rules:

• The `\$arg`1 and \$arg2 need to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DD-hh:mm

Sample:

• The following Data Mapper transformation rule: is-equal-date(current-date(), current-date()) will be translated to {xs:date(current-date()) = xs:date(current-date())} and the return will be true.

## Equal DateTime

This function states that it will return true or false based on whether with the specified DateTime values are equal.

Behind the scenes, this function is translated to the following XPath expression: xs:dateTime(\$arg1) = xs:dateTime(\$arg2)

• xs:dateTime(\$arg1) = xs:dateTime(\$arg2) as xs:boolean

Rules:

• The `\$arg`1 and \$arg2 need to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.

Sample:

• The following Data Mapper transformation rule: is-equal-datetime(current-dateTime(), current-dateTime()) will be translated to {xs:dateTime(current-dateTime()) = xs:dateTime(current-dateTime())} and the return will be true.

## Equal Day

This function states that it will return true or false based on whether the specified Day values (xs:gDay) are equal with the same starting time when the day values are in the same month and year.

Behind the scenes, this function is translated to the following XPath expression: xs:gDay(\$arg1) = xs:gDay(\$arg2)

• xs:gDay(\$arg1) = xs:gDay(\$arg2) as xs:boolean

Rules:

• Returns true if the two `xs:gDay` values (xs:gDay(“—25-14:00”)) have the same starting instant, when considered as days in the same month of the same year.

Sample:

• The following Data Mapper transformation rule: is-day-equal(day-from-date(…), day-from-date(…)) will be translated to xs:gDay(day-from-date(xs:date(‘2023-07-27’))) = xs:gDay(day-from-date(xs:date(‘2023-07-27’)))} and the return will be true.

## Equal Month

This function states that it will return true or false based on whether the specified Month values (xs:gMonth) have the same starting time when the month values are in the same year.

Behind the scenes, this function is translated to the following XPath expression: xs:gMonth(\$arg1) = xs:gMonth(\$arg2)

• xs:gMonth(\$arg1) = xs:gMonth(\$arg2) as xs:boolean

Rules:

• Returns true if the two `xs:gMonth` values (xs:gMonth(“–12-14:00”)) have the same starting instant, when considered as months in the same year.

Sample:

• The following Data Mapper transformation rule: is-month-equal(current-date(), current-date()) will be translated to {xs:gMonth(current-date()) = xs:gMonth(current-date())} and the return will be true.

## Equal MonthDay

This function states that it will return true or false based on whether the specified MonthDay values (xs:gMonthDay) are equal with the same starting time when the day values are in the same year.

Behind the scenes, this function is translated to the following XPath expression: xs:gMonthDay(\$arg1) = xs:gMonthDay(\$arg2)

• xs:gMonthDay(\$arg1) = xs:gMonthDay(\$arg2) as xs:boolean

Rules:

• Returns true if the two `xs:gMonthDay` values (xs:gMonthDay(“–12-25-14:00”)) have the same starting instant, when considered as days in the same year.

Sample:

• The following Data Mapper transformation rule: is-monthday-equal(current-date(), current-date()) will be translated to {xs:gMonthDay(current-date()) = xs:gMonthDay(current-date())} and the return will be true.

## Equal Time

This function states that it will return true or false based on whether the specified Time values are equal.

Behind the scenes, this function is translated to the following XPath expression: xs:time(\$arg1) = xs:time(\$arg2)

• xs:time(\$arg1) = xs:time(\$arg2) as xs:boolean

Rules:

• Returns `true` if the two `xs:time` values represent the same instant in time, when treated as being times on the same date, before adjusting the timezone.

Sample:

• The following Data Mapper transformation rule: is-equal-time(current-time(), current-time()) will be translated to xs:time(current-time()) = xs:time(current-time()) and the return will be true.

## Equal Year

This function states that it will return true or false based on whether the specified Year values (xs:gYear) have the same starting time.

Behind the scenes, this function is translated to the following XPath expression: xs:gYear(\$arg1) = xs:gYear(\$arg2)

• xs:gYear(\$arg1) = xs:gYear(\$arg2) as xs:boolean

Rules:

• Returns true if the two `xs:gYear` values (xs:gYear(“2005+12:00”)) have the same starting instant.

Sample:

• The following Data Mapper transformation rule: is-year-equal(current-date(), current-date()) will be translated to {xs:gYear(current-date()) = xs:gYear(current-date())} and the return will be true.

## Equal YearMonth

This function states that it will return true or false based on whether the specified YearMonth values (xs:gYearMonth) are the same.

Behind the scenes, this function is translated to the following XPath expression: xs:gYearMonth(\$arg1) = xs:gYearMonth(\$arg2)

• xs:gYearMonth(\$arg1) = xs:gYearMonth(\$arg2) as xs:boolean

Rules:

• Returns true if the two `xs:gYearMonth` values (xs:gYearMonth(“1986-02”)) have the same starting instant.

Sample:

• The following Data Mapper transformation rule: is-yearmonth-equal(current-date(), current-date()) will be translated to {xs:gYearMonth(current-date()) = xs:gYearMonth(current-date())} and the return will be true.

Stay tuned for the third part of this blog post.

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more, you can buy (or help buy) my son a Star Wars Lego!

##### Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

## Overview

Date and Time functions are used to perform a variety of operations over Dates, such as retrieving the current date and time or adding dates, etc. If you come from the BizTalk Server background or are migrating BizTalk Server projects, they are the equivalent of Date/Time Functoids inside BizTalk Mapper Editor.

## Available Functions

The Date and Time functoids are:

• Add days: Adds a positive or negative number of days to the specified timestamp. Returns a timestamp that’s respectively later or earlier than the specified timestamp.
• Add DayTime to Date: Adds a positive or negative DayTime duration to the specified Date value (xs:date). Returns a Date that’s respectively after or before the specified Date.
• Add DayTime to DateTime: Adds a positive or negative DayTime duration to the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively after or before the specified DateTime.
• Add DayTime to Time: Adds a positive or negative DayTime duration to the specified Time value (xs:time). Returns a Time that’s respectively after or before the specified Time. Durations that wrap around past midnight also return an earlier Time.
• Add YearMonth to DateTime: Adds a positive or negative YearMonth duration to the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively after or before the specified DateTime.
• Adjust Date: Adjusts the specified Date value (xs:date) to the current or dynamic time zone.
• Adjust DateTime: Adjusts the specified DateTime value (xs:dateTime) to the current or dynamic time zone.
• Adjust Time: Adjusts the specified Time value (xs:time) to the current or dynamic time zone.
• Current date: Returns the current date in YYYY-MM-DD format.
• Current DateTime value: Returns the current date and time in YYYY-MM-DDThh:mm:ss format.
• Current time: Returns the current date and time in YYYY-MM-DDThh:mm:ss format.
• DateTime: Creates and returns a DateTime value based on the specified Date and Time.
• Day from Date: Returns the day from the specified Date value (xs:date).
• Day from DateTime: Returns the day from the specified DateTime value (xs:dateTime).
• Equal Date: Returns true or false based on whether the specified Date values are equal.
• Equal DateTime: Returns true or false based on whether with the specified DateTime values are equal.
• Equal Day: Returns true or false based on whether the specified Day values (xs:gDay) are equal with the same starting time when the day values are in the same month and year.
• Equal Month: Returns true or false based on whether the specified Month values (xs:gMonth) have the same starting time when the month values are in the same year.
• Equal MonthDay: Returns true or false based on whether the specified MonthDay values (xs:gMonthDay) are equal with the same starting time when the day values are in the same year.
• Equal Time: Returns true or false based on whether the specified Time values are equal.
• Equal Year: Returns true or false based on whether the specified Year values (xs:gYear) have the same starting time.
• Equal YearMonth: Returns true or false based on whether the specified YearMonth values (xs:gYearMonth) are the same.
• Greater Date: Returns true or false based on whether the first Date value is later than the second Date value.
• Greater DateTime: Returns true or false based on whether the first DateTime value is later than the second DateTime value.
• Greater Time: Returns true or false based on whether the first Time value is later than the second Time value.
• Hours from DateTime: Returns the hours from the specified DateTime value (xs:dateTime).
• Hours from Time: Returns the hours from the specified Time value (xs:time).
• Less Date: Returns true or false based on whether the first Date value is earlier than the second Date value.
• Less DateTime: Returns true or false based on whether the first DateTime value is earlier than the second DateTime value.
• Less Time: Returns true or false based on whether the first Time value is earlier than the second Time value.
• Minutes from DateTime: Returns the minutes from the specified DateTime value (xs:dateTime).
• Minutes from Time: Returns the minutes from the specified Time value (xs:time).
• Month from Date: Returns the month from the specified Date value (xs:date).
• Month from DateTime: Returns the month from the specified DateTime value (xs:dateTime).
• Seconds from DateTime: Returns the seconds from the specified DateTime value (xs:dateTime).
• Seconds from Time: Returns the seconds from the specified Time value (xs:time).
• Subtract Dates: Returns the DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the starting times for the specified Date values.
• Subtract DateTimes: Returns a DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the specified DateTime values..
• Subtract DateTime from Date: Subtracts a positive or negative DayTime duration from the specified Date value (xs:date). Returns a Date that’s respectively before or after the specified Date..
• Subtract DateTime from DateTime: Subtracts a positive or negative DayTime duration from the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively before or after the specified DateTime.
• Subtract DateTime from Time: Subtracts a positive or negative Time duration from the specified Time value (xs:time). Returns a Time that’s respectively before or after the specified Time. A duration that wraps around past midnight also returns a later Time.
• Subtract Times: Returns a DayTimeDuration value (xs:dayTimeDuration) representing the elapsed time between the specified Time values, which are treated as times on the same date.
• Subtract YearMonth from Date: Subtracts a positive or negative YearMonth duration from the specified Date value (xs:date). Returns a Date that’s respectively before or after the specified Date.
• Subtract YearMonth from DateTime: Subtracts a positive or negative YearMonth duration from the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively before or after the specified DateTime.
• Time zone from Date: Returns the time zone from the specified Date value (xs:date).
• Time zone from DateTime: Returns the time zone from the specified DateTime value (xs:dateTime).
• Time zone from Time: Returns the time zone from the specified Time value (xs:time).
• Year from Date: Returns the year from the specified Date value (xs:date).
• Year from DateTime: Returns the year from the specified DateTime value (xs:dateTime).

This function states that it will add a positive or negative number of days to the specified timestamp. Returns a timestamp that’s respectively later or earlier than the specified timestamp.

To be documented in the future.

## Add DayTime to Date

This function states that it will add a positive or negative DayTime duration to the specified Date value (xs:date). Returns a Date that’s respectively after or before the specified Date.

Behind the scenes, this function is translated to the following XPath function: xs:date(xs:date(\$arg1) + xs:dayTimeDuration(\$arg2))

• The expression xs:date(xs:date(\$arg1) + xs:dayTimeDuration(\$arg2)) returns `xs:date`

Rules:

• The `\$arg`1 needs to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.
• The `\$arg`2 needs to be an interval in ISO 8601 format. ISO-8601 standard was created to elaborate crystal clear language to discuss dates and periods and avoid misinterpretation. Where Duration (“how long“) is represented with the format P[n]Y[n]M[n]DT[n]H[n]M[n]S, where n is a number.
• The letters mean the representation of date and time:
• P express that this is a period format and should be the first character;
• Y for years; M for months; D for days;
• T is the delimiter for the time;
• H for hours; M for minutes; S for seconds;
• Therefore PT means Period of Time.
• PT20S: parses as 20 seconds.
• PT15M: parses as 15 minutes (where a minute is 60 seconds).
• PT10H: parses as 10 hours (where an hour is 3600 seconds).
• P2D: parses as 2 days (where a day is 24 hours or 86400 seconds).
• P2DT3H4M: parses as 2 days, 3 hours, and 4 minutes.

Sample:

• The following Data Mapper transformation rule: add-daytime-to-date(“2023-07-25”, “P2D”) will be translated to {xs:date(xs:date(‘2023-07-25’) + xs:dayTimeDuration(‘P2D’))} and the return will be 2023-07-27

## Add DayTime to DateTime

This function states that it will add a positive or negative DayTime duration to the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively after or before the specified DateTime.

Behind the scenes, this function is translated to the following XPath function: xs:dateTime(xs:dateTime(\$arg1) + xs:dayTimeDuration(\$arg1))

• `The expression xs:dateTime(xs:dateTime(\$arg1) + xs:dayTimeDuration(\$arg1)) returns xs:date`Time

Rules:

• The `\$arg`1 needs to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.
• The `\$arg`2 needs to be an interval in ISO 8601 format. ISO-8601 standard was created to elaborate crystal clear language to talk about dates and periods and avoid misinterpretation. Where Duration (“how long“) is represented with the format P[n]Y[n]M[n]DT[n]H[n]M[n]S, where n is a number.
• The letters mean the representation of date and time:
• P express that this is a period format and should be the first character;
• Y for years; M for months; D for days;
• T is the delimiter for the time;
• H for hours; M for minutes; S for seconds;
• Therefore PT means Period of Time.
• PT20S: parses as 20 seconds.
• PT15M: parses as 15 minutes (where a minute is 60 seconds).
• PT10H: parses as 10 hours (where an hour is 3600 seconds).
• P2D: parses as 2 days (where a day is 24 hours or 86400 seconds).
• P2DT3H4M: parses as 2 days, 3 hours, and 4 minutes.

Sample:

• The following Data Mapper transformation rule: add-daytime-to-datetime(“2023-07-25T12:00:00”, “PT20S”) will be translated to {xs:dateTime(xs:dateTime(‘2023-07-25T12:00:00’) + xs:dayTimeDuration(‘PT20S’))} and the return will be 2023-07-25T12:00:20

## Add DayTime to Time

This function states that it will add a positive or negative DayTime duration to the specified Time value (xs:time). Returns a Time that’s respectively after or before the specified Time. Durations that wrap around past midnight also return at an earlier Time.

Behind the scenes, this function is translated to the following XPath function: xs:time(xs:time(\$arg1) + xs:dayTimeDuration(\$arg2))

• `The expression` xs:time(xs:time(\$arg1) + xs:dayTimeDuration(\$arg2)) returns xs:time

Rules:

• The `\$arg`1 needs to be an xs:time in the following format HH:mm:ss or HH:mm:ss-hh:mm.
• The `\$arg`2 needs to be an interval in ISO 8601 format. ISO-8601 standard was created to elaborate crystal clear language to discuss dates and periods and avoid misinterpretation. Where Duration (“how
• The letters mean the representation of date and time:
• P express that this is a period format and should be the first character;
• Y for years; M for months; D for days;
• T is the delimiter for the time;
• H for hours; M for minutes; S for seconds;
• Therefore PT means Period of Time.
• PT20S: parses as 20 seconds.
• PT15M: parses as 15 minutes (where a minute is 60 seconds).
• PT10H: parses as 10 hours (where an hour is 3600 seconds).
• P2D: parses as 2 days (where a day is 24 hours or 86400 seconds).
• P2DT3H4M: parses as 2 days, 3 hours, and 4 minutes.

Sample:

• The following Data Mapper transformation rule: add-daytime-to-time(“11:12:00”, “PT1M”) will be translated to {xs:time(xs:time(’11:12:00?) + xs:dayTimeDuration(‘PT1M’))} and the return will be 11:13:00

## Add YearMonth to DateTime

This function states that it will Add a positive or negative YearMonth duration to the specified DateTime value (xs:dateTime). Returns a DateTime that’s respectively after or before the specified DateTime.

Behind the scenes, this function is translated to the following XPath function: xs:date(xs:date(\$arg1) + xs:yearMonthDuration(\$arg2))

• The expression xs:date(xs:date(\$arg1) + xs:yearMonthDuration(\$arg2)) returns `xs:date`

Rules:

• The `\$arg`1 needs to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.
• The `\$arg`2 needs to be an interval in ISO 8601 format. ISO-8601 standard was created to elaborate crystal clear language to discuss dates and periods and avoid misinterpretation. Where Duration (“how long“) is represented with the format P[n]Y[n]M, where n is a number.
• The letters mean the representation of date and time:
• P express that this is a period format and should be the first character;
• Y for years; M for months;
• Therefore PT means Period of Time.
• PT1Y: parses as 1 Year.
• P1M: parses as 1 Month.

Sample:

• The following Data Mapper transformation rule: add-yearmonth-to-date(“2023-07-26Z”, “P1M”) will be translated to {xs:date(xs:date(‘2023-07-26Z’) + xs:yearMonthDuration(‘P1M’))} and the return will be 2023-08-26Z.

This function states that it will adjust the specified Date value (xs:date) to the current or dynamic time zone, or to no timezone at all; the result is the date in the target timezone that contains the starting instant of the supplied date.

Behind the scenes, this function is translated to the following XPath function: `adjust-date-to-timezone`(xs:date(\$arg))

• `fn:adjust-date-to-timezone`(`\$arg as xs:date?`)` as xs:date?`

Rules:

• The `\$arg` needs to be an xs:date in the following format yyyy-MM-DD or yyyy-MM-DDZ.

Sample:

• The expression `fn:adjust-date-to-timezone(xs:date("2002-03-07"))` returns `xs:date("2002-03-07-05:00")`.

This function states that it will adjust the specified DateTime value (xs:dateTime) to the current or dynamic time zone, or to no timezone at all.

Behind the scenes, this function is translated to the following XPath function: adjust-dateTime-to-timezone(xs:dateTime(\$arg))

• `fn:adjust-dateTime-to-timezone`(`\$arg as xs:dateTime?`)` as xs:dateTime?`

Rules:

• The `\$arg` needs to be an xs:dateTime in the following format yyyy-MM-DDTHH:mm:ss or yyyy-MM-DDTHH:mm:ss-hh:mm.

Sample:

• The expression fn:adjust-dateTime-to-timezone(xs:dateTime(‘2002-03-07T10:00:00-07:00’)) returns xs:dateTime(‘2002-03-07T12:00:00-05:00’).

This function states that it will adjust the specified Time value (xs:time) to the current or dynamic time zone, or to no timezone at all.

Behind the scenes, this function is translated to the following XPath function: adjust-time-to-timezone(xs:time(\$arg))

• `fn:adjust-time-to-timezone(\$arg as xs:time?) as xs:time?`

Rules:

• The `\$arg` needs to be an xs:time in the following format HH:mm:ss or HH:mm:ss-hh:mm.

Sample:

• The expression fn:adjust-time-to-timezone(xs:time(“10:00:00”)) returns xs:time(“10:00:00-05:00”).

## Current date

This function states that it will return the current date in YYYY-MM-DD format. It depends on the implicit timezone (in many cases, if not all, it will include the offset).

Behind the scenes, this function is translated to the following XPath function: current-date()

• `fn:current-date`()` as xs:date`

Rules:

• Returns `xs:date(fn:current-dateTime())`. This is an `xs:date` (with timezone) that is current at some time during the evaluation of a query or transformation in which `fn:current-date` is executed.
• The returned date will always have an associated timezone, which will always be the same as the implicit timezone in the dynamic context.

Sample:

• For example, a call of `fn:current-date()` might return `2023-07-21+01:00`.

## Current DateTime value

This function states that it will return the current date and time in YYYY-MM-DDThh:mm:ss format.

Behind the scenes, this function is translated to the following XPath function: current-dateTime()

• `fn:current-dateTime`()` as xs:dateTimeStamp`

Rules:

• Returns the current dateTime (with timezone) from the dynamic context. This is an `xs:dateTime` that is current at some time during the evaluation of a query or transformation in which `fn:current-dateTime` is executed.

Sample:

• For example, a call of `fn:current-dateTime()` might return 2023-07-26T23:43:42.392+01:00.

## Current time

This function states that it will return the current date and time in YYYY-MM-DDThh:mm:ss format. It depends on the implicit timezone (in many cases, if not all, it will include the offset – 23:19:30.985+01:00).

Behind the scenes, this function is translated to the following XPath function: current-time()

• `fn:current-time`()` as xs:time`

Rules:

• Returns `xs:time(fn:current-dateTime())`. This is an `xs:time` (with timezone) that is current at some time during the evaluation of a query or transformation in which `fn:current-time` is executed.
• The returned time will always have an associated timezone, which will always be the same as the implicit timezone in the dynamic context.

Sample:

• For example, a call of `fn:current-time()` might return `23:19:30.985+01:00`.

Stay tune for the second part of this blog post.

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more, you can buy (or help buy) my son a Star Wars Lego!

##### Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

## Overview

String functions are used to manipulate strings in standard ways, such as conversions to all uppercase or all lowercase, string concatenation, determination of string length, white space trimming, etc. If you come from the BizTalk Server background or are migrating BizTalk Server projects, they are the equivalent of String Functoids inside BizTalk Mapper Editor.

## Available Functions

The Conversion functoids are:

• To DateTime: Returns the specified value as a DateTime value.
• To integer: Returns the specified value as an integer.
• To number: Returns the specified value as a number.
• To string: Returns the specified value as a string.

## To DateTime

This function states that it returns the specified value as a DateTime value.

Behind the scenes, this function is translated to a Type casting rule in XQuery: date()

• date(string?)

Rules:

• Castable values are restricted by the target types implementation restrictions. For example, you cannot cast a date string with a negative year to xs:date. Such casts will result in the empty sequence if the value is provided at run time (instead of raising a run-time error).

## To integer

This function states that it returns the specified value as an integer.

Behind the scenes, this function is translated to the following XPath function: number() idiv 1

• `number`(`\$arg as xs:anyAtomicType?`)` as xs:double` idiv 1

Note: idiv is an integer division operator. XPath supports two division operators named `div` and `idiv`. Each of these operators accepts two operands of any numeric type. `\$arg1 idiv \$arg2` is equivalent to `(\$arg1 div \$arg2) cast as xs:integer?` except for error cases.

Rules:

• If `\$arg` is the empty sequence, or if `\$arg` cannot be converted to an `xs:double`, the `xs:double` value `NaN` is returned.
• Otherwise, `\$arg` is converted to an `xs:double` following the rules of casting to xs:double. If the conversion to `xs:double` fails, the `xs:double` value `NaN` is returned.

## To number

This function states that it returns the specified value as a number.

Behind the scenes, this function is translated to the following XPath function:: number()

• `number`(`\$arg as xs:anyAtomicType?`)` as xs:double`

Rules:

• If `\$arg` is the empty sequence, or if `\$arg` cannot be converted to an `xs:double`, the `xs:double` value `NaN` is returned.
• Otherwise, `\$arg` is converted to an `xs:double` following the rules of casting to xs:double. If the conversion to `xs:double` fails, the `xs:double` value `NaN` is returned.

## To string

This function states that it returns the specified value as a string.

Behind the scenes, this function is translated to a Type casting rule in XQuery: string()

• `string string(object?)`

Rules:

• A node-set is converted to a string by returning the string-value of the node in the node-set that is first in document order. If the node-set is empty, an empty string is returned.
• A number is converted to a string as follows
• NaN is converted to the string `NaN`
• positive zero is converted to the string `0`
• negative zero is converted to the string `0`
• positive infinity is converted to the string `Infinity`
• negative infinity is converted to the string `-Infinity`
• if the number is an integer, the number is represented in decimal form as a Number with no decimal point and no leading zeros, preceded by a minus sign (`-`) if the number is negative
• otherwise, the number is represented in decimal form as a Number including a decimal point with at least one digit before the decimal point and at least one digit after the decimal point, preceded by a minus sign (`-`) if the number is negative; there must be no leading zeros before the decimal point apart possibly from the one required digit immediately before the decimal point; beyond the one required digit after the decimal point there must be as many, but only as many, more digits as are needed to uniquely distinguish the number from all other IEEE 754 numeric values.
• The boolean false value is converted to the string `false`. The boolean true value is converted to the string `true`.
• An object of a type other than the four basic types is converted to a string in a way that is dependent on that type.

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more, you can buy (or help buy) my son a Star Wars Lego!

##### Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

## Logic Apps (Standard) Data Mapper: What is a Function Chain (video)

Function Chain? What is a Function Chain? And how that works inside the Data Mapper?

When we use more than one cascading function to perform a transformation rule, we call it a Function Chain, or a chain of functions that are going to be executed in order. This way, we can apply more complex mapping rules inside the Logic Apps (Standard) Data Mapper. By the way, we had the same concept inside BizTalk Server Maps and Logic App Consumption Map (that is, the BizTalk Server Maps extracted and isolated)

The picture below shows us a Function Chain inside the Data Mapper. In this case, we are calculating national and international calls based on the phone number:

In this video, we will learn t what a Function Chain is inside the Logic Apps (Standard) Data Mapper and how it works.

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more content, you can buy (or help buy) my son a Star Wars Lego!

##### Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira