- fixed property naming

- fixed conversion and equality checks for nullable types

Author: fknx

DynamicLinqPadPostgreSqlDriver/DynamicPostgreSqlDriver.cs

@@ -10,7 +10,6 @@
 using System.IO;
 using LinqToDB.Data;
 using System.Data;
-using LinqToDB.Mapping;
 using DynamicLinqPadPostgreSqlDriver.Extensions;
 using DynamicLinqPadPostgreSqlDriver.UI;
 using DynamicLinqPadPostgreSqlDriver.Shared.Extensions;
@@ -163,9 +162,8 @@ private static TableData PrepareTableEntity(IConnectionInfo cxInfo, ModuleBuilde
          // add the table attribute to the class
          typeBuilder.AddTableAttribute(tableName);
 
-         var columnAttributeConstructor = typeof(ColumnAttribute).GetConstructor(new[] { typeof(string) });
-
          var query = SqlHelper.LoadSql("QueryColumns.sql");
+         var propertyAndFieldNames = new HashSet<string>();
 
          var columns = dbConnection.Query(query, new { DatabaseName = databaseName, TableName = tableName });
          foreach (var column in columns)
@@ -197,6 +195,7 @@ private static TableData PrepareTableEntity(IConnectionInfo cxInfo, ModuleBuilde
                }
 
                text = $"{columnName} ({fieldType.GetTypeName()})";
+               propertyAndFieldNames.Add(columnName);
             }
             else
             {
@@ -212,7 +211,7 @@ private static TableData PrepareTableEntity(IConnectionInfo cxInfo, ModuleBuilde
             tableExplorerItem.Children.Add(explorerItem);
          }
 
-         return new TableData(tableName, tableExplorerItem, typeBuilder);
+         return new TableData(tableName, tableExplorerItem, typeBuilder, propertyAndFieldNames);
       }
 
       private void BuildAssociations(IDbConnection connection, ICollection<TableData> preparedTables)

DynamicLinqPadPostgreSqlDriver/Entity.cs

@@ -1,4 +1,5 @@
-using LinqToDB;
+using DynamicLinqPadPostgreSqlDriver.Extensions;
+using LinqToDB;
 using LinqToDB.Mapping;
 using System;
 using System.Collections.Generic;
@@ -68,25 +69,36 @@ private QueryData<T> PrepareQuery<T>(string propertyName) where T : class
          if (otherKeyField == null)
             throw new Exception($"The key field (other) with column name '{association.OtherKey}' does not exist.");
 
+         var key = thisKeyField.GetValue(this);
+         if (key == null)
+            return null;
+
          // build query expression
          var parameter = Expression.Parameter(typeof(T));
          var fieldExpression = (Expression) Expression.Field(parameter, otherKeyField);
 
+         Expression fieldNotNullExpression = null;
+         if (otherKeyField.FieldType.IsNullable())
+         {
+            // check whether the field is null before a cast or comparioson
+            fieldNotNullExpression = Expression.NotEqual(fieldExpression, Expression.Constant(null, otherKeyField.FieldType));
+         }
+
          if (thisKeyField.FieldType != otherKeyField.FieldType)
          {
             // the types are not matching, so try to convert the expression
             fieldExpression = Expression.Convert(fieldExpression, thisKeyField.FieldType);
          }
 
-         var key = thisKeyField.GetValue(this);
-         if (key == null)
-            return null;
+         var keyExpression = Expression.Constant(key, thisKeyField.FieldType);
+         var equalExpression = Expression.Equal(fieldExpression, keyExpression);
 
-         var keyExpression = Expression.Constant(key);
-         var equalsExpression = Expression.Equal(fieldExpression, keyExpression);
+         var notNullAndEqualExpression = fieldNotNullExpression != null
+            ? Expression.AndAlso(fieldNotNullExpression, equalExpression)
+            : equalExpression;
 
          // create & compile query
