Refactor Parsing

Improve MySql parsing

Author: Mimetis

Projects/Dotmim.Sync.Core/Dotmim.Sync.Core.csproj

@@ -19,7 +19,7 @@
 		<VersionSuffix>$(VersionSuffix)</VersionSuffix>
 		<Version>0.9.2</Version>
 		<Version Condition=" '$(VersionSuffix)' != '' ">$(Version)-$(VersionSuffix)</Version>
-		<LangVersion>8.0</LangVersion>
+		<LangVersion>9.0</LangVersion>
 		<ApplicationIcon>favicon.ico</ApplicationIcon>
 		<PackageIcon>packageIcon.png</PackageIcon>
 		<PublishRepositoryUrl>true</PublishRepositoryUrl>

Projects/Dotmim.Sync.Core/Manager/DbMetadata.cs

@@ -8,176 +8,58 @@ namespace Dotmim.Sync.Manager
 {
     public abstract class DbMetadata
     {
+
         /// <summary>
         /// Validate if a column definition is actualy supported by the provider
         /// </summary>
         public abstract bool IsValid(SyncColumn columnDefinition);
 
         /// <summary>
-        /// Get the datastore type name from a DbType for generating scripts
-        /// </summary>
-        public abstract string GetStringFromDbType(DbType dbType, int maxLength);
-
-        /// <summary>
-        /// Get the datastore type name from a provider dbType for generating scripts
-        /// </summary>
-        public abstract string GetStringFromOwnerDbType(object ownerType);
-
-        /// <summary>
-        /// Get the datastore precision / scale / length string for generating scripts
-        /// </summary>
-        public abstract string GetPrecisionStringFromDbType(DbType dbType, int maxLength, byte precision, byte scale);
-
-        /// <summary>
-        /// Get the datastore precision / scale / length string for generating scripts
-        /// </summary>
-        public abstract string GetPrecisionStringFromOwnerDbType(object dbType, int maxLength, byte precision, byte scale);
-
-        /// <summary>
-        /// Get the datastore precision / scale / length for DbParameter
-        /// </summary>
-        public abstract (byte precision, byte scale) GetPrecisionFromOwnerDbType(object dbType, byte precision, byte scale);
-
-        /// <summary>
-        /// Get the datastore precision / scale for DbParameter
-        /// </summary>
-        public abstract (byte precision, byte scale) GetPrecisionFromDbType(DbType dbType, byte precision, byte scale);
-
-        /// <summary>
-        /// Get the datastore MaxLength for DbParameter
+        /// Gets and validate a max length issued from the database definition
         /// </summary>
-        public abstract Int32 GetMaxLengthFromDbType(DbType dbType, Int32 maxLength);
+        public abstract int GetMaxLength(SyncColumn columnDefinition);
 
         /// <summary>
-        /// Get the datastore maxLength for DbParameter
+        /// Get the native datastore DbType (that's why we return object instead of SqlDbType or SqliteDbType or MySqlDbType)
         /// </summary>
-        public abstract Int32 GetMaxLengthFromOwnerDbType(object dbType, Int32 maxLength);
+        public abstract object GetOwnerDbType(SyncColumn columnDefinition);
 
         /// <summary>
         /// Get a DbType from a datastore type name
         /// </summary>
-        public abstract DbType ValidateDbType(string typeName, bool isUnsigned, bool isUnicode, long maxLength);
-
-        /// <summary>
-        /// Get a datastore DbType from a datastore type name
-        /// </summary>
-        public abstract object ValidateOwnerDbType(string typeName, bool isUnsigned, bool isUnicode, long maxLength);
+        public abstract DbType GetDbType(SyncColumn columnDefinition);
 
         /// <summary>
-        /// Gets and validate a max length issued from the database definition
-        /// </summary>
-        public abstract int ValidateMaxLength(string typeName, bool isUnsigned, bool isUnicode, long maxLength);
-
-        /// <summary>
-        /// Gets the corresponding DbType from a owner dbtype
-        /// </summary>
-        public abstract object GetOwnerDbTypeFromDbType(DbType dbType);
-
-        /// <summary>
-        /// Get a managed type from a datastore dbType
+        /// Validate if a column is readonly or not
         /// </summary>
-        public abstract Type ValidateType(object ownerType);
+        /// <param name="columnDefinition"></param>
+        /// <returns></returns>
+        public abstract bool IsReadonly(SyncColumn columnDefinition);
 
         /// <summary>
         /// Check if a type name is a numeric type
         /// </summary>
-        public abstract bool IsNumericType(string typeName);
-
-        /// <summary>
-        /// Check if a type name is a text type
-        /// </summary>
-        public abstract bool IsTextType(string typeName);
+        public abstract bool IsNumericType(SyncColumn columnDefinition);
 
         /// <summary>
         /// Check if a type name support scale
         /// </summary>
-        public abstract bool SupportScale(string typeName);
+        public abstract bool IsSupportingScale(SyncColumn columnDefinition);
 
         /// <summary>
         /// Get precision and scale from a SchemaColumn
         /// </summary>
-        public abstract (byte precision, byte scale) ValidatePrecisionAndScale(SyncColumn columnDefinition);
+        public abstract (byte precision, byte scale) GetPrecisionAndScale(SyncColumn columnDefinition);
 
         /// <summary>
         /// Get precision if supported (MySql supports int(10))
         /// </summary>
-        public abstract byte ValidatePrecision(SyncColumn columnDefinition);
-
-
-        /// <summary>
-        /// Validate if a column is readonly or not
-        /// </summary>
-        /// <param name="columnDefinition"></param>
-        /// <returns></returns>
-        public abstract bool ValidateIsReadonly(SyncColumn columnDefinition);
+        public abstract byte GetPrecision(SyncColumn columnDefinition);
 
         /// <summary>
-        /// Returns the corresponding Owner DbType. Because it could be lower case, we should handle it
+        /// Get a managed type from a datastore dbType
         /// </summary>
-        public object TryGetOwnerDbType(string ownerDbType, DbType fallbackDbType, bool isUnsigned, bool isUnicode, long maxLength, string fromProviderType, string ownerProviderType)
-        {
-            // We MUST check if we are from the same provider (if it's mysql or oracle, we fallback on dbtype
-            if (!string.IsNullOrEmpty(ownerDbType) && fromProviderType == ownerProviderType)
-                return ValidateOwnerDbType(ownerDbType, isUnsigned, isUnicode, maxLength);
-
-            // if it's not the same provider, fallback on DbType instead.
-            return GetOwnerDbTypeFromDbType(fallbackDbType);
-        }
-
-        public string TryGetOwnerDbTypeString(string originalDbType, DbType fallbackDbType, bool isUnsigned, bool isUnicode, long maxLength, string fromProviderType, string ownerProviderType)
-        {
-            // We MUST check if we are from the same provider (if it's mysql or oracle, we fallback on dbtype
-            if (!String.IsNullOrEmpty(originalDbType) && fromProviderType == ownerProviderType)
-            {
-                Object ownedDbType = ValidateOwnerDbType(originalDbType, isUnsigned, isUnicode, maxLength);
-                return GetStringFromOwnerDbType(ownedDbType);
-            }
-
-            // if it's not the same provider, fallback on DbType instead.
-            return GetStringFromDbType(fallbackDbType, Convert.ToInt32(maxLength));
-        }
-
-        public string TryGetOwnerDbTypePrecision(string originalDbType, DbType fallbackDbType, bool isUnsigned, bool isUnicode, int maxLength, byte precision, byte scale, string fromProviderType, string ownerProviderType)
-        {
-            // We MUST check if we are from the same provider (if it's mysql or oracle, we fallback on dbtype
-            if (!String.IsNullOrEmpty(originalDbType) && fromProviderType == ownerProviderType)
-            {
-                object ownedDbType = ValidateOwnerDbType(originalDbType, isUnsigned, isUnicode, maxLength);
-                return GetPrecisionStringFromOwnerDbType(ownedDbType, maxLength, precision, scale);
-            }
-
-            // if it's not the same provider, fallback on DbType instead.
-            return GetPrecisionStringFromDbType(fallbackDbType, maxLength, precision, scale);
-        }
-
-        public (byte precision, byte scale) TryGetOwnerPrecisionAndScale(string originalDbType, DbType fallbackDbType, bool isUnsigned, bool isUnicode, long maxLength, byte precision, byte scale, string fromProviderType, string ownerProviderType)
-        {
-            // We MUST check if we are from the same provider (if it's mysql or oracle, we fallback on dbtype
-            if (!String.IsNullOrEmpty(originalDbType) && fromProviderType == ownerProviderType)
-            {
-                Object ownedDbType = ValidateOwnerDbType(originalDbType, isUnsigned, isUnicode, maxLength);
-                return GetPrecisionFromOwnerDbType(ownedDbType, precision, scale);
-            }
-
-            // if it's not the same provider, fallback on DbType instead.
-            return GetPrecisionFromDbType(fallbackDbType, precision, scale);
-
-        }
-
-        public int TryGetOwnerMaxLength(string originalDbType, DbType fallbackDbType, bool isUnsigned, bool isUnicode, int maxLength, string fromProviderType, string ownerProviderType)
-        {
-            // We MUST check if we are from the same provider (if it's mysql or oracle, we fallback on dbtype
-            if (!String.IsNullOrEmpty(originalDbType) && fromProviderType == ownerProviderType)
-            {
-                Object ownedDbType = ValidateOwnerDbType(originalDbType, isUnsigned, isUnicode, maxLength);
-                return GetMaxLengthFromOwnerDbType(ownedDbType, maxLength);
-            }
-
-            // if it's not the same provider, fallback on DbType instead.
-            return GetMaxLengthFromDbType(fallbackDbType, maxLength);
-
-        }
-
+        public abstract Type GetType(SyncColumn columnDefinition);
 
     }
 }

