A powerful Data transformation language similar to Pascal is included in all our ETL and Business automation tools.

It can be used with Calculation Transformation FunctionPackage Script Action or inside any text object

1. Declaring Variables

var                               // This starts a section of variables
LineTotal :      Integer;  // This defines an Integer variable called LineTotal
First, Second: String;     // This defines two variables to hold strings of text

Assigning Values to Variables

Variables are simply a name for a block of memory cells in main memory. If a value is assigned to a variable, that value must be of the same type as the variable and will be stored in the memory address designated by the variable name. The assignment statement is the semicolon-equal :=.

  • Variables must be declared at the beginning of the program, a procedure, or a function  
  • Variables must be initialized before they can be used.  
  • Variables can be reused as often as necessary. Their old value is simply overwritten by a new assignment.  


i : Integer:     { variable name is i, type is integer)
i := 10;        { valid integer number assigned to variable i }

2. Variable Types
Numeric Data Types
Type Storage size Range
Byte 1 0 to 255
ShortInt 1 -127 to 127
Word 2 0 to 65,535
SmallInt 2 -32,768 to 32,767
LongWord 4 0 to 4,294,967,295
Cardinal 4* 0 to 4,294,967,295
LongInt 4 -2,147,483,648 to 2,147,483,647
Integer 4* -2,147,483,648 to 2,147,483,647
Int64 8 -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
Single 4 7  significant digits, exponent   -38 to +38
Currency 8 50+ significant digits, fixed 4 decimal places
Double 8 15  significant digits, exponent  -308 to +308
Extended 10 19  significant digits, exponent -4932 to +4932


Assigning to and from number variables

Number variables can be assigned from other numeric variables, and expressions:

Age       : Byte;       // Smallest positive integer type
Books    : SmallInt;   // Bigger signed integer
Salary         : Currency;   // Decimal used to hold financial amounts
Expenses    : Currency;
TakeHome : Currency;

Expenses      := 12345.67;  // Assign from a literal constant
TakeHome   := Salary;    // Assign from another variable
TakeHome   := TakeHome - Expenses;  // Assign from an expression


Numerical operators

Number calculations, or expressions, have a number of primitive operators available:

+       Add one number to another
-       Subtract one number from another
*       Multiply two numbers
/       Divide one decimal number by another
div     Divide one integer number by another
mod     Remainder from dividing one integer by another

When using these multiple operators in one expression, you should use round brackets to wrap around sub-expressions to ensure that the result is obtained. This is illustrated in the examples below:

myInt : Integer;  // Define integer and decimal variables
myDec : Single;

myInt := 20;           // myInt is now 20
myInt := myInt + 10;   // myInt is now 30
myInt := myInt - 5;    // myInt is now 25
myInt := myInt * 4;    // myInt is now 100
myInt := 14 div 3;     // myInt is now 4   (14 / 3 = 4 remainder 2)
myInt := 14 mod 3;     // myInt is now 2   (14 / 3 = 4 remainder 2)
myInt := 12 * 3 - 4;   // myInt is now 32  (* comes before -)
myInt := 12 * (3 - 4); // myInt is now -12 (brackets come before *)
myDec := 2.222 / 2.0;  // myDec is now 1.111
Character Types

Str1 : Char;            // Holds a single character, small alphabet
Str2 : WideChar;        // Holds a single character, International alphabet
Str3 : AnsiChar;        // Holds a single character, small alphabet
Str4 : ShortString;     // Holds a string of up to 255 Char's
Str5 : String;          // Holds strings of Char's of any size desired
Str6 : AnsiString;      // Holds strings of AnsiChar's any size desired
Str7 : WideString;      // Holds strings of WideChar's of any size desired

Some simple text variable usage examples are given below:

+       Concatenates two strings together
=       Compares for string equality
<       Is one string lower in sequence than another
<=     Is one string lower or equal in sequence with another
>       Is one string greater in sequence than another
>=    Is one string greater or equal in sequence with another
<>    Compares for string inequality


The Variant data type provides a flexible general-purpose data type.

It can hold anything but structured data and pointers.

Variants are useful in very specific circumstances, where data types and their content are determined at run time rather than at compile time.


myVar : Variant;

Date Variables



The TDateTime type holds a date and time value.

It is stored as a Double variable, with the date as an integral part, and time as a fractional part. The date is stored as the number of days since 30 Dec 1899. Quite why it is not 31 Dec is not clear. 01 Jan 1900 has a days value of 2.

Because TDateTime is actually a double, you can perform calculations on it as if it were a number. This is useful for calculations such as the difference between two dates.


No local time information is held with TDateTime - just the day and time values.


Finding the difference between two dates

day1, day2 : TDateTime;
diff : Double;
day1 := StrToDate('12/06/2002');
day2 := StrToDate('12/07/2002');
diff := day2 - day1;
Result:='day2 - day1 = '+FloatToStr(diff)+' days';

day2 - day1 = 30 days

Logical data types

These are used in conjunction with programming logic. They are very simple:

Log1 : Boolean;     // Can be 'True' or 'False'

Boolean variables are a form of the enumerated type. This means that they can hold one of a fixed number of values, designated by name. Here, the values can be True or False.

Next: Logical Operations