Add a configuration table query

Src/Asp.Net/SqlServerTest/Demo/Demo1_Queryable.cs

@@ -5,7 +5,6 @@ using System.Data;
 using System.Dynamic;
 using System.Linq;
 using System.Text;
-
 namespace OrmTest
 {
     public class Demo1_Queryable
@@ -22,6 +21,45 @@ namespace OrmTest
             SqlFuncTest();
             Subquery();
             ReturnType();
+            ConfiQuery();
+        }
+
+        private static void ConfiQuery()
+        {
+            var db = GetInstance();
+            db.SqlConfigTable.SetKeyValue<Order>(it=>it.Id ,it=>it.Name,"01",it=>it.Id>1);
+            db.SqlConfigTable.SetKeyValue<Order>(it => it.Id, it => it.Name, "02", it => it.Id > 2);
+            db.SqlConfigTable.SetKeyValue<Order>(it => it.Id, it => it.Name,null);
+            var list = db.Queryable<OrderItem>().Select(it => new OrderItem
+            {
+                ItemId = SqlFunc.GetSelfAndAutoFill(it.ItemId),
+                OrderName = it.OrderId.GetConfigValue<Order>("01")
+            }).ToList();
+            var list2 = db.Queryable<OrderItem>().Select(it => new OrderItem
+            {
+                ItemId = SqlFunc.GetSelfAndAutoFill(it.ItemId),
+                OrderName = it.OrderId.GetConfigValue<Order>("02")
+            }).ToList();
+            var list3 = db.Queryable<OrderItem>().Select(it => new OrderItem
+            {
+                ItemId = SqlFunc.GetSelfAndAutoFill(it.ItemId),
+                OrderName = it.OrderId.GetConfigValue<Order>()
+            }).ToList();
+
+            var list4 = db.Queryable<OrderItem>().Select(it => new OrderItem
+            {
+                ItemId = SqlFunc.GetSelfAndAutoFill(it.ItemId),
+                OrderName = it.OrderId.GetConfigValue<Order>()
+            })
+            .Where(it=>it.OrderId.GetConfigValue<Order>()=="jack")
+            .OrderBy(it=>it.OrderId.GetConfigValue<Order>()).ToList();
+
+            var list5 = db.Queryable<Order, OrderItem, Custom>((o, i, c) => o.Id == i.OrderId && c.Id == o.CustomId)
+                        .Select<ViewOrder>((o,i,c)=>new ViewOrder() { 
+                           Id=SqlFunc.GetSelfAndAutoFill(o.Id),
+                           Name=i.OrderId.GetConfigValue<Order>()
+                        })
+                        .ToList();
         }
 
         private static void EasyExamples()

Src/Asp.Net/SqlServerTest/Models/OrderItem.cs

@@ -14,5 +14,19 @@ namespace OrmTest
         public decimal? Price { get; set; }
         [SqlSugar.SugarColumn(IsNullable = true)]
         public DateTime? CreateTime { get; set; }
+        [SqlSugar.SugarColumn(IsNullable = true)]
+        public string OrderName { get; set; }
+    }
+    [SqlSugar.SugarTable("OrderDetail")]
+    public class VOrderItem
+    {
+        [SqlSugar.SugarColumn(IsPrimaryKey = true, IsIdentity = true)]
+        public int ItemId { get; set; }
+        public int OrderId { get; set; }
+        public decimal? Price { get; set; }
+        [SqlSugar.SugarColumn(IsNullable = true)]
+        public DateTime? CreateTime { get; set; }
+        [SqlSugar.SugarColumn(IsIgnore = true)]
+        public string OrderName { get; set; }
     }
 }

Src/Asp.Net/SqlSugar/Abstract/SugarProvider/SqlSugarAccessory.cs

@@ -31,6 +31,20 @@ namespace SqlSugar
         public MappingColumnList MappingColumns { get; set; }
         public IgnoreColumnList IgnoreColumns { get; set; }
         public IgnoreColumnList IgnoreInsertColumns { get; set; }
+        public SqlConfigTable SqlConfigTable { 
+            get 
+            {
+                if (_SqlConfigTable==null) 
+                {
+                    _SqlConfigTable = new SqlConfigTable() { Context = this.Context }; 
+                }
+                return _SqlConfigTable; 
+             }
+            set 
+            {
+                _SqlConfigTable = value;
+            }
+       }
 
 
         #endregion
@@ -46,6 +60,7 @@ namespace SqlSugar
         protected IContextMethods _RewritableMethods;
         protected IDbMaintenance _DbMaintenance;
         protected QueryFilterProvider _QueryFilterProvider;
