Data Types in DI#

The DI# language implements several methods allowing for easy manipulation of the basic data types (string, int, etc.).

In DI#, every manipulated value has a data type which determines: 

• the possible operations
• the available methods
• how the value can be displayed or compared

Understanding data types helps avoid common errors and write more robust and maintainable DI# code.

In order to be compatible with projects or relational tables that include nullable fields, some of the data types allow for null values. However, we strongly advise against using nullable types in your code, in order to reduce the risks of execution error. 

Note: For certain data types (int, decimal, datetime) the DI# language allows values larger than what is supported by the database, meaning that it's possible to create a variable containing a value that cannot be stored in a database field of the same type as the variable. Refer to the projects and relational tables documentation to make sure of what the database limits are. 

// Examples for each type  
string a = "text"; 
int b = 1; 
decimal c = 1.234; 
datetime d1 = 2016.01.01 12:34:56; 
datetime d2 = 2016.01.01; 
bool e = true; // or false or null 
timespan g = 2.25; // 2 days 6 hours 
datasource h = {1, 2, 3}; 	

Text (string)

A Unicode character string, each character is stored using 2 bytes. The string is delimited by quoting marks (").
Inside a string the symbol \ is used to escape when using special characters such as (\r) for carriage returns or (\n) for line breaks.

// Examples
[[  
string MyText = "this IS a character string ";  
MyText.Length; // Returns the number 28 
MyText.Capitalize (true); // Returns "This IS A Character String "  
MyText.Capitalize(); // or MyText.Capitalize(false); // Return the string: "This IS a character string "  
MyText.IndexOf("s"); // Returns the number 3  
MyText.LastIndexOf("s"); // Returns the number 20  
MyText.Left(12); // Returns the string: "This IS a ch"  
MyText.Right(12); // Returns the string: "cter string "  
MyText.Replace("character", "test");  
// Returns the string: "this IS a test string "  
MyText.Substring(12); // Returns "aracter string "  
MyText.Substring(12, 3); // Returns "ara"  
MyText.ToLower();  
// Returns "this is a character string "
MyText.ToUpper();  
// Returns the "THIS IS A CHARACTER STRING "  
MyText.Trim(); // Return "This IS a character string"  
]]

Note that based on the data type of the value returned by these methods and properties, you can chain other methods and properties. 

[[  
string MyTexte = "this is a CHARACTER string ";  
MonTexte.Trim() .Replace ("CHARACTER", "test") .Capitalize(); 
// Returns "this is a CHARACTER string"  
]]

Integer (int)

A 32 bits integer number between -2 147 483 648 and 2 147 483 647.

Decimal Number (decimal)

High precision floating point numbers (28-29 significant digits). Values range from (-7.9x10²⁸)/(100²⁸) to (7.9x10²⁸)/(100²⁸). 

Date and Time (datetime)

Specifies a date with the following formats:

• aaaa.MM.jj HH:mm:ss

• aaaa.MM.jj HH:mm

• aaaa.MM.jj

Note that it is not a string: a date must not be inside quotes. For the the time, it can be omited. The seconds can be omited too. If you don't specify the secondes, the value will be 0 seconds.

[[  
datetime MyDate = 2016.01.01 12:34:56;  
MyDate.AddYears (3); // Returns 2019-01-01 12:34:56  
MyDate.AddMonths (3); // Returns 2016-04-01 12:34:56  
MyDate.AddDays (3); // Returns 2016-01-04 12:34:56  
MyDate.AddHours (3); // Returns 2016-01-01 15:34:56  
MyDate.AddMinutes (3); // Returns 2016-01-01 12:37:56  
MyDate.AddSeconds (3); // Returns 2016-01-01 12:34:59  
MyDate.DateDiff ("2014.03.03").Days; // Returns 669  
MyDate.isDST (); // Returns False  
MyDate.ToString (); // Returns 2016.01.01 12:34:56  
MyDate.ToString ("d/M/yyyy HH:mm:ss"); // Returns "1-1-2016 12:34:56"  
MyDate.ToString ("F"); // Returns "1 January 2016 12:34:56"  
MyDate.ToString ("ddd, dd MMM yyyy HH':'mm':'ss 'GMT' ");  
// Returns "Friday., 1 January. 2016 12:34:56 GMT"  
MyDate.Date; // Returns 2016-01-01 00:00:00  
MyDate.Day; // Returnn 1  
MyDate.DayOfWeek; // Returns 5  
MyDate.DayOfYear; // Returns 1  
MyDate.Hour; // Returns 12  
MyDate.Minute; // Returns 34  
MyDate.Month; // Returns 1  
MyDate.Second; // Returns 56  
MyDate.Ticks; // Returns 635872484960000000  
MyDate.Year; // Returns 2016  
]]

Boolean (bool)

A boolean value can be either TRUE or FALSE.

Date and Time (timespan)

Contrary to some other languages, timespan, in DI#, represents an amount of time, whether it's days, hours, minutes or seconds. This type exists primarily to perform operations datetime variables. Example: timespan t = date1 – date2 ; 

Note: To directly assign a timespan variable, you must specify a value corresponding to a number of days (for example, 2.25 if you want to represent 2 days and 6 hours) 

Data Source (datasource)

Any type of data listed in this grid, or any complex data type like arrays, lists, dictionaries, etc. (similar to the var data type in C#.

A DI# array is a container for one or more variables, associating keys with values in an ordered way. It can be used for simple lists, dictionaries, or more complex purposes like hash tables, queues and more. The value of an array element can be a single variable, a list or a multidimensional array. The data type of each element in an array can be fixed or dynamic (the same way List<datatype> works in any .NET language).

datasource myArray = { 1, 2, 3, "abc", "def" };

datasource myDictionary = { FristName : "John", LastName : "Smith", Age : 30 };

// An element's value is an expression, which itself can contain other expressions like in
 this example
datasource myArray =  
{  
    { FirstName : "Jean", LastName : "Tremblay", Age : 40 },  
    { FirstName : "John", LastName : "Smith", Age : 30 }  
}; 

string a[] = {"text1", "text2", "text3"};  
int b[] = {1, 2, 3};  
decimal c[] = {1.111, 2.222, 3.333};  
datetime d[] = {2016.01.01 01:01:01, 2016.02.02 02:02:02, 2016.03.03 
03:03:03};  
bool e[] = {true, false, null};  
timespan g[] = {1472500, 1472500};  
datasource h[] = {123, "texte1", 1.111, 2016.01.01 01:01:01, true};

// You can assign inital values when declaring the array.
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
string b[] = { "texte 1", "test", "abc" };

// Let's suppose the following data source:
[[  
datasource Vehicules =  
{  
{ Brand: "Toyota", Model: "Sienna", Year: 2015},  
{ Brand: "Ford", Model: "Fusion", Year: 2013},  
{ Brand: "Chevrolet", Model: "Equinox", Year: 2005 },  
{ Brand: "Hyundai", Model: "Accent", Year: 2016 },    
{ Brand: "Mazda", Model: "CX-5", Year: 2015 },  
{ Brand: "Hyundai", Model: "Accent", Year: 2010 },
};  
]] 

// To select the brands of all the vehicle:
[[  
datasource Brands =  select car.Brand  
                      from car in Vehicules;  
/* The resulting Brands object would contain:  
Toyota  
Ford  
Chevrolet  
Hyundai  
Mazda  
Hyundai  
*/  
]] 

// To select the unique brands (without duplicates) of all the vehicle
[[  
datasource Brands =  select distinct car.Brand
                      from car in Vehicules;  
/* 
The resulting Brands object would contain:  
Toyota  
Ford  
Chevrolet  
Hyundai  
Mazda  
*/  
]]

// To select the unique brands of all the vehicles, from the most recent to the oldest: 

[[  
datasource Marques =  select distinct voiture.Marque  
                      from voiture in Vehicules  
                      order by (voiture.Annee desc);  
/*  
The resulting Brands object would contain:  
Hyundai  
Mazda  
Toyota  
Ford  
Chevrolet  
*/  
]]
 
// To select the unique brands of all the vehicles, from the most recent to the oldest,
 excluding those from before 2014 :
[[
 datasource Brands = select distinct car.Brand from car in Vehicles
 where (car.year > 2014) order by (car.Year desc);
 ]]
 /* The resulting Brands object would contain:
 Hyundai
 Mazda
 Toyota
*/
// Note that it's possible to clone an array by selecting all its items:
[[  
datasource VehiculesCopy =  select car from car in Vehicules;  
]]