-         return new QueryData<T>(dataContext, table, Expression.Lambda<Func<T, bool>>(equalsExpression, parameter).Compile());
+         return new QueryData<T>(dataContext, table, Expression.Lambda<Func<T, bool>>(notNullAndEqualExpression, parameter).Compile());
       }
 
       private FieldInfo GetFieldByColumnName(Type type, string columnName)

DynamicLinqPadPostgreSqlDriver/Extensions/TableDataExtensions.cs

@@ -13,7 +13,8 @@ public static string CreateOneToManyAssociation(this TableData table, TableData
          var typedEnumerableType = typeof(IEnumerable<>).MakeGenericType(table.TypeBuilder);
 
          // use the table's explorer item text as property name
-         var propertyName = table.ExplorerItem.Text;
+         var propertyName = foreignTable.FindFreePropertyName(table.ExplorerItem.Text);
+         foreignTable.PropertyAndFieldNames.Add(propertyName);
 
          // create a property in the foreign key's target table
          var property = foreignTable.TypeBuilder.DefineProperty(propertyName, typedEnumerableType);
@@ -51,7 +52,8 @@ public static string CreateOneToManyAssociation(this TableData table, TableData
       public static string CreateManyToOneAssociation(this TableData table, TableData foreignTable, string primaryKeyName, string foreignKeyName, bool backwardReference = false)
       {
          // use the foreign table's type name as property name
-         var propertyName = foreignTable.TypeBuilder.Name;
+         var propertyName = table.FindFreePropertyName(foreignTable.TypeBuilder.Name);
+         table.PropertyAndFieldNames.Add(propertyName);
 
          // create a property of the foreign table's type in the table entity
          var property = table.TypeBuilder.DefineProperty(propertyName, foreignTable.TypeBuilder);
@@ -82,5 +84,19 @@ public static string CreateManyToOneAssociation(this TableData table, TableData
 
          return property.Name;
       }
+
+      public static string FindFreePropertyName(this TableData tableData, string propertyName)
+      {
+         var originalPropertyName = propertyName;
+
+         // check for a naming collision
+         var i = 1;
+         while (tableData.PropertyAndFieldNames.Contains(propertyName))
+         {
+            propertyName = $"{originalPropertyName}{i++}";
+         }
+
+         return propertyName;
+      }
    }
 }

DynamicLinqPadPostgreSqlDriver/Extensions/TypeExtensions.cs

@@ -15,5 +15,23 @@ public static string GetTypeName(this Type type)
 
          return type.Name;
       }
+
+      /// <summary>
+      /// Checks whether the given <see cref="Type"/> is nullable.
+      /// 
+      /// Adopted from http://stackoverflow.com/a/374663
+      /// </summary>
+      /// <param name="type">The type which shall be checked.</param>
+      /// <returns><c>true</c> if the type is nullable, otherwise <c>false</c></returns>
+      public static bool IsNullable(this Type type)
+      {
+         if (!type.IsValueType)
+            return true; // ref-type
+
+         if (Nullable.GetUnderlyingType(type) != null)
+            return true; // Nullable<T>
+
+         return false; // value-type
+      }
    }
 }

DynamicLinqPadPostgreSqlDriver/TableData.cs

@@ -1,5 +1,6 @@
 using System.Reflection.Emit;
 using LINQPad.Extensibility.DataContext;
+using System.Collections.Generic;
 
 namespace DynamicLinqPadPostgreSqlDriver
 {
@@ -11,11 +12,15 @@ internal class TableData
 
       public TypeBuilder TypeBuilder { get; }
 
-      public TableData(string name, ExplorerItem explorerItem, TypeBuilder typeBuilder)
+      public ISet<string> PropertyAndFieldNames { get; }
+
+      public TableData(string name, ExplorerItem explorerItem, TypeBuilder typeBuilder, ISet<string> propertyAndFieldNames)
       {
          Name = name;
          ExplorerItem = explorerItem;
          TypeBuilder = typeBuilder;
+
+         PropertyAndFieldNames = propertyAndFieldNames;
       }
    }
 }