Projects/Dotmim.Sync.Core/Orchestrators/BaseOrchestrator.Schema.cs

@@ -155,7 +155,6 @@ private void FillSyncTableWithColumns(SetupTable setupTable, SyncTable schemaTab
             if (schemaTable.Columns.Count > 0)
                 schemaTable.Columns.Clear();
 
-
             IEnumerable<SyncColumn> lstColumns;
 
             // Validate columns list from setup table if any
@@ -184,7 +183,7 @@ private void FillSyncTableWithColumns(SetupTable setupTable, SyncTable schemaTab
             {
                 // First of all validate if the column is currently supported
                 if (!this.Provider.GetMetadata().IsValid(column))
-                    throw new UnsupportedColumnTypeException(column.ColumnName, column.OriginalTypeName, this.Provider.GetProviderTypeName());
+                    throw new UnsupportedColumnTypeException(setupTable.GetFullName(), column.ColumnName, column.OriginalTypeName, this.Provider.GetProviderTypeName()); ;
 
                 var columnNameLower = column.ColumnName.ToLowerInvariant();
                 if (columnNameLower == "sync_scope_id"
@@ -197,62 +196,58 @@ private void FillSyncTableWithColumns(SetupTable setupTable, SyncTable schemaTab
                     || columnNameLower == "sync_timestamp"
                     || columnNameLower == "sync_row_is_tombstone"
                     )
-                    throw new UnsupportedColumnNameException(column.ColumnName, column.OriginalTypeName, this.Provider.GetProviderTypeName());
-
-                // Validate max length
-                column.MaxLength = this.Provider.GetMetadata().ValidateMaxLength(column.OriginalTypeName, column.IsUnsigned, column.IsUnicode, column.MaxLength);
-
-                // Gets the datastore owner dbType (could be SqlDbtype, MySqlDbType, SqliteDbType, NpgsqlDbType & so on ...)
-                var datastoreDbType = this.Provider.GetMetadata().ValidateOwnerDbType(column.OriginalTypeName, column.IsUnsigned, column.IsUnicode, column.MaxLength);
-
-                // once we have the datastore type, we can have the managed type
-                var columnType = this.Provider.GetMetadata().ValidateType(datastoreDbType);
+                    throw new UnsupportedColumnNameException(setupTable.GetFullName(), column.ColumnName, column.OriginalTypeName, this.Provider.GetProviderTypeName()); ;
 
-                // Set the correct type
-                column.SetType(columnType);
-
-                // and the DbType
-                column.DbType = (int)this.Provider.GetMetadata().ValidateDbType(column.OriginalTypeName, column.IsUnsigned, column.IsUnicode, column.MaxLength);
+                // Gets the max length
+                column.MaxLength = this.Provider.GetMetadata().GetMaxLength(column);
 
                 // Gets the owner dbtype (SqlDbType, OracleDbType, MySqlDbType, NpsqlDbType & so on ...)
                 // Sqlite does not have it's own type, so it's DbType too
-                column.OriginalDbType = datastoreDbType.ToString();
+                column.OriginalDbType = this.Provider.GetMetadata().GetOwnerDbType(column).ToString();
+
+                // get the downgraded DbType
+                column.DbType = (int)this.Provider.GetMetadata().GetDbType(column);
 
-                // Validate if column should be readonly
-                column.IsReadOnly = this.Provider.GetMetadata().ValidateIsReadonly(column);
+                // Gets the column readonly's propertye
+                column.IsReadOnly = this.Provider.GetMetadata().IsReadonly(column);
 
                 // set position ordinal
                 column.Ordinal = ordinal;
                 ordinal++;
 
                 // Validate the precision and scale properties
-                if (this.Provider.GetMetadata().IsNumericType(column.OriginalTypeName))
+                if (this.Provider.GetMetadata().IsNumericType(column))
                 {
-                    if (this.Provider.GetMetadata().SupportScale(column.OriginalTypeName))
+                    if (this.Provider.GetMetadata().IsSupportingScale(column))
                     {
-                        var (p, s) = this.Provider.GetMetadata().ValidatePrecisionAndScale(column);
+                        var (p, s) = this.Provider.GetMetadata().GetPrecisionAndScale(column);
                         column.Precision = p;
                         column.PrecisionSpecified = true;
                         column.Scale = s;
                         column.ScaleSpecified = true;
                     }
                     else
                     {
-                        column.Precision = this.Provider.GetMetadata().ValidatePrecision(column);
+                        column.Precision = this.Provider.GetMetadata().GetPrecision(column);
                         column.PrecisionSpecified = true;
                         column.ScaleSpecified = false;
                     }
 
                 }
 
+                // Get the managed type
+                // Important to set it at the end, because we are altering column.DataType here
+                column.SetType(this.Provider.GetMetadata().GetType(column));
+
                 // if setup table has no columns, we add all columns from db
                 // otherwise check if columns exist in the data source
                 if (setupTable.Columns == null || setupTable.Columns.Count <= 0 || setupTable.Columns.Contains(column.ColumnName))
                     schemaTable.Columns.Add(column);
+
                 // If column does not allow null value and is not compute
                 // We will not be able to insert a row, so raise an error
                 else if (!column.AllowDBNull && !column.IsCompute && !column.IsReadOnly && string.IsNullOrEmpty(column.DefaultValue))
-                    throw new Exception($"Column {column.ColumnName} is not part of your setup. But it seems this columns is mandatory in your data source.");
+                    throw new Exception($"In table {setupTable.GetFullName()}, column {column.ColumnName} is not part of your setup. But it seems this columns is mandatory in your data source.");
 
             }
         }
@@ -284,7 +279,7 @@ private async Task SetPrimaryKeysAsync(SyncTable schemaTable, DbTableBuilder tab
                     || columnNameLower == "sync_row_is_tombstone"
                     || columnNameLower == "last_change_datetime"
                     )
-                    throw new UnsupportedPrimaryKeyColumnNameException(columnKey.ColumnName, columnKey.OriginalTypeName, this.Provider.GetProviderTypeName());
+                    throw new UnsupportedPrimaryKeyColumnNameException(schemaTable.GetFullName(), columnKey.ColumnName, columnKey.OriginalTypeName, this.Provider.GetProviderTypeName());
 
 
                 schemaTable.PrimaryKeys.Add(columnKey.ColumnName);

Projects/Dotmim.Sync.Core/Orchestrators/BaseOrchestrator.cs

@@ -188,7 +188,7 @@ internal void ReportProgress(SyncContext context, IProgress<ProgressArgs> progre
         /// <summary>
         /// Open a connection
         /// </summary>
-        [DebuggerStepThrough]
+        //[DebuggerStepThrough]
         internal async Task OpenConnectionAsync(DbConnection connection, CancellationToken cancellationToken)
         {
             // Make an interceptor when retrying to connect

Projects/Dotmim.Sync.Core/Set/SyncColumn.cs

@@ -78,6 +78,8 @@ public class SyncColumn : SyncNamedItem<SyncColumn>
         [DataMember(Name = "dv", IsRequired = false, EmitDefaultValue = false, Order = 21)]
         public string DefaultValue { get; set; }
 
+        [DataMember(Name = "ext1", IsRequired = false, EmitDefaultValue = false, Order = 22)]
+        public string ExtraProperty1 { get; set; }
 
 
 
@@ -140,6 +142,7 @@ public SyncColumn Clone()
             clone.Scale = this.Scale;
             clone.ScaleSpecified = this.ScaleSpecified;
             clone.DefaultValue = this.DefaultValue;
+            clone.ExtraProperty1 = this.ExtraProperty1;
             return clone;
         }
 
@@ -405,7 +408,8 @@ public override bool EqualsByProperties(SyncColumn column)
                string.Equals(this.OriginalDbType, column.OriginalDbType, sc) &&
                string.Equals(this.OriginalTypeName, column.OriginalTypeName, sc) &&
                this.DbType == column.DbType &&
-               string.Equals(this.DefaultValue, column.DefaultValue, sc);
+               string.Equals(this.DefaultValue, column.DefaultValue, sc) &&
+               string.Equals(this.ExtraProperty1, column.ExtraProperty1, sc);
 
         }