+        protected SqlConfigTable _SqlConfigTable;
         //protected SimpleClient _SimpleClient;
         protected IAdo ContextAdo
         {

Src/Asp.Net/SqlSugar/Entities/ConfigQuery.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+namespace SqlSugar 
+{
+    public class SqlConfigTable
+    {
+        public SqlSugarProvider Context { get; set; }
+        public void SetKeyValue<T>(Expression<Func<T, object>> keyExpression, Expression<Func<T, object>> valueExpression, string uniqueCode = null, Expression<Func<T, object>> whereExpression=null) 
+        {
+            var entity = this.Context.EntityMaintenance.GetEntityInfo<T>();
+            ExpressionContext context = new ExpressionContext();
+            var query = Context.Queryable<T>().QueryBuilder;
+            var keyValue= query.GetExpressionValue(keyExpression, ResolveExpressType.FieldSingle).GetString();
+            var ValueValue = query.GetExpressionValue(valueExpression, ResolveExpressType.FieldSingle).GetString();
+            string where = null;
+            if (whereExpression != null) 
+            {
+                where=query.GetExpressionValue(whereExpression, ResolveExpressType.WhereSingle).GetResultString();
+            }
+            context.MappingTables = this.Context.MappingTables;
+            if (!SqlFuncExtendsion.TableInfos.Any(y => y.Type == typeof(T) && y.Code == uniqueCode))
+            {
+                SqlFuncExtendsion.TableInfos.Add(new ConfigTableInfo()
+                {
+                    Type = typeof(T),
+                    TableName = entity.DbTableName,
+                    Key = keyValue,
+                    Value = ValueValue,
+                    Where = where,
+                    Parameter = query.Parameters,
+                    Code = uniqueCode
+                });
+            }
+            else
+            {
+                Check.Exception(true, "SetKeyValue error , entity & uniqueCode already exist");
+            }
+        }
+        public void SetKeyValue<T>(Expression<Func<T, object>> key, Expression<Func<T, object>> value)
+        {
+            SetKeyValue<T>(key,value, null,null);
+        }
+    }
+
+    public class ConfigTableInfo 
+    { 
+        public string Code { get; set; }
+        public Type Type { get; set; }
+        public string TableName { get; set; }
+        public string Key { get; set; }
+        public string Value { get; set; }
+        public string Where { get; set; }
+        public List<SugarParameter> Parameter { get; set; }
+    }
+}

Src/Asp.Net/SqlSugar/ExpressionsToSql/Common/ExpressionTool.cs

@@ -171,6 +171,25 @@ namespace SqlSugar
             return reval;
         }
 
+        internal static object GetExpressionValue(Expression expression)
+        {
+            try
+            {
+                if (expression is ConstantExpression)
+                {
+                    return (expression as ConstantExpression).Value;
+                }
+                else
+                {
+                    return GetMemberValue((expression as MemberExpression).Member, expression);
+                }
+            }
+            catch  
+            {
+                return LambdaExpression.Lambda(expression).Compile().DynamicInvoke();
+            }
+        }
+
         public static object GetFiledValue(MemberExpression memberExpr)
         {
             if (!(memberExpr.Member is FieldInfo))

Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/SqlFuncExtendsion.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SqlSugar 
+{
+    public static class SqlFuncExtendsion
+    {
+        internal static List<ConfigTableInfo> TableInfos = new List<ConfigTableInfo>();
+        public static string GetConfigValue<Type>(this object field)
+        {
+            throw new NotSupportedException("Can only be used in expressions");
+        }
+        public static string GetConfigValue<Type>(this object field,string uniqueCode)
+        {
+            throw new NotSupportedException("Can only be used in expressions");
+        }
+    }
+}

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

@@ -46,6 +46,11 @@ namespace SqlSugar
                 this.Context.Result.Append(this.Context.DbMehtods.GuidNew());
                 return;
             }
+            else if (methodName == "GetConfigValue") 
+            {
+                GetConfigValue(express,parameter);
+                return;
+            }
             else if (IsSubMethod(express, methodName))
             {
                 //Check.Exception(!(parameter.BaseExpression is BinaryExpression), "Current expressions are not supported");
@@ -95,6 +100,58 @@ namespace SqlSugar
             }
         }
 
