added timestamp types

Author: kerryjiang

src/SciSharp.MySQL.Replication/Events/LogEvent.cs

@@ -70,7 +70,8 @@ static LogEvent()
             DataTypes[(int)ColumnType.DATETIME_V2] = new DateTimeV2Type();
             DataTypes[(int)ColumnType.TIME] = new TimeType();
             DataTypes[(int)ColumnType.TIME_V2] = new TimeV2Type();
-            //DataTypes[(int)ColumnType.TIMESTAMP] = new TimestampType();
+            DataTypes[(int)ColumnType.TIMESTAMP] = new TimestampType();
+            DataTypes[(int)ColumnType.TIMESTAMP_V2] = new TimestampV2Type();
             DataTypes[(int)ColumnType.ENUM] = new EnumType();
             DataTypes[(int)ColumnType.SET] = new SetType();
         }

src/SciSharp.MySQL.Replication/Types/TimestampType.cs

@@ -13,6 +13,9 @@ namespace SciSharp.MySQL.Replication.Types
     /// </remarks>
     class TimestampType : IMySQLDataType
     {
+        // Unix epoch start for MySQL TIMESTAMP (1970-01-01 00:00:00 UTC)
+        private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
         /// <summary>
         /// Reads a TIMESTAMP value from the binary log.
         /// </summary>
@@ -21,7 +24,29 @@ class TimestampType : IMySQLDataType
         /// <returns>A DateTime object representing the MySQL TIMESTAMP value.</returns>
         public object ReadValue(ref SequenceReader<byte> reader, ColumnMetadata columnMetadata)
         {
-            return new DateTime(reader.ReadLong(4) * 1000);
+            // MySQL TIMESTAMP is stored as a 4-byte integer 
+            // representing seconds since Unix epoch (1970-01-01 00:00:00 UTC)
+            
+            // Read the 4 bytes as a 32-bit unsigned integer
+            uint secondsSinceEpoch = 0;
+            
+            // Read each byte individually
+            reader.TryRead(out byte b0);
+            reader.TryRead(out byte b1);
+            reader.TryRead(out byte b2);
+            reader.TryRead(out byte b3);
+            
+            // Combine bytes to form the 32-bit unsigned int (big-endian)
+            secondsSinceEpoch = ((uint)b0 << 24) | 
+                                ((uint)b1 << 16) | 
+                                ((uint)b2 << 8) | 
+                                b3;
+            
+            // Convert Unix timestamp to DateTime
+            // MySQL stores TIMESTAMP in UTC, so we return it as UTC DateTime
+            DateTime timestamp = UnixEpoch.AddSeconds(secondsSinceEpoch);
+            
+            return timestamp;
         }
     }
 }

src/SciSharp.MySQL.Replication/Types/TimestampV2Type.cs

@@ -11,8 +11,24 @@ namespace SciSharp.MySQL.Replication.Types
     /// <remarks>
     /// Handles the reading and conversion of MySQL TIMESTAMP values with fractional seconds.
     /// </remarks>
-    class TimestampV2Type : TimeBaseType, IMySQLDataType
+    class TimestampV2Type : TimeBaseType, IMySQLDataType, IColumnMetadataLoader
     {
+        // Unix epoch start for MySQL TIMESTAMP (1970-01-01 00:00:00 UTC)
+        private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+        /// <summary>
+        /// Loads metadata for TIMESTAMP2 type.
+        /// </summary>
+        /// <param name="columnMetadata">The column metadata object.</param>
+        public void LoadMetadataValue(ColumnMetadata columnMetadata)
+        {
+            // For TIMESTAMP2, the metadata value represents the fractional seconds precision (0-6)
+            columnMetadata.Options = new TimestampV2Options
+            {
+                FractionalSecondsPrecision = columnMetadata.MetadataValue[0]
+            };
+        }
+
         /// <summary>
         /// Reads a TIMESTAMP2 value from the binary log.
         /// </summary>
@@ -21,11 +37,56 @@ class TimestampV2Type : TimeBaseType, IMySQLDataType
         /// <returns>A DateTime object representing the MySQL TIMESTAMP2 value.</returns>
         public object ReadValue(ref SequenceReader<byte> reader, ColumnMetadata columnMetadata)
         {
-            int meta = columnMetadata.MetadataValue[0];
-            var millis = (long)reader.ReadBigEndianInteger(4);
-            var fsp = ReadFractionalSeconds(ref reader, meta);
-            var ticks = millis * 1000 + fsp / 1000;
-            return new DateTime(ticks);
+            // Get the precision from metadata
+            int fsp = columnMetadata.Options is TimestampV2Options options ? 
+                options.FractionalSecondsPrecision : 0;
+
+            // Read the 4-byte seconds part (big-endian integer representing seconds since Unix epoch)
+            byte b0, b1, b2, b3;
+            reader.TryRead(out b0);
+            reader.TryRead(out b1);
+            reader.TryRead(out b2);
+            reader.TryRead(out b3);
+            
+            uint secondsSinceEpoch = ((uint)b0 << 24) | ((uint)b1 << 16) | ((uint)b2 << 8) | b3;
+            
+            // Start with the base DateTime (seconds part)
+            DateTime timestamp = UnixEpoch.AddSeconds(secondsSinceEpoch);
+
+            // Read fractional seconds if precision > 0
+            if (fsp > 0)
+            {
+                int fractionalValue = ReadFractionalSeconds(ref reader, fsp);
+                
+                // Calculate microseconds
+                int microseconds = 0;
+                switch (fsp)
+                {
+                    case 1: microseconds = fractionalValue * 100000; break;
+                    case 2: microseconds = fractionalValue * 10000; break;
+                    case 3: microseconds = fractionalValue * 1000; break;
+                    case 4: microseconds = fractionalValue * 100; break;
+                    case 5: microseconds = fractionalValue * 10; break;
+                    case 6: microseconds = fractionalValue; break;
+                }
+                
+                // Add microsecond precision to the DateTime
+                // 1 tick = 100 nanoseconds, 1 microsecond = 10 ticks
+                timestamp = timestamp.AddTicks(microseconds * 10);
+            }
+            
+            return timestamp;
         }
     }
+
+    /// <summary>
+    /// Options specific to TIMESTAMP2 data type.
+    /// </summary>
+    class TimestampV2Options
+    {
+        /// <summary>
+        /// Gets or sets the precision of fractional seconds (0-6).
+        /// </summary>
+        public int FractionalSecondsPrecision { get; set; }
+    }
 }

tests/Test/DataTypesTest.cs

@@ -149,7 +149,7 @@ await TestDataType<TimeSpan>("time_table", currentValue, currentValue.Add(new Ti
             });
         }
 
-        //[Fact]
+        [Fact]
         public async Task TestTimestampType()
         {
             var currentValue = DateTime.UtcNow;