no message

Author: kccarter76

SubSonic.Tests/DAL/OData/ODataCompatibilityTests.cs

@@ -210,5 +210,47 @@ public void ShouldBeAbleToApplyOrderByThenByUsingOData(string direction)
                 query.Sql.Should().Contain("DESC");
             }
         }
+
+        /// <summary>
+        /// simulate a $top 
+        /// </summary>
+        /// <param name="top"></param>
+        [Test]
+        [TestCase(1)]
+        [TestCase(10)]
+        public void ShouldBeAbleToApplyTopUsingOData(int top)
+        {
+            personQueryOptions.ApplyTo(Arg.Any<IQueryable>())
+                .Returns(call =>
+                {
+                    if (call.Arg<IQueryable>() is IQueryable<Models.Person> people)
+                    {
+                        return people.Take(top);
+                    }
+
+                    throw new NotImplementedException();
+                });
+
+            IQueryable select = personQueryOptions.ApplyTo(Context.People);
+
+            IDbQuery query = null;
+
+            var logging = Context.Instance.GetService<ISubSonicLogger<DbSelectExpression>>();
+
+            using (var perf = logging.Start("SQL Query Writer"))
+            {
+                FluentActions.Invoking(() =>
+                {
+                    ISubSonicQueryProvider<Models.Person> builder = Context.Instance.GetService<ISubSonicQueryProvider<Models.Person>>();
+
+                    query = builder.ToQuery(select.Expression);
+                }).Should().NotThrow();
+            }
+
+            logging.LogInformation("\n" + query.Sql + "\n");
+
+            query.Sql.Should().NotBeNullOrEmpty();
+            query.Sql.Should().Contain($"SELECT TOP ({top})");
+        }
     }
 }

SubSonic/Error.cs

@@ -18,7 +18,12 @@ public static Exception Argument(string message, string parameter)
 
         public static Exception NotImplemented()
         {
-            throw new NotImplementedException();
+            return new NotImplementedException();
+        }
+
+        internal static Exception NotSupported(string message)
+        {
+            return new NotSupportedException(message);
         }
     }
 }

SubSonic/Extensions/Internal/MethodInfo.cs

@@ -28,5 +28,15 @@ public static bool IsWhere(this MethodInfo info)
         {
             return info.Name.Equals(nameof(Legacy.Where), StringComparison.CurrentCulture);
         }
+
+        public static bool IsTake(this MethodInfo info)
+        {
+            return info.Name.Equals(nameof(Legacy.Take), StringComparison.CurrentCulture);
+        }
+
+        public static bool IsSkip(this MethodInfo info)
+        {
+            return info.Name.Equals(nameof(Legacy.Skip), StringComparison.CurrentCulture);
+        }
     }
 }

SubSonic/Infrastructure/Builders/DbSqlQueryBuilder/DbSqlQueryBuilderBuildMethods.cs

@@ -495,9 +495,17 @@ protected virtual Expression BuildQuery(Expression expression)
                     {
                         return BuildSelectWithWhere(call);
                     }
+                    else if (call.Method.IsTake())
+                    {
+                        return BuildSelectWithTake(call);
+                    }
+                    else if (call.Method.IsSkip())
+                    {
+                        throw Error.NotImplemented();
+                    }
                     else
                     {
-                        throw new NotSupportedException(SubSonicErrorMessages.UnSupportedMethodException.Format(call.Method.Name));
+                        throw Error.NotSupported(SubSonicErrorMessages.UnSupportedMethodException.Format(call.Method.Name));
                     }
                 }
             }
@@ -526,6 +534,34 @@ private static Type[] GetTypeArguments(LambdaExpression expression)
             return Array.Empty<Type>();
         }
 
+        private Expression BuildSelectWithTake(MethodCallExpression expression)
+        {
+            if (!(expression is null))
+            {
+                DbSelectExpression select = null;
+                Expression take = null;
+
+                foreach (var argument in expression.Arguments)
+                {
+                    if (argument is DbSelectExpression _select)
+                    {
+                        select = _select;
+                    }
+                    else if (argument is ConstantExpression constant)
+                    {
+                        take = constant;
+                    }
+                }
+
+                return DbExpression.DbSelect(
+                        select,
+                        take
+                        );
+            }
+
+            return expression;
+        }
+
         private Expression BuildSelectWithWhere(MethodCallExpression expression)
         {
             if (!(expression is null))

SubSonic/Linq/Expressions/DbSelectExpression.cs

@@ -143,6 +143,16 @@ public static DbExpression DbSelect(DbSelectExpression select, DbExpression wher
             return new DbSelectExpression(select.QueryObject, select.Type, select.From, select.Columns, where ?? select.Where, select.OrderBy, select.GroupBy, select.IsDistinct, select.Take);
         }
 
+        public static DbExpression DbSelect(DbSelectExpression select, Expression take)
+        {
+            if (select is null)
+            {
+                throw Error.ArgumentNull(nameof(select));
+            }
+
+            return new DbSelectExpression(select.QueryObject, select.Type, select.From, select.Columns, select.Where, select.OrderBy, select.GroupBy, select.IsDistinct, take);
+        }
+
         public static DbExpression DbSelect(DbSelectExpression select, DbJoinExpression join)
         {
             if (select is null)