+        private void GetConfigValue(MethodCallExpression express,ExpressionParameter parameter)
+        {
+            var exp = express.Arguments[0];
+            var name =Regex.Match(express.Method.ToString(), @"GetConfigValue\[(.+)\]").Groups[1].Value;
+            string code = null;
+            if (express.Arguments.Count > 1) 
+            {
+                code=ExpressionTool.GetExpressionValue(express.Arguments[1])+"";
+            }
+            var entity= SqlFuncExtendsion.TableInfos.FirstOrDefault(y => y.Type.Name == name&&y.Code== code);
+            Check.Exception(entity == null,string.Format( "GetConfigValue no configuration  Entity={0} UniqueCode={1}",name,code));
+            string sql = " (SELECT {0} FROM {1} WHERE {2}={3}";
+            if (ExpressionTool.IsUnConvertExpress(exp)) 
+            {
+                exp = (exp as UnaryExpression).Operand;
+            }
+            var member = exp as MemberExpression;
+            var it = member.Expression;
+            var type = it.Type;
+            var properyName =member.Member.Name;
+            var eqName = string.Format("{0}.{1}",this.Context.GetTranslationColumnName(it.ToString()), this.Context.GetDbColumnName(type.Name,properyName));
+            if (this.Context.IsSingle)
+            {
+                this.Context.SingleTableNameSubqueryShortName = it.ToString();
+            }
+            sql = string.Format(sql,entity.Value,this.Context.GetTranslationColumnName(entity.TableName),entity.Key, eqName);
+            if (entity.Parameter != null)
+            {
+                foreach (var item in entity.Parameter)
+                {
+                    var oldName = item.ParameterName;
+                    item.ParameterName = oldName + "_con_" + this.Context.ParameterIndex;
+                    entity.Where = entity.Where.Replace(oldName, item.ParameterName);
+                }
+                this.Context.ParameterIndex++;
+                this.Context.Parameters.AddRange(entity.Parameter);
+            }
+            if (entity.Where.HasValue())
+            {
+                sql += " AND " + entity.Where;
+            }
+            sql += " )";
+            if (this.Context.ResolveType.IsIn(ResolveExpressType.SelectMultiple, ResolveExpressType.SelectSingle, ResolveExpressType.Update))
+            {
+                parameter.BaseParameter.CommonTempData = sql;
+            }
+            else 
+            {
+                AppendMember(parameter, parameter.IsLeft, sql);
+            }
+        }
+
         private bool IsValidNativeMethod(MethodCallExpression express, string methodName)
         {
             return MethodMapping.ContainsKey(methodName) && express.Method.DeclaringType.Namespace == ("System");

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

@@ -13,7 +13,7 @@ namespace SqlSugar
         IgnoreColumnList IgnoreColumns { get; set; }
         IgnoreColumnList IgnoreInsertColumns { get; set; }
         Dictionary<string, object> TempItems { get; set; }
-
+        SqlConfigTable SqlConfigTable { get; set; }
 
         bool IsSystemTablesConfig { get; }
         Guid ContextID { get; set; }

Src/Asp.Net/SqlSugar/SqlSugar.csproj

@@ -89,10 +89,12 @@
     <Compile Include="Abstract\InsertableProvider\InsertableProvider.cs" />
     <Compile Include="Abstract\DeleteProvider\DeleteableProvider.cs" />
     <Compile Include="Abstract\SaveableProvider\Storageable.cs" />
+    <Compile Include="Entities\ConfigQuery.cs" />
     <Compile Include="Entities\ManyToManyConfig.cs" />
     <Compile Include="Entities\StackTraceInfo.cs" />
     <Compile Include="Entities\SubInsertTree.cs" />
     <Compile Include="ExpressionsToSql\Common\MapperExpression.cs" />
+    <Compile Include="ExpressionsToSql\DbMethods\SqlFuncExtendsion.cs" />
     <Compile Include="ExpressionsToSql\ResolveItems\MapperExpressionResolve.cs" />
     <Compile Include="ExpressionsToSql\Subquery\Items\SubInnerJoin.cs" />
     <Compile Include="ExpressionsToSql\Subquery\Items\SubLeftJoin.cs" />

Src/Asp.Net/SqlSugar/SqlSugarClient.cs

@@ -52,7 +52,7 @@ namespace SqlSugar
         public bool IsSystemTablesConfig => this.Context.IsSystemTablesConfig;
         public ConnectionConfig CurrentConnectionConfig { get { return _CurrentConnectionConfig; } set { _CurrentConnectionConfig = value; } }
         public Guid ContextID { get { return this.Context.ContextID; } set { this.Context.ContextID = value; } }
-
+        public SqlConfigTable SqlConfigTable { get { return this.Context.SqlConfigTable; } set { this.Context.SqlConfigTable = value; } }
 
         public MappingTableList MappingTables { get { return _MappingTables; } set { _MappingTables = value; } }
         public MappingColumnList MappingColumns { get { return _MappingColumns; } set { _MappingColumns = value; } }