Merge pull request #77 from johelvisguzman/adonet

Fixed SQL Server Compact exception when performing a exists-trait for the ado-net repository

Author: johelvisguzman

src/DotNetToolkit.Repository.AdoNet/AdoNetRepositoryBase.cs

@@ -268,6 +268,32 @@ public IEnumerable<T> ExecuteList<T>(string cmdText, Func<DbDataReader, T> proje
             return ExecuteList<T>(cmdText, CommandType.Text, projector);
         }
 
+        /// <summary>
+        /// Executes the query, and returns a new <see cref="DataTable " />.
+        /// </summary>
+        /// <param name="cmdText">The command text.</param>
+        /// <param name="cmdType">The command type</param>
+        /// <param name="parameters">The command parameters</param>
+        /// <returns>A new <see cref="DataTable" />.</returns>
+        public DataTable ExecuteDataTable(string cmdText, CommandType cmdType, Dictionary<string, object> parameters = null)
+        {
+            using (var connection = CreateConnection())
+            {
+                return ExecuteDataTable(connection, cmdText, cmdType, parameters);
+            }
+        }
+
+        /// <summary>
+        /// Executes the query, and returns a new <see cref="DataTable " />.
+        /// </summary>
+        /// <param name="cmdText">The command text.</param>
+        /// <param name="parameters">The command parameters</param>
+        /// <returns>A new <see cref="DataTable" />.</returns>
+        public DataTable ExecuteDataTable(string cmdText, Dictionary<string, object> parameters = null)
+        {
+            return ExecuteDataTable(cmdText, CommandType.Text, parameters);
+        }
+
         /// <summary>
         /// Executes the query, and returns a new <see cref="Dictionary{TDictionaryKey, TElement}" /> according to the specified <paramref name="keyProjector" />, and <paramref name="elementProjector" />.
         /// </summary>
@@ -944,6 +970,42 @@ protected IEnumerable<T> ExecuteList<T>(DbConnection connection, string cmdText,
             return ExecuteList<T>(connection, cmdText, CommandType.Text, projector);
         }
 
+        /// <summary>
+        /// Executes the query, and returns a new <see cref="DataTable " />.
+        /// </summary>
+        /// <param name="connection">The connection.</param>
+        /// <param name="cmdText">The command text.</param>
+        /// <param name="cmdType">The command type</param>
+        /// <param name="parameters">The command parameters</param>
+        /// <returns>A new <see cref="DataTable" />.</returns>
+        protected virtual DataTable ExecuteDataTable(DbConnection connection, string cmdText, CommandType cmdType, Dictionary<string, object> parameters = null)
+        {
+            using (var adapter = Factory.CreateDataAdapter())
+            {
+                var command = CreateCommand(connection, cmdText, cmdType, parameters);
+
+                adapter.SelectCommand = command;
+
+                var table = new DataTable();
+
+                adapter.Fill(table);
+
+                return table;
+            }
+        }
+
+        /// <summary>
+        /// Executes the query, and returns a new <see cref="DataTable " />.
+        /// </summary>
+        /// <param name="connection">The connection.</param>
+        /// <param name="cmdText">The command text.</param>
+        /// <param name="parameters">The command parameters</param>
+        /// <returns>A new <see cref="DataTable" />.</returns>
+        protected DataTable ExecuteDataTable(DbConnection connection, string cmdText, Dictionary<string, object> parameters = null)
+        {
+            return ExecuteDataTable(connection, cmdText, CommandType.Text, parameters);
+        }
+
         /// <summary>
         /// Executes the query, and returns a new <see cref="Dictionary{TDictionaryKey, TElement}" /> according to the specified <paramref name="keyProjector" />, and <paramref name="elementProjector" />.
         /// </summary>
