General Rules
Type conversion is usually done when using the attrib (=) operator between variables of different types. This page refers to the automatic type conversion, and not the one you obtain using the cast operator.
The types convertible to a target type are listed in the table below:
Target Type
Convertible types
Additional Information / Examples
number
string, integer
"1" to 1
1 to 1.0
integer
string, number
"2" to 2
2.0 to 2
string
ALL
boolean
string, number, integer
"true" to true
value of number != 0
date
string, number, integer
Constructing a date from number assumes the number is a "to millis" representation of a date
interval
string, number, integer
Constructing a date from number assumes the number is a "to millis" representation of an interval
60000 to "1m"
"120m" (string) to "2h" (interval)| Info |
|---|
This document covers automatic type conversion rules and behavior, distinct from explicit type conversion using the cast operator. |
Basic Type Conversion Matrix
This table shows all possible conversions between types:
Target Type ↓ | Source Type → | Additional information, notes, and examples | |||||
|---|---|---|---|---|---|---|---|
string* | number | integer | boolean | date | interval | ||
string | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | Universal conversion target. |
number | ✓ | ✓ | ✓ | ❌ | ❌ | ❌ |
|
integer | ✓ | ✓ | ✓ | ❌ | ❌ | ❌ |
|
boolean | ✓ | ✓ | ✓ | ✓ | ❌ | ❌ |
|
date | ✓ | ✓ | ✓ | ❌ | ✓ | ❌ |
|
interval | ✓ | ✓ | ✓ | ❌ | ❌ | ✓ |
|
*The conversion from string to a target type is done by parsing the string as a text representation of the target type.
Conversion Examples
| Code Block |
|---|
// Number conversion examples
number n1 = "42"; // String to number: 42.0
number n2 = 42; // Integer to number: 42.0
// Integer conversion examples
integer i1 = "123"; // String to integer: 123
integer i2 = 123.7; // Number to integer: 123 (truncated)
// Boolean conversion examples
boolean b1 = "true"; // String to boolean: true
boolean b2 = 1; // Number to boolean: true
boolean b3 = 0; // Number to boolean: false
// Date conversion examples
date d1 = "2024-01-01"; // String to date
date d2 = 1704067200000; // Milliseconds to date
// Interval conversion examples
interval iv1 = "1h 30m"; // String to interval
interval iv2 = 5400000; // Milliseconds to interval |
When converting a string to an array type, the string is first transformed to a string[] by splitting it at every "|" character, and then the conversion is done from string [] to the target type array.
The conversion from string to a target type is done by parsing the string as a text representation of the target type.
Converting Arrays
Converting arrays of different typesAdvanced Type Conversions
Array Conversion Rules
Array conversion is possible if the following conditions are met:
The element types (inner type of the array) are convertible
.
The conversion rules for array elements follow the same rules as single-value conversions explained earlier in this document.
All elements in the source array must be convertible to the target type.
Array Conversion Examples
You can cast a number[] to a string[] because number is convertible to string
(Example 1). However you cannot convert a date[] to an interval[] because date cannot be converted to interval (Example 2).
Converting Structures
Structures can only be converted directly to string or an array type. Converting a structure to an array requires that each field of the structure is convertible to the element type (inner type) of the array.
| Code Block |
|---|
// Example 1: Number Array to String Array (Valid)
number[] numbers = [1, 2.5, 3.7, -4.2];
string[] stringNumbers = numbers; // Valid conversion
// Result: ["1", "2.5", "3.7", "-4.2"]
// Example 2: Date Array to Interval Array (Invalid)
date[] dates = [
"2024-01-01",
"2024-01-02",
"2024-01-03"
];
// interval[] periods = dates; // This would cause a conversion error
// Error: Cannot convert date to interval
|
String to Array Type Conversion Rules
When converting a string to an array, the process happens in two steps:
Step 1: |
| The string is first transformed to a |
|---|---|---|
Step 2: |
| The conversion is done from |
String Conversion Examples
| Code Block |
|---|
// Step 1: "1|2|3" → ["1", "2", "3"]
// Step 2: ["1", "2", "3"] → [1, 2, 3]
// Basic number array conversion
string numericString = "1|2|3|4|5";
number[] numbers = numericString;
// Result: [1.0, 2.0, 3.0, 4.0, 5.0]
// Basic boolean array conversion
string boolString = "true|false|true|true";
boolean[] flags = boolString;
// Result: [true, false, true, true] |
Structure Conversion Rules
Structures can only be converted directly to string or arraytypes. It may be possible for certain structures to be convertible to other types by using one or more intermediate types
.
Structure to String Conversion
Conversions of this type follow these rules:
All fields are first converted to strings.
Fields are joined with commas.
Casting a structure to a string is equivalent to casting to a string[], and then the resulting array to string.
| Code Block |
|---|
// Define a simple structure
struct Person {
string name;
integer age;
boolean isActive;
}
// Create and convert instance
Person person = { "John Smith", 30, true};
// Direct conversion to string
string personString = person;
return personString;
// Result: John Smith|30|true |
Structure to Array Conversion
Conversions of this type follow these rules:
All structure fields must be convertible to the array's element type.
Fields are converted in order of declaration.
| Code Block |
|---|
// Structure with all number fields
struct Point3D {
number x;
number y;
number z;
}
Point3D point = { 1.5, 2.0, 3.5 };
// Convert to number array (valid because all fields are numbers)
number[] coordinates = point;
// Result: [1.5, 2.0, 3.5]
// Convert to string array (always valid as all types can convert to string)
string[] stringCoords = point;
return stringCoords;
// Result: 1.5|2|3.5 |
Complex Conversions
Complex conversions (to types other than string/array) require:
Explicit intermediate steps
Manual casting between types
Fields that can ultimately convert to target type
Common common conversion patterns include:
Structure → string → target type
Structure → array → target type
In this example, a structure containing a single number field
can be converted to a number by first casting it to a string and then the resulting string to a number.
| Tip |
|---|
Casting a structure to a string is equivalent to casting to a string [] and then the resulting array to string. |
Calling routines
When calling a routine or UDR, if the given parameter's type is not the same as what the routine is expecting, the conversion will be done automatically according to the rules above| Code Block |
|---|
// Simple structure with a single numeric value
struct Temperature {
number value;
}
// Create instance
Temperature temp = { 25.5 };
// GOAL: Convert the structure to a number
// Invalid: Direct conversion
// number n = temp; // Error: Cannot convert structure to number
// Valid: Multi-step conversion
string tempStr = temp; // Step 1: Structure to string ("25.5")
number tempValue = tempStr; // Step 2: String to number (25.5)
// Alternative using array
string[] tempArray = temp; // Step 1: Structure to string array (["25.5"])
number tempValue2 = tempArray[0];// Step 2: First array element to number (25.5)
// Using explicit casts (more verbose but clearer)
number explicitValue = (number)((string)temp); |
Automatic Parameter Type Conversion
When calling functions (routines or UDRs), parameters are automatically converted to match the function’s expected parameter types, following the standard type conversion rules.
| Code Block |
|---|
function f(string s){
print(s);
}
f(2); //number automatically converted to string
f(true); // boolean automatically converted to string |
| Info |
|---|
CompatibilityThese conversions cover the functionality implemented before v2.5, so they are backwards compatible. |
Contents
toc