- 增加 WithTempQuery + FromQuery 嵌套查询功能；#1192

FreeSql.Tests/FreeSql.Tests/MySql/MySqlCodeFirstTest.cs

@@ -11,6 +11,23 @@ namespace FreeSql.Tests.MySql
 {
     public class MySqlCodeFirstTest
     {
+        [Fact]
+        public void Test_Bool01()
+        {
+            var fsql = g.mysql;
+            var dt = fsql.Insert(
+                new[] {
+                    new test_bool01 { id = Guid.NewGuid(), isdeleted = true},
+                    new test_bool01 { id = Guid.NewGuid(), isdeleted = false},
+                }).ToDataTable();
+        }
+
+        class test_bool01
+        {
+            public Guid id { get; set; }
+            public bool isdeleted { get; set; }
+        }
+
         [Fact]
         public void Test_0String()
         {

FreeSql.Tests/FreeSql.Tests/SqlServer/Curd/SqlServerSelectWithTempQueryTest.cs

@@ -0,0 +1,693 @@
+using FreeSql.DataAnnotations;
+using System;
+using System.Diagnostics;
+using Xunit;
+
+namespace FreeSql.Tests.SqlServer
+{
+    public class SqlServerSelectWithTempQueryTest
+    {
+        [Fact]
+        public void SingleTablePartitionBy()
+        {
+            var fsql = g.sqlserver;
+
+            fsql.Delete<SingleTablePartitionBy_User>().Where("1=1").ExecuteAffrows();
+            fsql.Insert(new[] {
+                new SingleTablePartitionBy_User { Id = 1, Nickname = "name01" },
+                new SingleTablePartitionBy_User { Id = 2, Nickname = "name01" },
+                new SingleTablePartitionBy_User { Id = 3, Nickname = "name01" },
+                new SingleTablePartitionBy_User { Id = 4, Nickname = "name02" },
+                new SingleTablePartitionBy_User { Id = 5, Nickname = "name03" },
+                new SingleTablePartitionBy_User { Id = 6, Nickname = "name03" },
+            }).ExecuteAffrows();
+
+            var sql01 = fsql.Select<SingleTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    item = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .ToSql();
+            var assertSql01 = @"SELECT * 
+FROM ( 
+    SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+    FROM [SingleTablePartitionBy_User] a ) a 
+WHERE (a.[rownum] = 1)";
+            Assert.Equal(assertSql01, sql01);
+
+            var sel01 = fsql.Select<SingleTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    item = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1);
+            Assert.Equal(assertSql01, sel01.ToSql());
+
+            var list01 = sel01.ToList();
+            Assert.Equal(3, list01.Count);
+            Assert.Equal(list01[0].rownum, 1);
+            Assert.Equal(list01[0].item.Id, 1);
+            Assert.Equal(list01[0].item.Nickname, "name01");
+            Assert.Equal(list01[1].rownum, 1);
+            Assert.Equal(list01[1].item.Id, 4);
+            Assert.Equal(list01[1].item.Nickname, "name02");
+            Assert.Equal(list01[2].rownum, 1);
+            Assert.Equal(list01[2].item.Id, 5);
+            Assert.Equal(list01[2].item.Nickname, "name03");
+
+
+            var sql02 = fsql.Select<SingleTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    item = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .ToSql(a => a.item);
+            var assertSql02 = @"SELECT a.[Id] as1, a.[Nickname] as2 
+FROM ( 
+    SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+    FROM [SingleTablePartitionBy_User] a ) a 
+WHERE (a.[rownum] = 1)";
+            Assert.Equal(assertSql02, sql02);
+
+            var sel02 = fsql.Select<SingleTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    item = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1);
+            Assert.Equal(assertSql02, sel02.ToSql(a => a.item));
+
+            var list02 = sel02.ToList(a => a.item);
+            Assert.Equal(3, list02.Count);
+            Assert.Equal(list02[0].Id, 1);
+            Assert.Equal(list02[0].Nickname, "name01");
+            Assert.Equal(list02[1].Id, 4);
+            Assert.Equal(list02[1].Nickname, "name02");
+            Assert.Equal(list02[2].Id, 5);
+            Assert.Equal(list02[2].Nickname, "name03");
+
+
+            var sql03 = fsql.Select<SingleTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    item = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .ToSql(a => new
+                {
+                    a.item.Id,
+                    a.rownum
+                });
+            var assertSql03 = @"SELECT a.[Id] as1, a.[rownum] as2 
+FROM ( 
+    SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+    FROM [SingleTablePartitionBy_User] a ) a 
+WHERE (a.[rownum] = 1)";
+            Assert.Equal(assertSql03, sql03);
+
+            var sel03 = fsql.Select<SingleTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    item = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1);
+            Assert.Equal(assertSql03, sel03.ToSql(a => new
+            {
+                a.item.Id,
+                a.rownum
+            }));
+
+            var list03 = sel03.ToList(a => new
+            {
+                a.item.Id,
+                a.rownum
+            });
+            Assert.Equal(3, list03.Count);
+            Assert.Equal(list03[0].rownum, 1);
+            Assert.Equal(list03[0].Id, 1);
+            Assert.Equal(list03[1].rownum, 1);
+            Assert.Equal(list03[1].Id, 4);
+            Assert.Equal(list03[2].rownum, 1);
+            Assert.Equal(list03[2].Id, 5);
+
+
+
+            var sql04 = fsql.Select<SingleTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    a.Id,
+                    a.Nickname,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .ToSql(a => new SingleTablePartitionBy_UserDto());
+            var assertSql04 = @"SELECT a.[Id] as1, a.[rownum] as2 
+FROM ( 
+    SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+    FROM [SingleTablePartitionBy_User] a ) a 
+WHERE (a.[rownum] = 1)";
+            Assert.Equal(assertSql04, sql04);
+
+            var sel04 = fsql.Select<SingleTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    a.Id,
+                    a.Nickname,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1);
+            Assert.Equal(assertSql04, sel04.ToSql(a => new SingleTablePartitionBy_UserDto()));
+
+            var list04 = sel04.ToList<SingleTablePartitionBy_UserDto>();
+            Assert.Equal(3, list04.Count);
+            Assert.Equal(list04[0].rownum, 1);
+            Assert.Equal(list04[0].Id, 1);
+            Assert.Equal(list04[1].rownum, 1);
+            Assert.Equal(list04[1].Id, 4);
+            Assert.Equal(list04[2].rownum, 1);
+            Assert.Equal(list04[2].Id, 5);
+        }
+        class SingleTablePartitionBy_User
+        {
+            public int Id { get; set; }
+            public string Nickname { get; set; }
+        }
+        class SingleTablePartitionBy_UserDto
+        {
+            public int Id { get; set; }
+            public int rownum { get; set; }
+        }
+
+
+        [Fact]
+        public void TwoTablePartitionBy()
+        {
+            var fsql = g.sqlserver;
+
+            fsql.Delete<TwoTablePartitionBy_User>().Where("1=1").ExecuteAffrows();
+            fsql.Delete<TwoTablePartitionBy_UserExt>().Where("1=1").ExecuteAffrows();
+            fsql.Insert(new[] {
+                new TwoTablePartitionBy_User { Id = 1, Nickname = "name01" },
+                new TwoTablePartitionBy_User { Id = 2, Nickname = "name01" },
+                new TwoTablePartitionBy_User { Id = 3, Nickname = "name01" },
+                new TwoTablePartitionBy_User { Id = 4, Nickname = "name02" },
+                new TwoTablePartitionBy_User { Id = 5, Nickname = "name03" },
+                new TwoTablePartitionBy_User { Id = 6, Nickname = "name03" },
+            }).ExecuteAffrows();
+            fsql.Insert(new[] {
+                new TwoTablePartitionBy_UserExt { UserId = 1, Remark = "remark01" },
+                new TwoTablePartitionBy_UserExt { UserId = 2, Remark = "remark02" },
+                new TwoTablePartitionBy_UserExt { UserId = 3, Remark = "remark03" },
+                new TwoTablePartitionBy_UserExt { UserId = 4, Remark = "remark04" },
+                new TwoTablePartitionBy_UserExt { UserId = 5, Remark = "remark05" },
+                new TwoTablePartitionBy_UserExt { UserId = 6, Remark = "remark06" },
+            }).ExecuteAffrows();
+
+            var sql01 = fsql.Select<TwoTablePartitionBy_User, TwoTablePartitionBy_UserExt>()
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .WithTempQuery((a, b) => new
+                {
+                    user = a,
+                    userext = b,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .ToSql();
+            var assertSql01 = @"SELECT * 
+FROM ( 
+    SELECT a.[Id], a.[Nickname], b.[UserId], b.[Remark], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+    FROM [TwoTablePartitionBy_User] a 
+    INNER JOIN [TwoTablePartitionBy_UserExt] b ON a.[Id] = b.[UserId] ) a 
+WHERE (a.[rownum] = 1)";
+            Assert.Equal(assertSql01, sql01);
+
+            var sel01 = fsql.Select<TwoTablePartitionBy_User, TwoTablePartitionBy_UserExt>()
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .WithTempQuery((a, b) => new
+                {
+                    user = a,
+                    userext = b,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1);
+            Assert.Equal(assertSql01, sel01.ToSql());
+
+            var list01 = sel01.ToList();
+            Assert.Equal(3, list01.Count);
+            Assert.Equal(list01[0].rownum, 1);
+            Assert.Equal(list01[0].user.Id, 1);
+            Assert.Equal(list01[0].user.Nickname, "name01");
+            Assert.Equal(list01[0].userext.Remark, "remark01");
+            Assert.Equal(list01[1].rownum, 1);
+            Assert.Equal(list01[1].user.Id, 4);
+            Assert.Equal(list01[1].user.Nickname, "name02");
+            Assert.Equal(list01[1].userext.Remark, "remark04");
+            Assert.Equal(list01[2].rownum, 1);
+            Assert.Equal(list01[2].user.Id, 5);
+            Assert.Equal(list01[2].user.Nickname, "name03");
+            Assert.Equal(list01[2].userext.Remark, "remark05");
+
+
+            var sql02 = fsql.Select<TwoTablePartitionBy_User, TwoTablePartitionBy_UserExt>()
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .WithTempQuery((a, b) => new
+                {
+                    user = a,
+                    userext = b,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .ToSql(a => a.user);
+            var assertSql02 = @"SELECT a.[Id] as1, a.[Nickname] as2 
+FROM ( 
+    SELECT a.[Id], a.[Nickname], b.[UserId], b.[Remark], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+    FROM [TwoTablePartitionBy_User] a 
+    INNER JOIN [TwoTablePartitionBy_UserExt] b ON a.[Id] = b.[UserId] ) a 
+WHERE (a.[rownum] = 1)";
+            Assert.Equal(assertSql02, sql02);
+
+            var sel02 = fsql.Select<TwoTablePartitionBy_User, TwoTablePartitionBy_UserExt>()
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .WithTempQuery((a, b) => new
+                {
+                    user = a,
+                    userext = b,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1);
+            Assert.Equal(assertSql02, sel02.ToSql(a => a.user));
+
+            var list02 = sel02.ToList(a => a.user);
+            Assert.Equal(3, list02.Count);
+            Assert.Equal(list02[0].Id, 1);
+            Assert.Equal(list02[0].Nickname, "name01");
+            Assert.Equal(list02[1].Id, 4);
+            Assert.Equal(list02[1].Nickname, "name02");
+            Assert.Equal(list02[2].Id, 5);
+            Assert.Equal(list02[2].Nickname, "name03");
+
+
+            var sql022 = fsql.Select<TwoTablePartitionBy_User, TwoTablePartitionBy_UserExt>()
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .WithTempQuery((a, b) => new
+                {
+                    user = a,
+                    userext = b,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .ToSql(a => a.userext);
+            var assertSql022 = @"SELECT a.[UserId] as1, a.[Remark] as2 
+FROM ( 
+    SELECT a.[Id], a.[Nickname], b.[UserId], b.[Remark], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+    FROM [TwoTablePartitionBy_User] a 
+    INNER JOIN [TwoTablePartitionBy_UserExt] b ON a.[Id] = b.[UserId] ) a 
+WHERE (a.[rownum] = 1)";
+            Assert.Equal(assertSql022, sql022);
+
+            var sel022 = fsql.Select<TwoTablePartitionBy_User, TwoTablePartitionBy_UserExt>()
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .WithTempQuery((a, b) => new
+                {
+                    user = a,
+                    userext = b,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1);
+            Assert.Equal(assertSql022, sel022.ToSql(a => a.userext));
+
+            var list022 = sel022.ToList(a => a.userext);
+            Assert.Equal(3, list022.Count);
+            Assert.Equal(list022[0].UserId, 1);
+            Assert.Equal(list022[0].Remark, "remark01");
+            Assert.Equal(list022[1].UserId, 4);
+            Assert.Equal(list022[1].Remark, "remark04");
+            Assert.Equal(list022[2].UserId, 5);
+            Assert.Equal(list022[2].Remark, "remark05");
+
+
+            var sql03 = fsql.Select<TwoTablePartitionBy_User, TwoTablePartitionBy_UserExt>()
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .WithTempQuery((a, b) => new
+                {
+                    user = a,
+                    userext = b,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .ToSql(a => new
+                {
+                    a.user.Id,
+                    a.rownum
+                });
+            var assertSql03 = @"SELECT a.[Id] as1, a.[rownum] as2 
+FROM ( 
+    SELECT a.[Id], a.[Nickname], b.[UserId], b.[Remark], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+    FROM [TwoTablePartitionBy_User] a 
+    INNER JOIN [TwoTablePartitionBy_UserExt] b ON a.[Id] = b.[UserId] ) a 
+WHERE (a.[rownum] = 1)";
+            Assert.Equal(assertSql03, sql03);
+
+            var sel03 = fsql.Select<TwoTablePartitionBy_User, TwoTablePartitionBy_UserExt>()
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .WithTempQuery((a, b) => new
+                {
+                    user = a,
+                    userext = b,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1);
+            Assert.Equal(assertSql03, sel03.ToSql(a => new
+            {
+                a.user.Id,
+                a.rownum
+            }));
+
+            var list03 = sel03.ToList(a => new
+            {
+                a.user.Id,
+                a.rownum
+            });
+            Assert.Equal(3, list03.Count);
+            Assert.Equal(list03[0].rownum, 1);
+            Assert.Equal(list03[0].Id, 1);
+            Assert.Equal(list03[1].rownum, 1);
+            Assert.Equal(list03[1].Id, 4);
+            Assert.Equal(list03[2].rownum, 1);
+            Assert.Equal(list03[2].Id, 5);
+
+
+
+            var sql04 = fsql.Select<TwoTablePartitionBy_User, TwoTablePartitionBy_UserExt>()
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .WithTempQuery((a, b) => new
+                {
+                    a.Id,
+                    a.Nickname,
+                    b.Remark,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .ToSql(a => new TwoTablePartitionBy_UserDto());
+            var assertSql04 = @"SELECT a.[Id] as1, a.[rownum] as2, a.[Remark] as3 
+FROM ( 
+    SELECT a.[Id], a.[Nickname], b.[Remark], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+    FROM [TwoTablePartitionBy_User] a 
+    INNER JOIN [TwoTablePartitionBy_UserExt] b ON a.[Id] = b.[UserId] ) a 
+WHERE (a.[rownum] = 1)";
+            Assert.Equal(assertSql04, sql04);
+
+            var sel04 = fsql.Select<TwoTablePartitionBy_User, TwoTablePartitionBy_UserExt>()
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .WithTempQuery((a, b) => new
+                {
+                    a.Id,
+                    a.Nickname,
+                    b.Remark,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1);
+            Assert.Equal(assertSql04, sel04.ToSql(a => new TwoTablePartitionBy_UserDto()));
+
+            var list04 = sel04.ToList<TwoTablePartitionBy_UserDto>();
+            Assert.Equal(3, list04.Count);
+            Assert.Equal(list04[0].rownum, 1);
+            Assert.Equal(list04[0].Id, 1);
+            Assert.Equal(list04[0].remark, "remark01");
+            Assert.Equal(list04[1].rownum, 1);
+            Assert.Equal(list04[1].Id, 4);
+            Assert.Equal(list04[1].remark, "remark04");
+            Assert.Equal(list04[2].rownum, 1);
+            Assert.Equal(list04[2].Id, 5);
+            Assert.Equal(list04[2].remark, "remark05");
+
+
+            var sql05 = fsql.Select<TwoTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    user = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .WithTempQuery(a => a.user)
+                .Where(a => a.Nickname == "name03")
+                .ToSql(a => new TwoTablePartitionBy_UserDto());
+            var assertSql05 = @"SELECT a.[Id] as1 
+FROM ( 
+    SELECT a.[Id], a.[Nickname] 
+    FROM ( 
+        SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+        FROM [TwoTablePartitionBy_User] a ) a 
+    WHERE (a.[rownum] = 1) ) a 
+WHERE (a.[Nickname] = N'name03')";
+            Assert.Equal(sql05, assertSql05);
+            var list05 = fsql.Select<TwoTablePartitionBy_User>()
+                 .WithTempQuery(a => new
+                 {
+                     user = a,
+                     rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                 })
+                 .Where(a => a.rownum == 1)
+                 .WithTempQuery(a => a.user)
+                 .Where(a => a.Nickname == "name03")
+                 .ToList<TwoTablePartitionBy_UserDto>();
+            Assert.Equal(list05.Count, 1);
+            Assert.Equal(5, list05[0].Id);
+            Assert.Equal(0, list05[0].rownum);
+            Assert.Null(list05[0].remark);
+
+
+            var sql06 = fsql.Select<TwoTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    user = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .WithTempQuery(a => a.user)
+                .From<TwoTablePartitionBy_UserExt>()
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .Where((a, b) => a.Nickname == "name03" || a.Nickname == "name02")
+                .ToSql((a, b) => new TwoTablePartitionBy_UserDto());
+            var assertSql06 = @"SELECT a.[Id] as1, b.[Remark] as2 
+FROM ( 
+    SELECT a.[Id], a.[Nickname] 
+    FROM ( 
+        SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+        FROM [TwoTablePartitionBy_User] a ) a 
+    WHERE (a.[rownum] = 1) ) a 
+INNER JOIN [TwoTablePartitionBy_UserExt] b ON a.[Id] = b.[UserId] 
+WHERE ((a.[Nickname] = N'name03' OR a.[Nickname] = N'name02'))";
+            Assert.Equal(sql06, assertSql06);
+            var list06 = fsql.Select<TwoTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    user = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .WithTempQuery(a => a.user)
+                .From<TwoTablePartitionBy_UserExt>()
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .Where((a, b) => a.Nickname == "name03" || a.Nickname == "name02")
+                .ToList<TwoTablePartitionBy_UserDto>();
+            Assert.Equal(list06.Count, 2);
+            Assert.Equal(list06[0].rownum, 0);
+            Assert.Equal(list06[0].Id, 4);
+            Assert.Equal(list06[0].remark, "remark04");
+            Assert.Equal(list06[1].rownum, 0);
+            Assert.Equal(list06[1].Id, 5);
+            Assert.Equal(list06[1].remark, "remark05");
+
+
+            var sql07 = fsql.Select<TwoTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    user = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .WithTempQuery(a => a.user)
+                .FromQuery(fsql.Select<TwoTablePartitionBy_UserExt>())
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .Where((a, b) => a.Nickname == "name03" || a.Nickname == "name02")
+                .ToSql((a, b) => new TwoTablePartitionBy_UserDto());
+            var assertSql07 = @"SELECT a.[Id] as1, b.[Remark] as2 
+FROM ( 
+    SELECT a.[Id], a.[Nickname] 
+    FROM ( 
+        SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+        FROM [TwoTablePartitionBy_User] a ) a 
+    WHERE (a.[rownum] = 1) ) a 
+INNER JOIN (SELECT a.[UserId], a.[Remark] 
+    FROM [TwoTablePartitionBy_UserExt] a) b ON a.[Id] = b.[UserId] 
+WHERE ((a.[Nickname] = N'name03' OR a.[Nickname] = N'name02'))";
+            Assert.Equal(sql07, assertSql07);
+            var list07 = fsql.Select<TwoTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    user = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .WithTempQuery(a => a.user)
+                .FromQuery(fsql.Select<TwoTablePartitionBy_UserExt>())
+                .InnerJoin((a, b) => a.Id == b.UserId)
+                .Where((a, b) => a.Nickname == "name03" || a.Nickname == "name02")
+                .ToList<TwoTablePartitionBy_UserDto>();
+            Assert.Equal(list07.Count, 2);
+            Assert.Equal(list07[0].rownum, 0);
+            Assert.Equal(list07[0].Id, 4);
+            Assert.Equal(list07[0].remark, "remark04");
+            Assert.Equal(list07[1].rownum, 0);
+            Assert.Equal(list07[1].Id, 5);
+            Assert.Equal(list07[1].remark, "remark05");
+
+
+            var sql08 = fsql.Select<TwoTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    user = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .FromQuery(fsql.Select<TwoTablePartitionBy_UserExt>().Where(b => b.UserId > 0))
+                .InnerJoin((a, b) => a.user.Id == b.UserId)
+                .Where((a, b) => a.user.Nickname == "name03" || a.user.Nickname == "name02")
+                .ToSql((a, b) => new TwoTablePartitionBy_UserDto());
+            var assertSql08 = @"SELECT a.[rownum] as1, b.[Remark] as2 
+FROM ( 
+    SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+    FROM [TwoTablePartitionBy_User] a ) a 
+INNER JOIN (SELECT a.[UserId], a.[Remark] 
+    FROM [TwoTablePartitionBy_UserExt] a 
+    WHERE (a.[UserId] > 0)) b ON a.[Id] = b.[UserId] 
+WHERE (a.[rownum] = 1) AND ((a.[Nickname] = N'name03' OR a.[Nickname] = N'name02'))";
+            Assert.Equal(sql08, assertSql08);
+            var list08 = fsql.Select<TwoTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    user = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .FromQuery(fsql.Select<TwoTablePartitionBy_UserExt>().Where(b => b.UserId > 0))
+                .InnerJoin((a, b) => a.user.Id == b.UserId)
+                .Where((a, b) => a.user.Nickname == "name03" || a.user.Nickname == "name02")
+                .ToList<TwoTablePartitionBy_UserDto>();
+            Assert.Equal(list08.Count, 2);
+            Assert.Equal(list08[0].rownum, 1);
+            Assert.Equal(list08[0].Id, 0);
+            Assert.Equal(list08[0].remark, "remark04");
+            Assert.Equal(list08[1].rownum, 1);
+            Assert.Equal(list08[1].Id, 0);
+            Assert.Equal(list08[1].remark, "remark05");
+
+
+            var sql09 = fsql.Select<TwoTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    user = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .FromQuery(fsql.Select<TwoTablePartitionBy_UserExt>().Where(b => b.UserId > 0).GroupBy(b => new { b.UserId, b.Remark }).WithTempQuery(b => b.Key))
+                .InnerJoin((a, b) => a.user.Id == b.UserId)
+                .Where((a, b) => a.user.Nickname == "name03" || a.user.Nickname == "name02")
+                .ToSql((a, b) => new TwoTablePartitionBy_UserDto());
+            var assertSql09 = @"SELECT a.[rownum] as1, b.[Remark] as2 
+FROM ( 
+    SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+    FROM [TwoTablePartitionBy_User] a ) a 
+INNER JOIN ( SELECT a.[UserId], a.[Remark] 
+    FROM [TwoTablePartitionBy_UserExt] a 
+    WHERE (a.[UserId] > 0) 
+    GROUP BY a.[UserId], a.[Remark] ) b ON a.[Id] = b.[UserId] 
+WHERE (a.[rownum] = 1) AND ((a.[Nickname] = N'name03' OR a.[Nickname] = N'name02'))";
+            Assert.Equal(sql09, assertSql09);
+            var list09 = fsql.Select<TwoTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    user = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .FromQuery(fsql.Select<TwoTablePartitionBy_UserExt>().Where(b => b.UserId > 0).GroupBy(b => new { b.UserId, b.Remark }).WithTempQuery(b => b.Key))
+                .InnerJoin((a, b) => a.user.Id == b.UserId)
+                .Where((a, b) => a.user.Nickname == "name03" || a.user.Nickname == "name02")
+                .ToList<TwoTablePartitionBy_UserDto>();
+            Assert.Equal(list09.Count, 2);
+            Assert.Equal(list09[0].rownum, 1);
+            Assert.Equal(list09[0].Id, 0);
+            Assert.Equal(list09[0].remark, "remark04");
+            Assert.Equal(list09[1].rownum, 1);
+            Assert.Equal(list09[1].Id, 0);
+            Assert.Equal(list09[1].remark, "remark05");
+
+
+            var sql10 = fsql.Select<TwoTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    user = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .FromQuery(fsql.Select<TwoTablePartitionBy_UserExt>().Where(b => b.UserId > 0).GroupBy(b => new { b.UserId, b.Remark }).WithTempQuery(b => new { b.Key, rownum = b.Sum(b.Value.UserId) }))
+                .InnerJoin((a, b) => a.user.Id == b.Key.UserId)
+                .Where((a, b) => a.user.Nickname == "name03" || a.user.Nickname == "name02")
+                .ToSql((a, b) => new TwoTablePartitionBy_UserDto());
+            var assertSql10 = @"SELECT a.[rownum] as1 
+FROM ( 
+    SELECT a.[Id], a.[Nickname], row_number() over( partition by a.[Nickname] order by a.[Id]) [rownum] 
+    FROM [TwoTablePartitionBy_User] a ) a 
+INNER JOIN ( SELECT a.[UserId], a.[Remark], sum(a.[UserId]) [rownum] 
+    FROM [TwoTablePartitionBy_UserExt] a 
+    WHERE (a.[UserId] > 0) 
+    GROUP BY a.[UserId], a.[Remark] ) b ON a.[Id] = b.[UserId] 
+WHERE (a.[rownum] = 1) AND ((a.[Nickname] = N'name03' OR a.[Nickname] = N'name02'))";
+            Assert.Equal(sql10, assertSql10);
+            var list10 = fsql.Select<TwoTablePartitionBy_User>()
+                .WithTempQuery(a => new
+                {
+                    user = a,
+                    rownum = SqlExt.RowNumber().Over().PartitionBy(a.Nickname).OrderBy(a.Id).ToValue()
+                })
+                .Where(a => a.rownum == 1)
+                .FromQuery(fsql.Select<TwoTablePartitionBy_UserExt>().Where(b => b.UserId > 0).GroupBy(b => new { b.UserId, b.Remark }).WithTempQuery(b => new { b.Key, rownum = b.Sum(b.Value.UserId) }))
+                .InnerJoin((a, b) => a.user.Id == b.Key.UserId)
+                .Where((a, b) => a.user.Nickname == "name03" || a.user.Nickname == "name02")
+                .ToList<TwoTablePartitionBy_UserDto>();
+            Assert.Equal(list10.Count, 2);
+            Assert.Equal(list10[0].rownum, 1);
+            Assert.Equal(list10[0].Id, 0);
+            Assert.Null(list10[0].remark);
+            Assert.Equal(list10[1].rownum, 1);
+            Assert.Equal(list10[1].Id, 0);
+            Assert.Null(list10[1].remark);
+        }
+        class TwoTablePartitionBy_User
+        {
+            public int Id { get; set; }
+            public string Nickname { get; set; }
+        }
+        class TwoTablePartitionBy_UserExt
+        {
+            public int UserId { get; set; }
+            public string Remark { get; set; }
+        }
+        class TwoTablePartitionBy_UserDto
+        {
+            public int Id { get; set; }
+            public int rownum { get; set; }
+            public string remark { get; set; }
+        }
+    }
+}

FreeSql.Tests/FreeSql.Tests/UnitTest2.cs

@@ -532,7 +532,7 @@ namespace FreeSql.Tests
             };
 
 
-            var dbs = g.sqlserver.DbFirst.GetDatabases();
+            //var dbs = g.sqlserver.DbFirst.GetDatabases();
             var tbs = g.sqlserver.DbFirst.GetTablesByDatabase("ds_shop");
 
             var dicParamslist = g.sqlite.Select<SysModule>().Page(1, 10)