@@ -1350,7 +1412,7 @@ private void PrepareSelectStatement(IFetchStrategy<TEntity> fetchStrategy, out D
             var mainTablePrimaryKeyName = typeof(TEntity).GetPrimaryKeyPropertyInfo().GetColumnName();
 
             // Default select
-            var selectSql = string.Join(",\n\t",
+            var columns = string.Join(",\n\t",
                 SqlPropertiesMapping.Select(x =>
                 {
                     var colAlias = cfg.GenerateColumnAlias(x.Value);
@@ -1367,7 +1429,7 @@ private void PrepareSelectStatement(IFetchStrategy<TEntity> fetchStrategy, out D
                 // the same type as the primary table
                 // Only do a join when the primary table has a foreign key property for the join table
                 var paths = mainTableProperties
-                    .Where(x => x.IsComplex() && !string.IsNullOrEmpty(x.PropertyType.GetForeignKeyName(mainTableType)))
+                    .Where(x => x.IsComplex() && !string.IsNullOrEmpty(x.PropertyType.GetPrimaryKeyPropertyInfo()?.GetColumnName()))
                     .Select(x => x.Name)
                     .ToList();
 
@@ -1389,13 +1451,13 @@ private void PrepareSelectStatement(IFetchStrategy<TEntity> fetchStrategy, out D
             {
                 var joinStatementSb = new StringBuilder();
 
-                sb.Append($"SELECT\n\t{selectSql}");
+                sb.Append($"SELECT\n\t{columns}");
 
                 foreach (var path in fetchStrategy.IncludePaths)
                 {
                     var joinTablePropertyInfo = mainTableProperties.Single(x => x.Name.Equals(path));
                     var joinTableType = joinTablePropertyInfo.PropertyType;
-                    var joinTableForeignKeyName = joinTableType.GetForeignKeyName(mainTableType);
+                    var joinTableForeignKeyName = joinTableType.GetForeignKeyPropertyInfo(mainTableType)?.GetColumnName();
 
                     // Only do a join when the primary table has a foreign key property for the join table
                     if (!string.IsNullOrEmpty(joinTableForeignKeyName))
@@ -1430,7 +1492,7 @@ private void PrepareSelectStatement(IFetchStrategy<TEntity> fetchStrategy, out D
             }
             else
             {
-                sb.Append($"SELECT\n\t{selectSql}\nFROM [{TableName}] AS [{mainTableAlias}]");
+                sb.Append($"SELECT\n\t{columns}\nFROM [{TableName}] AS [{mainTableAlias}]");
             }
 
             cfg.Sql = sb.ToString();
@@ -1779,6 +1841,31 @@ protected override int GetCount(ISpecification<TEntity> criteria)
             }
         }
 
+        /// <summary>
+        /// A protected overridable method for determining whether the repository contains an entity that satisfies the criteria specified by the <paramref name="criteria" /> from the repository.
+        /// </summary>
+        protected override bool GetExist(ISpecification<TEntity> criteria)
+        {
+            if (criteria == null)
+                throw new ArgumentNullException(nameof(criteria));
+
+            PrepareSelectStatement(criteria, (IQueryOptions<TEntity>)null, out DbSqlSelectStatementConfig config);
+
+            using (var reader = ExecuteReader(config.Sql, config.Parameters))
+            {
+                var hasRows = false;
+
+                while (reader.Read())
+                {
+                    hasRows = true;
+
+                    break;
+                }
+
+                return hasRows;
+            }
+        }
+
         /// <summary>
         /// Gets a new <see cref="Dictionary{TDictionaryKey, TElement}" /> according to the specified <paramref name="keySelector" />, an element selector.
         /// </summary>
@@ -1965,7 +2052,16 @@ public override void Dispose()
 
             using (var reader = await ExecuteReaderAsync(config.Sql, config.Parameters, cancellationToken))
             {
-                return reader.HasRows;
+                var hasRows = false;
+
+                while (await reader.ReadAsync(cancellationToken))
+                {
+                    hasRows = true;
+
+                    break;
+                }
+
+                return hasRows;
             }
         }
 

src/DotNetToolkit.Repository.AdoNet/Internal/ExtensionMethods.cs

@@ -143,45 +143,43 @@ public static int GetColumnOrder(this PropertyInfo pi)
         /// <param name="sourceType">The source type.</param>
         /// <param name="foreignType">The foreign type to match.</param>
         /// <returns>The name of the foreign key.</returns>
-        public static string GetForeignKeyName(this Type sourceType, Type foreignType)
+        public static PropertyInfo GetForeignKeyPropertyInfo(this Type sourceType, Type foreignType)
         {
             var properties = sourceType.GetRuntimeProperties().Where(x => x.IsMapped());
             var foreignPropertyInfo = properties.SingleOrDefault(x => x.PropertyType == foreignType);
-            var foreignKeyName = string.Empty;
+
+            PropertyInfo propertyInfo = null;
 
             if (foreignPropertyInfo != null)
             {
                 var propertyInfosWithForeignKeys = properties.Where(x => x.GetCustomAttribute<ForeignKeyAttribute>() != null);
                 if (propertyInfosWithForeignKeys.Any())
                 {
                     // Try to find by checking on the foreign key property
-                    foreignKeyName = propertyInfosWithForeignKeys
+                    propertyInfo = propertyInfosWithForeignKeys
                         .Where(x => x.IsPrimitive())
-                        .SingleOrDefault(x => x.GetCustomAttribute<ForeignKeyAttribute>().Name.Equals(foreignPropertyInfo.Name))
-                        ?.GetColumnName();
+                        .SingleOrDefault(x => x.GetCustomAttribute<ForeignKeyAttribute>().Name.Equals(foreignPropertyInfo.Name));
 
                     // Try to find by checking on the navigation property
-                    if (string.IsNullOrEmpty(foreignKeyName))
+                    if (propertyInfo == null)
                     {
-                        foreignKeyName = properties
+                        propertyInfo = properties
                             .Where(x => x.IsPrimitive())
-                            .SingleOrDefault(x => foreignPropertyInfo.GetCustomAttribute<ForeignKeyAttribute>().Name.Equals(x.GetColumnName()))
-                            ?.GetColumnName();
+                            .SingleOrDefault(x => foreignPropertyInfo.GetCustomAttribute<ForeignKeyAttribute>().Name.Equals(x.GetColumnName()));
                     }
                 }
 
                 // Try to find by naming convention
-                if (string.IsNullOrEmpty(foreignKeyName))
+                if (propertyInfo == null)
                 {
                     var foreignPrimaryKeyName = foreignType.GetPrimaryKeyPropertyInfo().GetColumnName();
 
-                    foreignKeyName = properties
-                        .SingleOrDefault(x => x.Name == $"{foreignType.Name}{foreignPrimaryKeyName}")
-                        ?.GetColumnName();
+                    propertyInfo = properties
+                        .SingleOrDefault(x => x.Name == $"{foreignPropertyInfo.Name}{foreignPrimaryKeyName}");
                 }
             }
 
-            return foreignKeyName;
+            return propertyInfo;
         }
 
         /// <summary>
@@ -239,4 +237,4 @@ private static IEnumerable<string> GetDefaultPrimaryKeyNameChecks(Type entityTyp
             return new[] { suffix, entityType.Name + suffix };
         }
     }
-}
+}

src/DotNetToolkit.Repository/Helpers/ConventionHelper.cs

@@ -535,9 +535,6 @@ protected RepositoryAsyncBase(ILogger logger) : base(logger)
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            if (fetchStrategy == null)
-                throw new ArgumentNullException(nameof(fetchStrategy));
-
             return GetEntityAsync(key, fetchStrategy, selector, cancellationToken);
         }