Subquery

Src/Asp.Net/SqlServerTest/Demos/1_Query.cs

@@ -27,6 +27,31 @@ namespace OrmTest.Demo
             Enum();
             Simple();
             Async();
+            Subqueryable();
+        }
+
+        private static void Subqueryable()
+        {
+            var db = GetInstance();
+            var getAll1 = db.Queryable<Student>()
+                      .Where(it => it.Id == SqlFunc.Subqueryable<School>().Where(s => s.Id == it.Id).Select(s => s.Id))
+                      .ToList();
+
+            var getAll2 = db.Queryable<Student, School>((st, sc) => new object[] {
+                JoinType.Left,st.Id==sc.Id
+            })
+          .Where(st => st.Id == SqlFunc.Subqueryable<School>().Where(s => s.Id == st.Id).Select(s => s.Id))
+          .ToList();
+
+            var getAll3 = db.Queryable<Student, School>((st, sc) => new object[] {
+                JoinType.Left,st.Id==sc.Id
+            })
+           .Select(st=>
+                    new {
+                           name=st.Name,
+                           id = SqlFunc.Subqueryable<School>().Where(s => s.Id == st.Id).Select(s => s.Id)
+                    })
+          .ToList();
         }
 
         private static void Async()
@@ -184,9 +209,6 @@ namespace OrmTest.Demo
         public static void Easy()
         {
             var db = GetInstance();
-            var getAll2 = db.Queryable<Student>()
-                .Where(it => it.Id == SqlFunc.Subqueryable<School>().Where(s => s.Id == it.Id).Select(s => s.Id))
-                .ToList();
             var getAll = db.Queryable<Student>().ToList();
             var getAllOrder = db.Queryable<Student>().OrderBy(it => it.Id).OrderBy(it => it.Name, OrderByType.Desc).ToList();
             var getId = db.Queryable<Student>().Select(it => it.Id).ToList();

Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs

@@ -219,6 +219,11 @@ namespace SqlSugar
             resolveExpress.Resolve(expression, resolveType);
             this.Parameters.AddRange(resolveExpress.Parameters);
             var reval = resolveExpress.Result;
+            var isSingleTableHasSubquery = IsSingle() && resolveExpress.SingleTableNameSubqueryShortName.IsValuable();
+            if (isSingleTableHasSubquery) {
+                Check.Exception(!string.IsNullOrEmpty(this.TableShortName) && resolveExpress.SingleTableNameSubqueryShortName != this.TableShortName, "{0} and {1} need same name");
+                this.TableShortName = resolveExpress.SingleTableNameSubqueryShortName;
+            }
             return reval;
         }
         public virtual string ToSqlString()

Src/Asp.Net/SqlSugar/ExpressionsToSql/ExpressionContext.cs

@@ -37,6 +37,7 @@ namespace SqlSugar
         }
         public int Index { get; set; }
         public int ParameterIndex { get; set; }
+        public string SingleTableNameSubqueryShortName{ get;  set; }
         public MappingColumnList MappingColumns { get; set; }
         public MappingTableList MappingTables { get; set; }
         public IgnoreColumnList IgnoreComumnList { get; set; }

Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs

@@ -42,7 +42,8 @@ namespace SqlSugar
             }
             else if (IsSubMethod(express, methodName))
             {
-                SubResolve subResolve = new SubResolve(express, this.Context);
+                Check.Exception(!(parameter.BaseExpression is BinaryExpression), "Current expressions are not supported");
+                SubResolve subResolve = new SubResolve(express, this.Context,parameter.OppsiteExpression);
                 var appendSql = subResolve.GetSql();
                 base.AppendValue(parameter, isLeft, appendSql);
                 return;

Src/Asp.Net/SqlSugar/ExpressionsToSql/Subquery/Items/SubWhere.cs

@@ -29,7 +29,11 @@ namespace SqlSugar.ExpressionsToSql.Subquery
         public string GetValue(ExpressionContext context, Expression expression)
         {
             var exp = expression as MethodCallExpression;
-            return "WHERE "+SubTools.GetMethodValue(context, exp.Arguments[0], ResolveExpressType.WhereMultiple);
+            var argExp= exp.Arguments[0];
+            var result= "WHERE "+SubTools.GetMethodValue(context, argExp, ResolveExpressType.WhereMultiple);
+            var selfParameterName =context.GetTranslationColumnName((argExp as LambdaExpression).Parameters.First().Name)+UtilConstants.Dot;
+            result = result.Replace(selfParameterName,string.Empty);
+            return result;
         }
     }
 }

Src/Asp.Net/SqlSugar/ExpressionsToSql/Subquery/SubResolve.cs

@@ -10,11 +10,15 @@ namespace SqlSugar
     {
         List<MethodCallExpression> allMethods = new List<MethodCallExpression>();
         private ExpressionContext context = null;
-        public SubResolve(MethodCallExpression expression, ExpressionContext context)
+        public SubResolve(MethodCallExpression expression, ExpressionContext context,Expression oppsiteExpression)
         {
             this.context = context;
             var currentExpression = expression;
             allMethods.Add(currentExpression);
+            if (context.IsSingle) {
+                var childExpression = (oppsiteExpression as MemberExpression).Expression;
+                this.context.SingleTableNameSubqueryShortName = (childExpression as ParameterExpression).Name;
+            }
             while (currentExpression != null)
             {
                 var addItem = currentExpression.Object as MethodCallExpression;

Src/Asp.Net/SqlSugar/Interface/ILambdaExpressions.cs

@@ -21,6 +21,8 @@ namespace SqlSugar
         List<SugarParameter> Parameters { get; set; }
         ExpressionResult Result { get; set; }
         string SqlParameterKeyWord { get; }
+        string SingleTableNameSubqueryShortName { get; set; }
+
         string GetAsString(string fieldName, string fieldValue);
         void Resolve(Expression expression, ResolveExpressType resolveType);
         void Clear();