Introduction to MQL4 Datetime and Integer Representations
In algorithmic trading with MetaTrader 4, managing time data is fundamental for various operations, from calculating bar durations to setting order expiry times. MQL4 provides the datetime data type specifically for handling date and time values. While intuitive for human readability, performing arithmetic or comparisons across systems or data storage often necessitates a different representation.
This is where converting datetime values into an integer format becomes crucial. Integers offer a universal, easily comparable format that simplifies calculations and storage, especially when dealing with large datasets or cross-platform compatibility concerns.
Understanding the MQL4 Datetime Format
The datetime type in MQL4 is an alias for the long integer type. However, when a variable is declared as datetime, the MQL4 compiler and runtime environment treat it specially. It represents the number of seconds that have elapsed since midnight, January 1, 1970, Coordinated Universal Time (UTC). This is the well-known Unix timestamp format.
When you initialize or assign a value to a datetime variable using a date/time literal (e.g., D'2023.10.27 10:30:00'), the MQL4 engine converts this literal into its corresponding Unix timestamp integer value. Functions returning time, like TimeCurrent(), Time[0], Time[i], also return this integer representation directly, albeit typed as datetime.
Why Convert Datetime to Integer?
While datetime variables implicitly hold an integer value, explicit conversion or understanding this underlying integer is beneficial for several reasons:
- Arithmetic Operations: Subtracting one
datetimefrom another directly yields the time difference in seconds, an integer. Working directly with the integer value can make calculations clearer. - Data Storage and Transfer: When saving time data to files, external databases, or sending it over networks, integer timestamps are often more efficient and standardized than formatted strings.
- Comparisons: Comparing two integer timestamps is a straightforward numerical comparison, faster and less prone to locale issues than comparing formatted strings.
- Compatibility: Unix timestamps are a widely adopted standard, facilitating integration with other systems or languages.
- Hashing/Indexing: Integer representations are ideal for use as keys in hash tables or indices in arrays where time is a primary identifier.
Overview of Integer Time Representation (Unix Timestamp)
The integer representation of time in MQL4 is, as mentioned, the Unix timestamp. This is a 32-bit (or 64-bit in MQL5’s long) signed integer representing the number of seconds that have elapsed since 00:00:00 UTC on Thursday, 1 January 1970. This epoch is the standard reference point.
Each increment of the integer value corresponds to one second passing. This provides a linear, absolute measure of time that is independent of time zones (though the value stored typically refers to a specific time zone depending on the source function, e.g., broker time or local time) and daylight saving time rules, making it highly reliable for internal calculations and comparisons.
Methods for Converting MQL4 Datetime to Integer
The primary methods in MQL4 leverage the fact that the datetime type is fundamentally an integer (long). Conversion is often implicit or involves type casting, rather than complex parsing.
Using the TimeCurrent() Function and Implicit Conversion
The TimeCurrent() function returns the current time on the broker’s server as a datetime type. Since datetime is an alias for long, you can directly assign the result of TimeCurrent() to an integer variable. The MQL4 compiler handles this implicit conversion seamlessly.
Similarly, time-related array functions like Time[0] (the open time of the current bar) or Time[i] (the open time of the i-th bar) return datetime, which can be implicitly converted to an integer.
Employing the StrToTime() Function for Specific Dates
If you have a date and time represented as a string (e.g., read from a file or input parameter), the StrToTime() function is the standard way to convert it into a datetime type. Once it’s a datetime, you can then use the implicit conversion method described above to get the integer value.
StrToTime() expects the string in a specific format: “YYYY.MM.DD HH:MM:SS”. If the time part is omitted, it defaults to “00:00:00”. If the date part is omitted, it uses the current date. The function returns 0 on failure.
Utilizing the datetime Variable Type Directly
Any variable declared as datetime already holds the Unix timestamp integer value. Accessing this variable in a context expecting an integer (like arithmetic operations or assignment to an integer type) performs the conversion automatically. No explicit cast is strictly needed in most MQL4 scenarios, though casting can sometimes improve code clarity.
For example, subtracting two datetime variables: datetime time1, time2; int difference = time1 - time2; The result difference will be an integer representing the number of seconds between time1 and time2.
Code Examples and Implementation
Let’s look at practical code examples demonstrating these conversion methods within typical MQL4 script or EA contexts.
Basic Conversion Example: Current Time to Integer
Getting the current server time as an integer is a common operation.
int OnInit()
{
// Get current server time as datetime
datetime currentTime_dt = TimeCurrent();
// Implicit conversion to integer (Unix timestamp)
int currentTime_int = currentTime_dt;
// Or more directly:
// int currentTime_int = TimeCurrent();
Print("Current Server Time (datetime): ", currentTime_dt);
Print("Current Server Time (integer): ", currentTime_int);
return(INIT_SUCCEEDED);
}
This example clearly shows that assigning a datetime variable (currentTime_dt) to an int variable (currentTime_int) performs the desired conversion. Accessing TimeCurrent() directly and assigning it to an int also works due to the underlying type.
Converting a Specific Date/Time String to Integer
Converting a specific date/time string involves StrToTime().
int OnInit()
{
string specificTimeString = "2024.01.15 12:00:00";
// Convert string to datetime
datetime specificTime_dt = StrToTime(specificTimeString);
// Check if conversion was successful
if (specificTime_dt > 0)
{
// Implicit conversion to integer
int specificTime_int = specificTime_dt;
Print("String: ", specificTimeString);
Print("Converted (dt):", specificTime_dt);
Print("Converted (int):", specificTime_int);
}
else
{
Print("Failed to convert string: ", specificTimeString);
}
return(INIT_SUCCEEDED);
}
Here, StrToTime() handles the parsing from the string format into the datetime (Unix timestamp) integer. We then implicitly convert the datetime result to an int.
Handling Potential Errors and Validating Conversions
The most common conversion that can fail is StrToTime(). It returns 0 if the input string format is incorrect or represents an invalid date/time. It’s crucial to check for this return value.
int OnInit()
{
string validString = "2025.05.20 09:30"; // Time part can be omitted (defaults to 00:00:00)
string invalidString = "Invalid Date";
string outOfRangeString = "1969.01.01 00:00:00"; // Before epoch
datetime time1_dt = StrToTime(validString);
datetime time2_dt = StrToTime(invalidString);
datetime time3_dt = StrToTime(outOfRangeString);
Print("Valid string ('", validString, "') conversion result: ", time1_dt);
Print("Invalid string ('", invalidString, "') conversion result: ", time2_dt);
Print("Out of range string ('", outOfRangeString, "') conversion result: ", time3_dt);
// For StrToTime, a result of 0 indicates failure or epoch start.
// Need context or validation if 1970.01.01 00:00:00 UTC is a possible valid input.
if (time2_dt == 0)
{
Print("Conversion of invalidString failed as expected.");
}
// Check out-of-range date results in 0
if (time3_dt == 0)
{
Print("Conversion of outOfRangeString failed as expected.");
}
return(INIT_SUCCEEDED);
}
When converting datetime variables from functions like TimeCurrent() or array access (Time[i]), the conversion itself is reliable, assuming the input datetime value is valid. The potential issue is with the source of the datetime value (e.g., an invalid time retrieved from somewhere).
Practical Applications of Integer Time in MQL4
Working with time as an integer opens up various possibilities within Expert Advisors, indicators, and scripts.
Calculating Time Differences Using Integer Representation
As noted, subtracting two datetime variables directly yields the difference in seconds as an integer. This is incredibly useful for calculating durations, checking time elapsed since an event, or determining intervals.
void OnTick()
{
static datetime lastTickTime = 0; // Static retains value across calls
datetime currentTickTime = TimeCurrent();
// Calculate difference in seconds (integer)
int timeDifferenceSeconds = currentTickTime - lastTickTime;
if (lastTickTime != 0) // Avoid calculation on the very first tick
{
Print("Time difference since last tick: ", timeDifferenceSeconds, " seconds.");
}
lastTickTime = currentTickTime;
}
This demonstrates how integer subtraction of datetime values provides a direct measure of time difference in seconds. This integer can then be easily converted to minutes (/ 60), hours (/ 3600), etc.
Storing and Retrieving Time Data in Custom Indicators/Expert Advisors
Integer timestamps are excellent for storing time-related states or historical data. You can store the timestamp of the last trade, the time an indicator line crossed a certain level, or the opening time of a specific bar for later retrieval and comparison.
Using global variables, file storage (FileWriteInteger), or even external storage, the integer format is efficient and avoids parsing overhead when reading the data back.
// Example: Saving the time of the last order operation
void OnOrderEvent()
{
// ... processing order event ...
int lastOperationTime_int = TimeCurrent(); // Get current time as integer
// Now you can save lastOperationTime_int to a file, global variable, etc.
// FileWriteInteger(handle, lastOperationTime_int);
Print("Last order operation time (int): ", lastOperationTime_int);
}
// Example: Retrieving saved time from a file
// int savedTime = FileReadInteger(handle);
// Now you can compare TimeCurrent() with savedTime
// if (TimeCurrent() > savedTime + 3600) // Check if over an hour has passed
// { /* ... */ }
Comparing Time Values Accurately
Comparing integer timestamps is a simple numerical comparison (>, <, ==, <=, >=). This is inherently accurate and avoids potential issues with comparing formatted strings or floating-point representations of time that might occur in other contexts.
void OnTick()
{
static datetime nextEventTime = 0;
// Example: Set next event 1 hour from now on initialization
if (nextEventTime == 0)
{
nextEventTime = TimeCurrent() + 3600; // 3600 seconds = 1 hour
}
// Compare current integer time with target integer time
if (TimeCurrent() >= nextEventTime)
{
Print("Event time reached!");
// Perform event action
// Set next event time
nextEventTime = TimeCurrent() + 3600; // Schedule next event 1 hour from now
}
}
Comparing TimeCurrent() (an integer timestamp) directly against nextEventTime (also an integer timestamp) is precise and reliable for scheduling or triggering logic based on time.
Advanced Techniques and Considerations
While the core conversion is straightforward, real-world applications might involve nuances.
Time Zone Considerations and Adjustments
MQL4’s TimeCurrent(), Time[i], and TimeTo* functions (like TimeToStruct) typically operate on the broker’s server time, which is effectively a fixed time zone relative to UTC. Functions like TimeLocal() provide the local computer’s time.
Unix timestamps are defined in UTC. However, the value you get from MQL4 functions like TimeCurrent() is the number of seconds from epoch to the specified time in the broker’s time zone, not UTC directly, unless the broker’s time zone is UTC+0. Be mindful of this when comparing timestamps obtained from different sources (e.g., broker time vs. local time vs. a truly UTC external source). If you need to work consistently in UTC, you might need to calculate the broker’s offset from UTC and adjust the timestamps accordingly.
MQL5 provides more explicit functions for handling UTC and local time, but in MQL4, you primarily deal with broker time unless you use TimeLocal().
Millisecond Precision and Integer Representation (If Applicable)
MQL4’s datetime type represents time with second precision. The underlying integer value counts seconds since the epoch.
MQL5, using the long type for datetime, inherently supports higher precision if provided by the platform or specific functions (e.g., some MQL5 functions can return millisecond Unix timestamps). However, in MQL4, you are limited to second precision.
If you require millisecond precision, you would typically need to handle this separately, potentially storing milliseconds in another variable or combining it with the second-based timestamp (e.g., timestamp_seconds * 1000 + milliseconds). This requires custom implementation and is not natively supported by the MQL4 datetime type itself.
Optimization Tips for Time Conversions
Converting datetime to integer in MQL4 is an extremely fast and efficient operation because it’s often just an implicit type cast of the underlying long value. There are rarely performance concerns related to the conversion itself when using TimeCurrent() or Time[i].
Performance considerations might arise when repeatedly calling StrToTime() on complex strings within performance-critical sections (like OnTick). While StrToTime() is optimized, parsing strings is generally slower than integer arithmetic. If you need to work with a fixed specific date/time repeatedly, convert the string to a datetime integer once (e.g., in OnInit()) and store the integer value in a variable for subsequent use.
Avoiding unnecessary calls to time functions within tight loops is a general optimization principle, but the conversion mechanism itself is highly optimized.